Inheritance diagram for CaloSimHitAnalysis:

Public Member Functions
	CaloSimHitAnalysis (const edm::ParameterSet &ps)

	~CaloSimHitAnalysis () 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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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)

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

void	analyzeHits (std::vector< PCaloHit > &, int)

void	analyzePassiveHits (std::vector< PassiveHit > &hits)

void	beginJob () override

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

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

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

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

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

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

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

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)

void	resetItemsToGetFrom (BranchType iType)

Private Attributes
const int	allSteps_

const CaloGeometry *	caloGeometry_

const std::vector< std::string >	detNames_

std::map< int, unsigned int >	etaDepth_

const std::string	g4Label_

TH1F *	h_edep1_ [nCalo_]

TH1F *	h_edep_ [nCalo_]

TH1F *	h_edepEM_ [nCalo_]

TH1F *	h_edepHad_ [nCalo_]

TH1F *	h_edepp_

TH1F *	h_edepT1_ [nCalo_]

TH1F *	h_edepT_ [nCalo_]

std::vector< TH1F * >	h_edepTk_

TH1F *	h_eta_ [nCalo_]

TH2F *	h_etaphi_

TH1F *	h_etot_ [nCalo_]

TH1F *	h_etotg_ [nCalo_]

TH1F *	h_hit_ [nCalo_]

TH1F *	h_hitp_

TH1F *	h_phi_ [nCalo_]

TH1F *	h_rr_ [nCalo_]

TH2F *	h_rz1_

TH2F *	h_rz_

std::vector< TH2F * >	h_rzH_

TH1F *	h_stepp_

TH1F *	h_time_ [nCalo_]

TH1F *	h_timep_

TH1F *	h_timeT_ [nCalo_]

std::vector< TH1F * >	h_timeTk_

TH1F *	h_trackp_

TH1F *	h_zz_ [nCalo_]

const HcalGeometry *	hcalGeom_

const std::vector< std::string >	hitLab_

const double	maxEnergy_

const double	maxTime_

const bool	passive_

const double	tCut_

const bool	testNumber_

const std::vector< double >	timeSliceUnit_

const double	tMax_

const edm::EDGetTokenT < edm::PassiveHitContainer >	tok_passive_

const edm::ESGetToken < CaloGeometry, CaloGeometryRecord >	tokGeom_

const std::vector < edm::EDGetTokenT < edm::PCaloHitContainer > >	toks_calo_

const double	tScale_

Static Private Attributes
static constexpr int	nCalo_ = 6

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

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Detailed Description

Definition at line 45 of file CaloSimHitAnalysis.cc.

Constructor & Destructor Documentation

CaloSimHitAnalysis::CaloSimHitAnalysis ( const edm::ParameterSet & ps )

Definition at line 87 of file CaloSimHitAnalysis.cc.

References g4Label_, hitLab_, mergeVDriftHistosByStation::name, AlCaHLTBitMon_QueryRunRegistry::string, and edm::vector_transform().

     : g4Label_(ps.getUntrackedParameter<std::string>("moduleLabel", "g4SimHits")),
       hitLab_(ps.getParameter<std::vector<std::string> >("hitCollection")),
       timeSliceUnit_(ps.getParameter<std::vector<double> >("timeSliceUnit")),
       maxEnergy_(ps.getUntrackedParameter<double>("maxEnergy", 250.0)),
       maxTime_(ps.getUntrackedParameter<double>("maxTime", 1000.0)),
       tMax_(ps.getUntrackedParameter<double>("timeCut", 100.0)),
       tScale_(ps.getUntrackedParameter<double>("timeScale", 1.0)),
       tCut_(ps.getUntrackedParameter<double>("timeThreshold", 15.0)),
       testNumber_(ps.getUntrackedParameter<bool>("testNumbering", false)),
       passive_(ps.getUntrackedParameter<bool>("passiveHits", false)),
       allSteps_(ps.getUntrackedParameter<int>("allSteps", 100)),
       detNames_(ps.getUntrackedParameter<std::vector<std::string> >("detNames")),
       tokGeom_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
       toks_calo_{edm::vector_transform(hitLab_,
                                        [this](const std::string& name) {
                                          return consumes<edm::PCaloHitContainer>(edm::InputTag{g4Label_, name});
                                        })},

CaloSimHitAnalysis::~CaloSimHitAnalysis ( )

inlineoverride

Definition at line 48 of file CaloSimHitAnalysis.cc.

48 {}

Member Function Documentation

void CaloSimHitAnalysis::analyze	(	edm::Event const &	e,
		edm::EventSetup const &	set
	)

overrideprotectedvirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 279 of file CaloSimHitAnalysis.cc.

