Inheritance diagram for HGCalTimingAnalyzer:

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

	~HGCalTimingAnalyzer ()

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

virtual void	beginJob () override

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

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

Private Attributes
std::string	detectorBeam_

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_

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
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 48 of file HGCalTimingAnalyzer.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 82 of file HGCalTimingAnalyzer.cc.

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

                                                                        {
 
   usesResource("TFileService");
 
   //now do whatever initialization is needed
   detectorEE_  = iConfig.getParameter<std::string>("DetectorEE");
   detectorBeam_= iConfig.getParameter<std::string>("DetectorBeam");
   // 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_.size() == 0) 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
 }

HGCalTimingAnalyzer::~HGCalTimingAnalyzer ( )

Definition at line 125 of file HGCalTimingAnalyzer.cc.

125 {}

Member Function Documentation

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 171 of file HGCalTimingAnalyzer.cc.

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

Referenced by endRun().

                                                {
 
 #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();
 
 }

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

private

Definition at line 242 of file HGCalTimingAnalyzer.cc.

References gather_cfg::cout, TauDecayModes::dec, plotBeamSpotDB::first, hgcons_, mps_fire::i, hit::id, crabWrapper::key, DetId::rawId(), edm::second(), simHitCellEnBeam_, simHitCellEnEE_, simHitCellIdBeam_, simHitCellIdEE_, simHitCellTmBeam_, simHitCellTmEE_, HGCalDDDConstants::simToReco(), ntuplemaker::time, timeUnit_, HGCalTestNumbering::unpackHexagonIndex(), HcalTestBeamNumbering::unpackIndex(), x, y, and HcalDigiParam_cfi::zside.

Referenced by analyze(), and endRun().

                                                        {
 
 #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
   }
 }

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

private

Definition at line 316 of file HGCalTimingAnalyzer.cc.

References gather_cfg::cout, DEFINE_FWK_MODULE, pBeam_, xBeam_, yBeam_, and zBeam_.

Referenced by analyze(), and endRun().

                                                                        {
 
   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();
   }
 
 }

void HGCalTimingAnalyzer::beginJob ( void )

overrideprivatevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 142 of file HGCalTimingAnalyzer.cc.

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

                                    {
   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_);
   }
 }

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

overrideprivatevirtual

Definition at line 159 of file HGCalTimingAnalyzer.cc.

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

                                                                              {
   edm::ESHandle<HGCalDDDConstants>  pHGDC;
   iSetup.get<IdealGeometryRecord>().get(detectorEE_, pHGDC);
   hgcons_ = &(*pHGDC);
     
 #ifdef EDM_ML_DEBUG
   std::cout << "HGCalTimingAnalyzer::" << detectorEE_ << " defined with "
         << hgcons_->layers(false) << " layers" << std::endl;
 #endif
   
 }

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

inlineoverrideprivatevirtual

Definition at line 59 of file HGCalTimingAnalyzer.cc.

References analyze(), analyzeSimHits(), analyzeSimTracks(), and hfClusterShapes_cfi::hits.

59 {}

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

static

Definition at line 127 of file HGCalTimingAnalyzer.cc.

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

                                                                                      {
   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);
 }