Inheritance diagram for HcalHBHEMuonSimAnalyzer:

Public Member Functions
	HcalHBHEMuonSimAnalyzer (const edm::ParameterSet &)

	~HcalHBHEMuonSimAnalyzer ()

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::SharedResources >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

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::vector< ModuleDescription const * > &modules, 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	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
double	activeLength (const DetId &)

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

virtual void	beginJob () override

virtual void	beginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

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

void	clearVectors ()

virtual void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	endRun (edm::Run const &, edm::EventSetup const &) override

unsigned int	matchId (const HcalDetId &, const HcalDetId &)

Private Attributes
std::vector< HcalDDDRecConstants::HcalActiveLength >	actHB_

std::vector< HcalDDDRecConstants::HcalActiveLength >	actHE_

unsigned int	bxNumber_

std::string	ebLabel_

std::vector< double >	ecal3x3Energy_

std::vector< unsigned int >	ecalDetId_

std::string	eeLabel_

std::vector< double >	etaGlob_

double	etaMax_

unsigned int	eventNumber_

edm::Service< TFileService >	fs_

std::string	g4Label_

std::vector< double >	hcal1x1Energy_

std::vector< double >	hcalActiveLength_

std::vector< double >	hcalActiveLengthHot_

std::vector< double >	hcalDepthActiveLength_ [depthMax_]

std::vector< double >	hcalDepthActiveLengthHot_ [depthMax_]

std::vector< double >	hcalDepthEnergy_ [depthMax_]

std::vector< double >	hcalDepthEnergyHot_ [depthMax_]

std::vector< unsigned int >	hcalDetId_

std::vector< unsigned int >	hcalHot_

std::string	hcLabel_

const int	idMuon_ =13

unsigned int	lumiNumber_

std::vector< double >	matchedId_

int	maxDepth_

std::vector< double >	phiGlob_

std::vector< double >	pMuon_

std::vector< double >	ptGlob_

unsigned int	runNumber_

double	tMaxE_

double	tMaxH_

double	tMinE_

double	tMinH_

edm::EDGetTokenT< edm::PCaloHitContainer >	tok_caloEB_

edm::EDGetTokenT< edm::PCaloHitContainer >	tok_caloEE_

edm::EDGetTokenT< edm::PCaloHitContainer >	tok_caloHH_

edm::EDGetTokenT< edm::SimTrackContainer >	tok_SimTk_

edm::EDGetTokenT< edm::SimVertexContainer >	tok_SimVtx_

TTree *	tree_

int	verbosity_

Static Private Attributes
static const int	depthMax_ =7

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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 43 of file HcalHBHEMuonSimAnalyzer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 90 of file HcalHBHEMuonSimAnalyzer.cc.

References gather_cfg::cout, depthMax_, ebLabel_, eeLabel_, etaMax_, g4Label_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hcLabel_, TFileService::kSharedResource, maxDepth_, AlCaHLTBitMon_QueryRunRegistry::string, tMaxE_, tMaxH_, tMinE_, tMinH_, tok_caloEB_, tok_caloEE_, tok_caloHH_, tok_SimTk_, tok_SimVtx_, and verbosity_.

                                                                                {
 
   usesResource(TFileService::kSharedResource);
 
   //now do what ever initialization is needed
   g4Label_   = iConfig.getParameter<std::string>("ModuleLabel");
   ebLabel_   = iConfig.getParameter<std::string>("EBCollection");
   eeLabel_   = iConfig.getParameter<std::string>("EECollection");
   hcLabel_   = iConfig.getParameter<std::string>("HCCollection");
   verbosity_ = iConfig.getUntrackedParameter<int>("Verbosity",0);
   maxDepth_  = iConfig.getUntrackedParameter<int>("MaxDepth",4);
   etaMax_    = iConfig.getUntrackedParameter<double>("EtaMax", 3.0);
   tMinE_     = iConfig.getUntrackedParameter<double>("TimeMinCutECAL", -500.);
   tMaxE_     = iConfig.getUntrackedParameter<double>("TimeMaxCutECAL",  500.);
   tMinH_     = iConfig.getUntrackedParameter<double>("TimeMinCutHCAL", -500.);
   tMaxH_     = iConfig.getUntrackedParameter<double>("TimeMaxCutHCAL",  500.);
 
   tok_SimTk_  = consumes<edm::SimTrackContainer>(edm::InputTag(g4Label_));
   tok_SimVtx_ = consumes<edm::SimVertexContainer>(edm::InputTag(g4Label_));
   tok_caloEB_ = consumes<edm::PCaloHitContainer>(edm::InputTag(g4Label_,ebLabel_));
   tok_caloEE_ = consumes<edm::PCaloHitContainer>(edm::InputTag(g4Label_,eeLabel_));
   tok_caloHH_ = consumes<edm::PCaloHitContainer>(edm::InputTag(g4Label_,hcLabel_));
   if      (maxDepth_ > depthMax_) maxDepth_ = depthMax_;
   else if (maxDepth_ < 1)         maxDepth_ = 4;
 #ifdef EDM_ML_DEBUG
   std::cout << "Labels: " << g4Label_ << ":" << ebLabel_ << ":" << eeLabel_
         << ":" << hcLabel_ << "\nVerbosity " << verbosity_ << " MaxDepth "
         << maxDepth_ << " Maximum Eta " << etaMax_ << " tMin|tMax "
         << tMinE_ << ":" << tMaxE_ << ":" << tMinH_ << ":" << tMaxH_
         << std::endl;
 #endif
 }