References analyzeHits(), analyzePassiveHits(), caloGeometry_, edm::EventID::event(), edm::EventSetup::getData(), edm::Event::getHandle(), CaloGeometry::getSubdetectorGeometry(), DetId::Hcal, HcalBarrel, hcalGeom_, mps_fire::i, edm::EventBase::id(), edm::HandleBase::isValid(), passive_, edm::EventID::run(), tok_passive_, tokGeom_, and toks_calo_.

                                                                             {
   edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis:Run = " << e.id().run() << " Event = " << e.id().event();
 
   caloGeometry_ = &set.getData(tokGeom_);
   hcalGeom_ = static_cast<const HcalGeometry*>(caloGeometry_->getSubdetectorGeometry(DetId::Hcal, HcalBarrel));
 
   for (unsigned int i = 0; i < toks_calo_.size(); i++) {
     const edm::Handle<edm::PCaloHitContainer>& hitsCalo = e.getHandle(toks_calo_[i]);
     bool getHits = (hitsCalo.isValid());
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis: Input flags Hits[" << i << "]: " << getHits;
 #endif
     if (getHits) {
       std::vector<PCaloHit> caloHits;
       caloHits.insert(caloHits.end(), hitsCalo->begin(), hitsCalo->end());
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis: Hit buffer [" << i << "] " << caloHits.size();
 #endif
       analyzeHits(caloHits, i);
     }
   }
 
   if (passive_) {
     const edm::Handle<edm::PassiveHitContainer>& hitsPassive = e.getHandle(tok_passive_);
     bool getHits = (hitsPassive.isValid());
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis: Passive: " << getHits;
 #endif
     if (getHits) {
       std::vector<PassiveHit> passiveHits;
       passiveHits.insert(passiveHits.end(), hitsPassive->begin(), hitsPassive->end());
 #ifdef EDM_ML_DEBUG
       edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis: Passive Hit buffer  " << passiveHits.size();
 #endif
       analyzePassiveHits(passiveHits);
     }
   }
 }

void CaloSimHitAnalysis::analyzeHits	(	std::vector< PCaloHit > &	hits,
		int	indx
	)

protected

Definition at line 318 of file CaloSimHitAnalysis.cc.

