Inheritance diagram for RecAnalyzerMinbias:

Classes
struct	myInfo

Public Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &) override

virtual void	beginJob ()

virtual void	beginRun (edm::Run const &iRun, edm::EventSetup const &iSetup)

virtual void	endJob ()

	RecAnalyzerMinbias (const edm::ParameterSet &)

	~RecAnalyzerMinbias ()

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

	EDAnalyzer ()

ModuleDescription const &	moduleDescription () const

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
void	analyzeHcal (const HBHERecHitCollection &, const HFRecHitCollection &, int, bool)

Private Attributes
int	cells

std::map< DetId, double >	corrFactor_

int	depth

double	eHighHB_

double	eHighHE_

double	eHighHF_

double	eLowHB_

double	eLowHE_

double	eLowHF_

bool	fillHist_

std::string	fOutputFileName_

std::vector< unsigned int >	hcalID_

std::map< HcalDetId, TH1D * >	histHB_

std::map< HcalDetId, TH1D * >	histHE_

std::map< HcalDetId, TH1D * >	histHF_

std::vector< TH1D * >	histo_

TFile *	hOutputFile_

int	ieta

bool	ignoreL1_

bool	init_

int	iphi

float	mom0_MB

float	mom1_MB

float	mom2_MB

float	mom3_MB

float	mom4_MB

std::map< std::pair< int, HcalDetId >, myInfo >	myMap_

int	mysubd

TTree *	myTree_

double	rnnum_

double	rnnumber

bool	runNZS_

bool	theRecalib_

edm::EDGetTokenT < HBHERecHitCollection >	tok_hbherecoMB_

edm::EDGetTokenT < HFRecHitCollection >	tok_hfrecoMB_

edm::EDGetTokenT < L1GlobalTriggerObjectMapRecord >	tok_hltL1GtMap_

int	trigbit

std::vector< int >	trigbit_

Additional Inherited Members
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

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

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

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

Detailed Description

Definition at line 34 of file RecAnalyzerMinbias.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 78 of file RecAnalyzerMinbias.cc.