HcalHBHEMuonSimAnalyzer::~HcalHBHEMuonSimAnalyzer ( )

Definition at line 123 of file HcalHBHEMuonSimAnalyzer.cc.

123 { }

Member Function Documentation

double HcalHBHEMuonSimAnalyzer::activeLength ( const DetId & id_ )

private

Definition at line 455 of file HcalHBHEMuonSimAnalyzer.cc.

References actHB_, actHE_, DEFINE_FWK_MODULE, particleFlowClusterECALTimeSelected_cfi::depth, HcalBarrel, mps_fire::i, and hcalTTPDigis_cfi::id.

Referenced by analyze(), and endLuminosityBlock().

                                                              {
   HcalDetId id(id_);
   int ieta = id.ietaAbs();
   int depth= id.depth();
   double lx(0);
   if (id.subdet() == HcalBarrel) {
     for (unsigned int i=0; i<actHB_.size(); ++i) {
       if (ieta == actHB_[i].ieta && depth == actHB_[i].depth) {
     lx = actHB_[i].thick;
     break;
       }
     }
   } else {
     for (unsigned int i=0; i<actHE_.size(); ++i) {
       if (ieta == actHE_[i].ieta && depth == actHE_[i].depth) {
     lx = actHE_[i].thick;
     break;
       }
     }
   }
   return lx;
 }

