EcalPedestalHistory Class Reference

#include <EcalPedestalHistory.h>

Inheritance diagram for EcalPedestalHistory:

Public Types
enum	{ kChannels = 75848, kEBChannels = 61200, kEEChannels = 14648 }
enum	{ kGains = 3, kFirstGainId = 1 }
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	beginJob () override
void	beginRun (edm::Run const &, edm::EventSetup const &) override
	EcalPedestalHistory (const edm::ParameterSet &)
void	endJob () override
void	endRun (edm::Run const &, edm::EventSetup const &) override
	~EcalPedestalHistory () override
Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns >
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDAnalyzerBase () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESProxyIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Public Attributes
EcalCondDBInterface *	econn

Private Attributes
unsigned int	cnt_evt_
std::string	ECALType_
unsigned int	m_firstRun
std::string	m_gentag
unsigned int	m_lastRun
std::string	m_location
std::string	m_locationsource
std::string	m_name
std::string	m_pass
std::string	m_sid
std::string	m_user
std::vector< int >	maskedChannels_
std::vector< int >	maskedEEChannels_
int	runnumber_
std::string	runType_
unsigned int	startevent_

Additional Inherited Members
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 44 of file EcalPedestalHistory.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
kChannels
kEBChannels
kEEChannels

Definition at line 55 of file EcalPedestalHistory.h.

{ kChannels = 75848, kEBChannels = 61200, kEEChannels = 14648 };

anonymous enum

anonymous enum

Enumerator
kGains
kFirstGainId

Definition at line 56 of file EcalPedestalHistory.h.

{ kGains = 3, kFirstGainId = 1 };

Constructor & Destructor Documentation

EcalPedestalHistory()

EcalPedestalHistory::EcalPedestalHistory ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 51 of file EcalPedestalHistory.cc.

References gather_cfg::cout, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                       {
  //====================================================================
  //now do what ever initialization is needed
  //  EBDigiCollection_          = iConfig.getParameter<edm::InputTag>("EBDigiCollection");
  runnumber_ = iConfig.getUntrackedParameter<int>("runnumber", -1);
  ECALType_ = iConfig.getParameter<std::string>("ECALType");
  runType_ = iConfig.getParameter<std::string>("runType");
  startevent_ = iConfig.getUntrackedParameter<unsigned int>("startevent", 1);

  std::cout << "EcalPedestals Source handler constructor\n" << std::endl;
  m_firstRun = static_cast<unsigned int>(atoi(iConfig.getParameter<std::string>("firstRun").c_str()));
  m_lastRun = static_cast<unsigned int>(atoi(iConfig.getParameter<std::string>("lastRun").c_str()));
  m_sid = iConfig.getParameter<std::string>("OnlineDBSID");
  m_user = iConfig.getParameter<std::string>("OnlineDBUser");
  m_pass = iConfig.getParameter<std::string>("OnlineDBPassword");
  m_locationsource = iConfig.getParameter<std::string>("LocationSource");
  m_location = iConfig.getParameter<std::string>("Location");
  m_gentag = iConfig.getParameter<std::string>("GenTag");
  std::cout << m_sid << "/" << m_user << "/" << m_pass << "/" << m_location << "/" << m_gentag << std::endl;

  vector<int> listDefaults;
  listDefaults.push_back(-1);

  cnt_evt_ = 0;
  //  cout << "Exiting constructor" << endl;
}  //constructor

~EcalPedestalHistory()

EcalPedestalHistory::~EcalPedestalHistory ( )

override

Definition at line 79 of file EcalPedestalHistory.cc.

References gather_cfg::cout.

                                          {
  //========================================================================
  cout << "ANALYSIS FINISHED" << endl;
}  //destructor

Member Function Documentation

analyze()