References funct::abs(), corrFactor_, depth, eHighHB_, eHighHE_, eHighHF_, eLowHB_, eLowHE_, eLowHF_, fillHist_, fOutputFileName_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), HcalBarrel, HcalEndcap, HcalForward, hcalID_, HcalOuter, ieta, ignoreL1_, EdgesToViz::infile, HLT_25ns14e33_v1_cff::InputTag, iphi, relval_steps::k, runNZS_, AlCaHLTBitMon_QueryRunRegistry::string, theRecalib_, tok_hbherecoMB_, tok_hfrecoMB_, tok_hltL1GtMap_, and trigbit_.

                                                                      :
   init_(false) {
 
   // get name of output file with histogramms
   runNZS_               = iConfig.getParameter<bool>("RunNZS");
   eLowHB_               = iConfig.getParameter<double>("ELowHB");
   eHighHB_              = iConfig.getParameter<double>("EHighHB");
   eLowHE_               = iConfig.getParameter<double>("ELowHE");
   eHighHE_              = iConfig.getParameter<double>("EHighHE");
   eLowHF_               = iConfig.getParameter<double>("ELowHF");
   eHighHF_              = iConfig.getParameter<double>("EHighHF");
   fOutputFileName_      = iConfig.getUntrackedParameter<std::string>("HistOutFile");
   trigbit_              = iConfig.getUntrackedParameter<std::vector<int>>("TriggerBits");
   ignoreL1_             = iConfig.getUntrackedParameter<bool>("IgnoreL1",false);
   std::string      cfile= iConfig.getUntrackedParameter<std::string>("CorrFile");
   fillHist_             = iConfig.getUntrackedParameter<bool>("FillHisto",false);
   std::vector<int> ieta = iConfig.getUntrackedParameter<std::vector<int>>("HcalIeta");
   std::vector<int> iphi = iConfig.getUntrackedParameter<std::vector<int>>("HcalIphi");
   std::vector<int> depth= iConfig.getUntrackedParameter<std::vector<int>>("HcalDepth");
 
   // get token names of modules, producing object collections
   tok_hbherecoMB_   = consumes<HBHERecHitCollection>(iConfig.getParameter<edm::InputTag>("hbheInputMB"));
   tok_hfrecoMB_     = consumes<HFRecHitCollection>(iConfig.getParameter<edm::InputTag>("hfInputMB"));
   tok_hltL1GtMap_   = consumes<L1GlobalTriggerObjectMapRecord>(edm::InputTag("hltL1GtObjectMap"));
 
   // Read correction factors
   std::ifstream infile(cfile);
   if (!infile.is_open()) {
     theRecalib_ = false;
     edm::LogInfo("AnalyzerMB") << "Cannot open '" << cfile 
                    << "' for the correction file";
   } else {
     unsigned int ndets(0), nrec(0);
     while(1) {
       unsigned int id;
       double       cfac;
       infile >> id >> cfac;
       if (!infile.good()) break;
       HcalDetId detId(id);
       nrec++;
       std::map<DetId,double>::iterator itr = corrFactor_.find(detId);
       if (itr == corrFactor_.end()) {
     corrFactor_[detId] = cfac;
     ndets++;
       }
     }
     infile.close();
     edm::LogInfo("AnalyzerMB") << "Reads " << nrec << " correction factors for "
                    << ndets << " detIds";
     theRecalib_ = (ndets>0);
   }
 
   edm::LogInfo("AnalyzerMB") << " Flags (ReCalib): " << theRecalib_
                  << " (IgnoreL1): " << ignoreL1_ << " (NZS) " 
                  << runNZS_ << " and with " << ieta.size() 
                  << " detId for full histogram";
   edm::LogInfo("AnalyzerMB") << "Thresholds for HB " << eLowHB_ << ":" 
                  << eHighHB_ << "  for HE " << eLowHE_ << ":" 
                  << eHighHE_ << "  for HF " << eLowHF_ << ":" 
                  << eHighHF_;
   for (unsigned int k=0; k<ieta.size(); ++k) {
     HcalSubdetector subd = ((std::abs(ieta[k]) > 29) ? HcalForward : 
                 (std::abs(ieta[k]) > 16) ? HcalEndcap :
                 ((std::abs(ieta[k]) == 16) && (depth[k] == 3)) ? HcalEndcap :
                 (depth[k] == 4) ? HcalOuter : HcalBarrel);
     unsigned int id = (HcalDetId(subd,ieta[k],iphi[k],depth[k])).rawId();
     hcalID_.push_back(id);
     edm::LogInfo("AnalyzerMB") << "DetId[" << k << "] " << HcalDetId(id);
   }
   edm::LogInfo("AnalyzerMB") << "Select on " << trigbit_.size() 
                  << " L1 Trigger selection";
   for (unsigned int k=0; k<trigbit_.size(); ++k)
     edm::LogInfo("AnalyzerMB") << "Bit[" << k << "] " << trigbit_[k];
 }

RecAnalyzerMinbias::~RecAnalyzerMinbias ( )

Definition at line 153 of file RecAnalyzerMinbias.cc.

153 {}

Member Function Documentation

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

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 302 of file RecAnalyzerMinbias.cc.

