Inheritance diagram for HGCalSimHitStudy:

Classes
struct	hitsinfo

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

	~HGCalSimHitStudy () 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	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 Member Functions
void	analyzeHits (int, const std::string &, const std::vector< PCaloHit > &)

Private Attributes
const std::vector< std::string >	caloHitSources_

const double	etamax_

const double	etamin_

std::vector< TH1D * >	h_C1_

std::vector< TH1D * >	h_C2_

std::vector< TH1D * >	h_E_

std::vector< TH2D * >	h_EtaPhi_

std::vector< TH2D * >	h_EtFiZm_

std::vector< TH2D * >	h_EtFiZp_

std::vector< TH1D * >	h_LayerZm_

std::vector< TH1D * >	h_LayerZp_

std::vector< TH1D * >	h_Ly_

std::vector< TH2D * >	h_RZ_

std::vector< TH1D * >	h_T_

std::vector< TH1D * >	h_W1_

std::vector< TH1D * >	h_W2_

std::vector< TH2D * >	h_XY_

std::vector< const HGCalDDDConstants * >	hgcons_

const bool	ifLayer_

const bool	ifNose_

std::vector< int >	layerFront_

std::vector< int >	layers_

const std::vector< std::string >	nameDetectors_

const int	nbinEta_

const int	nbinR_

const int	nbinZ_

const int	nLayers_

const double	rmax_

const double	rmin_

std::vector< edm::ESGetToken < HGCalDDDConstants, IdealGeometryRecord > >	tok_hgcGeom_

std::vector< edm::EDGetTokenT < edm::PCaloHitContainer > >	tok_hits_

const int	verbosity_

const double	zmax_

const double	zmin_

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

Constructor & Destructor Documentation

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

explicit

Definition at line 84 of file HGCalSimHitStudy.cc.

References caloHitSources_, TFileService::kSharedResource, mergeVDriftHistosByStation::name, nameDetectors_, source, tok_hgcGeom_, and tok_hits_.

     : nameDetectors_(iConfig.getParameter<std::vector<std::string> >("detectorNames")),
       caloHitSources_(iConfig.getParameter<std::vector<std::string> >("caloHitSources")),
       rmin_(iConfig.getUntrackedParameter<double>("rMin", 0.0)),
       rmax_(iConfig.getUntrackedParameter<double>("rMax", 3000.0)),
       zmin_(iConfig.getUntrackedParameter<double>("zMin", 3000.0)),
       zmax_(iConfig.getUntrackedParameter<double>("zMax", 6000.0)),
       etamin_(iConfig.getUntrackedParameter<double>("etaMin", 1.0)),
       etamax_(iConfig.getUntrackedParameter<double>("etaMax", 3.0)),
       nbinR_(iConfig.getUntrackedParameter<int>("nBinR", 300)),
       nbinZ_(iConfig.getUntrackedParameter<int>("nBinZ", 300)),
       nbinEta_(iConfig.getUntrackedParameter<int>("nBinEta", 200)),
       nLayers_(iConfig.getUntrackedParameter<int>("layers", 50)),
       verbosity_(iConfig.getUntrackedParameter<int>("verbosity", 0)),
       ifNose_(iConfig.getUntrackedParameter<bool>("ifNose", false)),
       ifLayer_(iConfig.getUntrackedParameter<bool>("ifLayer", false)) {
   usesResource(TFileService::kSharedResource);
 
   for (auto const& name : nameDetectors_)
     tok_hgcGeom_.emplace_back(
         esConsumes<HGCalDDDConstants, IdealGeometryRecord, edm::Transition::BeginRun>(edm::ESInputTag{"", name}));
   for (auto const& source : caloHitSources_)
     tok_hits_.emplace_back(consumes<edm::PCaloHitContainer>(edm::InputTag("g4SimHits", source)));
 }

HGCalSimHitStudy::~HGCalSimHitStudy ( )

inlineoverride

Definition at line 55 of file HGCalSimHitStudy.cc.

55 {}

Member Function Documentation

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

overrideprotectedvirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 131 of file HGCalSimHitStudy.cc.