void EcalPedestalHistory::analyze ( const edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 380 of file EcalPedestalHistory.cc.

References gather_cfg::cout, kEBChannels, and kEEChannels.

                                                                                     {
  //========================================================================

  if (cnt_evt_ == 0) {
    if (ECALType_ == "EB" || ECALType_ == "EA") {
      cout << " Barrel data : nb channels " << kEBChannels << endl;
    } else if (ECALType_ == "EE" || ECALType_ == "EA") {
      cout << " End cap data : nb channels " << kEEChannels << endl;
    } else {
      cout << " strange ECALtype : " << ECALType_ << " abort " << endl;
      return;
    }
    /*
    int NbOfmaskedChannels =  maskedChannels_.size();
    cout << " Nb masked EB channels " << NbOfmaskedChannels << endl;
    for (vector<int>::iterator iter = maskedChannels_.begin(); iter != maskedChannels_.end(); ++iter)
      cout<< " : masked channel " << *(iter) << endl;
    NbOfmaskedChannels =  maskedEEChannels_.size();
    cout << " Nb masked EE channels " << NbOfmaskedChannels << endl;
    for (vector<int>::iterator iter = maskedEEChannels_.begin(); iter != maskedEEChannels_.end(); ++iter)
      cout<< " : masked channel " << *(iter) << endl;
    */
  }
  cnt_evt_++;

}  //analyze

beginJob()

void EcalPedestalHistory::beginJob ( )

overridevirtual

========================================================================

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 364 of file EcalPedestalHistory.cc.

                                   {

}  //beginJob

beginRun()

void EcalPedestalHistory::beginRun ( edm::Run const &  , edm::EventSetup const &  c  )

override

========================================================================

Definition at line 85 of file EcalPedestalHistory.cc.

References gather_cfg::cout, test_db_connect::econn, Exception, f, EcalLogicID::getID1(), EcalLogicID::getID2(), EcalLogicID::getID3(), EcalLogicID::getName(), MonPedestalsDat::getPedMeanG1(), MonPedestalsDat::getPedMeanG12(), MonPedestalsDat::getPedMeanG6(), MonPedestalsDat::getPedRMSG1(), MonPedestalsDat::getPedRMSG12(), MonPedestalsDat::getPedRMSG6(), MonRunList::getRuns(), EBDetId::hashedIndex(), EEDetId::hashedIndex(), EBDetId::ieta(), EBDetId::iphi(), EEDetId::ix(), EEDetId::iy(), kChannels, kEBChannels, kEEChannels, Mean, test_db_connect::my_locdef, test_db_connect::my_rundef, AlCaHLTBitMon_ParallelJobs::p, mps_fire::result, RMS, RunTag::setGeneralTag(), MonRunTag::setGeneralTag(), RunTag::setLocationDef(), MonVersionDef::setMonitoringVersion(), MonRunList::setMonRunTag(), MonRunTag::setMonVersionDef(), MonRunList::setRunTag(), RunTag::setRunTypeDef(), EBDetId::SMCRYSTALMODE, EBDetId::unhashIndex(), EEDetId::unhashIndex(), EEDetId::validDetId(), and EEDetId::zside().

                                                                        {

  cout << "Entering beginRun" << endl;
  /*     do not use any tag...
  edm::ESHandle<EcalChannelStatus> pChannelStatus;
  c.get<EcalChannelStatusRcd>().get(pChannelStatus);
  const EcalChannelStatus* chStatus = pChannelStatus.product();  
  EcalChannelStatusMap::const_iterator chit;
  for (int iChannel = 0; iChannel < kEBChannels; iChannel++) {
    EBDetId id = EBDetId::unhashIndex(iChannel);
    chit = chStatus->getMap().find(id.rawId());
    if( chit != chStatus->getMap().end() ) {
      EcalChannelStatusCode ch_code = (*chit);
      uint16_t statusCode = ch_code.getStatusCode() & 31;
      if(statusCode == 1 || (statusCode > 7 && statusCode < 12))
    maskedChannels_.push_back(iChannel);
    }
  }
  for (int iChannel = 0; iChannel < kEEChannels; iChannel++) {
    EEDetId id = EEDetId::unhashIndex(iChannel);
    chit = chStatus->getMap().find(id.rawId());
    if( chit != chStatus->getMap().end() ) {
      EcalChannelStatusCode ch_code = (*chit);
      uint16_t statusCode = ch_code.getStatusCode() & 31;
      if(statusCode == 1 || (statusCode > 7 && statusCode < 12))
    maskedEEChannels_.push_back(iChannel);
    }
  }
  */
  TH1F** hMean = new TH1F*[15];
  TH1F** hRMS = new TH1F*[15];
  TFile f("PedHist.root", "RECREATE");

  typedef struct {
    int iChannel;
    int ix;
    int iy;
    int iz;
  } Chan_t;
  Chan_t Chan;
  Chan.iChannel = -1;
  Chan.ix = -1;
  Chan.iy = -1;
  Chan.iz = -1;

  TTree* tPedChan = new TTree("PedChan", "Channels");  // Output tree for channels
  tPedChan->Branch("Channels", &Chan.iChannel, "iChannel/I");
  tPedChan->Branch("x", &Chan.ix, "ix/I");
  tPedChan->Branch("y", &Chan.iy, "iy/I");
  tPedChan->Branch("z", &Chan.iz, "iz/I");
  for (int iChannel = 0; iChannel < kEBChannels; iChannel++) {
    Chan.iChannel = iChannel;
    EBDetId myEBDetId = EBDetId::unhashIndex(iChannel);
    Chan.ix = myEBDetId.ieta();  // -85:-1,1:85
    Chan.iy = myEBDetId.iphi();  // 1:360
    Chan.iz = 0;
    if (iChannel % 10000 == 0)
      cout << " EB channel " << iChannel << " eta " << Chan.ix << " phi " << Chan.iy << endl;
    tPedChan->Fill();
  }
  for (int iChannel = 0; iChannel < kEEChannels; iChannel++) {
    Chan.iChannel = iChannel;
    EEDetId myEEDetId = EEDetId::unhashIndex(iChannel);
    Chan.ix = myEEDetId.ix();
    Chan.iy = myEEDetId.iy();
    Chan.iz = myEEDetId.zside();
    if (iChannel % 1000 == 0)
      cout << " EE channel " << iChannel << " x " << Chan.ix << " y " << Chan.iy << " z " << Chan.iz << endl;
    tPedChan->Fill();
  }
  tPedChan->Write();
  tPedChan->Print();

  typedef struct {
    int Run;
    double Mean[kChannels];
    double RMS[kChannels];
  } Ped_t;
  Ped_t PedVal;
  PedVal.Run = -1;  // initialization
  for (int iChannel = 0; iChannel < kChannels; iChannel++) {
    PedVal.Mean[iChannel] = -1.;
    PedVal.RMS[iChannel] = -1.;
  }
  TTree* tPedHist = new TTree("PedHist", "Pedestal History");  // Output tree for pedestal mean/rms
  tPedHist->Branch("Pedestals", &PedVal.Run, "Run/I");
  tPedHist->Branch("Mean", PedVal.Mean, "Mean[75848]/D");
  tPedHist->Branch("RMS", PedVal.RMS, "RMS[75848]/D");

  // here we retrieve all the runs after the last from online DB
  std::cout << "Retrieving run list from ONLINE DB ... " << std::endl;
  econn = new EcalCondDBInterface(m_sid, m_user, m_pass);
  std::cout << "Connection done" << std::endl;
  if (!econn) {
    std::cout << " Problem with OMDS: connection parameters " << m_sid << "/" << m_user << "/" << m_pass << std::endl;
    throw cms::Exception("OMDS not available");
  }

  // these are the online conditions DB classes
  RunList my_runlist;
  RunTag my_runtag;
  LocationDef my_locdef;
  RunTypeDef my_rundef;

  my_locdef.setLocation(m_location);
  my_rundef.setRunType("PEDESTAL");
  my_runtag.setLocationDef(my_locdef);
  my_runtag.setRunTypeDef(my_rundef);
  my_runtag.setGeneralTag(m_gentag);

  // here we retrieve the Monitoring run records
  MonVersionDef monverdef;
  monverdef.setMonitoringVersion("test01");
  MonRunTag mon_tag;
  //    mon_tag.setGeneralTag("CMSSW");
  mon_tag.setGeneralTag("CMSSW-offline-private");
  mon_tag.setMonVersionDef(monverdef);
  MonRunList mon_list;
  mon_list.setMonRunTag(mon_tag);
  mon_list.setRunTag(my_runtag);
  //    mon_list=econn->fetchMonRunList(my_runtag, mon_tag);
  unsigned int min_run = 0, max_since = 0;
  if (m_firstRun < max_since) {
    min_run = max_since + 1;  // we have to add 1 to the last transferred one
  } else {
    min_run = m_firstRun;
  }

  unsigned int max_run = m_lastRun;
  mon_list = econn->fetchMonRunList(my_runtag, mon_tag, min_run, max_run);

  std::vector<MonRunIOV> mon_run_vec = mon_list.getRuns();
  int mon_runs = mon_run_vec.size();
  std::cout << "number of Mon runs is : " << mon_runs << std::endl;

  if (mon_runs > 0) {
    int NbChan = 0;
    for (int iChannel = 0; iChannel < kEBChannels; iChannel++) {
      if (iChannel % 10000 == 1) {
        hMean[NbChan] = new TH1F(Form("Mean_%i", NbChan), Form("Mean EB %i", iChannel), mon_runs, 0., mon_runs);
        hRMS[NbChan] = new TH1F(Form("RMS_%i", NbChan), Form("RMS EB %i", iChannel), mon_runs, 0., mon_runs);
        NbChan++;
      }
    }
    for (int iChannel = 0; iChannel < kEEChannels; iChannel++) {
      if (iChannel % 2000 == 1) {
        hMean[NbChan] = new TH1F(Form("Mean_%i", NbChan), Form("Mean EE %i", iChannel), mon_runs, 0., mon_runs);
        hRMS[NbChan] = new TH1F(Form("RMS_%i", NbChan), Form("RMS EE %i", iChannel), mon_runs, 0., mon_runs);
        NbChan++;
      }
    }

    //    int krmax = std::min(mon_runs, 30);
    int krmax = mon_runs;
    for (int kr = 0; kr < krmax; kr++) {
      std::cout << "-kr------:  " << kr << std::endl;

      unsigned int irun = static_cast<unsigned int>(mon_run_vec[kr].getRunIOV().getRunNumber());
      std::cout << "retrieve the data for run number: " << irun << std::endl;
      if (mon_run_vec[kr].getSubRunNumber() <= 1) {
        // retrieve the data for a given run
        RunIOV runiov_prime = mon_run_vec[kr].getRunIOV();
        // retrieve the pedestals from OMDS for this run
        std::map<EcalLogicID, MonPedestalsDat> dataset_mon;
        econn->fetchDataSet(&dataset_mon, &mon_run_vec[kr]);
        std::cout << "OMDS record for run " << irun << " is made of " << dataset_mon.size() << std::endl;
        int nEB = 0, nEE = 0, nEBbad = 0, nEEbad = 0;
        typedef std::map<EcalLogicID, MonPedestalsDat>::const_iterator CImon;
        EcalLogicID ecid_xt;
        MonPedestalsDat rd_ped;

        // this to validate ...
        int nbad = 0;
        for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
          ecid_xt = p->first;
          rd_ped = p->second;
          int sm_num = ecid_xt.getID1();
          int xt_num = ecid_xt.getID2();
          int yt_num = ecid_xt.getID3();

          //checkPedestal
          bool result = true;
          if (rd_ped.getPedRMSG12() > 3 || rd_ped.getPedRMSG12() <= 0 || rd_ped.getPedRMSG6() > 2 ||
              rd_ped.getPedRMSG12() <= 0 || rd_ped.getPedRMSG1() > 1 || rd_ped.getPedRMSG1() <= 0 ||
              rd_ped.getPedMeanG12() > 300 || rd_ped.getPedMeanG12() <= 100 || rd_ped.getPedMeanG6() > 300 ||
              rd_ped.getPedMeanG6() <= 100 || rd_ped.getPedMeanG1() > 300 || rd_ped.getPedMeanG6() <= 100)
            result = false;

          // here we check and count how many bad channels we have
          if (!result) {
            nbad++;
            if (nbad < 10)
              std::cout << "BAD LIST: channel " << sm_num << "/" << xt_num << "/" << yt_num << "ped/rms "
                        << rd_ped.getPedMeanG12() << "/" << rd_ped.getPedRMSG12() << std::endl;
          }
          if (ecid_xt.getName() == "EB_crystal_number") {
            nEB++;
            if (!result)
              nEBbad++;
          } else {
            nEE++;
            if (!result)
              nEEbad++;
          }
        }  // end loop over pedestal data
        // ok or bad? A bad run is for more than 5% bad channels

        //        if(nbad<(dataset_mon.size()*0.1)){
        if (nbad < (dataset_mon.size() * 0.05) &&
            (nEB > 10200 || nEE > 2460)) {  // this is good run, fill histo and tree
          PedVal.Run = irun;
          int NbChan = 0;
          for (CImon p = dataset_mon.begin(); p != dataset_mon.end(); p++) {
            ecid_xt = p->first;
            rd_ped = p->second;
            int sm_num = ecid_xt.getID1();
            int xt_num = ecid_xt.getID2();
            int yt_num = ecid_xt.getID3();

            if (ecid_xt.getName() == "EB_crystal_number") {  // Barrel
              EBDetId ebdetid(sm_num, xt_num, EBDetId::SMCRYSTALMODE);
              int iChannel = ebdetid.hashedIndex();
              if (iChannel < 0 || iChannel > 61200)
                cout << " SM " << sm_num << " Chan in SM " << xt_num << " IChannel " << iChannel << endl;
              if (iChannel % 10000 == 1) {
                hMean[NbChan]->Fill(kr, rd_ped.getPedMeanG12());
                hRMS[NbChan]->Fill(kr, rd_ped.getPedRMSG12());
                NbChan++;
              }
              PedVal.Mean[iChannel] = rd_ped.getPedMeanG12();
              PedVal.RMS[iChannel] = rd_ped.getPedRMSG12();
              if (iChannel % 10000 == 0)
                cout << " channel " << iChannel << " mean " << PedVal.Mean[iChannel] << " RMS " << PedVal.RMS[iChannel]
                     << endl;
            } else {  // Endcaps
              if (EEDetId::validDetId(xt_num, yt_num, sm_num)) {
                EEDetId eedetid(xt_num, yt_num, sm_num);
                int iChannel = eedetid.hashedIndex();
                if (iChannel < 0 || iChannel > 14648)
                  cout << " x " << sm_num << " y " << xt_num << " z " << yt_num << " IChannel " << iChannel << endl;
                if (iChannel % 2000 == 1) {
                  hMean[NbChan]->Fill(kr, rd_ped.getPedMeanG12());
                  hRMS[NbChan]->Fill(kr, rd_ped.getPedRMSG12());
                  NbChan++;
                }
                int iChanEE = kEBChannels + iChannel;
                //      cout << " channel EE " << iChanEE << endl;
                PedVal.Mean[iChanEE] = rd_ped.getPedMeanG12();
                PedVal.RMS[iChanEE] = rd_ped.getPedRMSG12();
              }  // valid ee Id
            }    // Endcaps
          }      // loop over channels
          tPedHist->Fill();
          cout << " We got a good run " << irun << endl;
        }  // good run
      }    // mon_run_vec
    }      // loop over all runs
  }        // number of runs > 0
  cout << "Exiting beginRun" << endl;
  for (int NbChan = 0; NbChan < 15; NbChan++) {
    if (hMean[NbChan]->GetEntries() > 0.) {  // save only when filled!
      hMean[NbChan]->Write();
      hRMS[NbChan]->Write();
    }
  }
  tPedHist->Write();
  tPedHist->Print();
  f.Close();

}  //beginRun