References analyzeHcal(), spr::find(), edm::Event::getByToken(), ignoreL1_, edm::HandleBase::isValid(), convertSQLiteXML::ok, edm::Handle< T >::product(), mathSSE::return(), rnnum_, edm::Event::run(), runNZS_, benchmark_cfg::select, edm::SortedCollection< T, SORT >::size(), tok_hbherecoMB_, tok_hfrecoMB_, tok_hltL1GtMap_, and trigbit_.

                                                                                     {
     
   rnnum_ = (float)iEvent.run(); 
     
   edm::Handle<HBHERecHitCollection> hbheMB;
   iEvent.getByToken(tok_hbherecoMB_, hbheMB);
   if (!hbheMB.isValid()) {
     edm::LogWarning("AnalyzerMB") << "HcalCalibAlgos: Error! can't get hbhe product!";
     return ;
   }
   const HBHERecHitCollection HithbheMB = *(hbheMB.product());
   edm::LogInfo("AnalyzerMB") << "HBHE MB size of collection "<<HithbheMB.size();
   if (HithbheMB.size() < 5100 && runNZS_) {
     edm::LogWarning("AnalyzerMB") << "HBHE problem " << rnnum_ << " size "
                   << HithbheMB.size();
     return;
   }
     
   edm::Handle<HFRecHitCollection> hfMB;
   iEvent.getByToken(tok_hfrecoMB_, hfMB);
   if (!hfMB.isValid()) {
     edm::LogWarning("AnalyzerMB") << "HcalCalibAlgos: Error! can't get hbhe product!";
     return ;
   }
   const HFRecHitCollection HithfMB = *(hfMB.product());
   edm::LogInfo("AnalyzerMB") << "HF MB size of collection " << HithfMB.size();
   if (HithfMB.size() < 1700 && runNZS_) {
     edm::LogWarning("AnalyzerMB") << "HF problem " << rnnum_ << " size "
                   << HithfMB.size();
     return;
   }
 
   bool select(false);
   if (trigbit_.size() > 0) {
     edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
     iEvent.getByToken(tok_hltL1GtMap_, gtObjectMapRecord);
     if (gtObjectMapRecord.isValid()) {
       const std::vector<L1GlobalTriggerObjectMap>& objMapVec = gtObjectMapRecord->gtObjectMap();
       for (std::vector<L1GlobalTriggerObjectMap>::const_iterator itMap = objMapVec.begin();
            itMap != objMapVec.end(); ++itMap) {
         bool resultGt = (*itMap).algoGtlResult();
         if (resultGt) {
           int algoBit = (*itMap).algoBitNumber();
           if (std::find(trigbit_.begin(),trigbit_.end(),algoBit) != 
           trigbit_.end()) {
             select = true;
             break;
           }
         }
       }
     }
   }
 
   if (ignoreL1_ || ((trigbit_.size() > 0) && select)) {
     analyzeHcal(HithbheMB, HithfMB, 1, true);
   } else if ((!ignoreL1_) && (trigbit_.size() == 0)) {
     edm::Handle<L1GlobalTriggerObjectMapRecord> gtObjectMapRecord;
     iEvent.getByToken(tok_hltL1GtMap_, gtObjectMapRecord);
     if (gtObjectMapRecord.isValid()) {
       const std::vector<L1GlobalTriggerObjectMap>& objMapVec = gtObjectMapRecord->gtObjectMap();
       bool ok(false);
       for (std::vector<L1GlobalTriggerObjectMap>::const_iterator itMap = objMapVec.begin();
        itMap != objMapVec.end(); ++itMap) {
     bool resultGt = (*itMap).algoGtlResult();
     if (resultGt) {
       int algoBit = (*itMap).algoBitNumber();
       analyzeHcal(HithbheMB, HithfMB, algoBit, (!ok));
       ok          = true;
     } 
       }
       if (!ok) {
     edm::LogInfo("AnalyzerMB") << "No passed L1 Trigger found";
       }
     }
   }
 }

void RecAnalyzerMinbias::analyzeHcal	(	const HBHERecHitCollection &	HithbheMB,
		const HFRecHitCollection &	HithfMB,
		int	algoBit,
		bool	fill
	)

private

Definition at line 379 of file RecAnalyzerMinbias.cc.

References edm::SortedCollection< T, SORT >::begin(), corrFactor_, eHighHB_, eHighHE_, eHighHF_, eLowHB_, eLowHE_, eLowHF_, edm::SortedCollection< T, SORT >::end(), CaloRecHit::energy(), HcalEndcap, hcalID_, histHB_, histHE_, histHF_, histo_, i, info(), myMap_, DetId::rawId(), rnnum_, runNZS_, HcalDetId::subdet(), and theRecalib_.