References analyzeHits(), edm::Event::getByToken(), edm::HandleBase::isValid(), isotrackApplyRegressor::k, nameDetectors_, tok_hits_, and verbosity_.

                                                                                   {
   //Now the hits
   for (unsigned int k = 0; k < tok_hits_.size(); ++k) {
     edm::Handle<edm::PCaloHitContainer> theCaloHitContainers;
     iEvent.getByToken(tok_hits_[k], theCaloHitContainers);
     if (theCaloHitContainers.isValid()) {
       if (verbosity_ > 0)
         edm::LogVerbatim("HGCalValidation") << " PcalohitItr = " << theCaloHitContainers->size();
       std::vector<PCaloHit> caloHits;
       caloHits.insert(caloHits.end(), theCaloHitContainers->begin(), theCaloHitContainers->end());
       analyzeHits(k, nameDetectors_[k], caloHits);
     } else if (verbosity_ > 0) {
       edm::LogVerbatim("HGCalValidation") << "PCaloHitContainer does not "
                                           << "exist for " << nameDetectors_[k];
     }
   }
 }

void HGCalSimHitStudy::analyzeHits	(	int	ih,
		const std::string &	name,
		const std::vector< PCaloHit > &	hits
	)

private

Definition at line 149 of file HGCalSimHitStudy.cc.

References funct::abs(), HFNoseDetId::cellU(), HGCSiliconDetId::cellU(), HFNoseDetId::cellV(), HGCSiliconDetId::cellV(), DetId::det(), relval_parameters_module::energy, HGCalSimHitStudy::hitsinfo::energy, HGCalSimHitStudy::hitsinfo::eta, h_C1_, h_C2_, h_E_, h_EtaPhi_, h_EtFiZm_, h_EtFiZp_, h_LayerZm_, h_LayerZp_, h_Ly_, h_RZ_, h_T_, h_W1_, h_W2_, h_XY_, hgcons_, gpuClustering::id, hit::id, HGCScintillatorDetId::ieta(), ifLayer_, ifNose_, HGCScintillatorDetId::iphi(), HGCScintillatorDetId::layer(), HGCalSimHitStudy::hitsinfo::layer, HFNoseDetId::layer(), HGCSiliconDetId::layer(), phase1PixelTopology::layer, layerFront_, HGCalSimHitStudy::hitsinfo::phi, DetId::subdetId(), HGCalSimHitStudy::hitsinfo::time, HGCScintillatorDetId::type(), HFNoseDetId::type(), HGCSiliconDetId::type(), HGCalTestNumbering::unpackHexagonIndex(), verbosity_, HFNoseDetId::waferU(), HGCSiliconDetId::waferU(), HGCSiliconDetId::waferV(), HFNoseDetId::waferV(), xy(), HGCScintillatorDetId::zside(), HFNoseDetId::zside(), HGCSiliconDetId::zside(), and ecaldqm::zside().

