#include <L1TSync_Harvest.h>

Inheritance diagram for L1TSync_Harvest:

Public Types
enum	BeamMode { NOMODE =1, SETUP =2, INJPILOT =3, INJINTR =4, INJNOMN =5, PRERAMP =6, RAMP =7, FLATTOP =8, QUEEZE =9, ADJUST =10, STABLE =11, UNSTABLE =12, BEAMDUMP =13, RAMPDOWN =14, RECOVERY =15, INJDUMP =16, CIRCDUMP =17, ABORT =18, CYCLING =19, WBDUMP =20, NOBEAM =21 }

enum	Errors { UNKNOWN = 1, WARNING_DB_CONN_FAILED = 2, WARNING_DB_QUERY_FAILED = 3, WARNING_DB_INCORRECT_NBUNCHES = 4, ERROR_UNABLE_RETRIVE_PRODUCT = 5, ERROR_TRIGGERALIAS_NOTVALID = 6, ERROR_LSBLOCK_NOTVALID = 7 }

Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

typedef WorkerT< EDAnalyzer >	WorkerType

Public Member Functions
	L1TSync_Harvest (const edm::ParameterSet &ps)

virtual	~L1TSync_Harvest ()

Public Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
	EDConsumerBase ()

ProductHolderIndex	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndex > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndex > &) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Protected Member Functions
void	analyze (const edm::Event &e, const edm::EventSetup &c)

void	beginJob ()

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c)

void	beginRun (const edm::Run &run, const edm::EventSetup &iSetup)
	BeginRun. More...

void	endJob (void)

virtual void	endLuminosityBlock (edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c)

void	endRun (const edm::Run &run, const edm::EventSetup &iSetup)

Protected Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

CurrentProcessingContext const *	currentContext () const

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Private Member Functions
void	certifyLSBlock (std::string iTrigger, int iInitLs, int iEndLs, float iValue)

void	doFractionInSync (bool iForce=false, bool iBad=false)

void	getBeamConfOMDS ()

Private Attributes
DQMStore *	dbe

const std::vector< std::vector < int > > *	ListsPrescaleFactors

std::map< std::string, bool >	m_algoAutoSelect

std::map< TString, int >	m_algoBit

std::map< TString, MonitorElement * >	m_algoCertification

std::map< TString, MonitorElement * >	m_algoVsBunchStructure

L1TBeamConfiguration	m_beamConfig

std::map< TString, unsigned int >	m_certFirstLS

std::map< TString, unsigned int >	m_certLastLS

unsigned int	m_currentLS

bool	m_currentLSValid

MonitorElement *	m_ErrorMonitor

edm::InputTag	m_l1GtDataDaqInputTag

edm::InputTag	m_l1GtEvmSource

unsigned int	m_lhcFill

std::string	m_outputFile

edm::ParameterSet	m_parameters

bool *	m_processedLS

int	m_refPrescaleSet

edm::InputTag	m_scalersSource

std::map< std::string, std::string >	m_selectedTriggers

bool	m_verbose

Additional Inherited Members
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Detailed Description

Definition at line 59 of file L1TSync_Harvest.h.

Member Enumeration Documentation

enum L1TSync_Harvest::BeamMode

Enumerator
NOMODE
SETUP
INJPILOT
INJINTR
INJNOMN
PRERAMP
RAMP
FLATTOP
QUEEZE
ADJUST
STABLE
UNSTABLE
BEAMDUMP
RAMPDOWN
RECOVERY
INJDUMP
CIRCDUMP
ABORT
CYCLING
WBDUMP
NOBEAM

Definition at line 63 of file L1TSync_Harvest.h.

                  {
       NOMODE=1,
       SETUP=2,
       INJPILOT=3,
       INJINTR=4,
       INJNOMN=5,
       PRERAMP=6,
       RAMP=7,
       FLATTOP=8,
       QUEEZE=9,
       ADJUST=10,
       STABLE=11,
       UNSTABLE=12,
       BEAMDUMP=13,
       RAMPDOWN=14,
       RECOVERY=15,
       INJDUMP=16,
       CIRCDUMP=17,
       ABORT=18,
       CYCLING=19,
       WBDUMP=20,
       NOBEAM=21
     };

enum L1TSync_Harvest::Errors

Enumerator
UNKNOWN
WARNING_DB_CONN_FAILED
WARNING_DB_QUERY_FAILED
WARNING_DB_INCORRECT_NBUNCHES
ERROR_UNABLE_RETRIVE_PRODUCT
ERROR_TRIGGERALIAS_NOTVALID
ERROR_LSBLOCK_NOTVALID