Referenced by analyze().

                                              {
   // Signal part for HB HE
   for (HBHERecHitCollection::const_iterator hbheItr=HithbheMB.begin(); 
        hbheItr!=HithbheMB.end(); hbheItr++) {
     // Recalibration of energy
     DetId mydetid = hbheItr->id().rawId();
     double icalconst(1.);    
     if (theRecalib_) {
       std::map<DetId,double>::iterator itr = corrFactor_.find(mydetid);
       if (itr != corrFactor_.end()) icalconst = itr->second;
     }
     HBHERecHit aHit(hbheItr->id(),hbheItr->energy()*icalconst,hbheItr->time());
     double energyhit = aHit.energy();
     DetId id         = (*hbheItr).detid(); 
     HcalDetId hid    = HcalDetId(id);
     double eLow      = (hid.subdet() == HcalEndcap) ? eLowHE_  : eLowHB_;
     double eHigh     = (hid.subdet() == HcalEndcap) ? eHighHE_ : eHighHB_;
     if (fill) {
       for (unsigned int i = 0; i < hcalID_.size(); i++) {
     if (hcalID_[i] == id.rawId()) {
       histo_[i]->Fill(energyhit);
       break;
     }
       }
       std::map<HcalDetId,TH1D*>::iterator itr1 = histHB_.find(hid);
       if (itr1 != histHB_.end()) itr1->second->Fill(energyhit);
       std::map<HcalDetId,TH1D*>::iterator itr2 = histHE_.find(hid);
       if (itr2 != histHE_.end()) itr2->second->Fill(energyhit);
     }
 
     if (runNZS_ || (energyhit >= eLow && energyhit <= eHigh)) {
       std::map<std::pair<int,HcalDetId>,myInfo>::iterator itr1 = myMap_.find(std::pair<int,HcalDetId>(algoBit,hid));
       if (itr1 == myMap_.end()) {
     myInfo info;
     myMap_[std::pair<int,HcalDetId>(algoBit,hid)] = info;
     itr1 = myMap_.find(std::pair<int,HcalDetId>(algoBit,hid));
       } 
       itr1->second.theMB0++;
       itr1->second.theMB1 += energyhit;
       itr1->second.theMB2 += (energyhit*energyhit);
       itr1->second.theMB3 += (energyhit*energyhit*energyhit);
       itr1->second.theMB4 += (energyhit*energyhit*energyhit*energyhit);
       itr1->second.runcheck = rnnum_;
     }
   } // HBHE_MB
  
   // Signal part for HF
   for (HFRecHitCollection::const_iterator hfItr=HithfMB.begin(); 
        hfItr!=HithfMB.end(); hfItr++) {
     // Recalibration of energy
     DetId mydetid = hfItr->id().rawId();
     double icalconst(1.);    
     if (theRecalib_) {
       std::map<DetId,double>::iterator itr = corrFactor_.find(mydetid);
       if (itr != corrFactor_.end()) icalconst = itr->second;
     }
     HFRecHit aHit(hfItr->id(),hfItr->energy()*icalconst,hfItr->time());
     
     double energyhit = aHit.energy();
     DetId id         = (*hfItr).detid(); 
     HcalDetId hid    = HcalDetId(id);
     if (fill) {
       for (unsigned int i = 0; i < hcalID_.size(); i++) {
     if (hcalID_[i] == id.rawId()) {
       histo_[i]->Fill(energyhit);
       break;
     }
       }
       std::map<HcalDetId,TH1D*>::iterator itr1 = histHF_.find(hid);
       if (itr1 != histHF_.end()) itr1->second->Fill(energyhit);
     }
 
     //
     // Remove PMT hits
     //   
     if ((runNZS_ && fabs(energyhit) <= 40.) || 
     (energyhit >= eLowHF_ && energyhit <= eHighHF_)) {
       std::map<std::pair<int,HcalDetId>,myInfo>::iterator itr1 = myMap_.find(std::pair<int,HcalDetId>(algoBit,hid));
       if (itr1 == myMap_.end()) {
     myInfo info;
     myMap_[std::pair<int,HcalDetId>(algoBit,hid)] = info;
     itr1 = myMap_.find(std::pair<int,HcalDetId>(algoBit,hid));
       }
       itr1->second.theMB0++;
       itr1->second.theMB1 += energyhit;
       itr1->second.theMB2 += (energyhit*energyhit);
       itr1->second.theMB3 += (energyhit*energyhit*energyhit);
       itr1->second.theMB4 += (energyhit*energyhit*energyhit*energyhit);
       itr1->second.runcheck = rnnum_;
     }
   }
 }

void RecAnalyzerMinbias::beginJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 155 of file RecAnalyzerMinbias.cc.