References funct::abs(), caloGeometry_, TauDecayModes::dec, HLT_FULL_cff::depth, PV3DBase< T, PVType, FrameType >::eta(), first, CaloGeometry::getPosition(), HcalGeometry::getPosition(), h_edep1_, h_edep_, h_edepEM_, h_edepHad_, h_edepT1_, h_edepT_, h_eta_, h_etaphi_, h_etot_, h_etotg_, h_hit_, h_phi_, h_rr_, h_rz1_, h_rz_, h_time_, h_timeT_, h_zz_, HcalBarrel, HcalEndcap, HcalForward, hcalGeom_, HcalOuter, gpuClustering::id, hit::id, isotrackApplyRegressor::k, nCalo_, PV3DBase< T, PVType, FrameType >::perp(), phi, PV3DBase< T, PVType, FrameType >::phi(), point, DetId::rawId(), edm::second(), HcalDetId::subdet(), tCut_, testNumber_, timeSliceUnit_, tMax_, tScale_, HcalTestNumbering::unpackHcalIndex(), z, and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

                                                                         {
   int nHit = hits.size();
   int nHB = 0, nHE = 0, nHO = 0, nHF = 0, nEB = 0, nEE = 0, nBad = 0, iHit = 0;
   std::map<CaloHitID, std::pair<double, double> > hitMap;
   double etot[nCalo_], etotG[nCalo_];
   for (unsigned int k = 0; k < nCalo_; ++k) {
     etot[k] = etotG[k] = 0;
   }
   for (const auto& hit : hits) {
     double edep = hit.energy();
     double time = tScale_ * hit.time();
     uint32_t id = hit.id();
     int itra = hit.geantTrackId();
     double edepEM = hit.energyEM();
     double edepHad = hit.energyHad();
     int idx(-1);
     if (indx != 2) {
       idx = indx;
       if (indx == 0)
         ++nEB;
       else
         ++nEE;
     } else {
       int subdet(0);
       if (testNumber_) {
         int ieta(0), phi(0), z(0), lay(0), depth(0);
         HcalTestNumbering::unpackHcalIndex(id, subdet, z, depth, ieta, phi, lay);
         id = HcalDetId(static_cast<HcalSubdetector>(subdet), z * ieta, phi, depth).rawId();
       } else {
         subdet = HcalDetId(id).subdet();
       }
       if (subdet == static_cast<int>(HcalBarrel)) {
         idx = indx;
         nHB++;
       } else if (subdet == static_cast<int>(HcalEndcap)) {
         idx = indx + 1;
         nHE++;
       } else if (subdet == static_cast<int>(HcalOuter)) {
         idx = indx + 2;
         nHO++;
       } else if (subdet == static_cast<int>(HcalForward)) {
         idx = indx + 3;
         nHF++;
       }
     }
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HitStudy") << "Hit[" << iHit << ":" << nHit << ":" << idx << "] E " << edep << ":" << edepEM
                                  << ":" << edepHad << " T " << time << " itra " << itra << " ID " << std::hex << id
                                  << std::dec;
 #endif
     ++iHit;
     if (idx >= 0) {
       CaloHitID hid(id, time, itra, 0, timeSliceUnit_[indx]);
       auto itr = hitMap.find(hid);
       if (itr == hitMap.end())
         hitMap[hid] = std::make_pair(time, edep);
       else
         ((itr->second).second) += edep;
       h_edepT_[idx]->Fill(edep);
       h_timeT_[idx]->Fill(time);
       if (edepEM > 0)
         h_edepEM_[idx]->Fill(edepEM);
       if (edepHad > 0)
         h_edepHad_[idx]->Fill(edepHad);
       if (time > tCut_)
         h_edepT1_[idx]->Fill(edep);
     } else {
       ++nBad;
     }
   }
 
   //Now make plots
   for (auto itr = hitMap.begin(); itr != hitMap.end(); ++itr) {
     int idx = -1;
     GlobalPoint point;
     DetId id((itr->first).unitID());
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HitStudy") << "Index " << indx << " Geom " << caloGeometry_ << ":" << hcalGeom_ << "  "
                                  << std::hex << id.rawId() << std::dec;
 #endif
     if (indx != 2) {
       idx = indx;
       point = caloGeometry_->getPosition(id);
     } else {
       int subdet = id.subdetId();
       if (subdet == static_cast<int>(HcalBarrel)) {
         idx = indx;
       } else if (subdet == static_cast<int>(HcalEndcap)) {
         idx = indx + 1;
       } else if (subdet == static_cast<int>(HcalOuter)) {
         idx = indx + 2;
       } else if (subdet == static_cast<int>(HcalForward)) {
         idx = indx + 3;
       }
       point = hcalGeom_->getPosition(id);
     }
     double edep = (itr->second).second;
     double time = (itr->second).first;
 #ifdef EDM_ML_DEBUG
     edm::LogVerbatim("HitStudy") << "Index " << idx << ":" << nCalo_ << " Point " << point << " E " << edep << " T "
                                  << time;
 #endif
     if (idx >= 0) {
       h_time_[idx]->Fill(time);
       h_edep_[idx]->Fill(edep);
       h_rr_[idx]->Fill(point.perp());
       h_zz_[idx]->Fill(point.z());
       h_eta_[idx]->Fill(point.eta());
       h_phi_[idx]->Fill(point.phi());
       h_rz_->Fill(std::abs(point.z()), point.perp());
       h_etaphi_->Fill(std::abs(point.eta()), std::abs(point.phi()));
       etot[idx] += edep;
       if (time < tMax_)
         etotG[idx] += edep;
       if (time > tCut_) {
         h_edep1_[idx]->Fill(edep);
         h_rz1_->Fill(std::abs(point.z()), point.perp());
       }
     }
   }
 
   if (indx < 2) {
     h_etot_[indx]->Fill(etot[indx]);
     h_etotg_[indx]->Fill(etotG[indx]);
     if (indx == 0)
       h_hit_[indx]->Fill(double(nEB));
     else
       h_hit_[indx]->Fill(double(nEE));
   } else {
     h_hit_[2]->Fill(double(nHB));
     h_hit_[3]->Fill(double(nHE));
     h_hit_[4]->Fill(double(nHO));
     h_hit_[5]->Fill(double(nHF));
     for (int idx = 2; idx < nCalo_; idx++) {
       h_etot_[idx]->Fill(etot[idx]);
       h_etotg_[idx]->Fill(etotG[idx]);
     }
   }
 
   edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis::analyzeHits: EB " << nEB << " EE " << nEE << " HB " << nHB
                                << " HE " << nHE << " HO " << nHO << " HF " << nHF << " Bad " << nBad << " All " << nHit
                                << " Reduced " << hitMap.size();
 }

void CaloSimHitAnalysis::analyzePassiveHits ( std::vector< PassiveHit > & hits )

protected

Definition at line 462 of file CaloSimHitAnalysis.cc.