void HcalHBHEMuonSimAnalyzer::analyze	(	edm::Event const &	,
		edm::EventSetup const &
	)

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 125 of file HcalHBHEMuonSimAnalyzer.cc.

                                                    {
 
   clearVectors();
   bool debug(false);
 #ifdef EDM_ML_DEBUG
   debug = ((verbosity_/10)>0);
 #endif
   // depthHE is the first depth index for HE for |ieta| = 16
   // It used to be 3 for all runs preceding 2017 and 4 beyond that
   int depthHE = (maxDepth_ <= 6) ? 3 : 4;
 
   edm::ESHandle<HcalDDDRecConstants> pHRNDC;
   iSetup.get<HcalRecNumberingRecord>().get(pHRNDC);
   const HcalDDDRecConstants* hcons = &(*pHRNDC);
 
   runNumber_   = iEvent.id().run();
   eventNumber_ = iEvent.id().event();
   lumiNumber_  = iEvent.id().luminosityBlock();
   bxNumber_    = iEvent.bunchCrossing();
   
   //get Handles to SimTracks and SimHits
   edm::Handle<edm::SimTrackContainer> SimTk;
   iEvent.getByToken(tok_SimTk_,SimTk);
   edm::SimTrackContainer::const_iterator simTrkItr;
   edm::Handle<edm::SimVertexContainer> SimVtx;
   iEvent.getByToken(tok_SimVtx_,SimVtx);
 
   //get Handles to PCaloHitContainers of eb/ee/hbhe
   edm::Handle<edm::PCaloHitContainer> pcaloeb;
   iEvent.getByToken(tok_caloEB_, pcaloeb);
   edm::Handle<edm::PCaloHitContainer> pcaloee;
   iEvent.getByToken(tok_caloEE_, pcaloee);
   edm::Handle<edm::PCaloHitContainer> pcalohh;
   iEvent.getByToken(tok_caloHH_, pcalohh);
   std::vector<PCaloHit> calohh;
   bool testN(false);
   for (unsigned int k=1; k<pcalohh->size(); ++k) {
     // if it is a standard DetId bits 28..31 will carry the det #
     // for HCAL det # is 4 and if there is at least one hit in the collection
     // have det # which is not 4 this collection is created using TestNumbering
     int det = ((((*pcalohh)[k].id())>>28)&0xF);
     if (det != 4) {testN = true; break;}
   }
   if (testN) {
     for (edm::PCaloHitContainer::const_iterator itr=pcalohh->begin(); itr != pcalohh->end(); ++itr) {
       PCaloHit hit(*itr);
       DetId newid = HcalHitRelabeller::relabel(hit.id(),hcons);
 #ifdef EDM_ML_DEBUG
       std::cout << "Old ID " << std::hex << hit.id() << std::dec << " New " 
         << HcalDetId(newid) << std::endl;
 #endif
       hit.setID(newid.rawId());
       calohh.push_back(hit);
     }
   } else {
     calohh.insert(calohh.end(),pcalohh->begin(),pcalohh->end());
   }
   
   // get handles to calogeometry and calotopology
   edm::ESHandle<CaloGeometry> pG;
   iSetup.get<CaloGeometryRecord>().get(pG);
   const CaloGeometry* geo = pG.product();
 
   edm::ESHandle<MagneticField> bFieldH;
   iSetup.get<IdealMagneticFieldRecord>().get(bFieldH);
   const MagneticField* bField = bFieldH.product();
 
   edm::ESHandle<CaloTopology> theCaloTopology;
   iSetup.get<CaloTopologyRecord>().get(theCaloTopology);
   const CaloTopology *caloTopology = theCaloTopology.product();
 
   edm::ESHandle<HcalTopology> htopo;
   iSetup.get<HcalRecNumberingRecord>().get(htopo);
   const HcalTopology* theHBHETopology = htopo.product();
 
   // Loop over all SimTracks
   for (edm::SimTrackContainer::const_iterator simTrkItr=SimTk->begin();
        simTrkItr!= SimTk->end(); simTrkItr++) {
     if ((std::abs(simTrkItr->type()) == idMuon_) && (simTrkItr->vertIndex() == 0) &&
     (std::abs(simTrkItr->momentum().eta()) < etaMax_)) {
       unsigned int thisTrk = simTrkItr->trackId();
       spr::propagatedTrackDirection trkD = spr::propagateCALO(thisTrk, SimTk, SimVtx, geo, bField, debug);
 
       double eEcal(0), eHcal(0), activeLengthTot(0), activeLengthHotTot(0);
       double eHcalDepth[depthMax_], eHcalDepthHot[depthMax_];
       double activeL[depthMax_], activeHotL[depthMax_];
       unsigned int isHot(0);
       bool         tmpmatch(false); 
       for (int i=0; i<depthMax_; ++i) 
     eHcalDepth[i] = eHcalDepthHot[i] = activeL[i] = activeHotL[i] = -10000;
 
 #ifdef EDM_ML_DEBUG
       if ((verbosity_%10) > 0)
     std::cout << "Track Type " << simTrkItr->type() << " Vertex "
           << simTrkItr->vertIndex() << " Charge " << simTrkItr->charge()
           << " Momentum " << simTrkItr->momentum().P() << ":"
           << simTrkItr->momentum().eta() << ":"
           << simTrkItr->momentum().phi() << " ECAL|HCAL " << trkD.okECAL
           << ":" << trkD.okHCAL << " Point " << trkD.pointECAL << ":"
           << trkD.pointHCAL << " Direction " << trkD.directionECAL.eta()
           << ":" << trkD.directionECAL.phi() << " | "
           << trkD.directionHCAL.eta() << ":" << trkD.directionHCAL.phi()
           << std::endl;
 #endif
       bool propageback(false);
       spr::propagatedTrackDirection trkD_back = spr::propagateHCALBack(thisTrk, SimTk, SimVtx, geo, bField, debug);
       HcalDetId closestCell_back;
       if(trkD_back.okHCAL) {
     closestCell_back = (HcalDetId) (trkD_back.detIdHCAL);
     propageback = true;
       }
       if (trkD.okHCAL) {
     // Muon properties
     spr::trackAtOrigin tkvx = spr::simTrackAtOrigin(thisTrk, SimTk, SimVtx, debug);
     ptGlob_.push_back(tkvx.momentum.perp());
     etaGlob_.push_back(tkvx.momentum.eta());
     phiGlob_.push_back(tkvx.momentum.phi());
     pMuon_.push_back(tkvx.momentum.mag());
 #ifdef EDM_ML_DEBUG
     if ((verbosity_%10) > 0)
       std::cout << "Track at vertex " << tkvx.ok << " position " 
             << tkvx.position << " Momentum " << tkvx.momentum.mag()
             << ":" << tkvx.momentum.eta() << ":"
             << tkvx.momentum.phi() << " Charge " << tkvx.charge
             << std::endl;
 #endif
 
     
     // Energy in ECAL
     DetId isoCell;
     if (trkD.okECAL) {
       isoCell = trkD.detIdECAL;
       eEcal = spr::eECALmatrix(isoCell, pcaloeb, pcaloee, geo, caloTopology, 1, 1, -100.0, -100.0, tMinE_, tMaxE_, debug);
     }
 
     // Energy in  Hcal
     const DetId closestCell(trkD.detIdHCAL);
     if ((propageback) && 
         (HcalDetId(closestCell).ieta()==HcalDetId(closestCell_back).ieta()) && 
         (HcalDetId(closestCell).iphi() == HcalDetId(closestCell_back).iphi()))
       tmpmatch= true;
     
     eHcal = spr::eHCALmatrix(theHBHETopology, closestCell, calohh,0,0, false, -100.0, -100.0, -100.0, -100.0, tMinH_, tMaxH_, debug);
 #ifdef EDM_ML_DEBUG
     if ((verbosity_%10) > 0)
       std::cout << "eEcal " << trkD.okECAL << ":" << eEcal << " eHcal " 
             << eHcal << std::endl;
 #endif
 
     HcalSubdetector subdet = HcalDetId(closestCell).subdet();
     int             ieta   = HcalDetId(closestCell).ieta();
     int             iphi   = HcalDetId(closestCell).iphi();
     bool            hbhe   = (std::abs(ieta) == 16);
     std::vector<std::pair<double,int> > ehdepth;
     spr::energyHCALCell((HcalDetId)closestCell, calohh, ehdepth, maxDepth_, -100.0, -100.0, -100.0, -100.0, -500.0, 500.0, debug);
     for (unsigned int i=0; i<ehdepth.size(); ++i) {
       eHcalDepth[ehdepth[i].second-1] = ehdepth[i].first;
       HcalSubdetector subdet0 = (hbhe) ? ((ehdepth[i].second >= depthHE) ? HcalEndcap : HcalBarrel) : subdet;
       HcalDetId hcid0(subdet0,ieta,iphi,ehdepth[i].second);
       double actL = activeLength(DetId(hcid0));
       activeL[ehdepth[i].second-1] = actL;
       activeLengthTot += actL;
 #ifdef EDM_ML_DEBUG
       if ((verbosity_%10) > 0)
         std::cout << hcid0 << " E " << ehdepth[i].first << " L " << actL 
               << std::endl;
 #endif
     }
 
     HcalDetId hotCell;
 #ifdef EDM_ML_DEBUG
     double h3x3 = 
 #endif
       spr::eHCALmatrix(geo,theHBHETopology, closestCell, calohh, 1,1, hotCell, debug);
     isHot = matchId(closestCell,hotCell);
 #ifdef EDM_ML_DEBUG
     if ((verbosity_%10) > 0)
       std::cout << "hcal 3X3  < " << h3x3 << ">" << " ClosestCell <" 
             << (HcalDetId)(closestCell) << "> hotCell id < " << hotCell
             << "> isHot" << isHot << std::endl;
 #endif
 
     if (hotCell != HcalDetId()) {
       subdet = HcalDetId(hotCell).subdet();
       ieta   = HcalDetId(hotCell).ieta();
       iphi   = HcalDetId(hotCell).iphi();
       hbhe   = (std::abs(ieta) == 16);
       std::vector<std::pair<double,int> > ehdepth;
       spr::energyHCALCell(hotCell, calohh, ehdepth, maxDepth_, -100.0, -100.0, -100.0, -100.0, tMinH_, tMaxH_, debug);
       for (unsigned int i=0; i<ehdepth.size(); ++i) {
         eHcalDepthHot[ehdepth[i].second-1] = ehdepth[i].first;
         HcalSubdetector subdet0 = (hbhe) ? ((ehdepth[i].second >= depthHE) ? HcalEndcap : HcalBarrel) : subdet;
         HcalDetId hcid0(subdet0,ieta,iphi,ehdepth[i].second);
         double actL = activeLength(DetId(hcid0));
         activeHotL[ehdepth[i].second-1] = actL;
         activeLengthHotTot += actL;
 #ifdef EDM_ML_DEBUG
         if ((verbosity_%10) > 0)
           std::cout << hcid0 << " E " << ehdepth[i].first << " L " 
             << actL << std::endl;
 #endif
       }
     }
 #ifdef EDM_ML_DEBUG
     if ((verbosity_%10) > 0) {
       for (int k=0; k<depthMax_; ++k)
         std::cout << "Depth " << k << " E " << eHcalDepth[k] << ":" 
               << eHcalDepthHot[k] << std::endl;
     }
 #endif     
     matchedId_.push_back(tmpmatch);                    
     ecal3x3Energy_.push_back(eEcal);
     ecalDetId_.push_back(isoCell.rawId());
     hcal1x1Energy_.push_back(eHcal);
     hcalDetId_.push_back(closestCell.rawId());
     for (int k=0; k<depthMax_; ++k) {
       hcalDepthEnergy_[k].push_back(eHcalDepth[k]);
       hcalDepthActiveLength_[k].push_back(activeL[k]);
       hcalDepthEnergyHot_[k].push_back(eHcalDepthHot[k]);
       hcalDepthActiveLengthHot_[k].push_back(activeHotL[k]);
     }
     hcalHot_.push_back(isHot);
     hcalActiveLengthHot_.push_back(activeLengthHotTot);
       }
     }
   }
   if (hcalHot_.size() > 0) tree_->Fill();
 }