References cells, depth, fOutputFileName_, AnalysisDataFormats_SUSYBSMObjects::hc, hcalID_, histo_, hOutputFile_, i, ieta, iphi, mom0_MB, mom1_MB, mom2_MB, mom4_MB, myMap_, mysubd, myTree_, mergeVDriftHistosByStation::name, rnnumber, AlCaHLTBitMon_QueryRunRegistry::string, indexGen::title, trigbit, SiStripMonitorClusterAlca_cfi::xmax, and SiStripMonitorClusterAlca_cfi::xmin.

                                   {
 
   std::string hc[5] = {"Empty", "HB", "HE", "HO", "HF"};
   char        name[700], title[700];
   for (unsigned int i=0; i<hcalID_.size(); i++) {
     HcalDetId id = HcalDetId(hcalID_[i]);
     int subdet   = id.subdetId();
     sprintf (name, "%s%d_%d_%d", hc[subdet].c_str(), id.ieta(), id.iphi(), id.depth());
     sprintf (title, "Energy Distribution for %s ieta %d iphi %d depth %d", hc[subdet].c_str(), id.ieta(), id.iphi(), id.depth());
     double xmin = (subdet == 4) ? -10 : -1;
     double xmax = (subdet == 4) ? 90 : 9;
     TH1D*  hh   = new TH1D(name, title, 50, xmin, xmax);
     histo_.push_back(hh);
   };
 
   hOutputFile_  = new TFile(fOutputFileName_.c_str(), "RECREATE");
   myTree_       = new TTree("RecJet","RecJet Tree");
   myTree_->Branch("cells",    &cells,    "cells/I");
   myTree_->Branch("mysubd",   &mysubd,   "mysubd/I");
   myTree_->Branch("depth",    &depth,    "depth/I");
   myTree_->Branch("ieta",     &ieta,     "ieta/I");
   myTree_->Branch("iphi",     &iphi,     "iphi/I");
   myTree_->Branch("mom0_MB",  &mom0_MB,  "mom0_MB/F");
   myTree_->Branch("mom1_MB",  &mom1_MB,  "mom1_MB/F");
   myTree_->Branch("mom2_MB",  &mom2_MB,  "mom2_MB/F");
   myTree_->Branch("mom3_MB",  &mom2_MB,  "mom3_MB/F");
   myTree_->Branch("mom4_MB",  &mom4_MB,  "mom4_MB/F");
   myTree_->Branch("trigbit",  &trigbit,  "trigbit/I");
   myTree_->Branch("rnnumber", &rnnumber, "rnnumber/D");
 
   myMap_.clear();
 }

