Inheritance diagram for HGCalTimingAnalyzer:

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

	~HGCalTimingAnalyzer () override

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::WatchRuns, edm::one::SharedResources >
	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 &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

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 &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

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)

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
void	analyze (edm::Event const &, edm::EventSetup const &) override

void	analyzeSimHits (int type, std::vector< PCaloHit > const &hits)

void	analyzeSimTracks (edm::Handle< edm::SimTrackContainer > const &SimTk, edm::Handle< edm::SimVertexContainer > const &SimVtx)

void	beginJob () override

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

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

Private Attributes
const std::string	detectorBeam_

const std::string	detectorEE_

bool	doTree_

edm::Service< TFileService >	fs_

bool	groupHits_

const HGCalDDDConstants *	hgcons_

std::vector< int >	idBeams_

double	pBeam_

std::vector< float >	simHitCellEnBeam_

std::vector< float >	simHitCellEnEE_

std::vector< uint32_t >	simHitCellIdBeam_

std::vector< uint32_t >	simHitCellIdEE_

std::vector< float >	simHitCellTmBeam_

std::vector< float >	simHitCellTmEE_

double	timeUnit_

edm::EDGetTokenT< edm::HepMCProduct >	tok_hepMC_

edm::EDGetTokenT< edm::PCaloHitContainer >	tok_hitsBeam_

edm::EDGetTokenT< edm::PCaloHitContainer >	tok_hitsEE_

edm::EDGetTokenT< edm::SimTrackContainer >	tok_simTk_

edm::EDGetTokenT< edm::SimVertexContainer >	tok_simVtx_

const edm::ESGetToken< HGCalDDDConstants, IdealGeometryRecord >	tokDDD_

TTree *	tree_

double	xBeam_

double	yBeam_

double	zBeam_

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
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

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

template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept

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<Transition Tr = Transition::Event>
constexpr auto	esConsumes () noexcept

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

template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag) noexcept

template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...

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

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

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

Detailed Description

Definition at line 44 of file HGCalTimingAnalyzer.cc.

Constructor & Destructor Documentation

◆ HGCalTimingAnalyzer()

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

explicit

Definition at line 78 of file HGCalTimingAnalyzer.cc.

     : detectorEE_(iConfig.getParameter<std::string>("DetectorEE")),
       detectorBeam_(iConfig.getParameter<std::string>("DetectorBeam")),
       tokDDD_(esConsumes<HGCalDDDConstants, IdealGeometryRecord, edm::Transition::BeginRun>(
           edm::ESInputTag("", detectorEE_))) {
   usesResource("TFileService");
  
   // now do whatever initialization is needed
   // Group hits (if groupHits_ = true) if hits come within timeUnit_
   groupHits_ = iConfig.getParameter<bool>("GroupHits");
   timeUnit_ = iConfig.getParameter<double>("TimeUnit");
   // Only look into the beam counters with ID's as in idBeams_
   idBeams_ = iConfig.getParameter<std::vector<int>>("IDBeams");
   doTree_ = iConfig.getUntrackedParameter<bool>("DoTree", false);
   if (!groupHits_)
     timeUnit_ = 0.000001;
 #ifdef EDM_ML_DEBUG
   std::cout << "HGCalTimingAnalyzer:: Group Hits " << groupHits_ << " in " << timeUnit_ << " IdBeam " << idBeams_.size()
             << ":";
   for (const auto& id : idBeams_)
     std::cout << " " << id;
   std::cout << std::endl;
 #endif
   if (idBeams_.empty())
     idBeams_.push_back(1001);
  
   edm::InputTag tmp0 = iConfig.getParameter<edm::InputTag>("GeneratorSrc");
   tok_hepMC_ = consumes<edm::HepMCProduct>(tmp0);
 #ifdef EDM_ML_DEBUG
   std::cout << "HGCalTimingAnalyzer:: GeneratorSource = " << tmp0 << std::endl;
 #endif
   tok_simTk_ = consumes<edm::SimTrackContainer>(edm::InputTag("g4SimHits"));
   tok_simVtx_ = consumes<edm::SimVertexContainer>(edm::InputTag("g4SimHits"));
   std::string tmp1 = iConfig.getParameter<std::string>("CaloHitSrcEE");
   tok_hitsEE_ = consumes<edm::PCaloHitContainer>(edm::InputTag("g4SimHits", tmp1));
 #ifdef EDM_ML_DEBUG
   std::cout << "HGCalTimingAnalyzer:: Detector " << detectorEE_ << " with tags " << tmp1 << std::endl;
 #endif
   tmp1 = iConfig.getParameter<std::string>("CaloHitSrcBeam");
   tok_hitsBeam_ = consumes<edm::PCaloHitContainer>(edm::InputTag("g4SimHits", tmp1));
 #ifdef EDM_ML_DEBUG
   std::cout << "HGCalTimingAnalyzer:: Detector " << detectorBeam_ << " with tags " << tmp1 << std::endl;
 #endif
 }