void HcalHBHEMuonSimAnalyzer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 355 of file HcalHBHEMuonSimAnalyzer.cc.

References bxNumber_, ecal3x3Energy_, ecalDetId_, etaGlob_, eventNumber_, fs_, hcal1x1Energy_, hcalActiveLength_, hcalActiveLengthHot_, hcalDepthActiveLength_, hcalDepthEnergy_, hcalDepthEnergyHot_, hcalDetId_, hcalHot_, gen::k, lumiNumber_, TFileService::make(), matchedId_, maxDepth_, dataset::name, phiGlob_, pMuon_, ptGlob_, runNumber_, and tree_.

                                        {
 
   tree_ = fs_->make<TTree>("TREE", "TREE");
   tree_->Branch("Run_No",           &runNumber_);
   tree_->Branch("Event_No",         &eventNumber_);
   tree_->Branch("LumiNumber",       &lumiNumber_);
   tree_->Branch("BXNumber",         &bxNumber_);
   tree_->Branch("pt_of_muon",       &ptGlob_);
   tree_->Branch("eta_of_muon",      &etaGlob_);
   tree_->Branch("phi_of_muon",      &phiGlob_);
   tree_->Branch("p_of_muon",        &pMuon_);
   tree_->Branch("matchedId",        &matchedId_);
   
   tree_->Branch("ecal_3x3",         &ecal3x3Energy_);
   tree_->Branch("ecal_detID",       &ecalDetId_);
   tree_->Branch("hcal_1x1",         &hcal1x1Energy_);
   tree_->Branch("hcal_detID",       &hcalDetId_);
   tree_->Branch("hcal_cellHot",     &hcalHot_);
   tree_->Branch("activeLength",     &hcalActiveLength_);
   tree_->Branch("activeLengthHot",  &hcalActiveLengthHot_);
   char name[100];
   for (int k=0; k<maxDepth_; ++k) {
     sprintf (name, "hcal_edepth%d", (k+1));
     tree_->Branch(name, &hcalDepthEnergy_[k]);
     sprintf (name, "hcal_activeL%d", (k+1));
     tree_->Branch(name,  &hcalDepthActiveLength_[k]);
     sprintf (name, "hcal_edepthHot%d", (k+1));
     tree_->Branch(name,  &hcalDepthEnergyHot_[k]);
     sprintf (name, "hcal_activeHotL%d", (k+1));
     tree_->Branch(name, &hcalDepthActiveLength_[k]);
   }
 }

