NtupleReader/src/MyTrigger.cxx

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// some other methods SM 
// 13.04.2007, AUTHOR: MANFRED GROH
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
//:: IMPLEMENTATION OF METHODS DEFINED IN THE CLASS MyTrigger ::
//::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::

//*****************************************************************************
#include "NtupleReader/MyTrigger.h"

//:::::::::::::::::::::::::
//:: NAME SPACE SETTINGS ::
//:::::::::::::::::::::::::

using namespace std;

//:::::::::::::::::
//:: METHOD init ::
//:::::::::::::::::
void MyTrigger::init(const bool  trigger_l1_defined,
                                         const bool  trigger_l2_defined,
                                         const bool  trigger_ef_defined,
                                         const vector<string> & trigger_keys_l1,
                                         const vector<int> & trigger_keys_status_l1,
                                         const vector<string> & trigger_keys_l2,
                                         const vector<int> & trigger_keys_status_l2,
                                         const vector<string> & trigger_keys_ef,
                                         const vector<int> & trigger_keys_status_ef){
        
        m_L1defined = trigger_l1_defined;
        m_L2defined = trigger_l2_defined;
        m_EFdefined = trigger_ef_defined;
        m_trigger_keys_l1 = trigger_keys_l1;
        m_trigger_keys_l2 = trigger_keys_l2;
        m_trigger_keys_ef = trigger_keys_ef;

        if(trigger_l1_defined){
                for(unsigned int j=0; j<trigger_keys_l1.size(); j++){
                        set_TriggerItem(trigger_keys_l1[j],
                                        (bool)trigger_keys_status_l1[j],1);
                }
        }       
        if(trigger_l2_defined){
                for(unsigned int j=0; j<trigger_keys_l2.size(); j++){
                        set_TriggerItem(trigger_keys_l2[j],
                                        (bool)trigger_keys_status_l2[j],2);
                }
        }
        if(trigger_ef_defined){
                for(unsigned int j=0; j<trigger_keys_ef.size(); j++){
                        set_TriggerItem(trigger_keys_ef[j],
                                        (bool)trigger_keys_status_ef[j],3);
                }
        }
        return;
}

//*****************************************************************************

map<string, bool> MyTrigger::triggermap(unsigned int level) {
  
  map<string, bool> dummy;
  if (level==1&& m_L1defined) {
    dummy=m_TriggerMapL1;
  }
  if (level==2&& m_L2defined) {
    dummy=m_TriggerMapL2;
  }
  if (level==3&& m_EFdefined) {
    dummy=m_TriggerMapEF;
  }
  return dummy;
}
vector<string> MyTrigger::triggerkey(unsigned int level) const {
  
  vector<string> dummy(0);
  
  if (level==1&& m_L1defined) {
    dummy=m_trigger_keys_l1;
  }
  if (level==2&& m_L2defined) {
    dummy=m_trigger_keys_l2;
  }
  if (level==3&& m_EFdefined) {
    dummy=m_trigger_keys_ef;
  }
  return dummy;
}

//::::::::::::::::::::::::::::
//:: METHOD set_TriggerItem ::
//::::::::::::::::::::::::::::

void MyTrigger::set_TriggerItem(string TriggerItem, bool triggered, unsigned int level){
                // insert trigger items in map
                // cout<<"Set trigger Level "<<level<<" "<<TriggerItem<<" "<<(int)triggered<<endl;
                if (level == 1 && m_L1defined) {
                        m_TriggerMapL1.insert(map<string,bool>::value_type(TriggerItem, triggered));
                        return;
                } else if (level == 2 && m_L2defined) {
                        m_TriggerMapL2.insert(map<string,bool>::value_type(TriggerItem, triggered));
                        return;
                } else if (level == 3 && m_EFdefined) {
                        m_TriggerMapEF.insert(map<string,bool>::value_type(TriggerItem, triggered));
                        return;
                }
}

//*****************************************************************************

//::::::::::::::::::::::::
//:: METHOD isTriggered ::
//::::::::::::::::::::::::
bool MyTrigger::isTriggered(string TriggerItem, unsigned int level) const {

  map<string,bool>::const_iterator it;

  if (level == 1 && m_L1defined) {
        it = m_TriggerMapL1.find(TriggerItem);
        if (it != m_TriggerMapL1.end()) {
          return (it->second);
        } else {
          cout << "Trigger Item " << TriggerItem
                  << " not defined!!!" << endl;
          return false;
        }
  } else if (level == 2 && m_L2defined) {
        it = m_TriggerMapL2.find(TriggerItem);
        if (it != m_TriggerMapL2.end()) {
          return (it->second);
        } else {
          cout << "Trigger Item " << TriggerItem
                  << " not defined!!!" << endl;
          return false;
        }
  } else if (level == 3 && m_EFdefined) {
        it = m_TriggerMapEF.find(TriggerItem);
        if (it != m_TriggerMapEF.end()) {
          return (it->second);
        } else {
          cout << "Trigger Item " << TriggerItem
                  << " not defined!!!" << endl;
          return false;
        }
  } else {
        cout << "Trigger level enum TrigLevel["
                << level << "] not defined!!!" << endl;
        return false;
  }
}

---