Definition at line 87 of file L1TSync_Harvest.h.

                {
       UNKNOWN                       = 1,
       WARNING_DB_CONN_FAILED        = 2,
       WARNING_DB_QUERY_FAILED       = 3,
       WARNING_DB_INCORRECT_NBUNCHES = 4,
       ERROR_UNABLE_RETRIVE_PRODUCT  = 5,
       ERROR_TRIGGERALIAS_NOTVALID   = 6,
       ERROR_LSBLOCK_NOTVALID        = 7
     };

Constructor & Destructor Documentation

L1TSync_Harvest::L1TSync_Harvest ( const edm::ParameterSet & ps )

m_parameters = pset;

// Mapping parameter input variables m_scalersSource = pset.getParameter <InputTag>("inputTagScalersResults"); m_l1GtDataDaqInputTag = pset.getParameter <InputTag>("inputTagL1GtDataDaq"); m_l1GtEvmSource = pset.getParameter <InputTag>("inputTagtEvmSource"); m_verbose = pset.getUntrackedParameter<bool> ("verbose",false); m_refPrescaleSet = pset.getParameter <int> ("refPrescaleSet");

// Getting which categories to monitor ParameterSet Categories = pset.getParameter< ParameterSet >("Categories");

bool forceGlobalParameters = Categories.getParameter<bool>("forceGlobalParameters"); bool doGlobalAutoSelection = Categories.getParameter<bool>("doGlobalAutoSelection");

ParameterSet CatBPTX = Categories.getParameter<ParameterSet>("BPTX"); ParameterSet CatMu = Categories.getParameter<ParameterSet>("Mu"); ParameterSet CatEG = Categories.getParameter<ParameterSet>("EG"); ParameterSet CatIsoEG = Categories.getParameter<ParameterSet>("IsoEG"); ParameterSet CatJet = Categories.getParameter<ParameterSet>("Jet"); ParameterSet CatCenJet = Categories.getParameter<ParameterSet>("CenJet"); ParameterSet CatForJet = Categories.getParameter<ParameterSet>("ForJet"); ParameterSet CatTauJet = Categories.getParameter<ParameterSet>("TauJet"); ParameterSet CatETM = Categories.getParameter<ParameterSet>("ETT"); ParameterSet CatETT = Categories.getParameter<ParameterSet>("ETM"); ParameterSet CatHTT = Categories.getParameter<ParameterSet>("HTT"); ParameterSet CatHTM = Categories.getParameter<ParameterSet>("HTM");

// –> Setting parameters related to which algos to monitor // If global parameters are forced they take precedence over algo-by-algo parameters if(forceGlobalParameters){

// If global automatic selection if enable all categories set to be monitored will have // their algos auto selected (the lowest prescale algo will be selected) if(doGlobalAutoSelection){

if(CatMu .getParameter<bool>("monitor")){m_algoAutoSelect["Mu"] = true;}else{m_algoAutoSelect["Mu"] = false;} if(CatEG .getParameter<bool>("monitor")){m_algoAutoSelect["EG"] = true;}else{m_algoAutoSelect["EG"] = false;} if(CatIsoEG .getParameter<bool>("monitor")){m_algoAutoSelect["IsoEG"] = true;}else{m_algoAutoSelect["IsoEG"] = false;} if(CatJet .getParameter<bool>("monitor")){m_algoAutoSelect["Jet"] = true;}else{m_algoAutoSelect["Jet"] = false;} if(CatCenJet.getParameter<bool>("monitor")){m_algoAutoSelect["CenJet"] = true;}else{m_algoAutoSelect["CenJet"] = false;} if(CatForJet.getParameter<bool>("monitor")){m_algoAutoSelect["ForJet"] = true;}else{m_algoAutoSelect["ForJet"] = false;} if(CatTauJet.getParameter<bool>("monitor")){m_algoAutoSelect["TauJet"] = true;}else{m_algoAutoSelect["TauJet"] = false;} if(CatETM .getParameter<bool>("monitor")){m_algoAutoSelect["ETM"] = true;}else{m_algoAutoSelect["ETM"] = false;} if(CatETT .getParameter<bool>("monitor")){m_algoAutoSelect["ETT"] = true;}else{m_algoAutoSelect["ETT"] = false;} if(CatHTM .getParameter<bool>("monitor")){m_algoAutoSelect["HTM"] = true;}else{m_algoAutoSelect["HTM"] = false;} if(CatHTT .getParameter<bool>("monitor")){m_algoAutoSelect["HTT"] = true;}else{m_algoAutoSelect["HTT"] = false;}

// If global non-automatic selection is enable all categories set to be monitored will use // user defined algos }else{