virtual void HcalHBHEMuonSimAnalyzer::beginLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

inlineprivatevirtual

Definition at line 56 of file HcalHBHEMuonSimAnalyzer.cc.

56 {}

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

overrideprivatevirtual

Definition at line 388 of file HcalHBHEMuonSimAnalyzer.cc.

References actHB_, actHE_, edm::EventSetup::get(), and HcalDDDRecConstants::getThickActive().

                                                     {
 
   edm::ESHandle<HcalDDDRecConstants> pHRNDC;
   iSetup.get<HcalRecNumberingRecord>().get(pHRNDC);
   const HcalDDDRecConstants & hdc = (*pHRNDC);
   actHB_.clear();
   actHE_.clear();
   actHB_ = hdc.getThickActive(0);
   actHE_ = hdc.getThickActive(1);
 }

void HcalHBHEMuonSimAnalyzer::clearVectors ( )

private

clearing vectots

Definition at line 418 of file HcalHBHEMuonSimAnalyzer.cc.

References bxNumber_, depthMax_, ecal3x3Energy_, ecalDetId_, etaGlob_, eventNumber_, hcal1x1Energy_, hcalActiveLength_, hcalActiveLengthHot_, hcalDepthActiveLength_, hcalDepthActiveLengthHot_, hcalDepthEnergy_, hcalDepthEnergyHot_, hcalDetId_, hcalHot_, gen::k, lumiNumber_, matchedId_, phiGlob_, pMuon_, ptGlob_, and runNumber_.