Referenced by analyze().

                                                                                                  {
   if (verbosity_ > 0)
     edm::LogVerbatim("HGCalValidation") << name << " with " << hits.size() << " PcaloHit elements";
 
   std::map<uint32_t, hitsinfo> map_hits;
   map_hits.clear();
 
   unsigned int nused(0);
   for (auto const& hit : hits) {
     double energy = hit.energy();
     double time = hit.time();
     uint32_t id = hit.id();
     int cell, sector, sector2(0), layer, zside;
     int subdet(0), cell2(0), type(0);
     HepGeom::Point3D<float> gcoord;
     std::pair<float, float> xy;
     if (ifNose_) {
       HFNoseDetId detId = HFNoseDetId(id);
       subdet = detId.subdetId();
       cell = detId.cellU();
       cell2 = detId.cellV();
       sector = detId.waferU();
       sector2 = detId.waferV();
       type = detId.type();
       layer = detId.layer();
       zside = detId.zside();
       xy = hgcons_[ih]->locateCell(layer, sector, sector2, cell, cell2, false, true);
       h_W2_[ih]->Fill(sector2);
       h_C2_[ih]->Fill(cell2);
     } else if (hgcons_[ih]->waferHexagon8()) {
       HGCSiliconDetId detId = HGCSiliconDetId(id);
       subdet = static_cast<int>(detId.det());
       cell = detId.cellU();
       cell2 = detId.cellV();
       sector = detId.waferU();
       sector2 = detId.waferV();
       type = detId.type();
       layer = detId.layer();
       zside = detId.zside();
       xy = hgcons_[ih]->locateCell(layer, sector, sector2, cell, cell2, false, true);
       h_W2_[ih]->Fill(sector2);
       h_C2_[ih]->Fill(cell2);
     } else if (hgcons_[ih]->tileTrapezoid()) {
       HGCScintillatorDetId detId = HGCScintillatorDetId(id);
       subdet = static_cast<int>(detId.det());
       sector = detId.ieta();
       cell = detId.iphi();
       type = detId.type();
       layer = detId.layer();
       zside = detId.zside();
       xy = hgcons_[ih]->locateCellTrap(layer, sector, cell, false);
     } else {
       HGCalTestNumbering::unpackHexagonIndex(id, subdet, zside, layer, sector, type, cell);
       xy = hgcons_[ih]->locateCell(cell, layer, sector, false);
     }
     double zp = hgcons_[ih]->waferZ(layer, false);
     if (zside < 0)
       zp = -zp;
     double xp = (zp < 0) ? -xy.first : xy.first;
     gcoord = HepGeom::Point3D<float>(xp, xy.second, zp);
     if (verbosity_ > 2)
       edm::LogVerbatim("HGCalValidation")
           << "i/p " << subdet << ":" << zside << ":" << layer << ":" << sector << ":" << sector2 << ":" << cell << ":"
           << cell2 << " o/p " << xy.first << ":" << xy.second << ":" << zp;
     nused++;
     double tof = (gcoord.mag() * CLHEP::mm) / CLHEP::c_light;
     if (verbosity_ > 1)
       edm::LogVerbatim("HGCalValidation")
           << "Detector " << name << " zside = " << zside << " layer = " << layer << " type = " << type
           << " wafer = " << sector << ":" << sector2 << " cell = " << cell << ":" << cell2 << " positon = " << gcoord
           << " energy = " << energy << " time = " << time << ":" << tof;
     time -= tof;
     if (time < 0)
       time = 0;
     hitsinfo hinfo;
     if (map_hits.count(id) != 0) {
       hinfo = map_hits[id];
     } else {
       hinfo.layer = layer + layerFront_[ih];
       hinfo.phi = gcoord.getPhi();
       hinfo.eta = gcoord.getEta();
       hinfo.time = time;
     }
     hinfo.energy += energy;
     map_hits[id] = hinfo;
 
     //Fill in histograms
     h_RZ_[0]->Fill(std::abs(gcoord.z()), gcoord.rho());
     h_RZ_[ih + 1]->Fill(std::abs(gcoord.z()), gcoord.rho());
     if (ifLayer_) {
       if (hinfo.layer <= static_cast<int>(h_XY_.size()))
         h_XY_[hinfo.layer - 1]->Fill(gcoord.x(), gcoord.y());
     } else {
       h_EtaPhi_[0]->Fill(std::abs(hinfo.eta), hinfo.phi);
       h_EtaPhi_[ih + 1]->Fill(std::abs(hinfo.eta), hinfo.phi);
     }
     h_Ly_[ih]->Fill(layer);
     h_W1_[ih]->Fill(sector);
     h_C1_[ih]->Fill(cell);
   }
   if (verbosity_ > 0)
     edm::LogVerbatim("HGCalValidation") << name << " with " << map_hits.size() << ":" << nused << " detector elements"
                                         << " being hit";
 
   for (auto const& hit : map_hits) {
     hitsinfo hinfo = hit.second;
     if (verbosity_ > 1)
       edm::LogVerbatim("HGCalValidation")
           << " ----------------------   eta = " << hinfo.eta << " phi = " << hinfo.phi << " layer = " << hinfo.layer
           << " E = " << hinfo.energy << " T = " << hinfo.time;
     h_E_[0]->Fill(hinfo.energy);
     h_E_[ih + 1]->Fill(hinfo.energy);
     h_T_[0]->Fill(hinfo.time);
     h_T_[ih + 1]->Fill(hinfo.time);
     if (hinfo.eta > 0) {
       if (!ifLayer_) {
         h_EtFiZp_[0]->Fill(std::abs(hinfo.eta), hinfo.phi, hinfo.energy);
         h_EtFiZp_[ih + 1]->Fill(std::abs(hinfo.eta), hinfo.phi, hinfo.energy);
       }
       h_LayerZp_[0]->Fill(hinfo.layer, hinfo.energy);
       h_LayerZp_[ih + 1]->Fill(hinfo.layer, hinfo.energy);
     } else {
       if (!ifLayer_) {
         h_EtFiZm_[0]->Fill(std::abs(hinfo.eta), hinfo.phi, hinfo.energy);
         h_EtFiZm_[ih + 1]->Fill(std::abs(hinfo.eta), hinfo.phi, hinfo.energy);
       }
       h_LayerZm_[0]->Fill(hinfo.layer, hinfo.energy);
       h_LayerZm_[ih + 1]->Fill(hinfo.layer, hinfo.energy);
     }
   }
 }