m_algoAutoSelect["Mu"] = false; m_algoAutoSelect["EG"] = false; m_algoAutoSelect["IsoEG"] = false; m_algoAutoSelect["Jet"] = false; m_algoAutoSelect["CenJet"] = false; m_algoAutoSelect["ForJet"] = false; m_algoAutoSelect["TauJet"] = false; m_algoAutoSelect["ETM"] = false; m_algoAutoSelect["ETT"] = false; m_algoAutoSelect["HTM"] = false; m_algoAutoSelect["HTT"] = false;

if(CatMu .getParameter<bool>("monitor")){m_selectedTriggers["Mu"] = CatMu .getParameter<string>("algo");} if(CatEG .getParameter<bool>("monitor")){m_selectedTriggers["EG"] = CatEG .getParameter<string>("algo");} if(CatIsoEG .getParameter<bool>("monitor")){m_selectedTriggers["IsoEG"] = CatIsoEG .getParameter<string>("algo");} if(CatJet .getParameter<bool>("monitor")){m_selectedTriggers["Jet"] = CatJet .getParameter<string>("algo");} if(CatCenJet.getParameter<bool>("monitor")){m_selectedTriggers["CenJet"] = CatCenJet.getParameter<string>("algo");} if(CatForJet.getParameter<bool>("monitor")){m_selectedTriggers["CatForJet"] = CatForJet.getParameter<string>("algo");} if(CatTauJet.getParameter<bool>("monitor")){m_selectedTriggers["TauJet"] = CatTauJet.getParameter<string>("algo");} if(CatETM .getParameter<bool>("monitor")){m_selectedTriggers["ETM"] = CatETM .getParameter<string>("algo");} if(CatETT .getParameter<bool>("monitor")){m_selectedTriggers["ETT"] = CatETT .getParameter<string>("algo");} if(CatHTM .getParameter<bool>("monitor")){m_selectedTriggers["HTM"] = CatHTM .getParameter<string>("algo");} if(CatHTT .getParameter<bool>("monitor")){m_selectedTriggers["HTT"] = CatHTT .getParameter<string>("algo");}

}

// If we are using algo-by-algo parametes we get them and set what is needed }else{

if(CatBPTX.getParameter<bool>("monitor")){ m_selectedTriggers["BPTX"] = CatBPTX.getParameter<string>("algo"); }

if(CatMu.getParameter<bool>("monitor")){ m_algoAutoSelect["Mu"] = CatMu.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["Mu"]){m_selectedTriggers["Mu"] = CatMu.getParameter<string>("algo");} }else{m_algoAutoSelect["Mu"] = false;}

if(CatEG.getParameter<bool>("monitor")){ m_algoAutoSelect["EG"] = CatEG.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["EG"]){m_selectedTriggers["EG"] = CatEG.getParameter<string>("algo");} }else{m_algoAutoSelect["EG"] = false;}

if(CatIsoEG.getParameter<bool>("monitor")){ m_algoAutoSelect["IsoEG"] = CatIsoEG.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["IsoEG"]){m_selectedTriggers["IsoEG"] = CatIsoEG.getParameter<string>("algo");} }else{m_algoAutoSelect["IsoEG"] = false;}

if(CatJet.getParameter<bool>("monitor")){ m_algoAutoSelect["Jet"] = CatJet.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["Jet"]){m_selectedTriggers["Jet"] = CatJet.getParameter<string>("algo");} }else{m_algoAutoSelect["Jet"] = false;}

if(CatCenJet.getParameter<bool>("monitor")){ m_algoAutoSelect["CenJet"] = CatCenJet.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["CenJet"]){m_selectedTriggers["CenJet"] = CatCenJet.getParameter<string>("algo");} }else{m_algoAutoSelect["CenJet"] = false;}

if(CatForJet.getParameter<bool>("monitor")){ m_algoAutoSelect["CatForJet"] = CatForJet.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["CatForJet"]){m_selectedTriggers["CatForJet"] = CatForJet.getParameter<string>("algo");} }else{m_algoAutoSelect["CatForJet"] = false;}

if(CatTauJet.getParameter<bool>("monitor")){ m_algoAutoSelect["TauJet"] = CatTauJet.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["TauJet"]){m_selectedTriggers["TauJet"] = CatTauJet.getParameter<string>("algo");} }else{m_algoAutoSelect["TauJet"] = false;}

if(CatETM.getParameter<bool>("monitor")){ m_algoAutoSelect["ETM"] = CatETM.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["ETM"]){m_selectedTriggers["ETM"] = CatETM.getParameter<string>("algo");} }else{m_algoAutoSelect["ETM"] = false;}

