Reference Manual

Go to the documentation of this file.
00001 
00002 /*
00003  * \class L1TSync_Offline
00004  *
00005  *
00006  * Description: offline DQM module for L1Trigger/bunchStructure synchronization
00007  * 
00008  * Implementation:
00009  *   <TODO: enter implementation details>
00010  *
00011  * \author: Pietro Vischia - LIP Lisbon pietro.vischia@gmail.com
00012  *
00013  * Changelog:
00014  *    2012/08/10 11:01:01: First creation. Dummy module with actual code commented.
00015  *
00016  * Todo:
00017  *  - implement the module in offline
00018  *  - check if there are user includes specific for offline/online that should be changed
00019  *
00020  * $Date: 2012/12/11 10:36:34 $
00021  * $Revision: 1.2 $
00022  *
00023  */
00024 
00025 // 
00026 
00027 // This class header
00028 #include "DQMOffline/L1Trigger/interface/L1TSync_Offline.h"
00029 
00030 // System include files
00031 // --
00032 
00033 // User include files
00034 #include "DQMServices/Core/interface/DQMStore.h"
00035 
00036 #include "DataFormats/Scalers/interface/LumiScalers.h"
00037 #include "DataFormats/Scalers/interface/Level1TriggerRates.h"
00038 #include "DataFormats/Scalers/interface/Level1TriggerScalers.h"
00039 
00040 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerReadoutRecord.h"
00041 #include "DataFormats/L1GlobalTrigger/interface/L1GlobalTriggerEvmReadoutRecord.h"
00042 
00043 #include "DataFormats/Common/interface/ConditionsInEdm.h" // Parameters associated to Run, LS and Event
00044 
00045 #include "CondFormats/L1TObjects/interface/L1GtTriggerMenuFwd.h"
00046 #include "CondFormats/L1TObjects/interface/L1GtTriggerMenu.h"
00047 #include "CondFormats/L1TObjects/interface/L1GtPrescaleFactors.h"
00048 #include "CondFormats/DataRecord/interface/L1GtTriggerMenuRcd.h"
00049 #include "CondFormats/DataRecord/interface/L1GtPrescaleFactorsAlgoTrigRcd.h"
00050 #include "CondFormats/L1TObjects/interface/L1GtMuonTemplate.h"
00052 // Luminosity Information
00053 //#include "DataFormats/Luminosity/interface/LumiDetails.h"
00054 //#include "DataFormats/Luminosity/interface/LumiSummary.h"
00055 
00056 // L1TMonitor includes
00058 #include "DQMOffline/L1Trigger/interface/L1TMenuHelper.h"
00059 
00060 #include "TList.h"
00061 
00062 using namespace edm;
00063 using namespace std;
00064 
00065 //-------------------------------------------------------------------------------------
00066 //-------------------------------------------------------------------------------------
00067 L1TSync_Offline::L1TSync_Offline(const ParameterSet & pset){
00068 
00069   m_parameters = pset;
00070   
00071   // Mapping parameter input variables
00072   m_scalersSource       = pset.getParameter         <InputTag>("inputTagScalersResults");
00073   m_l1GtDataDaqInputTag = pset.getParameter         <InputTag>("inputTagL1GtDataDaq");
00074   m_l1GtEvmSource       = pset.getParameter         <InputTag>("inputTagtEvmSource");
00075   m_verbose             = pset.getUntrackedParameter<bool>    ("verbose",false);
00076   m_refPrescaleSet      = pset.getParameter         <int>     ("refPrescaleSet");  
00077 
00078   // Getting which categories to monitor
00079   ParameterSet Categories = pset.getParameter< ParameterSet >("Categories");
00080 
00081   bool forceGlobalParameters = Categories.getParameter<bool>("forceGlobalParameters");
00082   bool doGlobalAutoSelection = Categories.getParameter<bool>("doGlobalAutoSelection");
00083 
00084   ParameterSet CatBPTX    = Categories.getParameter<ParameterSet>("BPTX");
00085   ParameterSet CatMu      = Categories.getParameter<ParameterSet>("Mu");  
00086   ParameterSet CatEG      = Categories.getParameter<ParameterSet>("EG");  
00087   ParameterSet CatIsoEG   = Categories.getParameter<ParameterSet>("IsoEG");  
00088   ParameterSet CatJet     = Categories.getParameter<ParameterSet>("Jet");  
00089   ParameterSet CatCenJet  = Categories.getParameter<ParameterSet>("CenJet");  
00090   ParameterSet CatForJet  = Categories.getParameter<ParameterSet>("ForJet");  
00091   ParameterSet CatTauJet  = Categories.getParameter<ParameterSet>("TauJet");  
00092   ParameterSet CatETM     = Categories.getParameter<ParameterSet>("ETT");  
00093   ParameterSet CatETT     = Categories.getParameter<ParameterSet>("ETM");  
00094   ParameterSet CatHTT     = Categories.getParameter<ParameterSet>("HTT");  
00095   ParameterSet CatHTM     = Categories.getParameter<ParameterSet>("HTM");  
00096 
00097   // --> Setting parameters related to which algos to monitor
00098   // If global parameters are forced they take precedence over algo-by-algo parameters 
00099   if(forceGlobalParameters){
00100 
00101     // If global automatic selection if enable all categories set to be monitored will have
00102     // their algos auto selected (the lowest prescale algo will be selected) 
00103     if(doGlobalAutoSelection){
00104  
00105       if(CatMu    .getParameter<bool>("monitor")){m_algoAutoSelect["Mu"]     = true;}else{m_algoAutoSelect["Mu"]     = false;}
00106       if(CatEG    .getParameter<bool>("monitor")){m_algoAutoSelect["EG"]     = true;}else{m_algoAutoSelect["EG"]     = false;}
00107       if(CatIsoEG .getParameter<bool>("monitor")){m_algoAutoSelect["IsoEG"]  = true;}else{m_algoAutoSelect["IsoEG"]  = false;}
00108       if(CatJet   .getParameter<bool>("monitor")){m_algoAutoSelect["Jet"]    = true;}else{m_algoAutoSelect["Jet"]    = false;}
00109       if(CatCenJet.getParameter<bool>("monitor")){m_algoAutoSelect["CenJet"] = true;}else{m_algoAutoSelect["CenJet"] = false;}
00110       if(CatForJet.getParameter<bool>("monitor")){m_algoAutoSelect["ForJet"] = true;}else{m_algoAutoSelect["ForJet"] = false;}
00111       if(CatTauJet.getParameter<bool>("monitor")){m_algoAutoSelect["TauJet"] = true;}else{m_algoAutoSelect["TauJet"] = false;}
00112       if(CatETM   .getParameter<bool>("monitor")){m_algoAutoSelect["ETM"]    = true;}else{m_algoAutoSelect["ETM"]    = false;}
00113       if(CatETT   .getParameter<bool>("monitor")){m_algoAutoSelect["ETT"]    = true;}else{m_algoAutoSelect["ETT"]    = false;}
00114       if(CatHTM   .getParameter<bool>("monitor")){m_algoAutoSelect["HTM"]    = true;}else{m_algoAutoSelect["HTM"]    = false;}
00115       if(CatHTT   .getParameter<bool>("monitor")){m_algoAutoSelect["HTT"]    = true;}else{m_algoAutoSelect["HTT"]    = false;}
00116 
00117     // If global non-automatic selection is enable all categories set to be monitored will use
00118     // user defined algos
00119     }else{
00120 
00121       m_algoAutoSelect["Mu"]     = false;
00122       m_algoAutoSelect["EG"]     = false;
00123       m_algoAutoSelect["IsoEG"]  = false;
00124       m_algoAutoSelect["Jet"]    = false;
00125       m_algoAutoSelect["CenJet"] = false;
00126       m_algoAutoSelect["ForJet"] = false;
00127       m_algoAutoSelect["TauJet"] = false;
00128       m_algoAutoSelect["ETM"]    = false;
00129       m_algoAutoSelect["ETT"]    = false;
00130       m_algoAutoSelect["HTM"]    = false;
00131       m_algoAutoSelect["HTT"]    = false;   
00132 
00133       if(CatMu    .getParameter<bool>("monitor")){m_selectedTriggers["Mu"]        = CatMu    .getParameter<string>("algo");}
00134       if(CatEG    .getParameter<bool>("monitor")){m_selectedTriggers["EG"]        = CatEG    .getParameter<string>("algo");}
00135       if(CatIsoEG .getParameter<bool>("monitor")){m_selectedTriggers["IsoEG"]     = CatIsoEG .getParameter<string>("algo");}
00136       if(CatJet   .getParameter<bool>("monitor")){m_selectedTriggers["Jet"]       = CatJet   .getParameter<string>("algo");}
00137       if(CatCenJet.getParameter<bool>("monitor")){m_selectedTriggers["CenJet"]    = CatCenJet.getParameter<string>("algo");}
00138       if(CatForJet.getParameter<bool>("monitor")){m_selectedTriggers["CatForJet"] = CatForJet.getParameter<string>("algo");}
00139       if(CatTauJet.getParameter<bool>("monitor")){m_selectedTriggers["TauJet"]    = CatTauJet.getParameter<string>("algo");}
00140       if(CatETM   .getParameter<bool>("monitor")){m_selectedTriggers["ETM"]       = CatETM   .getParameter<string>("algo");}
00141       if(CatETT   .getParameter<bool>("monitor")){m_selectedTriggers["ETT"]       = CatETT   .getParameter<string>("algo");}
00142       if(CatHTM   .getParameter<bool>("monitor")){m_selectedTriggers["HTM"]       = CatHTM   .getParameter<string>("algo");}
00143       if(CatHTT   .getParameter<bool>("monitor")){m_selectedTriggers["HTT"]       = CatHTT   .getParameter<string>("algo");}
00144 
00145     }
00146 
00147   // If we are using algo-by-algo parametes we get them and set what is needed
00148   }else{
00149 
00150     if(CatBPTX.getParameter<bool>("monitor")){
00151       m_selectedTriggers["BPTX"] = CatBPTX.getParameter<string>("algo");
00152     }
00153 
00154     if(CatMu.getParameter<bool>("monitor")){
00155       m_algoAutoSelect["Mu"] = CatMu.getParameter<bool>("doAutoSelection");
00156       if(!m_algoAutoSelect["Mu"]){m_selectedTriggers["Mu"] = CatMu.getParameter<string>("algo");}
00157     }else{m_algoAutoSelect["Mu"] = false;}
00158 
00159     if(CatEG.getParameter<bool>("monitor")){
00160       m_algoAutoSelect["EG"] = CatEG.getParameter<bool>("doAutoSelection");
00161       if(!m_algoAutoSelect["EG"]){m_selectedTriggers["EG"] = CatEG.getParameter<string>("algo");}
00162     }else{m_algoAutoSelect["EG"] = false;}
00163 
00164     if(CatIsoEG.getParameter<bool>("monitor")){
00165       m_algoAutoSelect["IsoEG"] = CatIsoEG.getParameter<bool>("doAutoSelection");
00166       if(!m_algoAutoSelect["IsoEG"]){m_selectedTriggers["IsoEG"] = CatIsoEG.getParameter<string>("algo");}
00167     }else{m_algoAutoSelect["IsoEG"] = false;}
00168 
00169     if(CatJet.getParameter<bool>("monitor")){
00170       m_algoAutoSelect["Jet"] = CatJet.getParameter<bool>("doAutoSelection");
00171       if(!m_algoAutoSelect["Jet"]){m_selectedTriggers["Jet"] = CatJet.getParameter<string>("algo");}
00172     }else{m_algoAutoSelect["Jet"] = false;}
00173 
00174     if(CatCenJet.getParameter<bool>("monitor")){
00175       m_algoAutoSelect["CenJet"] = CatCenJet.getParameter<bool>("doAutoSelection");
00176       if(!m_algoAutoSelect["CenJet"]){m_selectedTriggers["CenJet"] = CatCenJet.getParameter<string>("algo");}
00177     }else{m_algoAutoSelect["CenJet"] = false;}
00178 
00179     if(CatForJet.getParameter<bool>("monitor")){
00180       m_algoAutoSelect["CatForJet"] = CatForJet.getParameter<bool>("doAutoSelection");
00181       if(!m_algoAutoSelect["CatForJet"]){m_selectedTriggers["CatForJet"] = CatForJet.getParameter<string>("algo");}
00182     }else{m_algoAutoSelect["CatForJet"] = false;}
00183 
00184     if(CatTauJet.getParameter<bool>("monitor")){
00185       m_algoAutoSelect["TauJet"] = CatTauJet.getParameter<bool>("doAutoSelection");
00186       if(!m_algoAutoSelect["TauJet"]){m_selectedTriggers["TauJet"] = CatTauJet.getParameter<string>("algo");}
00187     }else{m_algoAutoSelect["TauJet"] = false;}
00188 
00189     if(CatETM.getParameter<bool>("monitor")){
00190       m_algoAutoSelect["ETM"] = CatETM.getParameter<bool>("doAutoSelection");
00191       if(!m_algoAutoSelect["ETM"]){m_selectedTriggers["ETM"] = CatETM.getParameter<string>("algo");}
00192     }else{m_algoAutoSelect["ETM"] = false;}
00193 
00194     if(CatETT.getParameter<bool>("monitor")){
00195       m_algoAutoSelect["ETT"] = CatETT.getParameter<bool>("doAutoSelection");
00196       if(!m_algoAutoSelect["ETT"]){m_selectedTriggers["ETT"] = CatETT.getParameter<string>("algo");}
00197     }else{m_algoAutoSelect["ETT"] = false;}
00198 
00199     if(CatHTM.getParameter<bool>("monitor")){
00200       m_algoAutoSelect["HTM"] = CatHTM.getParameter<bool>("doAutoSelection");
00201       if(!m_algoAutoSelect["HTM"]){m_selectedTriggers["HTM"] = CatHTM.getParameter<string>("algo");}
00202     }else{m_algoAutoSelect["HTM"] = false;}
00203 
00204     if(CatHTT.getParameter<bool>("monitor")){
00205       m_algoAutoSelect["HTT"] = CatHTT.getParameter<bool>("doAutoSelection");
00206       if(!m_algoAutoSelect["HTT"]){m_selectedTriggers["HTT"] = CatHTT.getParameter<string>("algo");}
00207     }else{m_algoAutoSelect["HTT"] = false;}
00208 
00209   }
00210 
00211 
00212   if (pset.getUntrackedParameter < bool > ("dqmStore", false)) {
00213     dbe = Service < DQMStore > ().operator->();
00214     dbe->setVerbose(0);
00215   }
00216 
00217   m_outputFile = pset.getUntrackedParameter < std::string > ("outputFile","");
00218 
00219   if (m_outputFile.size() != 0) {
00220     std::cout << "L1T Monitoring histograms will be saved to " <<       m_outputFile.c_str() << std::endl;
00221   }
00222 
00223   bool disable = pset.getUntrackedParameter < bool > ("disableROOToutput", false);
00224   if (disable) {m_outputFile = "";}
00225 
00226   if (dbe != NULL) {dbe->setCurrentFolder("L1T/L1TSync");}
00227 
00228 }
00229 
00230 //-------------------------------------------------------------------------------------
00231 //-------------------------------------------------------------------------------------
00232 L1TSync_Offline::~L1TSync_Offline(){}
00233 
00234 //-------------------------------------------------------------------------------------
00235 //-------------------------------------------------------------------------------------
00236 void L1TSync_Offline::beginJob(void){
00237 
00238   if (m_verbose){cout << "[L1TSync_Offline] Called beginJob." << endl;}
00239 
00240   // get hold of back-end interface
00241   DQMStore *dbe = 0;
00242   dbe = Service < DQMStore > ().operator->();
00243 
00244   if (dbe) {
00245     dbe->setCurrentFolder("L1T/L1TSync");
00246     dbe->rmdir("L1T/L1TSync");
00247   }
00248  
00249 }
00250 
00251 //-------------------------------------------------------------------------------------
00252 //-------------------------------------------------------------------------------------
00253 void L1TSync_Offline::endJob(void){
00254 
00255   if (m_verbose){cout << "[L1TSync_Offline] Called endJob." << endl;}
00256 
00257   if (m_outputFile.size() != 0 && dbe)
00258     dbe->save(m_outputFile);
00259 
00260   return;
00261 
00262 }
00263 
00264 //-------------------------------------------------------------------------------------
00266 //-------------------------------------------------------------------------------------
00267 void L1TSync_Offline::beginRun(const edm::Run& iRun, const edm::EventSetup& iSetup){
00268 
00269   if (m_verbose){cout << "[L1TSync_Offline] Called beginRun." << endl;}
00270 
00271   // Initializing variables
00272   int maxNbins = 2501;
00273 
00274   // Reseting run dependent variables
00275   m_lhcFill     = 0; 
00276   m_currentLS   = 0;
00277   m_certFirstLS.clear();
00278   m_certLastLS .clear();
00279   
00280   // Getting Trigger menu from GT
00281   ESHandle<L1GtTriggerMenu> menuRcd;
00282   iSetup.get<L1GtTriggerMenuRcd>().get(menuRcd);
00283   const L1GtTriggerMenu* menu = menuRcd.product();
00284 
00285   // Filling Alias-Bit Map
00286   for (CItAlgo algo = menu->gtAlgorithmAliasMap().begin(); algo!=menu->gtAlgorithmAliasMap().end(); ++algo){
00287     m_algoBit[(algo->second).algoAlias()] = (algo->second).algoBitNumber();
00288   }
00289 
00290   // Getting fill number for this run
00291   //Handle<ConditionsInRunBlock> runConditions;
00292   //iRun.getByType(runConditions);
00293   //int lhcFillNumber = runConditions->lhcFillNumber;
00294   //
00295   //ESHandle<L1GtPrescaleFactors> l1GtPfAlgo;
00296   //iSetup.get<L1GtPrescaleFactorsAlgoTrigRcd>().get(l1GtPfAlgo);
00297   //const L1GtPrescaleFactors* m_l1GtPfAlgo = l1GtPfAlgo.product();
00298 
00299   L1TMenuHelper myMenuHelper = L1TMenuHelper(iSetup);  
00300          
00301   m_selectedTriggers = myMenuHelper.testAlgos(m_selectedTriggers);
00302 
00303   map<string,string> tAutoSelTrig = myMenuHelper.getLUSOTrigger(m_algoAutoSelect,m_refPrescaleSet);
00304   m_selectedTriggers.insert(tAutoSelTrig.begin(),tAutoSelTrig.end());
00305 
00306   // Initializing DQM Monitor Elements
00307   dbe->setCurrentFolder("L1T/L1TSync");
00308   m_ErrorMonitor = dbe->book1D("ErrorMonitor","ErrorMonitor",7,0,7);
00309   m_ErrorMonitor->setBinLabel(UNKNOWN                      ,"UNKNOWN");
00310   m_ErrorMonitor->setBinLabel(WARNING_DB_CONN_FAILED       ,"WARNING_DB_CONN_FAILED");        // Errors from L1TOMDSHelper
00311   m_ErrorMonitor->setBinLabel(WARNING_DB_QUERY_FAILED      ,"WARNING_DB_QUERY_FAILED");       // Errors from L1TOMDSHelper
00312   m_ErrorMonitor->setBinLabel(WARNING_DB_INCORRECT_NBUNCHES,"WARNING_DB_INCORRECT_NBUNCHES"); // Errors from L1TOMDSHelper
00313   m_ErrorMonitor->setBinLabel(ERROR_UNABLE_RETRIVE_PRODUCT ,"ERROR_UNABLE_RETRIVE_PRODUCT"); 
00314   m_ErrorMonitor->setBinLabel(ERROR_TRIGGERALIAS_NOTVALID  ,"ERROR_TRIGGERALIAS_NOTVALID"); 
00315   m_ErrorMonitor->setBinLabel(ERROR_LSBLOCK_NOTVALID       ,"ERROR_LSBLOCK_NOTVALID"); 
00316 
00317   // Looping over selected triggers
00318   for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){
00319 
00320     string tCategory = (*i).first;
00321     string tTrigger  = (*i).second;
00322 
00323     // Initializing LS blocks for certification
00324     m_certFirstLS[(*i).second] = 0;
00325     m_certLastLS [(*i).second] = 0;
00326 
00327     // Initializing DQM Monitors 
00328     dbe->setCurrentFolder("L1T/L1TSync/AlgoVsBunchStructure/");
00329     m_algoVsBunchStructure[tTrigger] = dbe->book2D(tCategory,"min #Delta("+tTrigger+",Bunch)",maxNbins,-0.5,double(maxNbins)-0.5,5,-2.5,2.5);
00330     m_algoVsBunchStructure[tTrigger] ->setAxisTitle("Lumi Section" ,1);
00331     
00332     dbe->setCurrentFolder("L1T/L1TSync/Certification/");
00333     m_algoCertification[tTrigger] = dbe->book1D(tCategory, "fraction of in sync: "+tTrigger,maxNbins,-0.5,double(maxNbins)-0.5);
00334     m_algoCertification[tTrigger] ->setAxisTitle("Lumi Section" ,1);
00335 
00336  }   
00337 
00338 }
00339 
00340  //_____________________________________________________________________
00341  // Function: beginLuminosityBlock
00342  //_____________________________________________________________________
00343  void L1TSync_Offline::beginLuminosityBlock(LuminosityBlock const& lumiBlock, EventSetup const& c) {
00344  
00345    if (m_verbose){cout << "[L1TSync_Offline] Called beginLuminosityBlock." << endl;}
00346  
00347    m_currentLSValid = true; 
00348  
00349  }
00350  
00351 
00352 //_____________________________________________________________________
00353 void L1TSync_Offline::endRun(const edm::Run& run, const edm::EventSetup& iSetup){
00354   
00355   if(m_verbose){cout << "[L1TSync_Offline] Called endRun." << endl;}
00356   
00357   // When the run end for closing of the LS certification blocks and evaluation
00358   // of synchronization for that block
00359 
00360   // This will be for Harvesting
00361   //  doFractionInSync(true,false);    
00362 
00363 }
00364 
00365 //_____________________________________________________________________
00366 void L1TSync_Offline::analyze(const Event & iEvent, const EventSetup & eventSetup){
00367 
00368 
00369   if(m_verbose){cout << "[L1TSync_Offline] Called analyze." << endl;}
00370 
00371   // We only start analyzing if current LS is still valid
00372   if(m_currentLSValid){
00373   
00374     if(m_verbose){cout << "[L1TSync_Offline] -> m_currentLSValid=" << m_currentLSValid << endl;}
00375     
00376     // Retriving information from GT
00377     edm::Handle<L1GlobalTriggerEvmReadoutRecord> gtEvmReadoutRecord;
00378     iEvent.getByLabel(m_l1GtEvmSource, gtEvmReadoutRecord);
00379 
00380     // Determining beam mode and fill number
00381     if(gtEvmReadoutRecord.isValid()){
00382 
00383       const L1GtfeExtWord& gtfeEvmWord = gtEvmReadoutRecord->gtfeWord();
00384       unsigned int lhcBeamMode         = gtfeEvmWord.beamMode();          // Updating beam mode
00385 
00386       if(m_lhcFill == 0){
00387         m_lhcFill = gtfeEvmWord.lhcFillNumber(); // Getting LHC Fill Number from GT
00388 
00389         //I AM HERE
00390         getBeamConfOffline(iEvent);                       // Getting Beam Configuration from OMDS
00391         // no OMDS //
00392         /* (Savannah ticket https://savannah.cern.ch/task/?31857 )
00393           Purged the OMDS helper from the module, since apparently we don't have access to that information from Offline.
00394           The comparison with the closest BPTX trigger will be performed via conditions objects which are being implemented by Joao Pela.
00395           In the meantime, for being able to test the module, he suggested to pass the correct bunch structure by hand for the specific run which is run during the test.
00396           The idea of the temporary fix is setting the vector variable that stores the bunch structure either by hand or filling it with the BPTX fires (that is check for the event the BX's where tech0 fired and set those as true in the vector.
00397         */
00398         // no OMDS //    m_beamConfig = myOMDSHelper.getBeamConfiguration(m_lhcFill,errorRetrieve); Yuhuuu!!!OB asked Joao Pela how to fetch that
00399 
00400 
00401         
00402         
00403       }
00404 
00405       if(lhcBeamMode != STABLE){m_currentLSValid = false;
00406         if(m_verbose){cout << "[L1TSync_Offline] -> m_currentLSValid=" << m_currentLSValid << "because beams mode not stable, being " << lhcBeamMode << endl;}
00407       } // If Beams are not stable we invalidate this LS
00408     }else{
00409       int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
00410       eCount++;
00411       m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT,eCount);
00412     }
00413   }else{
00414     if(m_verbose){cout << "[L1TSync_Offline] -> m_currentLSValid=" << m_currentLSValid << endl;}
00415   }
00416 
00417   // Commenting out un-necessary  print outs (S.Dutta)
00418   /*  for(size_t l=0; l<m_beamConfig.beam1.size(); l++){
00419     cout << "Beam 1: element " << l << " is in state " << m_beamConfig.beam1[l] << " --- Beam 2: element " << l << " is in state " << m_beamConfig.beam2[l] << endl;
00420     }*/
00421   //------------------------------------------------------------------------------
00422   // If current LS is valid and Beam Configuration is Valid we analyse this event
00423   //------------------------------------------------------------------------------
00424   if(m_currentLSValid && m_beamConfig.isValid()){     
00425 
00426     // Getting Final Decision Logic (FDL) Data from GT
00427     edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecordData;
00428     iEvent.getByLabel(m_l1GtDataDaqInputTag, gtReadoutRecordData);
00429 
00430     if(gtReadoutRecordData.isValid()){
00431 
00432       const vector<L1GtFdlWord>& gtFdlVectorData = gtReadoutRecordData->gtFdlVector();
00433 
00434       // Running over selected triggers
00435       for(map<string,string>::const_iterator i=m_selectedTriggers.begin() ; i!=m_selectedTriggers.end() ; i++){
00436 
00437         string tTrigger = (*i).second;
00438 
00439         // Analyse only defined triggers
00440         if(tTrigger != "Undefined" && tTrigger != "Undefined (Wrong Name)"){
00441 
00442           bool beamSingleConfig = false; // Single beam configured for this event
00443           bool firedAlgo        = false; // Algo fired in this event
00444           unsigned int  eventBx = ~0;      
00445 
00446           // Running over FDL results to get which bits fired
00447           for(unsigned int a=0 ; a<gtFdlVectorData.size() ; a++){
00448    
00449             // Selecting the FDL that triggered
00450             if(gtFdlVectorData[a].bxInEvent() == 0){
00451               eventBx = gtFdlVectorData[a].localBxNr();
00452               if(gtFdlVectorData[a].gtDecisionWord()[ m_algoBit[tTrigger] ]){firedAlgo = true;}
00453             }
00454           }
00455 
00456           // Checking beam configuration
00457           if ( m_beamConfig.beam1.size() > eventBx && m_beamConfig.beam2.size() > eventBx) {
00458             if( m_beamConfig.beam1[eventBx] && !m_beamConfig.beam2[eventBx]){beamSingleConfig = true;}
00459             if(!m_beamConfig.beam1[eventBx] &&  m_beamConfig.beam2[eventBx]){beamSingleConfig = true;}
00460           } 
00461           // Analyse only if this trigger fired in this event
00462           // NOTE: Veto cases where a single beam is configured since
00463           //       for this cases this could be a real-satelite bunch collision
00464           // -> Calculate the minimum bx diference between this event and a configured bx
00465           if(firedAlgo && !beamSingleConfig){
00466 
00467             int DifAlgoVsBunchStructure = 9999; // Majorated
00468 
00469             for(unsigned int a=0 ; a<gtFdlVectorData.size() ; a++){
00470 
00471               int bxFDL     = gtFdlVectorData[a].localBxNr();
00472               int bxInEvent = gtFdlVectorData[a].bxInEvent();
00473 
00474               if(m_beamConfig.bxConfig(bxFDL) && abs(bxInEvent)<abs(DifAlgoVsBunchStructure)){
00475                 DifAlgoVsBunchStructure = -1*bxInEvent;
00476               }
00477             }
00478 
00479             m_algoVsBunchStructure[tTrigger]->Fill(m_currentLS,DifAlgoVsBunchStructure);
00480 
00481           }
00482         }
00483       }
00484     }
00485     else{
00486       int eCount = m_ErrorMonitor->getTH1()->GetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT);
00487       eCount++;
00488       m_ErrorMonitor->getTH1()->SetBinContent(ERROR_UNABLE_RETRIVE_PRODUCT,eCount);
00489     }
00490 
00491   }
00492 }
00493 
00494 //_____________________________________________________________________
00495 // Method: getBunchStructureOffline
00496 // Description: Attempt to retrive Beam Configuration from Offline and if 
00497 //              we find error handle it
00498 //_____________________________________________________________________
00499 void L1TSync_Offline::getBeamConfOffline(const Event& iEvent){
00500 
00501   //Getting connection parameters
00502   //  [11:21:35] Pietro Vischia: pathCondDB and oracleDB are available in offline?
00503   //  [11:21:51] Joao Pela: no
00504   //  [11:21:56] Pietro Vischia: cool
00505   //  [11:21:58] Pietro Vischia: tks
00506   //  [11:22:00] Joao Pela: well
00507   //  [11:22:02] Joao Pela: maybe
00508   //  [11:22:05] Joao Pela: but assume no
00509   //  [11:22:22] Joao Pela: definitely assume no
00510   // *** UPDATE: now we have a DB for Rate parameters, it would be useful to have s.th also for L1TSync
00511 
00512   // string oracleDB   = m_parameters.getParameter<string>("oracleDB");
00513   // string pathCondDB = m_parameters.getParameter<string>("pathCondDB");
00514   
00515   //  m_beamConfig = myOMDSHelper.getBeamConfiguration(m_lhcFill,errorRetrieve);
00516   //  m_lhcFill -> lhcFillNumber
00517   //  errorRetrieve -> error
00518   // m_beamConfig -> bConfig
00519   
00520 
00521   // No error codes at the moment. Taking info from BPTX fires
00522   //  int errorRetrieve = 0; // NO_ERROR;
00523   m_beamConfig.m_valid = true;
00524 
00525 
00526 
00527   //  bool beamSingleConfig = false; // Single beam configured for this event
00528   bool firedAlgo        = false; // Algo fired in this event
00529   //  int  eventBx          = -1;      
00530   
00531   // Running over FDL results to get which bits fired for BPTX (temporary fix Savannah ticket https://savannah.cern.ch/task/?31857 )
00532   // Getting Final Decision Logic (FDL) Data from GT
00533   edm::Handle<L1GlobalTriggerReadoutRecord> gtReadoutRecordData;
00534   iEvent.getByLabel(m_l1GtDataDaqInputTag, gtReadoutRecordData);
00535   
00536   if(gtReadoutRecordData.isValid()){
00537     
00538     const vector<L1GtFdlWord>& gtFdlVectorData = gtReadoutRecordData->gtFdlVector();
00539     
00540     for(unsigned int a=0 ; a<gtFdlVectorData.size() ; a++){
00541       // Selecting the FDL that triggered
00542       if(gtFdlVectorData[a].bxInEvent() == 0){
00543         //eventBx = gtFdlVectorData[a].localBxNr();
00544         if(gtFdlVectorData[a].gtDecisionWord()[ m_algoBit[ m_selectedTriggers["BPTX"] ] ]){firedAlgo = true;}
00545       }
00546       
00547       // Fill beam status with BPTX fires
00548       if(firedAlgo){
00549         m_beamConfig.beam1.push_back(true);
00550         m_beamConfig.beam2.push_back(true);
00551       }
00552       else {
00553         m_beamConfig.beam1.push_back(false);
00554         m_beamConfig.beam2.push_back(false);
00555       }
00556       // End fill beam status with BPTX fires
00557     } // End loop on FDL
00558   } // End if readout is valid  
00559   
00560 }
00561 
00562 
00563 
00564 //_____________________________________________________________________
00565 // Method: doFractionInSync
00566 // Description: Produce plot with the fraction of in sync trigger for
00567 //              LS blocks with enough statistics.
00568 // Variable: iForce - Forces closing of all blocks and calculation of 
00569 //                    the respective fractions
00570 // Variable: iBad   - (Only works with iForce=true) Forces the current 
00571 //                    all current blocks to be marked as bad 
00572 //_____________________________________________________________________
00573 //void L1TSync_Offline::doFractionInSync(bool iForce,bool iBad){
00574 //  
00673 //}
00674 
00675 
00676 //_____________________________________________________________________
00677 // Method: certifyLSBlock
00678 // Description: Fill the trigger certification plot by blocks
00679 // Variable: iTrigger - Which trigger to certify
00680 // Variable: iInitLs  - Blocks initial LS
00681 // Variable: iEndLs   - Blocks end LS
00682 // Variable: iValue   - Value to be used to fill
00683 //_____________________________________________________________________
00684 //void L1TSync_Offline::certifyLSBlock(string iTrigger, int iInitLs, int iEndLs ,float iValue){
00685 //  
00693 //
00694 //}
00695 
00696 //define this as a plug-in
00697 DEFINE_FWK_MODULE(L1TSync_Offline);
/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_7/src/DQMOffline/L1Trigger/src/L1TSync_Offline.cc