Referenced by analyze(), and endLuminosityBlock().

                                            {
 
   runNumber_   = -99999;
   eventNumber_ = -99999;
   lumiNumber_  = -99999;
   bxNumber_    = -99999;
     
   ptGlob_.clear();
   etaGlob_.clear(); 
   phiGlob_.clear(); 
   pMuon_.clear();
   matchedId_.clear();
   ecal3x3Energy_.clear();
   ecalDetId_.clear();
   hcal1x1Energy_.clear();
   hcalDetId_.clear();
   hcalHot_.clear();
   hcalActiveLength_.clear();
   hcalActiveLengthHot_.clear();
   for (int k=0; k<depthMax_; ++k) {
     hcalDepthEnergy_[k].clear();
     hcalDepthActiveLength_[k].clear();
     hcalDepthEnergyHot_[k].clear();
     hcalDepthActiveLengthHot_[k].clear();
   }
 }

virtual void HcalHBHEMuonSimAnalyzer::endLuminosityBlock	(	edm::LuminosityBlock const &	,
		edm::EventSetup const &
	)

inlineprivatevirtual

Definition at line 57 of file HcalHBHEMuonSimAnalyzer.cc.

References activeLength(), clearVectors(), and matchId().

57 {}

virtual void HcalHBHEMuonSimAnalyzer::endRun	(	edm::Run const &	,
		edm::EventSetup const &
	)

inlineoverrideprivatevirtual

Definition at line 55 of file HcalHBHEMuonSimAnalyzer.cc.

55 {}

void HcalHBHEMuonSimAnalyzer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 401 of file HcalHBHEMuonSimAnalyzer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
 
   edm::ParameterSetDescription desc;
   desc.add<std::string>("ModuleLabel","g4SimHits");
   desc.add<std::string>("EBCollection","EcalHitsEB");
   desc.add<std::string>("EECollection","EcalHitsEE");
   desc.add<std::string>("HCCollection","HcalHits");
   desc.addUntracked<int>("Verbosity",0);
   desc.addUntracked<int>("MaxDepth",4);
   desc.addUntracked<double>("EtaMax",3.0);
   desc.addUntracked<double>("TimeMinCutECAL",-500.);
   desc.addUntracked<double>("TimeMaxCutECAL",500.);
   desc.addUntracked<double>("TimeMinCutHCAL",-500.);
   desc.addUntracked<double>("TimeMaxCutHCAL",500.);
   descriptions.add("hcalHBHEMuonSim",desc);
 }

unsigned int HcalHBHEMuonSimAnalyzer::matchId	(	const HcalDetId &	id1,
		const HcalDetId &	id2
	)

private

Definition at line 446 of file HcalHBHEMuonSimAnalyzer.cc.

References HcalDetId::ieta(), HcalDetId::iphi(), match(), and HcalDetId::subdet().

Referenced by analyze(), and endLuminosityBlock().

                                                 {
   
   HcalDetId kd1(id1.subdet(),id1.ieta(),id1.iphi(),1);
   HcalDetId kd2(id2.subdet(),id2.ieta(),id2.iphi(),1);
   unsigned int match = ((kd1 == kd2) ? 1 : 0);
   return match;
 }