void HGCalSimHitStudy::beginJob ( void )

overrideprotectedvirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 293 of file HGCalSimHitStudy.cc.

References etamax_, etamin_, compareTotals::fs, h_C1_, h_C2_, h_E_, h_EtaPhi_, h_EtFiZm_, h_EtFiZp_, h_LayerZm_, h_LayerZp_, h_Ly_, h_RZ_, h_T_, h_W1_, h_W2_, h_XY_, ifLayer_, M_PI, TFileService::make(), mergeVDriftHistosByStation::name, nameDetectors_, nbinEta_, nbinR_, nbinZ_, nLayers_, rmax_, rmin_, runGCPTkAlMap::title, zmax_, and zmin_.

                                 {
   edm::Service<TFileService> fs;
 
   std::ostringstream name, title;
   for (unsigned int ih = 0; ih <= nameDetectors_.size(); ++ih) {
     name.str("");
     title.str("");
     if (ih == 0) {
       name << "RZ_AllDetectors";
       title << "R vs Z for All Detectors";
     } else {
       name << "RZ_" << nameDetectors_[ih - 1];
       title << "R vs Z for " << nameDetectors_[ih - 1];
     }
     h_RZ_.emplace_back(
         fs->make<TH2D>(name.str().c_str(), title.str().c_str(), nbinZ_, zmin_, zmax_, nbinR_, rmin_, rmax_));
     if (ifLayer_) {
       if (ih == 0) {
         for (int ly = 0; ly < nLayers_; ++ly) {
           name.str("");
           title.str("");
           name << "XY_L" << (ly + 1);
           title << "Y vs X at Layer " << (ly + 1);
           h_XY_.emplace_back(
               fs->make<TH2D>(name.str().c_str(), title.str().c_str(), nbinR_, -rmax_, rmax_, nbinR_, -rmax_, rmax_));
         }
       }
     } else {
       name.str("");
       title.str("");
       if (ih == 0) {
         name << "EtaPhi_AllDetectors";
         title << "#phi vs #eta for All Detectors";
       } else {
         name << "EtaPhi_" << nameDetectors_[ih - 1];
         title << "#phi vs #eta for " << nameDetectors_[ih - 1];
       }
       h_EtaPhi_.emplace_back(
           fs->make<TH2D>(name.str().c_str(), title.str().c_str(), nbinEta_, etamin_, etamax_, 200, -M_PI, M_PI));
       name.str("");
       title.str("");
       if (ih == 0) {
         name << "EtFiZp_AllDetectors";
         title << "#phi vs #eta (+z) for All Detectors";
       } else {
         name << "EtFiZp_" << nameDetectors_[ih - 1];
         title << "#phi vs #eta (+z) for " << nameDetectors_[ih - 1];
       }
       h_EtFiZp_.emplace_back(
           fs->make<TH2D>(name.str().c_str(), title.str().c_str(), nbinEta_, etamin_, etamax_, 200, -M_PI, M_PI));
       name.str("");
       title.str("");
       if (ih == 0) {
         name << "EtFiZm_AllDetectors";
         title << "#phi vs #eta (-z) for All Detectors";
       } else {
         name << "EtFiZm_" << nameDetectors_[ih - 1];
         title << "#phi vs #eta (-z) for " << nameDetectors_[ih - 1];
       }
       h_EtFiZm_.emplace_back(
           fs->make<TH2D>(name.str().c_str(), title.str().c_str(), nbinEta_, etamin_, etamax_, 200, -M_PI, M_PI));
     }
     name.str("");
     title.str("");
     if (ih == 0) {
       name << "LayerZp_AllDetectors";
       title << "Energy vs Layer (+z) for All Detectors";
     } else {
       name << "LayerZp_" << nameDetectors_[ih - 1];
       title << "Energy vs Layer (+z) for " << nameDetectors_[ih - 1];
     }
     h_LayerZp_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 60, 0.0, 60.0));
     name.str("");
     title.str("");
     if (ih == 0) {
       name << "LayerZm_AllDetectors";
       title << "Energy vs Layer (-z) for All Detectors";
     } else {
       name << "LayerZm_" << nameDetectors_[ih - 1];
       title << "Energy vs Layer (-z) for " << nameDetectors_[ih - 1];
     }
     h_LayerZm_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 60, 0.0, 60.0));
 
     name.str("");
     title.str("");
     if (ih == 0) {
       name << "E_AllDetectors";
       title << "Energy Deposit for All Detectors";
     } else {
       name << "E_" << nameDetectors_[ih - 1];
       title << "Energy Deposit for " << nameDetectors_[ih - 1];
     }
     h_E_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 1000, 0.0, 1.0));
 
     name.str("");
     title.str("");
     if (ih == 0) {
       name << "T_AllDetectors";
       title << "Time for All Detectors";
     } else {
       name << "T_" << nameDetectors_[ih - 1];
       title << "Time for " << nameDetectors_[ih - 1];
     }
     h_T_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 1000, 0.0, 200.0));
   }
 
   for (unsigned int ih = 0; ih < nameDetectors_.size(); ++ih) {
     name.str("");
     title.str("");
     name << "LY_" << nameDetectors_[ih];
     title << "Layer number for " << nameDetectors_[ih];
     h_Ly_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 200, 0, 100));
     if (nameDetectors_[ih] == "HGCalHEScintillatorSensitive") {
       name.str("");
       title.str("");
       name << "IR_" << nameDetectors_[ih];
       title << "Radius index for " << nameDetectors_[ih];
       h_W1_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 200, -50, 50));
       name.str("");
       title.str("");
       name << "FI_" << nameDetectors_[ih];
       title << "#phi index for " << nameDetectors_[ih];
       h_C1_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 720, 0, 360));
     } else {
       name.str("");
       title.str("");
       name << "WU_" << nameDetectors_[ih];
       title << "u index of wafers for " << nameDetectors_[ih];
       h_W1_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 200, -50, 50));
       name.str("");
       title.str("");
       name << "WV_" << nameDetectors_[ih];
       title << "v index of wafers for " << nameDetectors_[ih];
       h_W2_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 100, -50, 50));
       name.str("");
       title.str("");
       name << "CU_" << nameDetectors_[ih];
       title << "u index of cells for " << nameDetectors_[ih];
       h_C1_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 100, 0, 50));
       name.str("");
       title.str("");
       name << "CV_" << nameDetectors_[ih];
       title << "v index of cells for " << nameDetectors_[ih];
       h_C2_.emplace_back(fs->make<TH1D>(name.str().c_str(), title.str().c_str(), 100, 0, 50));
     }
   }
 }

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