endJob()

void EcalPedestalHistory::endJob ( void  )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 370 of file EcalPedestalHistory.cc.

                                 {
  //========================================================================

}  //endJob

endRun()

void EcalPedestalHistory::endRun ( edm::Run const &  , edm::EventSetup const &  c  )

override

Definition at line 358 of file EcalPedestalHistory.cc.

                                                                      {
  //========================================================================

}  //endRun

Member Data Documentation

cnt_evt_

unsigned int EcalPedestalHistory::cnt_evt_

private

Definition at line 60 of file EcalPedestalHistory.h.

ECALType_

std::string EcalPedestalHistory::ECALType_

private

Definition at line 61 of file EcalPedestalHistory.h.

econn

EcalCondDBInterface* EcalPedestalHistory::econn

Definition at line 53 of file EcalPedestalHistory.h.

m_firstRun

unsigned int EcalPedestalHistory::m_firstRun

private

Definition at line 66 of file EcalPedestalHistory.h.

m_gentag

std::string EcalPedestalHistory::m_gentag

private

Definition at line 69 of file EcalPedestalHistory.h.

m_lastRun

unsigned int EcalPedestalHistory::m_lastRun

private

Definition at line 67 of file EcalPedestalHistory.h.

m_location

std::string EcalPedestalHistory::m_location