References gather_cfg::cout, detectorBeam_, detectorEE_, doTree_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), groupHits_, triggerObjects_cff::id, idBeams_, AlCaHLTBitMon_QueryRunRegistry::string, timeUnit_, tok_hepMC_, tok_hitsBeam_, tok_hitsEE_, tok_simTk_, and tok_simVtx_.

◆ ~HGCalTimingAnalyzer()

HGCalTimingAnalyzer::~HGCalTimingAnalyzer ( )

override

Definition at line 123 of file HGCalTimingAnalyzer.cc.

123 {}

Member Function Documentation

◆ analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 166 of file HGCalTimingAnalyzer.cc.

                                                                                      {
 #ifdef EDM_ML_DEBUG
   // Generator input
   edm::Handle<edm::HepMCProduct> evtMC;
   iEvent.getByToken(tok_hepMC_, evtMC);
   if (!evtMC.isValid()) {
     edm::LogWarning("HGCal") << "no HepMCProduct found";
   } else {
     const HepMC::GenEvent* myGenEvent = evtMC->GetEvent();
     unsigned int k(0);
     for (HepMC::GenEvent::particle_const_iterator p = myGenEvent->particles_begin(); p != myGenEvent->particles_end();
          ++p, ++k) {
       std::cout << "Particle[" << k << "] with p " << (*p)->momentum().rho() << " theta " << (*p)->momentum().theta()
                 << " phi " << (*p)->momentum().phi() << std::endl;
     }
   }
 #endif
  
   // Now the Simhits
   edm::Handle<edm::SimTrackContainer> SimTk;
   iEvent.getByToken(tok_simTk_, SimTk);
   edm::Handle<edm::SimVertexContainer> SimVtx;
   iEvent.getByToken(tok_simVtx_, SimVtx);
   analyzeSimTracks(SimTk, SimVtx);
  
   simHitCellIdEE_.clear();
   simHitCellIdBeam_.clear();
   simHitCellEnEE_.clear();
   simHitCellEnBeam_.clear();
   simHitCellTmEE_.clear();
   simHitCellTmBeam_.clear();
  
   edm::Handle<edm::PCaloHitContainer> theCaloHitContainers;
   std::vector<PCaloHit> caloHits;
   iEvent.getByToken(tok_hitsEE_, theCaloHitContainers);
   if (theCaloHitContainers.isValid()) {
 #ifdef EDM_ML_DEBUG
     std::cout << "PcalohitContainer for " << detectorEE_ << " has " << theCaloHitContainers->size() << " hits"
               << std::endl;
 #endif
     caloHits.clear();
     caloHits.insert(caloHits.end(), theCaloHitContainers->begin(), theCaloHitContainers->end());
     analyzeSimHits(0, caloHits);
   } else {
 #ifdef EDM_ML_DEBUG
     std::cout << "PCaloHitContainer does not exist for " << detectorEE_ << " !!!" << std::endl;
 #endif
   }
  
   iEvent.getByToken(tok_hitsBeam_, theCaloHitContainers);
   if (theCaloHitContainers.isValid()) {
 #ifdef EDM_ML_DEBUG
     std::cout << "PcalohitContainer for " << detectorBeam_ << " has " << theCaloHitContainers->size() << " hits"
               << std::endl;
 #endif
     caloHits.clear();
     caloHits.insert(caloHits.end(), theCaloHitContainers->begin(), theCaloHitContainers->end());
     analyzeSimHits(1, caloHits);
   } else {
 #ifdef EDM_ML_DEBUG
     std::cout << "PCaloHitContainer does not exist for " << detectorBeam_ << " !!!" << std::endl;
 #endif
   }
   if (doTree_)
     tree_->Fill();
 }

References analyzeSimHits(), analyzeSimTracks(), edm::HandleBase::clear(), gather_cfg::cout, detectorBeam_, detectorEE_, doTree_, edm::HepMCProduct::GetEvent(), iEvent, edm::HandleBase::isValid(), dqmdumpme::k, AlCaHLTBitMon_ParallelJobs::p, simHitCellEnBeam_, simHitCellEnEE_, simHitCellIdBeam_, simHitCellIdEE_, simHitCellTmBeam_, simHitCellTmEE_, tok_hepMC_, tok_hitsBeam_, tok_hitsEE_, tok_simTk_, tok_simVtx_, and tree_.