void RecAnalyzerMinbias::beginRun	(	edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 189 of file RecAnalyzerMinbias.cc.

References depth, eHighHB_, eHighHE_, eHighHF_, eta, fillHist_, edm::EventSetup::get(), h, HcalBarrel, HcalEndcap, HcalForward, histHB_, histHE_, histHF_, init_, edm::ESHandleBase::isValid(), HcalTopology::maxDepthHB(), mergeVDriftHistosByStation::name, phi, edm::ESHandle< class >::product(), indexGen::title, and HcalTopology::valid().

                                                                         {
  
   if (!init_) {
     init_ = true;
     if (fillHist_) {
       edm::ESHandle<HcalTopology> htopo;
       iS.get<IdealGeometryRecord>().get(htopo);
       if (htopo.isValid()) {
     const HcalTopology* hcaltopology = htopo.product();
 
     char  name[700], title[700];
     // For HB
     int maxDepthHB = hcaltopology->maxDepthHB();
     int nbinHB     = int(200*eHighHB_);
     for (int eta = -50; eta < 50; eta++) {
       for (int phi = 0; phi < 100; phi++) {
         for (int depth = 1; depth < maxDepthHB; depth++) {
           HcalDetId cell (HcalBarrel, eta, phi, depth);
           if (hcaltopology->valid(cell)) {
         sprintf (name, "HBeta%dphi%ddep%d", eta, phi, depth);
         sprintf (title,"Energy (HB #eta %d #phi %d depth %d)", eta, phi, depth);
         TH1D* h = new TH1D(name, title, nbinHB, 0, 2*eHighHB_);
         histHB_[cell] = h;
           }
         }
       }
     }
     // For HE
     int maxDepthHE = hcaltopology->maxDepthHB();
     int nbinHE     = int(200*eHighHE_);
     for (int eta = -50; eta < 50; eta++) {
       for (int phi = 0; phi < 100; phi++) {
         for (int depth = 1; depth < maxDepthHE; depth++) {
           HcalDetId cell (HcalEndcap, eta, phi, depth);
           if (hcaltopology->valid(cell)) {
         sprintf (name, "HEeta%dphi%ddep%d", eta, phi, depth);
         sprintf (title,"Energy (HE #eta %d #phi %d depth %d)", eta, phi, depth);
         TH1D* h = new TH1D(name, title, nbinHE, 0, 2*eHighHE_);
         histHE_[cell] = h;
           }
         }
       }
     }
     // For HF
     int maxDepthHF = 4;
     int nbinHF     = int(200*eHighHF_);
     for (int eta = -50; eta < 50; eta++) {
       for (int phi = 0; phi < 100; phi++) {
         for (int depth = 1; depth < maxDepthHF; depth++) {
           HcalDetId cell (HcalForward, eta, phi, depth);
           if (hcaltopology->valid(cell)) {
         sprintf (name, "HFeta%dphi%ddep%d", eta, phi, depth);
         sprintf (title,"Energy (HF #eta %d #phi %d depth %d)", eta, phi, depth);
         TH1D* h = new TH1D(name, title, nbinHF, 0, 2*eHighHF_);
         histHF_[cell] = h;
           }
         }
       }
     }
       }
     }
   }
 }

void RecAnalyzerMinbias::endJob ( void )

virtual

Reimplemented from edm::EDAnalyzer.

Definition at line 255 of file RecAnalyzerMinbias.cc.

References cells, depth, histHB_, histHE_, histHF_, histo_, hOutputFile_, i, ieta, info(), iphi, python.multivaluedict::map(), mom0_MB, mom1_MB, mom2_MB, mom3_MB, mom4_MB, myMap_, mysubd, myTree_, rnnumber, RecAnalyzerMinbias::myInfo::runcheck, RecAnalyzerMinbias::myInfo::theMB0, RecAnalyzerMinbias::myInfo::theMB1, RecAnalyzerMinbias::myInfo::theMB2, RecAnalyzerMinbias::myInfo::theMB3, RecAnalyzerMinbias::myInfo::theMB4, and trigbit.

                                 {
 
   cells = 0;
   for (std::map<std::pair<int,HcalDetId>,myInfo>::const_iterator itr=myMap_.begin(); itr != myMap_.end(); ++itr) {
     edm::LogInfo("AnalyzerMB") << "Fired trigger bit number "<<itr->first.first;
     myInfo info = itr->second;
     if (info.theMB0 > 0) { 
       mom0_MB  = info.theMB0;
       mom1_MB  = info.theMB1;
       mom2_MB  = info.theMB2;
       mom3_MB  = info.theMB3;
       mom4_MB  = info.theMB4;
       rnnumber = info.runcheck;
       trigbit  = itr->first.first;
       mysubd   = itr->first.second.subdet();
       depth    = itr->first.second.depth();
       iphi     = itr->first.second.iphi();
       ieta     = itr->first.second.ieta();
       edm::LogInfo("AnalyzerMB") << " Result=  " << trigbit << " " << mysubd 
                  << " " << ieta << " " << iphi << " mom0  " 
                  << mom0_MB << " mom1 " << mom1_MB << " mom2 " 
                  << mom2_MB << " mom3 " << mom3_MB << " mom4 " 
                  << mom4_MB;
       myTree_->Fill();
       cells++;
     }
   }
   edm::LogInfo("AnalyzerMB") << "cells" << " " << cells;
   
   hOutputFile_->Write();   
   hOutputFile_->cd();
   for (unsigned int i=0; i<histo_.size(); i++) histo_[i]->Write();
   for (std::map<HcalDetId,TH1D*>::iterator itr=histHB_.begin();
        itr != histHB_.end(); ++itr) itr->second->Write();
   for (std::map<HcalDetId,TH1D*>::iterator itr=histHE_.begin();
        itr != histHE_.end(); ++itr) itr->second->Write();
   for (std::map<HcalDetId,TH1D*>::iterator itr=histHF_.begin();
        itr != histHF_.end(); ++itr) itr->second->Write();
   myTree_->Write();
   hOutputFile_->Close() ;
 }