if(CatETT.getParameter<bool>("monitor")){ m_algoAutoSelect["ETT"] = CatETT.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["ETT"]){m_selectedTriggers["ETT"] = CatETT.getParameter<string>("algo");} }else{m_algoAutoSelect["ETT"] = false;}

if(CatHTM.getParameter<bool>("monitor")){ m_algoAutoSelect["HTM"] = CatHTM.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["HTM"]){m_selectedTriggers["HTM"] = CatHTM.getParameter<string>("algo");} }else{m_algoAutoSelect["HTM"] = false;}

if(CatHTT.getParameter<bool>("monitor")){ m_algoAutoSelect["HTT"] = CatHTT.getParameter<bool>("doAutoSelection"); if(!m_algoAutoSelect["HTT"]){m_selectedTriggers["HTT"] = CatHTT.getParameter<string>("algo");} }else{m_algoAutoSelect["HTT"] = false;}

}

Definition at line 41 of file L1TSync_Harvest.cc.

References gather_cfg::cout, edm::ParameterSet::getUntrackedParameter(), NULL, cppFunctionSkipper::operator, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                          {
 
   if (pset.getUntrackedParameter < bool > ("dqmStore", false)) {
     dbe = Service < DQMStore > ().operator->();
     dbe->setVerbose(0);
   }
 
   m_outputFile = pset.getUntrackedParameter < std::string > ("outputFile","");
 
   if (m_outputFile.size() != 0) {
     std::cout << "L1T Monitoring histograms will be saved to " <<   m_outputFile.c_str() << std::endl;
   }
 
   bool disable = pset.getUntrackedParameter < bool > ("disableROOToutput", false);
   if (disable) {m_outputFile = "";}
 
   if (dbe != NULL) {dbe->setCurrentFolder("L1T/L1TSync");}
 
 }

L1TSync_Harvest::~L1TSync_Harvest ( )

virtual

Definition at line 206 of file L1TSync_Harvest.cc.

206 {}

Member Function Documentation

void L1TSync_Harvest::analyze	(	const edm::Event &	e,
		const edm::EventSetup &	c
	)

protectedvirtual

if(m_verbose){cout << "[L1TSync_Harvest] Called analyze." << endl;}

// We only start analyzing if current LS is still valid if(m_currentLSValid){

if(m_verbose){cout << "[L1TSync_Harvest] -> m_currentLSValid=" << m_currentLSValid << endl;}

// Retriving information from GT edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvmReadoutRecord; iEvent.getByLabel(m_l1GtEvmSource, gtEvmReadoutRecord);

// Determining beam mode and fill number if(gtEvmReadoutRecord.isValid()){

const L1GtfeExtWord& gtfeEvmWord = gtEvmReadoutRecord->gtfeWord(); unsigned int lhcBeamMode = gtfeEvmWord.beamMode(); // Updating beam mode

if(m_lhcFill == 0){ m_lhcFill = gtfeEvmWord.lhcFillNumber(); // Getting LHC Fill Number from GT getBeamConfOMDS(); // Getting Beam Configuration from OMDS }

if(lhcBeamMode != STABLE){m_currentLSValid = false;} // If Beams are not stable we invalidate this LS

}else{ int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT); eCount++; m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT,eCount); } }else{ if(m_verbose){cout << "[L1TSync_Harvest] -> m_currentLSValid=" << m_currentLSValid << endl;} }

//---------------------------------------------------------------------------— // If current LS is valid and Beam Configuration is Valid we analyse this event //---------------------------------------------------------------------------— if(m_currentLSValid && m_beamConfig.isValid()){

// Getting Final Decision Logic (FDL) Data from GT edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecordData; iEvent.getByLabel(m_l1GtDataDaqInputTag, gtReadoutRecordData);