◆ analyzeSimHits()

void HGCalTimingAnalyzer::analyzeSimHits	(	int	type,
		std::vector< PCaloHit > const &	hits
	)

private

Definition at line 233 of file HGCalTimingAnalyzer.cc.

                                                                                   {
 #ifdef EDM_ML_DEBUG
   unsigned int i(0);
 #endif
   std::map<std::pair<uint32_t, uint64_t>, std::pair<double, double>> map_hits;
   for (const auto& hit : hits) {
     double energy = hit.energy();
     double time = hit.time();
     uint32_t id = hit.id();
     if (type == 0) {
       int subdet, zside, layer, sector, subsector, cell;
       HGCalTestNumbering::unpackHexagonIndex(id, subdet, zside, layer, sector, subsector, cell);
       std::pair<int, int> recoLayerCell = hgcons_->simToReco(cell, layer, sector, true);
       id = HGCalDetId((ForwardSubdetector)(subdet), zside, recoLayerCell.second, subsector, sector, recoLayerCell.first)
                .rawId();
 #ifdef EDM_ML_DEBUG
       std::cout << "SimHit:Hit[" << i << "] Id " << subdet << ":" << zside << ":" << layer << ":" << sector << ":"
                 << subsector << ":" << recoLayerCell.first << ":" << recoLayerCell.second << " Energy " << energy
                 << " Time " << time << std::endl;
 #endif
     } else {
 #ifdef EDM_ML_DEBUG
       int subdet, layer, x, y;
       HcalTestBeamNumbering::unpackIndex(id, subdet, layer, x, y);
       std::cout << "SimHit:Hit[" << i << "] Beam Subdet " << subdet << " Layer " << layer << " x|y " << x << ":" << y
                 << " Energy " << energy << " Time " << time << std::endl;
 #endif
     }
     uint64_t tid = (uint64_t)((time + 50.0) / timeUnit_);
     std::pair<uint32_t, uint64_t> key(id, tid);
     auto itr = map_hits.find(key);
     if (itr == map_hits.end()) {
       map_hits[key] = std::pair<double, double>(time, 0.0);
       itr = map_hits.find(key);
     }
     energy += (itr->second).second;
     map_hits[key] = std::pair<double, double>((itr->second).first, energy);
 #ifdef EDM_ML_DEBUG
     ++i;
 #endif
   }
  
 #ifdef EDM_ML_DEBUG
   std::cout << "analyzeSimHits: Finds " << map_hits.size() << " hits "
             << " from the Hit Vector of size " << hits.size() << " for type " << type << std::endl;
 #endif
   for (const auto& itr : map_hits) {
     uint32_t id = (itr.first).first;
     double time = (itr.second).first;
     double energy = (itr.second).second;
     if (type == 0) {
       simHitCellIdEE_.push_back(id);
       simHitCellEnEE_.push_back(energy);
       simHitCellTmEE_.push_back(time);
     } else {
       simHitCellIdBeam_.push_back(id);
       simHitCellEnBeam_.push_back(energy);
       simHitCellTmBeam_.push_back(time);
     }
 #ifdef EDM_ML_DEBUG
     std::cout << "SimHit::ID: " << std::hex << id << std::dec << " T: " << time << " E: " << energy << std::endl;
 #endif
   }
 }

References gather_cfg::cout, TauDecayModes::dec, HCALHighEnergyHPDFilter_cfi::energy, first, hgcons_, hfClusterShapes_cfi::hits, mps_fire::i, hit::id, crabWrapper::key, phase1PixelTopology::layer, DetId::rawId(), edm::second(), simHitCellEnBeam_, simHitCellEnEE_, simHitCellIdBeam_, simHitCellIdEE_, simHitCellTmBeam_, simHitCellTmEE_, HGCalDDDConstants::simToReco(), protons_cff::time, timeUnit_, HGCalTestNumbering::unpackHexagonIndex(), HcalTestBeamNumbering::unpackIndex(), x, y, and ecaldqm::zside().

Referenced by analyze().

◆ analyzeSimTracks()

void HGCalTimingAnalyzer::analyzeSimTracks	(	edm::Handle< edm::SimTrackContainer > const &	SimTk,
		edm::Handle< edm::SimVertexContainer > const &	SimVtx
	)

private

