L1GlobalTriggerRecord.cc

Go to the documentation of this file.

// this class header
#include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerRecord.h"

// system include files
#include <iomanip>


// user include files
#include "FWCore/MessageLogger/interface/MessageLogger.h"

// constructors
L1GlobalTriggerRecord::L1GlobalTriggerRecord()
{

    // empty 

}

L1GlobalTriggerRecord::L1GlobalTriggerRecord(const unsigned int numberPhysTriggers,
        const unsigned int numberTechnicalTriggers) {
    
    m_gtDecisionWord.reserve(numberPhysTriggers);
    m_gtTechnicalTriggerWord.reserve(numberTechnicalTriggers);

    m_gtDecisionWordBeforeMask.reserve(numberPhysTriggers);
    m_gtTechnicalTriggerWordBeforeMask.reserve(numberTechnicalTriggers);
    
}

// copy constructor
L1GlobalTriggerRecord::L1GlobalTriggerRecord(
    const L1GlobalTriggerRecord& result)
{

    m_gtGlobalDecision = result.m_gtGlobalDecision;
    
    m_gtDecisionWord = result.m_gtDecisionWord;
    m_gtTechnicalTriggerWord = result.m_gtTechnicalTriggerWord;

    m_gtDecisionWordBeforeMask = result.m_gtDecisionWordBeforeMask;
    m_gtTechnicalTriggerWordBeforeMask = result.m_gtTechnicalTriggerWordBeforeMask;
 
    m_gtPrescaleFactorIndexTech = result.m_gtPrescaleFactorIndexTech;
    m_gtPrescaleFactorIndexAlgo = result.m_gtPrescaleFactorIndexAlgo;

}

// destructor
L1GlobalTriggerRecord::~L1GlobalTriggerRecord()
{

    // empty now

}

// assignment operator
L1GlobalTriggerRecord& L1GlobalTriggerRecord::operator=(
    const L1GlobalTriggerRecord& result)
{

    if ( this != &result ) {

        m_gtGlobalDecision = result.m_gtGlobalDecision;

        m_gtDecisionWord = result.m_gtDecisionWord;
        m_gtTechnicalTriggerWord = result.m_gtTechnicalTriggerWord;

        m_gtDecisionWordBeforeMask = result.m_gtDecisionWordBeforeMask;
        m_gtTechnicalTriggerWordBeforeMask = result.m_gtTechnicalTriggerWordBeforeMask;

        m_gtPrescaleFactorIndexTech = result.m_gtPrescaleFactorIndexTech;
        m_gtPrescaleFactorIndexAlgo = result.m_gtPrescaleFactorIndexAlgo;
    }

    return *this;

}

// equal operator
bool L1GlobalTriggerRecord::operator==(
    const L1GlobalTriggerRecord& result) const
{

    if (m_gtGlobalDecision != result.m_gtGlobalDecision) {
        return false;
    }
    
    if (m_gtDecisionWord != result.m_gtDecisionWord) {
        return false;
    }
    
    if (m_gtTechnicalTriggerWord != result.m_gtTechnicalTriggerWord) {
        return false;
    }

    if (m_gtDecisionWordBeforeMask != result.m_gtDecisionWordBeforeMask) {
        return false;
    }
    
    if (m_gtTechnicalTriggerWordBeforeMask != result.m_gtTechnicalTriggerWordBeforeMask) {
        return false;
    }

    if (m_gtPrescaleFactorIndexTech != result.m_gtPrescaleFactorIndexTech) {
        return false;
    }
    
    if (m_gtPrescaleFactorIndexAlgo != result.m_gtPrescaleFactorIndexAlgo) {
        return false;
    }

    // all members identical
    return true;

}

// unequal operator
bool L1GlobalTriggerRecord::operator!=(
    const L1GlobalTriggerRecord& result) const
{

    return !( result == *this);

}
// methods


// set global decision
void L1GlobalTriggerRecord::setDecision(const bool& dValue)
{

    m_gtGlobalDecision = dValue;
    
}

// set decision word
void L1GlobalTriggerRecord::setDecisionWord(
    const DecisionWord& dWordValue)
{

    m_gtDecisionWord = dWordValue;
    
}

void L1GlobalTriggerRecord::setTechnicalTriggerWord(
        const TechnicalTriggerWord& ttWordValue)
{

    m_gtTechnicalTriggerWord = ttWordValue;

}