if(gtReadoutRecordData.isValid()){

const vector<L1GtFdlWord>& gtFdlVectorData = gtReadoutRecordData->gtFdlVector();

// Running over selected triggers for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){

string tTrigger = (*i).second;

// Analyse only defined triggers if(tTrigger != "Undefined" && tTrigger != "Undefined (Wrong Name)"){

bool beamSingleConfig = false; // Single beam configured for this event bool firedAlgo = false; // Algo fired in this event int eventBx = -1;

// Running over FDL results to get which bits fired for(unsigned int a=0 ; a<gtFdlVectorData.size() ; a++){

// Selecting the FDL that triggered if(gtFdlVectorData[a].bxInEvent() == 0){ eventBx = gtFdlVectorData[a].localBxNr(); if(gtFdlVectorData[a].gtDecisionWord()[ m_algoBit[tTrigger] ]){firedAlgo = true;} } }

// Checking beam configuration if( m_beamConfig.beam1[eventBx] && !m_beamConfig.beam2[eventBx]){beamSingleConfig = true;} if(!m_beamConfig.beam1[eventBx] && m_beamConfig.beam2[eventBx]){beamSingleConfig = true;}

// Analyse only if this trigger fired in this event // NOTE: Veto cases where a single beam is configured since // for this cases this could be a real-satelite bunch collision // -> Calculate the minimum bx diference between this event and a configured bx if(firedAlgo && !beamSingleConfig){

int DifAlgoVsBunchStructure = 9999; // Majorated

for(unsigned int a=0 ; a<gtFdlVectorData.size() ; a++){

int bxFDL = gtFdlVectorData[a].localBxNr(); int bxInEvent = gtFdlVectorData[a].bxInEvent();

if(m_beamConfig.bxConfig(bxFDL) && abs(bxInEvent)<abs(DifAlgoVsBunchStructure)){ DifAlgoVsBunchStructure = -1*bxInEvent; } }

m_algoVsBunchStructure[tTrigger]->Fill(m_currentLS,DifAlgoVsBunchStructure);

} } } } else{ int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT); eCount++; m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT,eCount); }

}

Implements edm::EDAnalyzer.

Definition at line 431 of file L1TSync_Harvest.cc.

                                                                                 {
  
 }

void L1TSync_Harvest::beginJob ( void )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 210 of file L1TSync_Harvest.cc.

References gather_cfg::cout, cppFunctionSkipper::operator, DQMStore::rmdir(), and DQMStore::setCurrentFolder().

                                   {
 
   if (m_verbose){cout << "[L1TSync_Harvest] Called beginJob." << endl;}
 
   // get hold of back-end interface
   DQMStore *dbe = 0;
   dbe = Service < DQMStore > ().operator->();
 
   if (dbe) {
     dbe->setCurrentFolder("L1T/L1TSync");
     dbe->rmdir("L1T/L1TSync");
   }
  
 }

void L1TSync_Harvest::beginLuminosityBlock	(	edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &	c
	)

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 317 of file L1TSync_Harvest.cc.

References gather_cfg::cout, i, edm::LuminosityBlockBase::id(), and edm::LuminosityBlockID::luminosityBlock().

                                                                                                 {
 
   if (m_verbose){cout << "[L1TSync_Harvest] Called beginLuminosityBlock." << endl;}
 
   // If this LS is not the next to last one force closing of current LS blocks
   // for certification
   if(m_currentLS !=0 && m_currentLS+1 != lumiBlock.id().luminosityBlock()){
 
     if (m_verbose){
       cout << "[L1TSync_Harvest] None consecutive: doFractionInSync() - LAST=" 
            << m_currentLS << " CURRENT=" << lumiBlock.id().luminosityBlock() << endl;
     }
 
     doFractionInSync(true,false);    
 
   }
     
   // Updating current LS number
   m_currentLS = lumiBlock.id().luminosityBlock();
 
   // If this is the fist valid LS update first LS for certification 
   for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){
 
     string theTriggerAlias = (*i).second;
     if(m_certFirstLS[theTriggerAlias]==0){m_certFirstLS[theTriggerAlias] = m_currentLS;}
 
   }
 
   // A LS will be valid if:
   //   * BeamMode == STABLE for all events monitored
   m_currentLSValid = true; 
 
 }

void L1TSync_Harvest::beginRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

protectedvirtual

BeginRun.

if (m_verbose){cout << "[L1TSync_Harvest] Called beginRun." << endl;}

// Initializing variables int maxNbins = 2501;

// Reseting run dependent variables m_lhcFill = 0; m_currentLS = 0; m_certFirstLS.clear(); m_certLastLS .clear();

// Getting Trigger menu from GT ESHandle<L1GtTriggerMenu> menuRcd; iSetup.get<L1GtTriggerMenuRcd>().get(menuRcd); const L1GtTriggerMenu* menu = menuRcd.product();

// Filling Alias-Bit Map for (CItAlgo algo = menu->gtAlgorithmAliasMap().begin(); algo!=menu->gtAlgorithmAliasMap().end(); ++algo){ m_algoBit[(algo->second).algoAlias()] = (algo->second).algoBitNumber(); }

// Getting fill number for this run //Handle<ConditionsInRunBlock> runConditions; //iRun.getByType(runConditions); //int lhcFillNumber = runConditions->lhcFillNumber; // //ESHandle<L1GtPrescaleFactors> l1GtPfAlgo; //iSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo); //const L1GtPrescaleFactors* m_l1GtPfAlgo = l1GtPfAlgo.product();

