/data/refman/pasoursint/CMSSW_4_1_8_patch13/src/L1Trigger/GlobalTriggerAnalyzer/src/L1GtPatternWriter.cc

Go to the documentation of this file.

// this class header
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtPatternWriter.h"

// system include files
#include <iostream>
#include <iomanip>
#include <algorithm> 

// user include files
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtPatternMap.h"
#include "L1Trigger/GlobalTriggerAnalyzer/interface/L1GtPatternWriter.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

L1GtPatternWriter::L1GtPatternWriter(std::ostream& destination, const std::string& header,
                    const std::string& footer, const std::vector<std::string> columns,
                    const std::vector<uint32_t>& lengths, const std::vector<uint32_t>& defaults, 
                    const std::vector<int>& bx, bool debug) :
    m_dest(destination),
    m_header(header),
    m_footer(footer),
    m_columns(columns),
    m_lengths(lengths),
    m_defaults(defaults),
    m_bx(bx),
    m_debug(debug),
    m_lineNo(0)

{
    m_dest << m_header;
}

void L1GtPatternWriter::writePatterns(const L1GtPatternMap& patterns) { 
    for(L1GtPatternMap::LineMap::const_iterator it = patterns.begin(); it != patterns.end() ; ++it) { 
        int event = it->first.first;
        int bx = it->first.second;

        if(edm::isDebugEnabled() && m_debug) {
            std::stringstream dump;
            patterns.print(dump);
            LogTrace("L1GtPatternGenerator") << dump.str();
        }

        if(m_bx.empty() || std::find(m_bx.begin(), m_bx.end(), bx) != m_bx.end()) {
            if(m_debug) { 
                m_dest << "# Event " << std::dec << event << ", bx " << bx << std::endl;
            }
            writePatternLine(it->second);
            ++m_lineNo;
        } else { 
            LogTrace("L1GtPatternGenerator") << "Skipping event " << it->first.first << " bx " << it->first.second << " because of bx filter";
        }
    }
}

void L1GtPatternWriter::writePatternLine(const L1GtPatternLine& line) { 
    m_dest << std::setfill('0');
    // open each line with a line number
    // the line number is in decimal, while everything else is hex.
    m_dest << std::dec << std::setw(4) << m_lineNo << ' ' << std::hex ;
    
    for(uint32_t i = 0 ; i < m_columns.size() ; ++i) { 
        // space beween fields
        if(i) m_dest << ' ';
      
        // retrieve column value
        uint32_t value;
        if(line.has(m_columns[i])) { 
           // value comes from data     
           value = line.get(m_columns[i]);
        } else if(m_defaults.size() > i) {
           // value was specified as a config default.
           value = m_defaults[i];
        } else  { 
           // no default specified, set to 0
           value = 0;
        } 
        uint32_t digits = (m_lengths[i]+3)/4;
        
        // write to file with configured length (truncating value if neccessary)
        m_dest << std::setw(digits) << (value & mask(m_lengths[i]));
    }

    // next line
    m_dest << std::endl;
}

void L1GtPatternWriter::close() { 
    if(m_dest) {
        m_dest << m_footer;
    }
}


L1GtPatternWriter::~L1GtPatternWriter() { 
    close();
}

uint32_t L1GtPatternWriter::mask(uint32_t length) { 
    if(length < 32) { 
        return ~((~0) << length);
    } else { 
        return ~0;
    }
}