Inheritance diagram for HcalHBHEMuonSimAnalyzer:

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

	~HcalHBHEMuonSimAnalyzer () override

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () 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

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

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

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 &)

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

void	beginJob () override

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

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

void	clearVectors ()

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

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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

References gather_cfg::cout, depthMax_, ebLabel_, eeLabel_, etaMax_, g4Label_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), hcLabel_, HLT_2018_cff::InputTag, 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 ( )

override

Definition at line 121 of file HcalHBHEMuonSimAnalyzer.cc.

121 {}

Member Function Documentation

double HcalHBHEMuonSimAnalyzer::activeLength ( const DetId & id_ )

private

Definition at line 447 of file HcalHBHEMuonSimAnalyzer.cc.

References actHB_, actHE_, DEFINE_FWK_MODULE, LEDCalibrationChannels::depth, HcalBarrel, mps_fire::i, triggerObjects_cff::id, and LEDCalibrationChannels::ieta.

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

                                                                                          {
   clearVectors();
   bool debug(false);
 #ifdef EDM_ML_DEBUG
   debug = ((verbosity_ / 10) > 0);
 #endif
 
   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::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();
         int zside = HcalDetId(closestCell).zside();
         bool hbhe = (std::abs(ieta) == 16);
         int depthHE = hcons->getMinDepth(1, 16, iphi, zside);
         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,
                             depthHE,
                             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();
           zside = HcalDetId(hotCell).zside();
           hbhe = (std::abs(ieta) == 16);
           depthHE = hcons->getMinDepth(1, 16, iphi, zside);
           std::vector<std::pair<double, int> > ehdepth;
           spr::energyHCALCell(
               hotCell, calohh, ehdepth, maxDepth_, -100.0, -100.0, -100.0, -100.0, tMinH_, tMaxH_, depthHE, 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_.empty())
     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_, dqmdumpme::k, lumiNumber_, TFileService::make(), matchedId_, maxDepth_, Skims_PA_cff::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 55 of file HcalHBHEMuonSimAnalyzer.cc.

55 {}

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

overrideprivate

Definition at line 387 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 413 of file HcalHBHEMuonSimAnalyzer.cc.

References bxNumber_, depthMax_, ecal3x3Energy_, ecalDetId_, etaGlob_, eventNumber_, hcal1x1Energy_, hcalActiveLength_, hcalActiveLengthHot_, hcalDepthActiveLength_, hcalDepthActiveLengthHot_, hcalDepthEnergy_, hcalDepthEnergyHot_, hcalDetId_, hcalHot_, dqmdumpme::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 56 of file HcalHBHEMuonSimAnalyzer.cc.

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

56 {}

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

inlineoverrideprivate

Definition at line 54 of file HcalHBHEMuonSimAnalyzer.cc.

54 {}

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

static

Definition at line 397 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 440 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;
 }