ExternalCondition.cc

Go to the documentation of this file.

// this class header
#include "L1Trigger/L1TGlobal/interface/ExternalCondition.h"

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

#include <string>
#include <vector>
#include <algorithm>

// user include files
//   base classes
#include "L1Trigger/L1TGlobal/interface/ExternalTemplate.h"
#include "L1Trigger/L1TGlobal/interface/ConditionEvaluation.h"
#include "DataFormats/L1Trigger/interface/L1Candidate.h"
#include "CondFormats/L1TObjects/interface/GlobalStableParameters.h"
#include "CondFormats/DataRecord/interface/L1TGlobalStableParametersRcd.h"
#include "L1Trigger/L1TGlobal/interface/GtBoard.h"

#include "DataFormats/L1TGlobal/interface/GlobalExtBlk.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"

// constructors
//     default
l1t::ExternalCondition::ExternalCondition() :
    ConditionEvaluation() {

    //empty

}

//     from base template condition (from event setup usually)
l1t::ExternalCondition::ExternalCondition(const GtCondition* eSumTemplate, const GtBoard* ptrGTB) :
    ConditionEvaluation(),
    m_gtExternalTemplate(static_cast<const ExternalTemplate*>(eSumTemplate)),
    m_uGtB(ptrGTB)

{

    // maximum number of objects received for the evaluation of the condition
    // energy sums are global quantities - one object per event

    m_condMaxNumberObjects = 1;  //blw ???

}

// copy constructor
void l1t::ExternalCondition::copy(const l1t::ExternalCondition &cp) {

    m_gtExternalTemplate = cp.gtExternalTemplate();
    m_uGtB = cp.getuGtB();

    m_condMaxNumberObjects = cp.condMaxNumberObjects();
    m_condLastResult = cp.condLastResult();
    m_combinationsInCond = cp.getCombinationsInCond();

    m_verbosity = cp.m_verbosity;

}

l1t::ExternalCondition::ExternalCondition(const l1t::ExternalCondition& cp) :
    ConditionEvaluation() {

    copy(cp);

}

// destructor
l1t::ExternalCondition::~ExternalCondition() {

    // empty

}

// equal operator
l1t::ExternalCondition& l1t::ExternalCondition::operator= (const l1t::ExternalCondition& cp)
{
    copy(cp);
    return *this;
}

// methods
void l1t::ExternalCondition::setGtExternalTemplate(const ExternalTemplate* eSumTempl) {

    m_gtExternalTemplate = eSumTempl;

}

void l1t::ExternalCondition::setuGtB(const GtBoard* ptrGTB) {

    m_uGtB = ptrGTB;

}

// try all object permutations and check spatial correlations, if required
const bool l1t::ExternalCondition::evaluateCondition(const int bxEval) const {



    LogDebug("L1TGlobal") << "Evaluating External Condition " 
                          <<  m_gtExternalTemplate->condName() 
              << " on Channel "  << m_gtExternalTemplate->extChannel() 
              << " relative Bx " << m_gtExternalTemplate->condRelativeBx() << std::endl;
    // number of trigger objects in the condition
    // in fact, there is only one object
//    int iCondition = 0;

    // condition result condResult set to true if the energy sum
    // passes all requirements
    bool condResult = false;

    // store the indices of the calorimeter objects
    // from the combination evaluated in the condition
    SingleCombInCond objectsInComb;

    // clear the m_combinationsInCond vector
    (combinationsInCond()).clear();

    // clear the indices in the combination
    objectsInComb.clear();

    const BXVector<const GlobalExtBlk*>* candVec = m_uGtB->getCandL1External();

    // Look at objects in bx = bx + relativeBx
    int useBx = bxEval + m_gtExternalTemplate->condRelativeBx();
    unsigned int exCondCh = m_gtExternalTemplate->extChannel(); 

    // Fail condition if attempting to get Bx outside of range
    if( ( useBx < candVec->getFirstBX() ) ||
    ( useBx > candVec->getLastBX() ) ) {
      return false;
    }

    int numberObjects = candVec->size(useBx);
    if (numberObjects < 1) {
        return false;
    }

    //get external block (should only be one for the bx)
    GlobalExtBlk ext = *(candVec->at(useBx,0));
    //ext.print(std::cout);

    // check external bit
    if ( !ext.getExternalDecision(exCondCh) ) {
      LogDebug("L1TGlobal") << "\t\t External Condition was not set" << std::endl;
        return false;
    }

    // index is always zero, as they are global quantities (there is only one object)
    int indexObj = 0;

    //Do we need this?
    objectsInComb.push_back(indexObj);
    (combinationsInCond()).push_back(objectsInComb);

    // if we get here all checks were successfull for this combination
    // set the general result for evaluateCondition to "true"
    condResult = true;
    LogDebug("L1TGlobal") << "\t\t Congrats, External Condition was set!" << std::endl;
    
    return condResult;

}

void l1t::ExternalCondition::print(std::ostream& myCout) const {

    m_gtExternalTemplate->print(myCout);
    ConditionEvaluation::print(myCout);

}