overrideprotected

Definition at line 282 of file HGCalSimHitStudy.cc.

References edm::EventSetup::getData(), hgcons_, isotrackApplyRegressor::k, layerFront_, layers_, nameDetectors_, tok_hgcGeom_, and verbosity_.

                                                                           {
   for (unsigned int k = 0; k < nameDetectors_.size(); ++k) {
     hgcons_.emplace_back(&iSetup.getData(tok_hgcGeom_[k]));
     layers_.emplace_back(hgcons_.back()->layers(false));
     layerFront_.emplace_back(hgcons_.back()->firstLayer());
     if (verbosity_ > 0)
       edm::LogVerbatim("HGCalValidation") << nameDetectors_[k] << " defined with " << layers_.back() << " Layers with "
                                           << layerFront_.back() << " in front";
   }
 }

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

inlineoverrideprotected

Definition at line 62 of file HGCalSimHitStudy.cc.

62 {}

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

static

Definition at line 109 of file HGCalSimHitStudy.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, and names.

                                                                                   {
   edm::ParameterSetDescription desc;
   std::vector<std::string> names = {"HGCalEESensitive", "HGCalHESiliconSensitive", "HGCalHEScintillatorSensitive"};
   std::vector<std::string> sources = {"HGCHitsEE", "HGCHitsHEfront", "HGCHitsHEback"};
   desc.add<std::vector<std::string> >("detectorNames", names);
   desc.add<std::vector<std::string> >("caloHitSources", sources);
   desc.addUntracked<double>("rMin", 0.0);
   desc.addUntracked<double>("rMax", 3000.0);
   desc.addUntracked<double>("zMin", 3000.0);
   desc.addUntracked<double>("zMax", 6000.0);
   desc.addUntracked<double>("etaMin", 1.0);
   desc.addUntracked<double>("etaMax", 3.0);
   desc.addUntracked<int>("nBinR", 300);
   desc.addUntracked<int>("nBinZ", 300);
   desc.addUntracked<int>("nBinEta", 200);
   desc.addUntracked<int>("layers", 50);
   desc.addUntracked<int>("verbosity", 0);
   desc.addUntracked<bool>("ifNose", false);
   desc.addUntracked<bool>("ifLayer", false);
   descriptions.add("hgcalSimHitStudy", desc);
 }