References allSteps_, HcalDetId::depth(), detNames_, etaDepth_, h_edepp_, h_edepTk_, h_hitp_, h_rzH_, h_stepp_, h_timep_, h_timeTk_, h_trackp_, DetId::Hcal, hit::id, HcalDetId::ietaAbs(), isotrackApplyRegressor::k, findQualityFiles::rr, mathSSE::sqrt(), AlCaHLTBitMon_QueryRunRegistry::string, tracks, hit::x, hit::y, and hit::z.

Referenced by analyze().

                                                                        {
   const std::string active = "Active";
   const std::string sensor = "Sensor";
   std::map<std::pair<std::string, uint32_t>, int> hitx;
   std::map<int, int> tracks;
   unsigned int passive1(0), passive2(0);
   for (auto& hit : hits) {
     std::string name = hit.vname();
     std::pair<std::string, uint32_t> volume = std::make_pair(name, (hit.id() % 1000000));
     auto itr = hitx.find(volume);
     if (itr == hitx.end())
       hitx[volume] = 1;
     else
       ++(itr->second);
     auto ktr = tracks.find(hit.trackId());
     if (ktr == tracks.end())
       tracks[hit.trackId()] = 1;
     else
       ++(ktr->second);
     h_edepp_->Fill(hit.energy());
     h_timep_->Fill(hit.time());
     h_stepp_->Fill(hit.stepLength());
     if ((name.find(active) != std::string::npos) || (name.find(sensor) != std::string::npos)) {
       unsigned idet = detNames_.size();
       for (unsigned int k = 0; k < detNames_.size(); ++k) {
         if (name.find(detNames_[k]) != std::string::npos) {
           idet = k;
           break;
         }
       }
       if (idet < detNames_.size()) {
         h_edepTk_[idet]->Fill(hit.energy());
         h_timeTk_[idet]->Fill(hit.time());
       }
     }
 
     if ((allSteps_ / 100) % 10 > 0) {
       uint32_t id = hit.id();
       if (DetId(id).det() == DetId::Hcal) {
         HcalDetId hid = HcalDetId(id);
         int indx = (100 * hid.ietaAbs() + hid.depth());
         auto itr = etaDepth_.find(indx);
 #ifdef EDM_ML_DEBUG
         edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis::ID: " << hid << " Index " << indx << " Iterator "
                                      << (itr != etaDepth_.end());
 #endif
         ++passive1;
         if (itr != etaDepth_.end()) {
           uint32_t ipos = itr->second;
           double rr = std::sqrt(hit.x() * hit.x() + hit.y() * hit.y());
           if (ipos < h_rzH_.size()) {
             h_rzH_[ipos]->Fill(hit.z(), rr);
             ++passive2;
           }
         }
       }
     }
   }
   h_hitp_->Fill(hitx.size());
   h_trackp_->Fill(tracks.size());
   edm::LogVerbatim("HitStudy") << "CaloSimHitAnalysis::analyzPassiveHits: Total " << hits.size() << " Cells "
                                << hitx.size() << " Tracks " << tracks.size() << " Passive " << passive1 << ":"
                                << passive2;
 }

void CaloSimHitAnalysis::beginJob ( void )

inlineoverrideprotectedvirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 52 of file CaloSimHitAnalysis.cc.

52 {}

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

inlineoverrideprotected

Definition at line 54 of file CaloSimHitAnalysis.cc.

54 {}

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

inlineoverrideprotected

Definition at line 55 of file CaloSimHitAnalysis.cc.

55 {}

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

static

Definition at line 259 of file CaloSimHitAnalysis.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, HLT_FULL_cff::labels, names, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                     {
   edm::ParameterSetDescription desc;
   std::vector<std::string> labels = {"EcalHitsEB1", "EcalHitsEE1", "HcalHits1"};
   std::vector<double> times = {1, 1, 1};
   desc.addUntracked<std::string>("moduleLabel", "g4SimHits");
   desc.add<std::vector<std::string> >("hitCollection", labels);
   desc.add<std::vector<double> >("timeSliceUnit", times);
   desc.addUntracked<double>("maxEnergy", 250.0);
   desc.addUntracked<double>("maxTime", 1000.0);
   desc.addUntracked<double>("timeCut", 100.0);
   desc.addUntracked<double>("timeScale", 1.0);
   desc.addUntracked<double>("timeThreshold", 15.0);
   desc.addUntracked<bool>("testNumbering", false);
   desc.addUntracked<bool>("passiveHits", false);
   std::vector<std::string> names = {"PixelBarrel", "PixelForward", "TIB", "TID", "TOB", "TEC"};
   desc.addUntracked<std::vector<std::string> >("detNames", names);
   desc.addUntracked<int>("allStep", 100);
   descriptions.add("caloSimHitAnalysis", desc);
 }