Definition at line 298 of file HGCalTimingAnalyzer.cc.

                                                                                            {
   xBeam_ = yBeam_ = zBeam_ = pBeam_ = -1000000;
   int vertIndex(-1);
   for (edm::SimTrackContainer::const_iterator simTrkItr = SimTk->begin(); simTrkItr != SimTk->end(); simTrkItr++) {
 #ifdef EDM_ML_DEBUG
     std::cout << "Track " << simTrkItr->trackId() << " Vertex " << simTrkItr->vertIndex() << " Type "
               << simTrkItr->type() << " Charge " << simTrkItr->charge() << " momentum " << simTrkItr->momentum() << " "
               << simTrkItr->momentum().P() << std::endl;
 #endif
     if (vertIndex == -1) {
       vertIndex = simTrkItr->vertIndex();
       pBeam_ = simTrkItr->momentum().P();
     }
   }
   if (vertIndex != -1 && vertIndex < (int)SimVtx->size()) {
     edm::SimVertexContainer::const_iterator simVtxItr = SimVtx->begin();
     for (int iv = 0; iv < vertIndex; iv++)
       simVtxItr++;
 #ifdef EDM_ML_DEBUG
     std::cout << "Vertex " << vertIndex << " position " << simVtxItr->position() << std::endl;
 #endif
     xBeam_ = simVtxItr->position().X();
     yBeam_ = simVtxItr->position().Y();
     zBeam_ = simVtxItr->position().Z();
   }
 }

References gather_cfg::cout, gpuVertexFinder::iv, pBeam_, xBeam_, yBeam_, and zBeam_.

Referenced by analyze().

◆ beginJob()

void HGCalTimingAnalyzer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 140 of file HGCalTimingAnalyzer.cc.

                                    {
   std::string det(detectorEE_);
   if (doTree_) {
     tree_ = fs_->make<TTree>("HGCTB", "SimHitEnergy");
     tree_->Branch("xBeam", &xBeam_, "xBeam/D");
     tree_->Branch("yBeam", &yBeam_, "yBeam/D");
     tree_->Branch("zBeam", &zBeam_, "zBeam/D");
     tree_->Branch("pBeam", &pBeam_, "pBeam/D");
     tree_->Branch("simHitCellIdEE_", &simHitCellIdEE_);
     tree_->Branch("simHitCellEnEE_", &simHitCellEnEE_);
     tree_->Branch("simHitCellTmEE_", &simHitCellTmEE_);
     tree_->Branch("simHitCellIdBeam_", &simHitCellIdBeam_);
     tree_->Branch("simHitCellEnBeam_", &simHitCellEnBeam_);
     tree_->Branch("simHitCellTmBeam_", &simHitCellTmBeam_);
   }
 }

References detectorEE_, doTree_, fs_, TFileService::make(), pBeam_, simHitCellEnBeam_, simHitCellEnEE_, simHitCellIdBeam_, simHitCellIdEE_, simHitCellTmBeam_, simHitCellTmEE_, AlCaHLTBitMon_QueryRunRegistry::string, tree_, xBeam_, yBeam_, and zBeam_.

◆ beginRun()

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

overrideprivate

Definition at line 157 of file HGCalTimingAnalyzer.cc.

                                                                              {
   hgcons_ = &iSetup.getData(tokDDD_);
  
 #ifdef EDM_ML_DEBUG
   std::cout << "HGCalTimingAnalyzer::" << detectorEE_ << " defined with " << hgcons_->layers(false) << " layers"
             << std::endl;
 #endif
 }

References gather_cfg::cout, detectorEE_, edm::EventSetup::getData(), hgcons_, HGCalDDDConstants::layers(), and tokDDD_.

◆ endRun()

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

inlineoverrideprivate

Definition at line 54 of file HGCalTimingAnalyzer.cc.

54 {}

◆ fillDescriptions()

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

static

Definition at line 125 of file HGCalTimingAnalyzer.cc.

                                                                                      {
   edm::ParameterSetDescription desc;
   desc.add<std::string>("DetectorEE", "HGCalEESensitive");
   desc.add<std::string>("DetectorBeam", "HcalTB06BeamDetector");
   desc.add<bool>("GroupHits", false);
   desc.add<double>("TimeUnit", 0.001);
   std::vector<int> ids = {1001, 1002, 1003, 1004, 1005};
   desc.add<std::vector<int>>("IDBeams", ids);
   desc.addUntracked<bool>("DoTree", true);
   desc.add<edm::InputTag>("GeneratorSrc", edm::InputTag("generatorSmeared"));
   desc.add<std::string>("CaloHitSrcEE", "HGCHitsEE");
   desc.add<std::string>("CaloHitSrcBeam", "HcalTB06BeamHits");
   descriptions.add("HGCalTimingAnalyzer", desc);
 }