L1TMenuHelper myMenuHelper = L1TMenuHelper(iSetup);

m_selectedTriggers = myMenuHelper.testAlgos(m_selectedTriggers);

map<string,string> tAutoSelTrig = myMenuHelper.getLUSOTrigger(m_algoAutoSelect,m_refPrescaleSet); m_selectedTriggers.insert(tAutoSelTrig.begin(),tAutoSelTrig.end());

// Initializing DQM Monitor Elements dbe->setCurrentFolder("L1T/L1TSync"); m_ErrorMonitor = dbe->book1D("ErrorMonitor","ErrorMonitor",7,0,7); m_ErrorMonitor->setBinLabel(UNKNOWN ,"UNKNOWN"); m_ErrorMonitor->setBinLabel(WARNING_DB_CONN_FAILED ,"WARNING_DB_CONN_FAILED"); // Errors from L1TOMDSHelper m_ErrorMonitor->setBinLabel(WARNING_DB_QUERY_FAILED ,"WARNING_DB_QUERY_FAILED"); // Errors from L1TOMDSHelper m_ErrorMonitor->setBinLabel(WARNING_DB_INCORRECT_NBUNCHES,"WARNING_DB_INCORRECT_NBUNCHES"); // Errors from L1TOMDSHelper m_ErrorMonitor->setBinLabel(ERROR_UNABLE_RETRIVE_PRODUCT ,"ERROR_UNABLE_RETRIVE_PRODUCT"); m_ErrorMonitor->setBinLabel(ERROR_TRIGGERALIAS_NOTVALID ,"ERROR_TRIGGERALIAS_NOTVALID"); m_ErrorMonitor->setBinLabel(ERROR_LSBLOCK_NOTVALID ,"ERROR_LSBLOCK_NOTVALID");

// Looping over selected triggers for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){

string tCategory = (*i).first; string tTrigger = (*i).second;

// Initializing LS blocks for certification m_certFirstLS[(*i).second] = 0; m_certLastLS [(*i).second] = 0;

// Initializing DQM Monitors dbe->setCurrentFolder("L1T/L1TSync/AlgoVsBunchStructure/"); m_algoVsBunchStructure[tTrigger] = dbe->book2D(tCategory,"min #Delta("+tTrigger+",Bunch)",maxNbins,-0.5,double(maxNbins)-0.5,5,-2.5,2.5); m_algoVsBunchStructure[tTrigger] ->setAxisTitle("Lumi Section" ,1);

dbe->setCurrentFolder("L1T/L1TSync/Certification/"); m_algoCertification[tTrigger] = dbe->book1D(tCategory, "fraction of in sync: "+tTrigger,maxNbins,-0.5,double(maxNbins)-0.5); m_algoCertification[tTrigger] ->setAxisTitle("Lumi Section" ,1);

}

Reimplemented from edm::EDAnalyzer.

Definition at line 241 of file L1TSync_Harvest.cc.

                                                                              {
 
 }

void L1TSync_Harvest::certifyLSBlock	(	std::string	iTrigger,
		int	iInitLs,
		int	iEndLs,
		float	iValue
	)

private

// Finding correct bins in the histogram for this block int binInit = m_algoCertification[iTrigger]->getTH1()->FindBin(iInitLs); int binEnd = m_algoCertification[iTrigger]->getTH1()->FindBin(iEndLs);

for(int ls=binInit ; ls<=binEnd ; ls++){ m_algoCertification[iTrigger]->setBinContent(ls,iValue); }

Definition at line 664 of file L1TSync_Harvest.cc.

                                                                                           {
   
 }

void L1TSync_Harvest::doFractionInSync	(	bool	iForce = `false`,
		bool	iBad = `false`
	)

private

Definition at line 553 of file L1TSync_Harvest.cc.