private

Definition at line 68 of file EcalPedestalHistory.h.

m_locationsource

std::string EcalPedestalHistory::m_locationsource

private

Definition at line 73 of file EcalPedestalHistory.h.

m_name

std::string EcalPedestalHistory::m_name

private

Definition at line 74 of file EcalPedestalHistory.h.

m_pass

std::string EcalPedestalHistory::m_pass

private

Definition at line 72 of file EcalPedestalHistory.h.

m_sid

std::string EcalPedestalHistory::m_sid

private

Definition at line 70 of file EcalPedestalHistory.h.

m_user

std::string EcalPedestalHistory::m_user

private

Definition at line 71 of file EcalPedestalHistory.h.

maskedChannels_

std::vector<int> EcalPedestalHistory::maskedChannels_

private

Definition at line 64 of file EcalPedestalHistory.h.

maskedEEChannels_

std::vector<int> EcalPedestalHistory::maskedEEChannels_

private

Definition at line 65 of file EcalPedestalHistory.h.

runnumber_

int EcalPedestalHistory::runnumber_

private

Definition at line 59 of file EcalPedestalHistory.h.

runType_

std::string EcalPedestalHistory::runType_

private

Definition at line 62 of file EcalPedestalHistory.h.

startevent_

unsigned int EcalPedestalHistory::startevent_

private

Definition at line 63 of file EcalPedestalHistory.h.