/data/refman/pasoursint/CMSSW_5_3_8_patch3/src/DQM/TrigXMonitor/src/L1TScalersSCAL.cc

Go to the documentation of this file.

// Class:      L1TScalersSCAL
// user include files

#include <sstream>
#include <vector>

#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ServiceRegistry/interface/Service.h"

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

#include "DataFormats/Scalers/interface/Level1TriggerScalers.h"
#include "DataFormats/Scalers/interface/Level1TriggerRates.h"
#include "DataFormats/Scalers/interface/LumiScalers.h"
#include "DataFormats/Scalers/interface/L1AcceptBunchCrossing.h"
#include "DataFormats/Scalers/interface/ScalersRaw.h"
#include "DataFormats/Scalers/interface/TimeSpec.h"

#include "DQM/TrigXMonitor/interface/L1TScalersSCAL.h"
#include "DataFormats/Common/interface/Handle.h"
#include "DQMServices/Core/interface/DQMStore.h"


const double SECS_PER_LUMI = 23.31040958083832;


using namespace edm;
using namespace std;


L1TScalersSCAL::L1TScalersSCAL(const edm::ParameterSet& ps):
  dbe_(0),
  scalersSource_( ps.getParameter< edm::InputTag >("scalersResults")),
  verbose_(ps.getUntrackedParameter <bool> ("verbose", false)),
  denomIsTech_(ps.getUntrackedParameter <bool> ("denomIsTech", true)),
  denomBit_(ps.getUntrackedParameter <unsigned int> ("denomBit", 40)),
  muonBit_(ps.getUntrackedParameter <unsigned int> ("muonBit", 55)),
  egammaBit_(ps.getUntrackedParameter <unsigned int> ("egammaBit", 46)),
  jetBit_(ps.getUntrackedParameter <unsigned int> ("jetBit", 15))
{
  LogDebug("Status") << "constructor" ;

  for ( int i=0; i<Level1TriggerScalers::nLevel1Triggers; i++) 
    { bufferAlgoRates_.push_back(0); algorithmRates_.push_back(0); integral_algo_.push_back(0.);}
  for ( int i=0; i<Level1TriggerScalers::nLevel1TestTriggers; i++) 
    { bufferTechRates_.push_back(0); technicalRates_.push_back(0); integral_tech_.push_back(0.);}

  buffertime_ = 0;
  reftime_ = 0;
  nev_ = 0;
  integral_tech_42_OR_43_ = 0;
  bufferLumi_ = 0;

  int maxNbins = 2001;

  dbe_ = Service<DQMStore>().operator->();
  if(dbe_) {
    dbe_->setVerbose(0);
        
    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/Level1TriggerScalers");
        
    //orbitNum = dbe_->book1D("Orbit_Number","Orbit_Number", 1000,0,10E8);
    orbitNum = dbe_->book1D("Orbit_Number","Orbit_Number", maxNbins,-0.5,double(maxNbins)-0.5);

    trigNum = dbe_->book1D("Number_of_Triggers","Number_of_Triggers",1000,0,4E4);
    trigNum->setAxisTitle("Time [sec]", 1);

    //eventNum = dbe_->book1D("Number_of_Events","Number_of_Events", 1000,0,1E7);
    eventNum = dbe_->book1D("Number_of_Events","Number_of_Events", maxNbins,-0.5,double(maxNbins)-0.5);

    physTrig = dbe_->book1D("Physics_Triggers","Physics_Triggers", maxNbins,-0.5,double(maxNbins)-0.5);
    physTrig->setAxisTitle("Lumi Section", 1);

    randTrig = dbe_->book1D("Random_Triggers","Random_Triggers", maxNbins,-0.5,double(maxNbins)-0.5);
    randTrig->setAxisTitle("Lumi Section", 1);

    //numberResets = dbe_->book1D("Number_Resets","Number_Resets", 1000,0,1000);
    numberResets = dbe_->book1D("Number_Resets","Number_Resets", maxNbins,-0.5,double(maxNbins)-0.5);
   
    //deadTime = dbe_->book1D("DeadTime","DeadTime", 1000,0,1E9);
    deadTime = dbe_->book1D("DeadTime","DeadTime", maxNbins,-0.5,double(maxNbins)-0.5);
    
    //lostFinalTriggers = dbe_->book1D("Lost_Final_Trigger","Lost_Final_Trigger", 1000,0,1E6);
    lostFinalTriggers = dbe_->book1D("Lost_Final_Trigger","Lost_Final_Trigger", maxNbins,-0.5,double(maxNbins)-0.5);
   
    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/Level1TriggerRates");

    physRate = dbe_->book1D("Physics_Trigger_Rate","Physics_Trigger_Rate", 
                            maxNbins,-0.5,double(maxNbins)-0.5);
    //physRate->setAxisTitle("Lumi Section", 1);

    randRate = dbe_->book1D("Random_Trigger_Rate","Random_Trigger_Rate", 
                            maxNbins,-0.5,double(maxNbins)-0.5);
    //randRate->setAxisTitle("Lumi Section", 1);

    deadTimePercent = dbe_->book1D("Deadtime_Percent","Deadtime_Percent", 
                                   maxNbins,-0.5,double(maxNbins)-0.5);
    //deadTimePercent->setAxisTitle("Lumi Section", 1);

    lostPhysRate = dbe_->book1D("Lost_Physics_Trigger_Rate","Lost_Physics_Trigger_Rate", 
                                maxNbins,-0.5,double(maxNbins)-0.5);
    //lostPhysRate->setAxisTitle("Lumi Section", 1);

    lostPhysRateBeamActive = dbe_->book1D("Lost_Physics_Trigger_Rate_Beam_Active",
                                          "Lost_Physics_Trigger_Rate_Beam_Active", 
                                          maxNbins,-0.5,double(maxNbins)-0.5);
    //lostPhysRateBeamActive->setAxisTitle("Lumi Section", 1);

    
    instTrigRate = dbe_->book1D("instTrigRate","instTrigRate",1000,0,4E4);
    instTrigRate->setAxisTitle("Time [sec]", 1);

    instEventRate = dbe_->book1D("instEventRate","instEventRate",1000,0,4E4);
    instEventRate->setAxisTitle("Time [sec]", 1);

    char hname[40];//histo name
    char mename[40];//ME name

    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/Level1TriggerRates/AlgorithmRates");

    for(int i=0; i<Level1TriggerScalers::nLevel1Triggers; i++) {
      sprintf(hname, "Rate_AlgoBit_%03d", i);
      sprintf(mename, "Rate_AlgoBit _%03d", i);

      algoRate[i] = dbe_->book1D(hname, mename,maxNbins,-0.5,double(maxNbins)-0.5);
      algoRate[i]->setAxisTitle("Lumi Section" ,1);
    }    
                                     
    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/Level1TriggerRates/AlgorithmRates/Integrated");

    for(int i=0; i<Level1TriggerScalers::nLevel1Triggers; i++) {
      sprintf(hname, "Integral_AlgoBit_%03d", i);
      sprintf(mename, "Integral_AlgoBit _%03d", i);

      integralAlgo[i] = dbe_->book1D(hname, mename,maxNbins,-0.5,double(maxNbins)-0.5);
      integralAlgo[i]->setAxisTitle("Lumi Section" ,1);
    }                                        

    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/Level1TriggerRates/TechnicalRates");

    for(int i=0; i<Level1TriggerScalers::nLevel1TestTriggers; i++) {
      sprintf(hname, "Rate_TechBit_%03d", i);
      sprintf(mename, "Rate_TechBit _%03d", i);

      techRate[i] = dbe_->book1D(hname, mename,maxNbins,-0.5,double(maxNbins)-0.5);
      techRate[i]->setAxisTitle("Lumi Section" ,1);
    }

    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/Level1TriggerRates/TechnicalRates/Integrated");

    for(int i=0; i<Level1TriggerScalers::nLevel1TestTriggers; i++) {
      sprintf(hname, "Integral_TechBit_%03d", i);
      sprintf(mename, "Integral_TechBit _%03d", i);

      integralTech[i] = dbe_->book1D(hname, mename,maxNbins,-0.5,double(maxNbins)-0.5);
      integralTech[i]->setAxisTitle("Lumi Section" ,1);
    }                                        
    integralTech_42_OR_43 = dbe_->book1D("Integral_TechBit_042_OR_043","Integral_TechBit _042_OR_043",maxNbins,-0.5,double(maxNbins)-0.5);
    integralTech_42_OR_43->setAxisTitle("Lumi Section" ,1);


    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/Level1TriggerRates/Ratios");

    std::stringstream smu,seg,sjet,sdenom;
    //denominator string
    if(denomIsTech_) sdenom << "_TechBit_";
    else sdenom << "_AlgoBit_";
    sdenom << denomBit_;
    //Muon ratio
    smu << muonBit_;
    rateRatio_mu = dbe_->book1D("Rate_Ratio_mu_PhysBit_"+ smu.str()+sdenom.str(), "Rate_Ratio_mu_PhysBit_" + smu.str()+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    //rateRatio_mu->setAxisTitle("Lumi Section" , 1);
    //Egamma ratio
    seg << egammaBit_;
    rateRatio_egamma = dbe_->book1D("Rate_Ratio_egamma_PhysBit_"+ seg.str()+sdenom.str(), "Rate_Ratio_egamma_PhysBit_" + seg.str()+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    //rateRatio_egamma->setAxisTitle("Lumi Section" , 1);
    //Jet ratio
    sjet << jetBit_;
    rateRatio_jet = dbe_->book1D("Rate_Ratio_jet_PhysBit_" + sjet.str()+sdenom.str(), "Rate_Ratio_jet_PhysBit_" + sjet.str()+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    //rateRatio_jet->setAxisTitle("Lumi Section" , 1);

    //HF bit ratios
    techRateRatio_8 = dbe_->book1D("Rate_Ratio_TechBit_8"+sdenom.str(), "Rate_Ratio_TechBit_8"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    //techRateRatio_8->setAxisTitle("Lumi Section" ,1);
    techRateRatio_9 = dbe_->book1D("Rate_Ratio_TechBit_9"+sdenom.str(), "Rate_Ratio_TechBit_9"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    //techRateRatio_9->setAxisTitle("Lumi Section" ,1);
    techRateRatio_10 = dbe_->book1D("Rate_Ratio_TechBit_10"+sdenom.str(), "Rate_Ratio_TechBit_10"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    //techRateRatio_10->setAxisTitle("Lumi Section" ,1);

    //Other tech bit ratios
    techRateRatio_33_over_32 = dbe_->book1D("Rate_Ratio_TechBits_33_over_32", "Rate_Ratio_TechBits_33_over_32",maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_36 = dbe_->book1D("Rate_Ratio_TechBit_36"+sdenom.str(), "Rate_Ratio_TechBit_36"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_37 = dbe_->book1D("Rate_Ratio_TechBit_37"+sdenom.str(), "Rate_Ratio_TechBit_37"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_38 = dbe_->book1D("Rate_Ratio_TechBit_38"+sdenom.str(), "Rate_Ratio_TechBit_38"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_39 = dbe_->book1D("Rate_Ratio_TechBit_39"+sdenom.str(), "Rate_Ratio_TechBit_39"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_40 = dbe_->book1D("Rate_Ratio_TechBit_40"+sdenom.str(), "Rate_Ratio_TechBit_40"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_41 = dbe_->book1D("Rate_Ratio_TechBit_41"+sdenom.str(), "Rate_Ratio_TechBit_41"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_42 = dbe_->book1D("Rate_Ratio_TechBit_42"+sdenom.str(), "Rate_Ratio_TechBit_42"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);
    techRateRatio_43 = dbe_->book1D("Rate_Ratio_TechBit_43"+sdenom.str(), "Rate_Ratio_TechBit_43"+sdenom.str(),maxNbins,-0.5,double(maxNbins)-0.5);

                                
    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/LumiScalers");
    //instLumi = dbe_->book1D("Instant Lumi","Instant Lumi",100,0,100);
    instLumi = dbe_->book1D("Instant_Lumi","Instant_Lumi", maxNbins,-0.5,double(maxNbins)-0.5);
    //instLumiErr = dbe_->book1D("Instant Lumi Err","Instant Lumi Err",100,
    //                         0,100);
    instLumiErr = dbe_->book1D("Instant_Lumi_Err","Instant_Lumi_Err",maxNbins,-0.5,double(maxNbins)-0.5);
    //instLumiQlty = dbe_->book1D("Instant Lumi Qlty","Instant Lumi Qlty",100,
    //                          0,100);
    instLumiQlty = dbe_->book1D("Instant_Lumi_Qlty","Instant_Lumi_Qlty",maxNbins,-0.5,double(maxNbins)-0.5);
    //instEtLumi = dbe_->book1D("Instant Et Lumi","Instant Et Lumi",100,0,100);
    instEtLumi = dbe_->book1D("Instant_Et_Lumi","Instant_Et_Lumi",maxNbins,-0.5,double(maxNbins)-0.5);
    //instEtLumiErr = dbe_->book1D("Instant Et Lumi Err","Instant Et Lumi Err",
    //                           100,0,100);
    instEtLumiErr = dbe_->book1D("Instant_Et_Lumi_Err","Instant_Et_Lumi_Err",maxNbins,-0.5,double(maxNbins)-0.5);
    //instEtLumiQlty = dbe_->book1D("Instant Et Lumi Qlty",
    //                            "Instant Et Lumi Qlty",100,0,100);
    instEtLumiQlty = dbe_->book1D("Instant_Et_Lumi_Qlty",
                                  "Instant_Et_Lumi_Qlty",maxNbins,-0.5,double(maxNbins)-0.5);
    //sectionNum = dbe_->book1D("Section Number","Section Number",100,0,100);
    //startOrbit = dbe_->book1D("Start Orbit","Start Orbit",100,0,100);
    startOrbit = dbe_->book1D("Start_Orbit","Start_Orbit", maxNbins,-0.5,double(maxNbins)-0.5);
    //numOrbits = dbe_->book1D("Num Orbits","Num Orbits",100,0,100);
    numOrbits = dbe_->book1D("Num_Orbits","Num_Orbits", maxNbins,-0.5,double(maxNbins)-0.5);
        
    
    dbe_->setCurrentFolder("L1T/L1TScalersSCAL/L1AcceptBunchCrossing");
       
    for(int i=0; i<4; i++){

      sprintf(hname, "OrbitNumber_L1A_%d", i+1);
      sprintf(mename, "OrbitNumber_L1A_%d", i+1);
      orbitNumL1A[i] = dbe_->book1D(hname,mename,200,0,10E8);          

      sprintf(hname, "Bunch_Crossing_L1A_%d", i+1);
      sprintf(mename, "Bunch_Crossing_L1A_%d", i+1);
      bunchCrossingL1A[i]= dbe_->book1D(hname, mename, 3564, -0.5, 3563.5);
    }
    orbitNumL1A[0]->setAxisTitle("Current BX",1);
    orbitNumL1A[1]->setAxisTitle("Previous BX",1);
    orbitNumL1A[2]->setAxisTitle("Second Previous BX",1);
    orbitNumL1A[3]->setAxisTitle("Third Previous BX",1);

    bunchCrossingL1A[0]->setAxisTitle("Current BX",1);
    bunchCrossingL1A[1]->setAxisTitle("Previous BX",1);
    bunchCrossingL1A[2]->setAxisTitle("Second Previous BX",1);
    bunchCrossingL1A[3]->setAxisTitle("Third Previous BX",1);


    for(int j=0; j<3; j++) {
      sprintf(hname, "BX_Correlation_%d", j+1);
      sprintf(mename, "BX_Correlation_%d", j+1);

      bunchCrossingCorr[j] = dbe_->book2D(hname, mename, 99,-0.5,3563.5, 99,-0.5,3563.5);
      bunchCrossingCorr[j]->setAxisTitle("Current Event", 1);

      sprintf(hname, "Bunch_Crossing_Diff_%d", j+1);
      sprintf(mename, "Bunch_Crossing_Diff_%d", j+1);
      
      bunchCrossingDiff[j] = dbe_->book1D(hname, mename, 1000,0,1E6);

      sprintf(hname, "Bunch_Crossing_Diff_small_%d", j+1);
      sprintf(mename, "Bunch_Crossing_Diff_small_%d", j+1);
      
      bunchCrossingDiff_small[j] = dbe_->book1D(hname, mename, 1000,0,1000);

    }                                        
    bunchCrossingCorr[0]->setAxisTitle("Previous Event" , 2);
    bunchCrossingCorr[1]->setAxisTitle("Second Previous Event" , 2);
    bunchCrossingCorr[2]->setAxisTitle("Third Previous Event" , 2);

    bunchCrossingDiff[0]->setAxisTitle("BX_Current - BX_Previous" , 1);
    bunchCrossingDiff[1]->setAxisTitle("BX_Current - BX_SecondPrevious" , 1);
    bunchCrossingDiff[2]->setAxisTitle("BX_Current - BX_ThirdPrevious" , 1);

    bunchCrossingDiff_small[0]->setAxisTitle("BX_Current - BX_Previous" , 1);
    bunchCrossingDiff_small[1]->setAxisTitle("BX_Current - BX_SecondPrevious" , 1);
    bunchCrossingDiff_small[2]->setAxisTitle("BX_Current - BX_ThirdPrevious" , 1);

  }    

}


L1TScalersSCAL::~L1TScalersSCAL()
{
   // do anything here that needs to be done at destruction time
   // (e.g. close files, deallocate resources etc.)
}


//
// member functions
//

// ------------ method called to for each event  ------------
void
L1TScalersSCAL::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup)
{
  nev_++;

  //access SCAL info
  edm::Handle<Level1TriggerScalersCollection> triggerScalers;
  bool a = iEvent.getByLabel(scalersSource_, triggerScalers);
  //edm::Handle<L1TriggerRatesCollection> triggerRates;
  //edm::Handle<Level1TriggerRatesCollection> triggerRates;
  //bool b = iEvent.getByLabel(scalersSource_, triggerRates);
  edm::Handle<LumiScalersCollection> lumiScalers;
  bool c = iEvent.getByLabel(scalersSource_, lumiScalers);
  edm::Handle<L1AcceptBunchCrossingCollection> bunchCrossings;
  bool d = iEvent.getByLabel(scalersSource_, bunchCrossings);
  
  double evtLumi = iEvent.luminosityBlock();
  int run = iEvent.id().run();


  if ( ! (a && c && d) ) {
    LogInfo("Status") << "getByLabel failed with label " 
                      << scalersSource_;
  }
                                
  else { // we have the data 
    
    Level1TriggerScalersCollection::const_iterator it = triggerScalers->begin();
    if(triggerScalers->size()){ 

      //for(L1TriggerScalersCollection::const_iterator it = triggerScalers->begin();
      //it != triggerScalers->end();
      //++it){
       
      unsigned int lumisection = it->lumiSegmentNr();
      struct timespec thetime = it->collectionTime();
      long currenttime;
      //cout << "lumisection = " << lumisection << endl;
      if(nev_ == 1) reftime_ = thetime.tv_sec; 
      //cout << "reftime = " << reftime_ << endl;
      if(lumisection){

        //orbitNum->Fill(it->orbitNr());
        orbitNum->setBinContent(lumisection+1,it->orbitNr());

        //trigNum ->Fill(it->gtTriggers());
        //trigNum->setBinContent(lumisection+1, it->gtTriggers()); 

        //eventNum->Fill(it->gtEvents());
        eventNum->setBinContent(lumisection+1,it->gtEvents());

        //physTrig ->Fill(it->l1AsPhysics());
        physTrig->setBinContent(lumisection+1, it->l1AsPhysics()); 

        //randTrig ->Fill(it->l1AsRandom());
        randTrig->setBinContent(lumisection+1, it->l1AsRandom()); 

        //numberResets ->Fill(it->gtResets());   
        numberResets->setBinContent(lumisection+1, it->gtResets());      

        //deadTime ->Fill(it->deadtime());
        deadTime->setBinContent(lumisection+1, it->deadtime());

        //lostFinalTriggers ->Fill(it->triggersPhysicsLost());                       
        lostFinalTriggers->setBinContent(lumisection+1, it->triggersPhysicsLost());
         
        //cout << "lumisection = " << lumisection << " , orbitNum = " 
        //     << it->orbitNr() << ", lumiSegmentOrbits = " << it->lumiSegmentOrbits() 
        //     << ", l1AsPhys = " << it->l1AsPhysics() << endl;
        //cout << "gtTriggersRate = " << it->gtTriggersRate() << endl;

        if(buffertime_ < thetime.tv_sec){
          buffertime_ = thetime.tv_sec;
          currenttime = thetime.tv_sec - reftime_ ;
          int timebin = (int)(currenttime/30) + 1;
          //cout << "time bin = " << timebin << endl;
          trigNum->setBinContent((int)timebin ,it->gtTriggers());
          instTrigRate->setBinContent((int)timebin ,it->gtTriggersRate());
          instEventRate->setBinContent((int)timebin ,it->gtEventsRate());
        }
        
        //cout << "tv_sec = " << thetime.tv_sec << endl;

        //std::vector<unsigned int> algoBits = it->gtAlgoCounts();
        //std::vector<unsigned int> techBits = it->gtTechCounts();
        /*         
                   int length = algoBits.size() / 4;
                   char line[128];
                   for ( int i=0; i<length; i++)
                   {
                   sprintf(line," %3.3d: %10u    %3.3d: %10u    %3.3d: %10u    %3.3d: %10u",
                   i,              algoBits[i], 
                   (i+length),     algoBits[i+length], 
                   (i+(length*2)), algoBits[i+(length*2)], 
                   (i+(length*3)), algoBits[i+(length*3)]);
                   std::cout << line << std::endl;
                   }
        */
        //sprintf(line,
        //        " LuminositySection: %15d  BunchCrossingErrors:      %15d",
        //        it->luminositySection(), it->bunchCrossingErrors());
        //std::cout << line << std::endl;
         
        //Level1TriggerRatesCollection::const_iterator it2 = triggerRates->begin();

        Level1TriggerRates trigRates(*it,run);
        Level1TriggerRates *triggerRates = &trigRates;
        if(triggerRates){
          algorithmRates_ = triggerRates->gtAlgoCountsRate();
          technicalRates_ = triggerRates->gtTechCountsRate();
          
          if( ((bufferLumi_!=lumisection) && (bufferLumi_<lumisection) && (evtLumi>1 || evtLumi==lumisection+1)) ){
            bufferLumi_ = lumisection;
 
            if(bufferAlgoRates_ != algorithmRates_){ 
              bufferAlgoRates_ = algorithmRates_;
              for (unsigned int i=0; i< algorithmRates_.size(); i++){ 
                integral_algo_[i]+=(algorithmRates_[i]*SECS_PER_LUMI);
                algoRate[i]->setBinContent(lumisection+1, algorithmRates_[i]); 
                integralAlgo[i]->setBinContent(lumisection+1,integral_algo_[i]); 
              }            
            }
            if(bufferTechRates_ != technicalRates_){ 
              bufferTechRates_ = technicalRates_;
              for (unsigned int i=0; i< technicalRates_.size(); i++){ 
                integral_tech_[i]+=(technicalRates_[i]*SECS_PER_LUMI);
                techRate[i]->setBinContent(lumisection+1, technicalRates_[i]); 
                integralTech[i]->setBinContent(lumisection+1, integral_tech_[i]); 
                if( (i==42 || i==43) ) integral_tech_42_OR_43_+=(technicalRates_[i]*SECS_PER_LUMI);
              } 

              //fill rate ratio plots
              if(denomIsTech_){
                if( denomBit_ < technicalRates_.size() ){
                  if(technicalRates_[denomBit_]){

                    if( muonBit_ < algorithmRates_.size() )
                      rateRatio_mu->setBinContent(lumisection+1, algorithmRates_[muonBit_]/technicalRates_[denomBit_]);
                    if( egammaBit_ < algorithmRates_.size() )
                      rateRatio_egamma->setBinContent(lumisection+1, algorithmRates_[egammaBit_]/technicalRates_[denomBit_]);
                    if( jetBit_ < algorithmRates_.size() )
                      rateRatio_jet->setBinContent(lumisection+1, algorithmRates_[jetBit_]/technicalRates_[denomBit_]);

                    techRateRatio_8->setBinContent(lumisection+1, technicalRates_[8]/technicalRates_[denomBit_]);
                    techRateRatio_9->setBinContent(lumisection+1, technicalRates_[9]/technicalRates_[denomBit_]);
                    techRateRatio_10->setBinContent(lumisection+1, technicalRates_[10]/technicalRates_[denomBit_]);

                    techRateRatio_36->setBinContent(lumisection+1, technicalRates_[36]/technicalRates_[denomBit_]);
                    techRateRatio_37->setBinContent(lumisection+1, technicalRates_[37]/technicalRates_[denomBit_]);
                    techRateRatio_38->setBinContent(lumisection+1, technicalRates_[38]/technicalRates_[denomBit_]);
                    techRateRatio_39->setBinContent(lumisection+1, technicalRates_[39]/technicalRates_[denomBit_]);
                    techRateRatio_40->setBinContent(lumisection+1, technicalRates_[40]/technicalRates_[denomBit_]);
                    techRateRatio_41->setBinContent(lumisection+1, technicalRates_[41]/technicalRates_[denomBit_]);
                    techRateRatio_42->setBinContent(lumisection+1, technicalRates_[42]/technicalRates_[denomBit_]);
                    techRateRatio_43->setBinContent(lumisection+1, technicalRates_[43]/technicalRates_[denomBit_]);
                  }
                }
              }
              if( technicalRates_[32]!=0 ) techRateRatio_33_over_32->setBinContent(lumisection+1, technicalRates_[33]/technicalRates_[32]);
              integralTech_42_OR_43->setBinContent(lumisection+1, integral_tech_42_OR_43_);        

            }

            physRate->setBinContent(lumisection+1, 
                                    triggerRates->l1AsPhysicsRate()); 
            randRate->setBinContent(lumisection+1, 
                                    triggerRates->l1AsRandomRate());
            lostPhysRate->setBinContent(lumisection+1, 
                                        triggerRates->triggersPhysicsLostRate()); 
            lostPhysRateBeamActive->setBinContent(lumisection+1, 
                                                  triggerRates->triggersPhysicsLostBeamActiveRate()); 
            deadTimePercent->setBinContent(lumisection+1, 
                                           triggerRates->deadtimePercent()); 
           
          }//bufferLumi test
        }//triggerRates  
      }//lumisection
    }//triggerScalers->size()

     
    LumiScalersCollection::const_iterator it3 = lumiScalers->begin();
    if(lumiScalers->size()){ 
    
      //for(LumiScalersCollection::const_iterator it3 = lumiScalers->begin();
      //it3 != lumiScalers->end();
      //++it3){
      unsigned int lumisection = it3->sectionNumber();
      if(lumisection){
       
        instLumi->setBinContent(lumisection+1, it3->instantLumi());
        instLumiErr->setBinContent(lumisection+1, it3->instantLumiErr()); 
        instLumiQlty->setBinContent(lumisection+1, it3->instantLumiQlty()); 
        instEtLumi->setBinContent(lumisection+1, it3->instantETLumi()); 
        instEtLumiErr->setBinContent(lumisection+1, it3->instantETLumiErr()); 
        instEtLumiQlty->setBinContent(lumisection+1, it3->instantETLumiQlty()); 
        //sectionNum->Fill(it3->sectionNumber()); 
        startOrbit->setBinContent(lumisection+1, it3->startOrbit()); 
        numOrbits->setBinContent(lumisection+1, it3->numOrbits()); 

      }       
      /*
        char line2[128];
        sprintf(line2," InstantLumi:       %e  Err: %e  Qlty: %d",
        it3->instantLumi(), it3->instantLumiErr(), it3->instantLumiQlty());
        std::cout << line2 << std::endl;

        sprintf(line2," SectionNumber: %10d   StartOrbit: %10d  NumOrbits: %10d",
        it3->sectionNumber(), it3->startOrbit(), it3->numOrbits());
        std::cout << line2 << std::endl;
      */
    }

    //     L1AcceptBunchCrossingCollection::const_iterator it4 = bunchCrossings->begin();
    //if(bunchCrossings->size()){
    //int counttest=0;
    int l1accept; 
    unsigned int bx_current = 0, orbitnumber_current = 0, bxdiff = 0;

    for(L1AcceptBunchCrossingCollection::const_iterator it4 = bunchCrossings->begin();
        it4 != bunchCrossings->end();
        ++it4){
      //counttest++;
      //cout << "counttest = " << counttest << endl;
      //cout << "bunchCrossing = "  << it4->bunchCrossing() << endl;
      //cout << "l1AcceptOffset = " << it4->l1AcceptOffset() << endl;

      l1accept = std::abs(it4->l1AcceptOffset());   

      //cout << "l1a orbit number (before if)= " << it4->orbitNumber() << endl;
      //cout << "l1a bunch crossing = " << it4->bunchCrossing() << endl;

      if(l1accept == 0){
        orbitnumber_current = it4->orbitNumber();
        orbitNumL1A[l1accept]->Fill(orbitnumber_current);

        bx_current = it4->bunchCrossing();
        bunchCrossingL1A[l1accept]->Fill(bx_current);

      }
      else if (l1accept==1 || l1accept==2 || l1accept==3){
        orbitNumL1A[l1accept]->Fill(it4->orbitNumber());
        bunchCrossingL1A[l1accept]->Fill(it4->bunchCrossing());
        //cout << "l1accept = " << l1accept << ", bx_current = " << bx_current << ", it4->bunchCrossing() = " << it4->bunchCrossing() << endl;
        bunchCrossingCorr[l1accept-1]->Fill(bx_current, it4->bunchCrossing());
        bxdiff = 3564*(orbitnumber_current-it4->orbitNumber()) + bx_current - it4->bunchCrossing();
        bunchCrossingDiff[l1accept-1]->Fill(bxdiff);
        bunchCrossingDiff_small[l1accept-1]->Fill(bxdiff);
      }

    }
   
  } // getByLabel succeeds for scalers
       


}


// ------------ method called once each job just before starting event loop  ------------
void 
L1TScalersSCAL::beginJob(void)
{

}

// ------------ method called once each job just after ending the event loop  ------------
void 
L1TScalersSCAL::endJob() {
}


void L1TScalersSCAL::endLuminosityBlock(const edm::LuminosityBlock& lumiSeg, 
                                   const edm::EventSetup& iSetup)
{                                   
}                   
void L1TScalersSCAL::beginRun(const edm::Run& run, const edm::EventSetup& iSetup)
{
}
                                    
void L1TScalersSCAL::endRun(const edm::Run& run, const edm::EventSetup& iSetup)
{
}