References a, gather_cfg::cout, edm::ParameterSet::getParameter(), i, and python.rootplot.utilities::ls().

                                                            {
   
   for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){
 
     string theCategory     = (*i).first;
     string theTriggerAlias = (*i).second;
 
     // Caching frequently used values from maps
     unsigned int fLS = m_certFirstLS[theTriggerAlias];
     unsigned int lLS = m_certLastLS [theTriggerAlias];
     
     // Checking validity of the trigger alias and of the LS block
     bool triggerAlias_isValid = theTriggerAlias != "Undefined" && theTriggerAlias != "Undefined (Wrong Name)";
     bool lsBlock_exists       = !(fLS == 0 && lLS == 0);
     bool lsBlock_isValid      = fLS <= lLS && fLS > 0 && lLS > 0; 
 
     if(triggerAlias_isValid && lsBlock_exists && lsBlock_isValid){
 
       // If we are forced to close blocks and mark them bad
       if(iForce && iBad){
         certifyLSBlock(theTriggerAlias,fLS,lLS,-1);
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS [theTriggerAlias] = 0;
       }
 
       // If we are not forced to mark bad, we check if we have enough statistics
       else{
 
         // Getting events with 0 bx difference between BPTX and Algo for current LS
         double CountSync = 0;
         double CountAll  = 0;
   
         // Adding all entries for current LS block
         for(unsigned int ls=fLS ; ls<=lLS ; ls++){
 
           CountSync += m_algoVsBunchStructure[theTriggerAlias]->getBinContent(ls+1,3);
           for(int a=1 ; a<6 ; a++){
             CountAll  += m_algoVsBunchStructure[theTriggerAlias]->getBinContent(ls+1,a);
           }
         }
 
         if(m_verbose){
           cout << "Alias = " << theTriggerAlias 
                << " InitLS=" << fLS 
                << " EndLS=" <<  lLS 
                << " Events=" << CountAll ;
         } 
 
         if(iForce ||
            CountAll >= m_parameters.getParameter<ParameterSet>("Categories")
                                    .getParameter<ParameterSet>(theCategory)
                                    .getParameter<int>("CertMinEvents")){
 
           if(m_verbose){cout << " <--------------- Enough Statistics: ";}
 
         
           // Calculating fraction of in time 
           double fraction = 0;
           if(CountAll >0){fraction = CountSync/CountAll;}
 
           // This is to avoid having an entry equal to zero and thus
           // disregarded by the automatic tests
           if(fraction==0){fraction=0.000001;}
         
           certifyLSBlock(theTriggerAlias,fLS,lLS,fraction);
           m_certFirstLS[theTriggerAlias] = 0;
           m_certLastLS [theTriggerAlias] = 0;
         }
 
         if(m_verbose){cout << endl;}
 
       }
     }
 
     // A problem was found. We report it and set a not physical vale (-1) to the certification plot
     else{
 
       // If trigger alias is not valid report it to m_ErrorMonitor
       if(!triggerAlias_isValid){
         int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_TRIGGERALIAS_NOTVALID);
         eCount++;
         m_ErrorMonitor->getTH1()->SetBinContent(ERROR_TRIGGERALIAS_NOTVALID,eCount);
         certifyLSBlock(theTriggerAlias,fLS,lLS,-1);
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS [theTriggerAlias] = 0;
       }
 
       // If LS Block is not valid report it to m_ErrorMonitor
       if(lsBlock_exists && !lsBlock_isValid){
         int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_LSBLOCK_NOTVALID);
         eCount++;
         m_ErrorMonitor->getTH1()->SetBinContent(ERROR_LSBLOCK_NOTVALID,eCount);
         certifyLSBlock(theTriggerAlias,fLS,lLS,-1);
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS [theTriggerAlias] = 0;
       }
 
     }
   }
 
 }

void L1TSync_Harvest::endJob ( void )

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 227 of file L1TSync_Harvest.cc.

References gather_cfg::cout.

                                 {
 
   if (m_verbose){cout << "[L1TSync_Harvest] Called endJob." << endl;}
 
   if (m_outputFile.size() != 0 && dbe)
     dbe->save(m_outputFile);
 
   return;
 
 }

void L1TSync_Harvest::endLuminosityBlock	(	edm::LuminosityBlock const &	lumiBlock,
		edm::EventSetup const &	c
	)

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 355 of file L1TSync_Harvest.cc.

References gather_cfg::cout, and i.

                                                                                               {
 
   if(m_verbose){cout << "[L1TSync_Harvest] Called endLuminosityBlock." << endl;}
 
   if(m_verbose){
     cout << "[L1TSync_Harvest] m_currentLSValid      : " << m_currentLSValid       << endl;
     cout << "[L1TSync_Harvest] m_beamConfig.isValid(): " << m_beamConfig.isValid() << endl;
   }  
 
   for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){
 
     // Update last LS for certification      
     string theTriggerAlias = (*i).second;
     m_certLastLS[theTriggerAlias] = m_currentLS;
 
   }
 
   // If this LS is valid (i.e. all events recorded with stable beams)
   if(m_currentLSValid && m_beamConfig.isValid()){
 
     if(m_verbose){cout << "[L1TSync_Harvest] Regular call: doFractionInSync()" << endl;}
     doFractionInSync(false,false);
     
   }
   // If this LS is not valid it can be in the following context:
   //  * We still hadn't stable beam (no need to certify nothing
   //  * Beam just got unstable or dumped (we may have a complete block of data do certify)  
   else{
     
     //-> First we close all blocks from certFirstLS[] to m_currentLS-1
     for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){
 
       string theTriggerAlias = (*i).second;
       
       int fLs = m_certFirstLS[theTriggerAlias];
       int lLS = m_certLastLS [theTriggerAlias];
 
       // If this is a single LS block we do nothing (in this step)
       if(fLs == lLS){
         m_certFirstLS[theTriggerAlias] = 0;
         m_certLastLS [theTriggerAlias] = 0;
       }
       // If block is multi LS then we remove the current LS 
       else{
         m_certLastLS [theTriggerAlias] = m_currentLS-1;
       }
 
     }
     doFractionInSync(true,false);
 
     //-> Second we mark this single LS bad for all triggers
     for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){
       string theTriggerAlias = (*i).second;
       m_certFirstLS[theTriggerAlias] = m_currentLS;
       m_certLastLS [theTriggerAlias] = m_currentLS;
     }
     doFractionInSync(true,true);
 
     if(m_verbose){cout << "[L1TSync_Harvest] Error call: doFractionInSync()" << endl;}  
 
   }
 
 }