// set decision word before applying the masks
void L1GlobalTriggerRecord::setDecisionWordBeforeMask(
    const DecisionWord& dWordValue)
{

    m_gtDecisionWordBeforeMask = dWordValue;
    
}

void L1GlobalTriggerRecord::setTechnicalTriggerWordBeforeMask(
        const TechnicalTriggerWord& ttWordValue)
{

    m_gtTechnicalTriggerWordBeforeMask = ttWordValue;

}


// print global decision and algorithm decision word
void L1GlobalTriggerRecord::printGtDecision(std::ostream& myCout) const
{

    myCout << std::endl;
    myCout << "\n  Global decision (FinalOR): " << m_gtGlobalDecision << std::endl;

    // decision word (in 64bits words)
    int sizeW64 = 64; // 64 bits words

    int iBit = 0;
    int jBit = m_gtDecisionWord.size();
    int nrDecWord = m_gtDecisionWord.size()/sizeW64;

    std::ostringstream stream64;

    std::vector<std::string> decWord;
    decWord.reserve(nrDecWord);

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtDecisionWord.rbegin();
            ritBit != m_gtDecisionWord.rend(); ++ritBit) {

        stream64 << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) ) {
            stream64  << " ";
        }

        if ( ((iBit + 1)%sizeW64) == 0) {
            std::string iW = stream64.str();
            stream64.str("");

            decWord.push_back(iW);
        }


        iBit++;
        jBit--;
    }

    int iWord = 0;

    myCout << "\n  DecisionWord after trigger mask (bitset style)";
    for (std::vector<std::string>::reverse_iterator ritWord = decWord.rbegin();
            ritWord != decWord.rend(); ++ritWord) {

        myCout << "\n  Bits "
        << iWord*sizeW64 + sizeW64 - 1 << " : " << iWord*sizeW64 << "\n  ";
        myCout << *ritWord;

        iWord++;

    }

}

// print technical trigger word (reverse order for vector<bool>)
void L1GlobalTriggerRecord::printTechnicalTrigger(std::ostream& myCout) const
{

    myCout << "\n  Technical triggers after trigger mask  (bitset style):    \n  " ;

    int sizeW64 = 64; // 64 bits words
    int iBit = 0;

    for (std::vector<bool>::const_reverse_iterator ritBit = m_gtTechnicalTriggerWord.rbegin();
            ritBit != m_gtTechnicalTriggerWord.rend(); ++ritBit) {

        myCout << (*ritBit ? '1' : '0');

        if ( (((iBit + 1)%16) == (sizeW64%16)) && (iBit != 63) ) {
            myCout << " ";
        }

        iBit++;
    }


}

// clear the record
void L1GlobalTriggerRecord::reset()
{

    m_gtGlobalDecision = false;

    for (std::vector<bool>::iterator itBit = m_gtDecisionWord.begin(); 
        itBit != m_gtDecisionWord.end(); ++itBit) {
        
        *itBit = false;
        
    }
    for (std::vector<bool>::iterator itBit = m_gtTechnicalTriggerWord.begin(); 
        itBit != m_gtTechnicalTriggerWord.end(); ++itBit) {
        
        *itBit = false;
        
    }
    for (std::vector<bool>::iterator itBit = m_gtDecisionWordBeforeMask.begin(); 
        itBit != m_gtDecisionWordBeforeMask.end(); ++itBit) {
        
        *itBit = false;
        
    }

    for (std::vector<bool>::iterator itBit = m_gtTechnicalTriggerWordBeforeMask.begin(); 
        itBit != m_gtTechnicalTriggerWordBeforeMask.end(); ++itBit) {
        
        *itBit = false;
        
    }
 
    m_gtPrescaleFactorIndexTech = 0;
    m_gtPrescaleFactorIndexAlgo = 0;

}


// pretty print the content of a L1GlobalTriggerRecord
void L1GlobalTriggerRecord::print(std::ostream& myCout) const
{

    printGtDecision(myCout);
    
    myCout << std::endl;
        
    printTechnicalTrigger(myCout);
    
    myCout << std::endl;
    myCout << "\n  Index of prescale factor set for technical triggers: " 
        << m_gtPrescaleFactorIndexTech << std::endl;
    myCout << "  Index of prescale factor set for algorithm triggers: " 
        << m_gtPrescaleFactorIndexTech << std::endl;
    myCout << std::endl;
   

}

// output stream operator
std::ostream& operator<<(std::ostream& streamRec, const L1GlobalTriggerRecord& result)
{
    result.print(streamRec);
    return streamRec;

}