|
|
|
#include <L1TBPTX.h>
Public Types | |
| enum | BeamMode { NOMODE = 1, SETUP = 2, INJPILOT = 3, INJINTR = 4, INJNOMN = 5, PRERAMP = 6, RAMP = 7, FLATTOP = 8, SQUEEZE = 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 Member Functions | |
| L1TBPTX (const edm::ParameterSet &ps) | |
| virtual | ~L1TBPTX () |
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. | |
| void | endJob (void) |
| virtual void | endLuminosityBlock (edm::LuminosityBlock const &lumiBlock, edm::EventSetup const &c) |
| void | endRun (const edm::Run &run, const edm::EventSetup &iSetup) |
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 |
| std::map< int, TString > | m_algoBit_Alias |
| BeamConfiguration | m_beamConfig |
| unsigned int | m_currentGTLS |
| unsigned int | m_currentLS |
| bool | m_currentLSValid |
| int | m_currentPrescalesIndex |
| std::map< TString, int > | m_effDenominator |
| std::map< TString, int > | m_effNumerator |
| MonitorElement * | m_ErrorMonitor |
| edm::InputTag | m_l1GtDataDaqInputTag |
| edm::InputTag | m_l1GtEvmSource |
| std::map< std::pair< bool, int > , double > | m_l1Rate |
| unsigned int | m_lhcFill |
| std::map< TString, MonitorElement * > | m_meAlgoEfficiency |
| std::map< TString, MonitorElement * > | m_meAlgoMissFire |
| std::map< std::pair< bool, int > , MonitorElement * > | m_meRate |
| std::map< TString, MonitorElement * > | m_meTechEfficiency |
| std::map< TString, MonitorElement * > | m_meTechMissFire |
| std::map< TString, int > | m_missFireDenominator |
| std::map< TString, int > | m_missFireNumerator |
| std::vector< edm::ParameterSet > | m_monitorBits |
| std::vector< edm::ParameterSet > | m_monitorRates |
| std::string | m_outputFile |
| edm::ParameterSet | m_parameters |
| const std::vector< std::vector < int > > * | m_prescaleFactorsAlgoTrig |
| const std::vector< std::vector < int > > * | m_prescaleFactorsTechTrig |
| bool * | m_processedLS |
| int | m_refPrescaleSet |
| edm::InputTag | m_scalersSource |
| std::vector< std::pair< int, int > > | m_selAlgoBit |
| std::vector< std::pair< int, int > > | m_selTechBit |
| std::map< int, TString > | m_techBit_Alias |
| bool | m_verbose |
| enum L1TBPTX::BeamMode |
| enum L1TBPTX::Errors |
| 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 95 of file L1TBPTX.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
};
| L1TBPTX::L1TBPTX | ( | const edm::ParameterSet & | ps | ) |
Definition at line 36 of file L1TBPTX.cc.
References edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), i, evf::evtn::offset(), and cppFunctionSkipper::operator.
{
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");
m_monitorBits = pset.getParameter< vector<ParameterSet> >("MonitorBits");
for(unsigned i=0; i<m_monitorBits.size(); i++){
// Algorithms
if(m_monitorBits[i].getParameter<bool>("bitType")){
int bit = m_monitorBits[i].getParameter<int>("bitNumber");
int offset = m_monitorBits[i].getParameter<int>("bitOffset");
m_selAlgoBit.push_back( pair<int,int>(bit,offset) );
}
// Tech
else{
int bit = m_monitorBits[i].getParameter<int>("bitNumber");
int offset = m_monitorBits[i].getParameter<int>("bitOffset");
m_selTechBit.push_back( pair<int,int>(bit,offset) );
}
}
m_monitorRates = pset.getParameter< vector<ParameterSet> >("MonitorRates");
if (pset.getUntrackedParameter < bool > ("dqmStore", false)) {
dbe = Service < DQMStore > ().operator->();
dbe->setVerbose(0);
}
}
| L1TBPTX::~L1TBPTX | ( | ) | [virtual] |
Definition at line 77 of file L1TBPTX.cc.
{}
| void L1TBPTX::analyze | ( | const edm::Event & | e, |
| const edm::EventSetup & | c | ||
| ) | [protected, virtual] |
Implements edm::EDAnalyzer.
Definition at line 352 of file L1TBPTX.cc.
References a, L1GtfeExtWord::beamMode(), gather_cfg::cout, edm::Event::getByLabel(), i, edm::EventBase::id(), edm::HandleBase::isValid(), L1GtfeExtWord::lhcFillNumber(), evf::evtn::offset(), and edm::EventID::run().
{
if(m_verbose){cout << "[L1TBPTX] Called analyze." << endl;}
// We only start analyzing if current LS is still valid
if(m_currentLSValid){
if(m_verbose){cout << "[L1TBPTX] -> 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_verbose){cout << "[L1TBPTX] Beam mode: "<< lhcBeamMode << endl;}
if(lhcBeamMode==RAMP || lhcBeamMode==FLATTOP || lhcBeamMode==SQUEEZE || lhcBeamMode==ADJUST || lhcBeamMode==STABLE){
if(m_lhcFill==0){
if(m_verbose){cout << "[L1TBPTX] No valid bunch structure yet retrived. Attemptting to retrive..." << endl;}
m_lhcFill = gtfeEvmWord.lhcFillNumber(); // Getting LHC Fill Number from GT
getBeamConfOMDS(); // Getting Beam Configuration from OMDS
// We are between RAMP and STABLE so there should be some colliding bunches
// in the machine. If 0 colliding bunched are found might be due to a delay
// of the update of the database. So we declare this LS as invalid and try
// again on the next one.
if(m_beamConfig.nCollidingBunches<=0){
m_lhcFill=0;
m_currentLSValid=false;
}
}
}
else{m_currentLSValid=false;}
}else{
int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
eCount++;
m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT,eCount);
}
}
//______________________________________________________________________________
// If current LS is valid and Beam Configuration is Valid we analyse this event
//______________________________________________________________________________
if(m_currentLSValid && m_beamConfig.isValid()){
if(m_verbose){cout << "Current event in valid LS and beam config" << endl;}
// 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();
// Getting the index for the fdl data for this event
int eventFDL=0;
for(unsigned int i=0; i<gtFdlVectorData.size(); i++){
if(gtFdlVectorData[i].bxInEvent()==0){eventFDL=i; break;}
}
m_currentPrescalesIndex = gtFdlVectorData[eventFDL].gtPrescaleFactorIndexAlgo();
for(unsigned i=0; i<m_monitorBits.size(); i++){
TString triggerName = "";
bool isAlgo = m_monitorBits[i].getParameter<bool>("bitType");
int bit = m_monitorBits[i].getParameter<int> ("bitNumber");
int offset = m_monitorBits[i].getParameter<int> ("bitOffset");
if(isAlgo){triggerName = "algo_"+bit;}
else {triggerName = "tech_"+bit;}
int evBxStart = -2;
int evBxEnd = 2;
if(offset<0){evBxStart+=-1*offset;}
if(offset>0){evBxEnd +=-1*offset;}
for(unsigned a=0; a<gtFdlVectorData.size(); a++){
int testBx = gtFdlVectorData[a].localBxNr()-offset;
bool lhcBxFilled = m_beamConfig.beam1[testBx] && m_beamConfig.beam2[testBx];
bool algoFired = false;
if(isAlgo){
if(gtFdlVectorData[a].gtDecisionWord()[bit]){algoFired=true;}
}
else{
if(gtFdlVectorData[a].gtTechnicalTriggerWord()[bit]){algoFired=true;}
}
if(lhcBxFilled) {m_effDenominator[triggerName]++;}
if(lhcBxFilled && algoFired){m_effNumerator [triggerName]++;}
if(algoFired) {m_missFireNumerator[triggerName]++;}
if(algoFired && !lhcBxFilled){m_missFireNumerator[triggerName]++;}
}
}
}
}
//______________________________________________________________________________
// Rate calculation
//______________________________________________________________________________
edm::Handle<Level1TriggerScalersCollection> triggerScalers;
iEvent.getByLabel(m_scalersSource,triggerScalers);
if(triggerScalers.isValid()){
Level1TriggerScalersCollection::const_iterator itL1TScalers = triggerScalers->begin();
Level1TriggerRates trigRates(*itL1TScalers,iEvent.id().run());
m_currentGTLS= (*itL1TScalers).lumiSegmentNr();
for(unsigned i=0; i<m_monitorRates.size(); i++){
bool isAlgo = m_monitorRates[i].getParameter<bool>("bitType");
int bit = m_monitorRates[i].getParameter<int> ("bitNumber");
pair<bool,int> refTrig = pair<bool,int>(isAlgo,bit);
if(isAlgo){m_l1Rate[refTrig] = trigRates.gtAlgoCountsRate()[bit];}
else {m_l1Rate[refTrig] = trigRates.gtTechCountsRate()[bit];}
}
}
}
| void L1TBPTX::beginJob | ( | void | ) | [protected, virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 81 of file L1TBPTX.cc.
References gather_cfg::cout, cppFunctionSkipper::operator, DQMStore::rmdir(), and DQMStore::setCurrentFolder().
| void L1TBPTX::beginLuminosityBlock | ( | edm::LuminosityBlock const & | lumiBlock, |
| edm::EventSetup const & | c | ||
| ) | [protected, virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 236 of file L1TBPTX.cc.
References gather_cfg::cout, i, edm::LuminosityBlockBase::id(), and edm::LuminosityBlockID::luminosityBlock().
{
if (m_verbose){cout << "[L1TBPTX] Called beginLuminosityBlock." << endl;}
// Updating current LS number
m_currentLS = lumiBlock.id().luminosityBlock();
// A LS will be valid if BeamMode==STABLE for all events monitored
m_currentLSValid = true;
for(unsigned i=0; i<m_monitorBits.size(); i++){
TString triggerName = "";
if(m_monitorBits[i].getParameter<bool>("bitType")){
triggerName = "algo_"+m_monitorBits[i].getParameter<int>("bitNumber");
}else{
triggerName = "tech_"+m_monitorBits[i].getParameter<int>("bitNumber");
}
m_effNumerator [triggerName] = 0;
m_effDenominator [triggerName] = 0;
m_missFireNumerator [triggerName] = 0;
m_missFireDenominator[triggerName] = 0;
}
}
| void L1TBPTX::beginRun | ( | const edm::Run & | run, |
| const edm::EventSetup & | iSetup | ||
| ) | [protected, virtual] |
BeginRun.
Reimplemented from edm::EDAnalyzer.
Definition at line 112 of file L1TBPTX.cc.
References gather_cfg::cout, edm::EventSetup::get(), L1GtTriggerMenu::gtAlgorithmAliasMap(), L1GtPrescaleFactors::gtPrescaleFactors(), L1GtTriggerMenu::gtTechnicalTriggerMap(), i, edm::ESHandleBase::isValid(), relval_steps::menu, edm::ESHandle< T >::product(), and pat::UNKNOWN.
{
if (m_verbose){cout << "[L1TBPTX] Called beginRun." << endl;}
// Initializing variables
int maxNbins = 2501;
// Reseting run dependent variables
m_lhcFill = 0;
m_currentLS = 0;
// 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_Alias[(algo->second).algoBitNumber()] = (algo->second).algoAlias();
}
for (CItAlgo algo = menu->gtTechnicalTriggerMap().begin(); algo!=menu->gtTechnicalTriggerMap().end(); ++algo){
m_techBit_Alias[(algo->second).algoBitNumber()] = (algo->second).algoName();
}
// Initializing DQM Monitor Elements
dbe->setCurrentFolder("L1T/L1TBPTX");
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");
for(unsigned i=0; i<m_monitorBits.size(); i++){
bool isAlgo = m_monitorBits[i].getParameter<bool> ("bitType");
TString testName = m_monitorBits[i].getParameter<string>("testName");
int bit = m_monitorBits[i].getParameter<int> ("bitNumber");
TString meTitle = "";
dbe->setCurrentFolder("L1T/L1TBPTX/Efficiency/");
if(isAlgo){
meTitle="Algo ";meTitle+=bit; meTitle+=" - "; meTitle+=m_algoBit_Alias[bit]; meTitle+=" Efficiency";
m_meAlgoEfficiency[bit] = dbe->book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
m_meAlgoEfficiency[bit]->setAxisTitle("Lumi Section" ,1);
}
else{
meTitle="Tech "; meTitle+=bit; meTitle+=" - "; meTitle+=m_techBit_Alias[bit]; meTitle+=" Efficiency";
m_meTechEfficiency[bit] = dbe->book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
m_meTechEfficiency[bit]->setAxisTitle("Lumi Section" ,1);
}
meTitle = "";
dbe->setCurrentFolder("L1T/L1TBPTX/MissFire/");
if(isAlgo){
meTitle="Algo "; meTitle+=bit; meTitle+=" - "; meTitle+=m_algoBit_Alias[bit]; meTitle+="(1 - Miss Fire Rate)";
m_meAlgoMissFire[bit] = dbe->book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
m_meAlgoMissFire[bit]->setAxisTitle("Lumi Section" ,1);
m_meAlgoMissFire[bit]->setAxisTitle("1 - Miss Fire Rate",2);
}
else{
meTitle="Tech "; meTitle+=bit; meTitle+=" - "; meTitle+=m_techBit_Alias[bit]; meTitle+="(1 - Miss Fire Rate)";
m_meTechMissFire[bit] = dbe->book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
m_meTechMissFire[bit]->setAxisTitle("Lumi Section" ,1);
m_meTechMissFire[bit]->setAxisTitle("1 - Miss Fire Rate",2);
}
}
for(unsigned i=0; i<m_monitorRates.size(); i++){
TString testName = m_monitorRates[i].getParameter<string>("testName");
bool isAlgo = m_monitorRates[i].getParameter<bool> ("bitType");
int bit = m_monitorRates[i].getParameter<int> ("bitNumber");
pair<bool,int> refME = pair<bool,int>(isAlgo,bit);
TString meTitle = "";
dbe->setCurrentFolder("L1T/L1TBPTX/Rate/");
if(isAlgo){
meTitle="Algo "+bit; meTitle+=" - "; meTitle+=m_algoBit_Alias[bit]; meTitle+=" Rate";
m_meRate[refME] = dbe->book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
m_meRate[refME]->setAxisTitle("Lumi Section" ,1);
m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]",2);
}
else{
meTitle="Tech "+bit; meTitle+=" - "; meTitle+=m_techBit_Alias[bit]; meTitle+=" Rate";
m_meRate[refME] = dbe->book1D(testName,meTitle,maxNbins,-0.5,double(maxNbins)-0.5);
m_meRate[refME]->setAxisTitle("Lumi Section" ,1);
m_meRate[refME]->setAxisTitle("Rate (unprescaled) [Hz]",2);
}
}
//_____________________________________________________________________
// Getting the prescale columns definition for this run
ESHandle<L1GtPrescaleFactors> l1GtPfAlgo;
ESHandle<L1GtPrescaleFactors> l1GtPfTech;
iSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
iSetup.get<L1GtPrescaleFactorsTechTrigRcd>().get(l1GtPfTech);
if(l1GtPfAlgo.isValid()){
const L1GtPrescaleFactors* m_l1GtPfAlgo = l1GtPfAlgo.product();
m_prescaleFactorsAlgoTrig = &(m_l1GtPfAlgo->gtPrescaleFactors());
}else{
//TODO: Some error handling
}
if(l1GtPfAlgo.isValid()){
const L1GtPrescaleFactors* m_l1GtPfTech = l1GtPfTech.product();
m_prescaleFactorsTechTrig = &(m_l1GtPfTech->gtPrescaleFactors());
}else{
//TODO: Some error handling
}
}
| void L1TBPTX::certifyLSBlock | ( | std::string | iTrigger, |
| int | iInitLs, | ||
| int | iEndLs, | ||
| float | iValue | ||
| ) | [private] |
| void L1TBPTX::doFractionInSync | ( | bool | iForce = false, |
| bool | iBad = false |
||
| ) | [private] |
Definition at line 569 of file L1TBPTX.cc.
{
}
| void L1TBPTX::endJob | ( | void | ) | [protected, virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 98 of file L1TBPTX.cc.
References gather_cfg::cout.
{
if (m_verbose){cout << "[L1TBPTX] Called endJob." << endl;}
if (m_outputFile.size() != 0 && dbe)
dbe->save(m_outputFile);
return;
}
| void L1TBPTX::endLuminosityBlock | ( | edm::LuminosityBlock const & | lumiBlock, |
| edm::EventSetup const & | c | ||
| ) | [protected, virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 268 of file L1TBPTX.cc.
References newFWLiteAna::bin, gather_cfg::cout, and i.
{
//______________________________________________________________________________
// Monitoring efficiencies
//______________________________________________________________________________
if(m_verbose){cout << "[L1TBPTX] Called endLuminosityBlock." << endl;}
// If this LS is valid (i.e. all events recorded with stable beams)
if(m_currentLSValid && m_beamConfig.isValid()){
for(unsigned i=0; i<m_monitorBits.size(); i++){
bool isAlgo = m_monitorBits[i].getParameter<bool> ("bitType");
TString testName = m_monitorBits[i].getParameter<string>("testName");
int bit = m_monitorBits[i].getParameter<int> ("bitNumber");
TString triggerName;
if(isAlgo){triggerName = "algo_"+bit;}
else {triggerName = "tech_"+bit;}
double valEff;
double valMiss;
if(m_effDenominator[triggerName]!=0) {valEff = (double)m_effNumerator[triggerName]/m_effDenominator[triggerName];}
else {valEff = 0;}
if(m_missFireDenominator[triggerName]!=0){valMiss = (double)m_missFireNumerator[triggerName]/m_missFireDenominator[triggerName];}
else {valMiss = 0;}
if(isAlgo){
int bin = m_meAlgoEfficiency[bit]->getTH1()->FindBin(m_currentLS);
m_meAlgoEfficiency[bit]->setBinContent(bin,valEff);
m_meAlgoMissFire[bit] ->setBinContent(bin,1-valMiss);
}
else{
int bin = m_meTechEfficiency[bit]->getTH1()->FindBin(m_currentLS);
m_meTechEfficiency[bit]->setBinContent(bin,valEff);
m_meTechMissFire[bit] ->setBinContent(bin,1-valMiss);
}
}
}
//______________________________________________________________________________
// Monitoring rates
//______________________________________________________________________________
// We are only interested in monitoring lumisections where the the LHC state is
// RAMP, FLATTOP, SQUEEZE, ADJUST or STABLE since the bunch configuration and
// therefore the BPTX rate will not change.
if(m_currentLSValid){
const vector<int>& currentPFAlgo = (*m_prescaleFactorsAlgoTrig).at(m_currentPrescalesIndex);
const vector<int>& currentPFTech = (*m_prescaleFactorsTechTrig).at(m_currentPrescalesIndex);
for(unsigned i=0; i<m_monitorRates.size(); i++){
bool isAlgo = m_monitorRates[i].getParameter<bool> ("bitType");
int bit = m_monitorRates[i].getParameter<int> ("bitNumber");
pair<bool,int> refME = pair<bool,int>(isAlgo,bit);
if(isAlgo){
int bin = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
int trigPS = currentPFAlgo[bit];
double trigRate = (double) trigPS*m_l1Rate[refME];
m_meRate[refME]->setBinContent(bin,trigRate);
}else{
int bin = m_meRate[refME]->getTH1()->FindBin(m_currentGTLS);
int trigPS = currentPFTech[bit];
double trigRate = (double) trigPS*m_l1Rate[refME];
m_meRate[refME]->setBinContent(bin,trigRate);
}
}
}
}
| void L1TBPTX::endRun | ( | const edm::Run & | run, |
| const edm::EventSetup & | iSetup | ||
| ) | [protected, virtual] |
Reimplemented from edm::EDAnalyzer.
Definition at line 344 of file L1TBPTX.cc.
References gather_cfg::cout.
| void L1TBPTX::getBeamConfOMDS | ( | ) | [private] |
Definition at line 498 of file L1TBPTX.cc.
References gather_cfg::cout, L1TOMDSHelper::NO_ERROR, pat::UNKNOWN, L1TOMDSHelper::WARNING_DB_CONN_FAILED, L1TOMDSHelper::WARNING_DB_INCORRECT_NBUNCHES, and L1TOMDSHelper::WARNING_DB_QUERY_FAILED.
{
if(m_verbose){cout << "[L1TBPTX] Called getBeamConfOMDS()" << endl;}
//Getting connection paremeters
string oracleDB = m_parameters.getParameter<string>("oracleDB");
string pathCondDB = m_parameters.getParameter<string>("pathCondDB");
// Connecting to OMDS
L1TOMDSHelper myOMDSHelper = L1TOMDSHelper();
int conError;
myOMDSHelper.connect(oracleDB,pathCondDB,conError);
if(conError == L1TOMDSHelper::NO_ERROR){
if(m_verbose){cout << "[L1TBPTX] Connected to DB with no error." << endl;}
int errorRetrive;
m_beamConfig = myOMDSHelper.getBeamConfiguration(m_lhcFill,errorRetrive);
if(errorRetrive == L1TOMDSHelper::NO_ERROR){
if(m_verbose){
cout << "[L1TBPTX] Retriving LHC Bunch Structure: NO_ERROR" << endl;
cout << "[L1TSync] -> LHC Bunch Structure valid=" << m_beamConfig.m_valid << " nBunches=" << m_beamConfig.nCollidingBunches << endl;
}
}
else if(errorRetrive == L1TOMDSHelper::WARNING_DB_QUERY_FAILED){
if(m_verbose){cout << "[L1TBPTX] Retriving LHC Bunch Structure: WARNING_DB_QUERY_FAILED" << endl;}
int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_QUERY_FAILED);
eCount++;
m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_QUERY_FAILED,eCount);
}
else if(errorRetrive == L1TOMDSHelper::WARNING_DB_INCORRECT_NBUNCHES){
if(m_verbose){cout << "[L1TBPTX] Retriving LHC Bunch Structure: WARNING_DB_INCORRECT_NBUNCHES" << endl;}
int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_INCORRECT_NBUNCHES);
eCount++;
m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_INCORRECT_NBUNCHES,eCount);
}
else{
if(m_verbose){cout << "[L1TBPTX] Retriving LHC Bunch Structure: UNKNOWN" << endl;}
int eCount = m_ErrorMonitor->getTH1()->GetBinContent(UNKNOWN);
eCount++;
m_ErrorMonitor->getTH1()->SetBinContent(UNKNOWN,eCount);
}
}
else if(conError == L1TOMDSHelper::WARNING_DB_CONN_FAILED){
if(m_verbose){cout << "[L1TBPTX] Connection to DB: WARNING_DB_CONN_FAILED" << endl;}
int eCount = m_ErrorMonitor->getTH1()->GetBinContent(WARNING_DB_CONN_FAILED);
eCount++;
m_ErrorMonitor->getTH1()->SetBinContent(WARNING_DB_CONN_FAILED,eCount);
}
else{
if(m_verbose){cout << "[L1TBPTX] Connection to DB: UNKNOWN" << endl;}
int eCount = m_ErrorMonitor->getTH1()->GetBinContent(UNKNOWN);
eCount++;
m_ErrorMonitor->getTH1()->SetBinContent(UNKNOWN,eCount);
}
}
DQMStore* L1TBPTX::dbe [private] |
std::map<int,TString> L1TBPTX::m_algoBit_Alias [private] |
BeamConfiguration L1TBPTX::m_beamConfig [private] |
unsigned int L1TBPTX::m_currentGTLS [private] |
unsigned int L1TBPTX::m_currentLS [private] |
bool L1TBPTX::m_currentLSValid [private] |
int L1TBPTX::m_currentPrescalesIndex [private] |
std::map<TString,int> L1TBPTX::m_effDenominator [private] |
std::map<TString,int> L1TBPTX::m_effNumerator [private] |
MonitorElement* L1TBPTX::m_ErrorMonitor [private] |
edm::InputTag L1TBPTX::m_l1GtDataDaqInputTag [private] |
edm::InputTag L1TBPTX::m_l1GtEvmSource [private] |
std::map<std::pair<bool,int>,double> L1TBPTX::m_l1Rate [private] |
unsigned int L1TBPTX::m_lhcFill [private] |
std::map<TString,MonitorElement*> L1TBPTX::m_meAlgoEfficiency [private] |
std::map<TString,MonitorElement*> L1TBPTX::m_meAlgoMissFire [private] |
std::map<std::pair<bool,int>,MonitorElement*> L1TBPTX::m_meRate [private] |
std::map<TString,MonitorElement*> L1TBPTX::m_meTechEfficiency [private] |
std::map<TString,MonitorElement*> L1TBPTX::m_meTechMissFire [private] |
std::map<TString,int> L1TBPTX::m_missFireDenominator [private] |
std::map<TString,int> L1TBPTX::m_missFireNumerator [private] |
std::vector<edm::ParameterSet> L1TBPTX::m_monitorBits [private] |
std::vector<edm::ParameterSet> L1TBPTX::m_monitorRates [private] |
std::string L1TBPTX::m_outputFile [private] |
edm::ParameterSet L1TBPTX::m_parameters [private] |
const std::vector<std::vector<int> >* L1TBPTX::m_prescaleFactorsAlgoTrig [private] |
const std::vector<std::vector<int> >* L1TBPTX::m_prescaleFactorsTechTrig [private] |
bool* L1TBPTX::m_processedLS [private] |
int L1TBPTX::m_refPrescaleSet [private] |
edm::InputTag L1TBPTX::m_scalersSource [private] |
std::vector< std::pair<int,int> > L1TBPTX::m_selAlgoBit [private] |
std::vector< std::pair<int,int> > L1TBPTX::m_selTechBit [private] |
std::map<int,TString> L1TBPTX::m_techBit_Alias [private] |
bool L1TBPTX::m_verbose [private] |
1.7.3