void L1TSync_Harvest::endRun	(	const edm::Run &	run,
		const edm::EventSetup &	iSetup
	)

protectedvirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 420 of file L1TSync_Harvest.cc.

References gather_cfg::cout.

                                                                           {
   
   if(m_verbose){cout << "[L1TSync_Harvest] Called endRun." << endl;}
   
   // When the run end for closing of the LS certification blocks and evaluation
   // of synchronization for that block
   doFractionInSync(true,false);    
 
 }

void L1TSync_Harvest::getBeamConfOMDS ( )

private

Member Data Documentation

DQMStore* L1TSync_Harvest::dbe

private

Definition at line 126 of file L1TSync_Harvest.h.

const std::vector< std::vector<int> >* L1TSync_Harvest::ListsPrescaleFactors

private

Definition at line 149 of file L1TSync_Harvest.h.

std::map<std::string,bool> L1TSync_Harvest::m_algoAutoSelect

private

Definition at line 157 of file L1TSync_Harvest.h.

std::map<TString,int> L1TSync_Harvest::m_algoBit

private

Definition at line 152 of file L1TSync_Harvest.h.

std::map<TString,MonitorElement*> L1TSync_Harvest::m_algoCertification

private

Definition at line 155 of file L1TSync_Harvest.h.

std::map<TString,MonitorElement*> L1TSync_Harvest::m_algoVsBunchStructure

private

Definition at line 156 of file L1TSync_Harvest.h.

L1TBeamConfiguration L1TSync_Harvest::m_beamConfig

private

Definition at line 146 of file L1TSync_Harvest.h.

std::map<TString,unsigned int> L1TSync_Harvest::m_certFirstLS

private

Definition at line 153 of file L1TSync_Harvest.h.

std::map<TString,unsigned int> L1TSync_Harvest::m_certLastLS

private

Definition at line 154 of file L1TSync_Harvest.h.

unsigned int L1TSync_Harvest::m_currentLS

private

Definition at line 141 of file L1TSync_Harvest.h.

bool L1TSync_Harvest::m_currentLSValid

private

Definition at line 136 of file L1TSync_Harvest.h.

MonitorElement* L1TSync_Harvest::m_ErrorMonitor

private

Definition at line 161 of file L1TSync_Harvest.h.

edm::InputTag L1TSync_Harvest::m_l1GtDataDaqInputTag

private

Definition at line 166 of file L1TSync_Harvest.h.

edm::InputTag L1TSync_Harvest::m_l1GtEvmSource

private

Definition at line 165 of file L1TSync_Harvest.h.

unsigned int L1TSync_Harvest::m_lhcFill

private

Definition at line 143 of file L1TSync_Harvest.h.

std::string L1TSync_Harvest::m_outputFile

private

Definition at line 132 of file L1TSync_Harvest.h.

edm::ParameterSet L1TSync_Harvest::m_parameters

private

Definition at line 129 of file L1TSync_Harvest.h.

bool* L1TSync_Harvest::m_processedLS

private

Definition at line 137 of file L1TSync_Harvest.h.

int L1TSync_Harvest::m_refPrescaleSet

private

Definition at line 140 of file L1TSync_Harvest.h.

edm::InputTag L1TSync_Harvest::m_scalersSource

private

Definition at line 164 of file L1TSync_Harvest.h.

std::map<std::string,std::string> L1TSync_Harvest::m_selectedTriggers

private

Definition at line 158 of file L1TSync_Harvest.h.

bool L1TSync_Harvest::m_verbose

private

Definition at line 135 of file L1TSync_Harvest.h.

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation