File indexing completed on 2025-04-30 22:24:43
0001 #include <memory>
0002
0003 #include "Validation/HGCalValidation/interface/HGCalValidator.h"
0004
0005 #include "SimCalorimetry/HGCalAssociatorProducers/interface/AssociatorTools.h"
0006
0007 #include "FWCore/Framework/interface/MakerMacros.h"
0008 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0009
0010 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0011 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0012
0013 using namespace std;
0014 using namespace edm;
0015 using namespace ticl;
0016
0017 namespace {
0018 bool assignTracksterMaps(const edm::Handle<std::vector<ticl::Trackster>>& tracksterHandle,
0019 const edm::Handle<std::vector<ticl::Trackster>>& simTracksterHandle,
0020 const edm::Handle<std::vector<ticl::Trackster>>& simTracksterFromCPHandle,
0021 const std::vector<edm::Handle<TracksterToTracksterMap>>& tracksterToTracksterMapsHandles,
0022 edm::Handle<TracksterToTracksterMap>& trackstersToSimTrackstersMap,
0023 edm::Handle<TracksterToTracksterMap>& simTrackstersToTrackstersMap,
0024 edm::Handle<TracksterToTracksterMap>& trackstersToSimTrackstersFromCPsMap,
0025 edm::Handle<TracksterToTracksterMap>& simTrackstersFromCPsToTrackstersMap) {
0026 const auto recoTrackstersProductId = tracksterHandle.id();
0027 const auto simTrackstersProductId = simTracksterHandle.id();
0028 const auto simTrackstersFromCPsProductId = simTracksterFromCPHandle.id();
0029 if (recoTrackstersProductId == simTrackstersProductId or recoTrackstersProductId == simTrackstersFromCPsProductId) {
0030 edm::LogInfo("MissingProduct") << "no SimTrackster to Simtrackster map available.";
0031 return false;
0032 }
0033 for (const auto& handle : tracksterToTracksterMapsHandles) {
0034 const auto& firstID = handle->getCollectionIDs().first.id();
0035 const auto& secondID = handle->getCollectionIDs().second.id();
0036
0037 if (firstID == recoTrackstersProductId && secondID == simTrackstersProductId) {
0038 trackstersToSimTrackstersMap = handle;
0039 } else if (firstID == simTrackstersProductId && secondID == recoTrackstersProductId) {
0040 simTrackstersToTrackstersMap = handle;
0041 } else if (firstID == recoTrackstersProductId && secondID == simTrackstersFromCPsProductId) {
0042 trackstersToSimTrackstersFromCPsMap = handle;
0043 } else if (firstID == simTrackstersFromCPsProductId && secondID == recoTrackstersProductId) {
0044 simTrackstersFromCPsToTrackstersMap = handle;
0045 }
0046 }
0047 if (not trackstersToSimTrackstersMap.isValid()) {
0048 edm::LogError("MissingProduct") << "trackstersToSimTrackstersMap is not valid";
0049 return false;
0050 }
0051 if (not simTrackstersToTrackstersMap.isValid()) {
0052 edm::LogError("MissingProduct") << "simTrackstersToTrackstersMap is not valid";
0053 return false;
0054 }
0055 if (not trackstersToSimTrackstersFromCPsMap.isValid()) {
0056 edm::LogError("MissingProduct") << "trackstersToSimTrackstersFromCPsMap is not valid";
0057 return false;
0058 }
0059 if (not simTrackstersFromCPsToTrackstersMap.isValid()) {
0060 edm::LogError("MissingProduct") << "simTrackstersFromCPsToTrackstersMap is not valid";
0061 return false;
0062 }
0063 return true;
0064 }
0065
0066 }
0067
0068 HGCalValidator::HGCalValidator(const edm::ParameterSet& pset)
0069 : caloGeomToken_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
0070 label_lcl(pset.getParameter<edm::InputTag>("label_lcl")),
0071 label_tst(pset.getParameter<std::vector<edm::InputTag>>("label_tst")),
0072 allTracksterTracksterAssociatorsLabels_(
0073 pset.getParameter<std::vector<edm::InputTag>>("allTracksterTracksterAssociatorsLabels")),
0074 allTracksterTracksterByHitsAssociatorsLabels_(
0075 pset.getParameter<std::vector<edm::InputTag>>("allTracksterTracksterByHitsAssociatorsLabels")),
0076 label_simTS(pset.getParameter<edm::InputTag>("label_simTS")),
0077 label_simTSFromCP(pset.getParameter<edm::InputTag>("label_simTSFromCP")),
0078 associator_(pset.getUntrackedParameter<edm::InputTag>("associator")),
0079 associatorSim_(pset.getUntrackedParameter<edm::InputTag>("associatorSim")),
0080 SaveGeneralInfo_(pset.getUntrackedParameter<bool>("SaveGeneralInfo")),
0081 doCaloParticlePlots_(pset.getUntrackedParameter<bool>("doCaloParticlePlots")),
0082 doCaloParticleSelection_(pset.getUntrackedParameter<bool>("doCaloParticleSelection")),
0083 doSimClustersPlots_(pset.getUntrackedParameter<bool>("doSimClustersPlots")),
0084 label_SimClustersPlots_(pset.getParameter<edm::InputTag>("label_SimClusters")),
0085 label_SimClustersLevel_(pset.getParameter<edm::InputTag>("label_SimClustersLevel")),
0086 doLayerClustersPlots_(pset.getUntrackedParameter<bool>("doLayerClustersPlots")),
0087 label_layerClustersPlots_(pset.getParameter<edm::InputTag>("label_layerClusterPlots")),
0088 label_LCToCPLinking_(pset.getParameter<edm::InputTag>("label_LCToCPLinking")),
0089 doTrackstersPlots_(pset.getUntrackedParameter<bool>("doTrackstersPlots")),
0090 label_TS_(pset.getParameter<std::string>("label_TS")),
0091 label_TSbyHitsCP_(pset.getParameter<std::string>("label_TSbyHitsCP")),
0092 label_TSbyHits_(pset.getParameter<std::string>("label_TSbyHits")),
0093 label_TSbyLCsCP_(pset.getParameter<std::string>("label_TSbyLCsCP")),
0094 label_TSbyLCs_(pset.getParameter<std::string>("label_TSbyLCs")),
0095 label_clustersmask(pset.getParameter<std::vector<edm::InputTag>>("LayerClustersInputMask")),
0096 doCandidatesPlots_(pset.getUntrackedParameter<bool>("doCandidatesPlots")),
0097 label_candidates_(pset.getParameter<std::string>("ticlCandidates")),
0098 cummatbudinxo_(pset.getParameter<edm::FileInPath>("cummatbudinxo")),
0099 isTICLv5_(pset.getUntrackedParameter<bool>("isticlv5")),
0100 hits_label_(pset.getParameter<std::vector<edm::InputTag>>("hits")),
0101 scToCpMapToken_(
0102 consumes<SimClusterToCaloParticleMap>(pset.getParameter<edm::InputTag>("simClustersToCaloParticlesMap"))) {
0103
0104 const edm::InputTag& label_cp_effic_tag = pset.getParameter<edm::InputTag>("label_cp_effic");
0105 const edm::InputTag& label_cp_fake_tag = pset.getParameter<edm::InputTag>("label_cp_fake");
0106
0107 for (auto& label : hits_label_) {
0108 hits_tokens_.push_back(consumes<HGCRecHitCollection>(label));
0109 }
0110 label_cp_effic = consumes<std::vector<CaloParticle>>(label_cp_effic_tag);
0111 label_cp_fake = consumes<std::vector<CaloParticle>>(label_cp_fake_tag);
0112
0113 simVertices_ = consumes<std::vector<SimVertex>>(pset.getParameter<edm::InputTag>("simVertices"));
0114
0115 for (auto& itag : label_clustersmask) {
0116 clustersMaskTokens_.push_back(consumes<std::vector<float>>(itag));
0117 }
0118
0119 associatorMapSimtR = consumes<ticl::SimToRecoCollectionWithSimClusters>(associatorSim_);
0120 associatorMapRtSim = consumes<ticl::RecoToSimCollectionWithSimClusters>(associatorSim_);
0121
0122 simTrackstersMap_ = consumes<std::map<uint, std::vector<uint>>>(pset.getParameter<edm::InputTag>("simTrackstersMap"));
0123
0124 hitMap_ = consumes<std::unordered_map<DetId, const unsigned int>>(pset.getParameter<edm::InputTag>("hitMap"));
0125
0126 simClusters_ = consumes<std::vector<SimCluster>>(pset.getParameter<edm::InputTag>("label_scl"));
0127
0128 layerclusters_ = consumes<reco::CaloClusterCollection>(label_lcl);
0129 for (const auto& tag : allTracksterTracksterAssociatorsLabels_) {
0130 tracksterToTracksterAssociatorsTokens_.emplace_back(consumes<TracksterToTracksterMap>(tag));
0131 }
0132
0133 for (const auto& tag : allTracksterTracksterByHitsAssociatorsLabels_) {
0134 tracksterToTracksterByHitsAssociatorsTokens_.emplace_back(consumes<TracksterToTracksterMap>(tag));
0135 }
0136
0137 if (doCandidatesPlots_) {
0138 edm::EDGetTokenT<std::vector<TICLCandidate>> TICLCandidatesToken =
0139 consumes<std::vector<TICLCandidate>>(pset.getParameter<edm::InputTag>("ticlTrackstersMerge"));
0140 edm::EDGetTokenT<std::vector<TICLCandidate>> simTICLCandidatesToken =
0141 consumes<std::vector<TICLCandidate>>(pset.getParameter<edm::InputTag>("simTiclCandidates"));
0142 edm::EDGetTokenT<std::vector<reco::Track>> recoTracksToken =
0143 consumes<std::vector<reco::Track>>(pset.getParameter<edm::InputTag>("recoTracks"));
0144 edm::EDGetTokenT<std::vector<ticl::Trackster>> trackstersToken =
0145 consumes<std::vector<ticl::Trackster>>(pset.getParameter<edm::InputTag>("ticlTrackstersMerge"));
0146 edm::EDGetTokenT<ticl::TracksterToTracksterMap> associatorMapRtSToken =
0147 consumes<ticl::TracksterToTracksterMap>(pset.getParameter<edm::InputTag>("mergeRecoToSimAssociator"));
0148 edm::EDGetTokenT<ticl::TracksterToTracksterMap> associatorMapStRToken =
0149 consumes<ticl::TracksterToTracksterMap>(pset.getParameter<edm::InputTag>("mergeSimToRecoAssociator"));
0150
0151 candidateVal_ = std::make_unique<TICLCandidateValidator>(TICLCandidatesToken,
0152 simTICLCandidatesToken,
0153 recoTracksToken,
0154 trackstersToken,
0155 associatorMapRtSToken,
0156 associatorMapStRToken,
0157 isTICLv5_);
0158 }
0159
0160 for (auto& itag : label_tst) {
0161 label_tstTokens.push_back(consumes<ticl::TracksterCollection>(itag));
0162 }
0163
0164 simTracksters_ = consumes<ticl::TracksterCollection>(label_simTS);
0165 simTracksters_fromCPs_ = consumes<ticl::TracksterCollection>(label_simTSFromCP);
0166
0167 associatorMapRtS = consumes<ticl::RecoToSimCollection>(associator_);
0168 associatorMapStR = consumes<ticl::SimToRecoCollection>(associator_);
0169
0170 cpSelector = CaloParticleSelector(pset.getParameter<double>("ptMinCP"),
0171 pset.getParameter<double>("ptMaxCP"),
0172 pset.getParameter<double>("minRapidityCP"),
0173 pset.getParameter<double>("maxRapidityCP"),
0174 pset.getParameter<double>("lipCP"),
0175 pset.getParameter<double>("tipCP"),
0176 pset.getParameter<int>("minHitCP"),
0177 pset.getParameter<int>("maxSimClustersCP"),
0178 pset.getParameter<bool>("signalOnlyCP"),
0179 pset.getParameter<bool>("intimeOnlyCP"),
0180 pset.getParameter<bool>("chargedOnlyCP"),
0181 pset.getParameter<bool>("stableOnlyCP"),
0182 pset.getParameter<bool>("notConvertedOnlyCP"),
0183 pset.getParameter<std::vector<int>>("pdgIdCP"));
0184
0185 tools_ = std::make_shared<hgcal::RecHitTools>();
0186
0187 particles_to_monitor_ = pset.getParameter<std::vector<int>>("pdgIdCP");
0188 totallayers_to_monitor_ = pset.getParameter<int>("totallayers_to_monitor");
0189 thicknesses_to_monitor_ = pset.getParameter<std::vector<int>>("thicknesses_to_monitor");
0190
0191
0192 std::ifstream fmb(cummatbudinxo_.fullPath().c_str());
0193 double thelay = 0.;
0194 double mbg = 0.;
0195 for (unsigned ilayer = 1; ilayer <= totallayers_to_monitor_; ++ilayer) {
0196 fmb >> thelay >> mbg;
0197 cumulative_material_budget.insert(std::pair<double, double>(thelay, mbg));
0198 }
0199
0200 fmb.close();
0201
0202 ParameterSet psetForHistoProducerAlgo = pset.getParameter<ParameterSet>("histoProducerAlgoBlock");
0203 histoProducerAlgo_ = std::make_unique<HGVHistoProducerAlgo>(psetForHistoProducerAlgo);
0204
0205 dirName_ = pset.getParameter<std::string>("dirName");
0206 }
0207
0208 HGCalValidator::~HGCalValidator() {}
0209
0210 void HGCalValidator::bookHistograms(DQMStore::IBooker& ibook,
0211 edm::Run const&,
0212 edm::EventSetup const& setup,
0213 Histograms& histograms) const {
0214 if (SaveGeneralInfo_) {
0215 ibook.cd();
0216 ibook.setCurrentFolder(dirName_ + "GeneralInfo");
0217 histoProducerAlgo_->bookInfo(ibook, histograms.histoProducerAlgo);
0218 }
0219
0220 if (doCaloParticlePlots_) {
0221 ibook.cd();
0222
0223 for (auto const particle : particles_to_monitor_) {
0224 ibook.setCurrentFolder(dirName_ + "SelectedCaloParticles/" + std::to_string(particle));
0225 histoProducerAlgo_->bookCaloParticleHistos(
0226 ibook, histograms.histoProducerAlgo, particle, totallayers_to_monitor_);
0227 }
0228 ibook.cd();
0229 ibook.setCurrentFolder(dirName_);
0230 }
0231
0232
0233 if (doSimClustersPlots_) {
0234 ibook.cd();
0235 ibook.setCurrentFolder(dirName_ + label_SimClustersPlots_.label() + "/" + label_SimClustersLevel_.label());
0236 histoProducerAlgo_->bookSimClusterHistos(
0237 ibook, histograms.histoProducerAlgo, totallayers_to_monitor_, thicknesses_to_monitor_);
0238
0239 for (unsigned int ws = 0; ws < label_clustersmask.size(); ws++) {
0240 ibook.cd();
0241 InputTag algo = label_clustersmask[ws];
0242 string dirName = dirName_ + label_SimClustersPlots_.label() + "/";
0243 if (!algo.process().empty())
0244 dirName += algo.process() + "_";
0245 LogDebug("HGCalValidator") << dirName << "\n";
0246 if (!algo.label().empty())
0247 dirName += algo.label() + "_";
0248 LogDebug("HGCalValidator") << dirName << "\n";
0249 if (!algo.instance().empty())
0250 dirName += algo.instance() + "_";
0251 LogDebug("HGCalValidator") << dirName << "\n";
0252
0253 if (!dirName.empty()) {
0254 dirName.resize(dirName.size() - 1);
0255 }
0256
0257 LogDebug("HGCalValidator") << dirName << "\n";
0258
0259 ibook.setCurrentFolder(dirName);
0260
0261 histoProducerAlgo_->bookSimClusterAssociationHistos(
0262 ibook, histograms.histoProducerAlgo, totallayers_to_monitor_, thicknesses_to_monitor_);
0263 }
0264 }
0265
0266
0267 if (doLayerClustersPlots_) {
0268 ibook.cd();
0269 ibook.setCurrentFolder(dirName_ + label_layerClustersPlots_.label() + "/ClusterLevel");
0270 histoProducerAlgo_->bookClusterHistos_ClusterLevel(ibook,
0271 histograms.histoProducerAlgo,
0272 totallayers_to_monitor_,
0273 thicknesses_to_monitor_,
0274 cummatbudinxo_.fullPath());
0275 ibook.cd();
0276 ibook.setCurrentFolder(dirName_ + label_layerClustersPlots_.label() + "/" + label_LCToCPLinking_.label());
0277 histoProducerAlgo_->bookClusterHistos_LCtoCP_association(
0278 ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0279
0280 ibook.cd();
0281 ibook.setCurrentFolder(dirName_ + label_layerClustersPlots_.label() + "/CellLevel");
0282 histoProducerAlgo_->bookClusterHistos_CellLevel(
0283 ibook, histograms.histoProducerAlgo, totallayers_to_monitor_, thicknesses_to_monitor_);
0284 }
0285
0286
0287 for (unsigned int www = 0; www < label_tst.size(); www++) {
0288 ibook.cd();
0289 InputTag algo = label_tst[www];
0290 string dirName = dirName_;
0291 if (!algo.process().empty())
0292 dirName += algo.process() + "_";
0293 LogDebug("HGCalValidator") << dirName << "\n";
0294 if (!algo.label().empty())
0295 dirName += algo.label() + "_";
0296 LogDebug("HGCalValidator") << dirName << "\n";
0297 if (!algo.instance().empty())
0298 dirName += algo.instance() + "_";
0299 LogDebug("HGCalValidator") << dirName << "\n";
0300
0301 if (!dirName.empty()) {
0302 dirName.resize(dirName.size() - 1);
0303 }
0304
0305 ibook.setCurrentFolder(dirName);
0306
0307
0308 if (doTrackstersPlots_) {
0309
0310 ibook.setCurrentFolder(dirName + "/" + label_TS_);
0311 histoProducerAlgo_->bookTracksterHistos(ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0312
0313 ibook.setCurrentFolder(dirName + "/" + label_TSbyHitsCP_);
0314 histoProducerAlgo_->bookTracksterSTSHistos(
0315 ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byHits_CP);
0316
0317 ibook.setCurrentFolder(dirName + "/" + label_TSbyLCsCP_);
0318
0319 histoProducerAlgo_->bookTracksterSTSHistos(
0320 ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byLCs_CP);
0321
0322 ibook.setCurrentFolder(dirName + "/" + label_TSbyHits_);
0323 histoProducerAlgo_->bookTracksterSTSHistos(
0324 ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byHits);
0325
0326 ibook.setCurrentFolder(dirName + "/" + label_TSbyLCs_);
0327 histoProducerAlgo_->bookTracksterSTSHistos(
0328 ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byLCs);
0329 }
0330 }
0331
0332
0333 if (doCandidatesPlots_) {
0334 ibook.cd();
0335 ibook.setCurrentFolder(dirName_ + label_candidates_);
0336 candidateVal_->bookCandidatesHistos(ibook, histograms.histoTICLCandidates, dirName_ + label_candidates_);
0337 }
0338 }
0339
0340 void HGCalValidator::cpParametersAndSelection(const Histograms& histograms,
0341 std::vector<CaloParticle> const& cPeff,
0342 std::vector<SimVertex> const& simVertices,
0343 std::vector<size_t>& selected_cPeff,
0344 unsigned int layers,
0345 std::unordered_map<DetId, const unsigned int> const& hitMap,
0346 MultiVectorManager<HGCRecHit> const& hits) const {
0347 selected_cPeff.reserve(cPeff.size());
0348
0349 size_t j = 0;
0350 for (auto const& caloParticle : cPeff) {
0351 int id = caloParticle.pdgId();
0352
0353 if (!doCaloParticleSelection_ || (doCaloParticleSelection_ && cpSelector(caloParticle, simVertices))) {
0354 selected_cPeff.push_back(j);
0355 if (doCaloParticlePlots_) {
0356 histoProducerAlgo_->fill_caloparticle_histos(
0357 histograms.histoProducerAlgo, id, caloParticle, simVertices, layers, hitMap, hits);
0358 }
0359 }
0360 ++j;
0361 }
0362 }
0363
0364 void HGCalValidator::dqmAnalyze(const edm::Event& event,
0365 const edm::EventSetup& setup,
0366 const Histograms& histograms) const {
0367 using namespace reco;
0368
0369 LogDebug("HGCalValidator") << "\n===================================================="
0370 << "\n"
0371 << "Analyzing new event"
0372 << "\n"
0373 << "====================================================\n"
0374 << "\n";
0375
0376 edm::Handle<std::vector<SimVertex>> simVerticesHandle;
0377 event.getByToken(simVertices_, simVerticesHandle);
0378 std::vector<SimVertex> const& simVertices = *simVerticesHandle;
0379
0380 edm::Handle<std::vector<CaloParticle>> caloParticleHandle;
0381 event.getByToken(label_cp_effic, caloParticleHandle);
0382 std::vector<CaloParticle> const& caloParticles = *caloParticleHandle;
0383
0384 edm::Handle<ticl::TracksterCollection> simTracksterHandle;
0385 event.getByToken(simTracksters_, simTracksterHandle);
0386 if (!simTracksterHandle.isValid()) {
0387 edm::LogWarning("MissingInput") << "Missing SimTrackster collection";
0388 return;
0389 }
0390 ticl::TracksterCollection const& simTracksters = *simTracksterHandle;
0391
0392 edm::Handle<ticl::TracksterCollection> simTracksterFromCPHandle;
0393 event.getByToken(simTracksters_fromCPs_, simTracksterFromCPHandle);
0394 if (!simTracksterFromCPHandle.isValid()) {
0395 edm::LogWarning("MissingInput") << "Missing SimTrackster collection from CP";
0396 return;
0397 }
0398 ticl::TracksterCollection const& simTrackstersFromCPs = *simTracksterFromCPHandle;
0399
0400 edm::Handle<std::map<uint, std::vector<uint>>> simTrackstersMapHandle;
0401 event.getByToken(simTrackstersMap_, simTrackstersMapHandle);
0402 const std::map<uint, std::vector<uint>>& cpToSc_SimTrackstersMap = *simTrackstersMapHandle;
0403
0404 edm::ESHandle<CaloGeometry> geom = setup.getHandle(caloGeomToken_);
0405 tools_->setGeometry(*geom);
0406 histoProducerAlgo_->setRecHitTools(tools_);
0407
0408 edm::Handle<ticl::SimToRecoCollection> simtorecoCollectionH;
0409 event.getByToken(associatorMapStR, simtorecoCollectionH);
0410 const auto& simRecColl = *simtorecoCollectionH;
0411 edm::Handle<ticl::RecoToSimCollection> recotosimCollectionH;
0412 event.getByToken(associatorMapRtS, recotosimCollectionH);
0413 const auto& recSimColl = *recotosimCollectionH;
0414
0415 edm::Handle<std::unordered_map<DetId, const unsigned int>> hitMapHandle;
0416 event.getByToken(hitMap_, hitMapHandle);
0417 const std::unordered_map<DetId, const unsigned int>& hitMap = *hitMapHandle;
0418
0419 MultiVectorManager<HGCRecHit> rechitManager;
0420 for (const auto& token : hits_tokens_) {
0421 Handle<HGCRecHitCollection> hitsHandle;
0422 event.getByToken(token, hitsHandle);
0423 rechitManager.addVector(*hitsHandle);
0424 }
0425
0426
0427 if (SaveGeneralInfo_) {
0428 histoProducerAlgo_->fill_info_histos(histograms.histoProducerAlgo, totallayers_to_monitor_);
0429 }
0430
0431 std::vector<size_t> cPIndices;
0432
0433
0434 removeCPFromPU(caloParticles, cPIndices);
0435
0436
0437
0438
0439
0440 LogTrace("HGCalValidator") << "\n# of CaloParticles: " << caloParticles.size() << "\n" << std::endl;
0441 std::vector<size_t> selected_cPeff;
0442 cpParametersAndSelection(
0443 histograms, caloParticles, simVertices, selected_cPeff, totallayers_to_monitor_, hitMap, rechitManager);
0444
0445
0446
0447 edm::Handle<std::vector<SimCluster>> simClustersHandle;
0448 event.getByToken(simClusters_, simClustersHandle);
0449 std::vector<SimCluster> const& simClusters = *simClustersHandle;
0450
0451
0452 edm::Handle<reco::CaloClusterCollection> clusterHandle;
0453 event.getByToken(layerclusters_, clusterHandle);
0454 const reco::CaloClusterCollection& clusters = *clusterHandle;
0455
0456 std::vector<edm::Handle<TracksterToTracksterMap>> tracksterToTracksterMapsHandles;
0457 for (auto& token : tracksterToTracksterAssociatorsTokens_) {
0458 edm::Handle<TracksterToTracksterMap> tracksterToTracksterMapHandle;
0459 event.getByToken(token, tracksterToTracksterMapHandle);
0460 tracksterToTracksterMapsHandles.push_back(tracksterToTracksterMapHandle);
0461 }
0462
0463 std::vector<edm::Handle<TracksterToTracksterMap>> tracksterToTracksterByHitsMapsHandles;
0464 for (auto& token : tracksterToTracksterByHitsAssociatorsTokens_) {
0465 edm::Handle<TracksterToTracksterMap> tracksterToTracksterByHitsMapHandle;
0466 event.getByToken(token, tracksterToTracksterByHitsMapHandle);
0467 tracksterToTracksterByHitsMapsHandles.push_back(tracksterToTracksterByHitsMapHandle);
0468 }
0469
0470 edm::Handle<SimClusterToCaloParticleMap> scToCpMapHandle;
0471 event.getByToken(scToCpMapToken_, scToCpMapHandle);
0472 const SimClusterToCaloParticleMap& scToCpMap = *scToCpMapHandle;
0473
0474 auto nSimClusters = simClusters.size();
0475 std::vector<size_t> sCIndices;
0476
0477
0478 for (unsigned int scId = 0; scId < nSimClusters; ++scId) {
0479 if (simClusters[scId].g4Tracks()[0].eventId().event() != 0 or
0480 simClusters[scId].g4Tracks()[0].eventId().bunchCrossing() != 0) {
0481 LogDebug("HGCalValidator") << "Excluding SimClusters from event: "
0482 << simClusters[scId].g4Tracks()[0].eventId().event()
0483 << " with BX: " << simClusters[scId].g4Tracks()[0].eventId().bunchCrossing()
0484 << std::endl;
0485 continue;
0486 }
0487 sCIndices.emplace_back(scId);
0488 }
0489
0490
0491
0492
0493 if (doSimClustersPlots_) {
0494 histoProducerAlgo_->fill_simCluster_histos(
0495 histograms.histoProducerAlgo, simClusters, totallayers_to_monitor_, thicknesses_to_monitor_);
0496
0497 for (unsigned int ws = 0; ws < label_clustersmask.size(); ws++) {
0498 const auto& inputClusterMaskHandle = event.getHandle(clustersMaskTokens_[ws]);
0499
0500 if (!inputClusterMaskHandle.isValid()) {
0501 edm::LogError("ClusterMaskError") << "Failed to retrieve clusters mask for ws index: " << ws;
0502 continue;
0503 }
0504
0505 const auto& inputClusterMask = *inputClusterMaskHandle;
0506
0507 edm::Handle<ticl::SimToRecoCollectionWithSimClusters> simtorecoCollectionH;
0508 event.getByToken(associatorMapSimtR, simtorecoCollectionH);
0509 auto simRecColl = *simtorecoCollectionH;
0510 edm::Handle<ticl::RecoToSimCollectionWithSimClusters> recotosimCollectionH;
0511 event.getByToken(associatorMapRtSim, recotosimCollectionH);
0512 auto recSimColl = *recotosimCollectionH;
0513
0514 histoProducerAlgo_->fill_simClusterAssociation_histos(histograms.histoProducerAlgo,
0515 ws,
0516 clusterHandle,
0517 clusters,
0518 simClustersHandle,
0519 simClusters,
0520 sCIndices,
0521 inputClusterMask,
0522 hitMap,
0523 totallayers_to_monitor_,
0524 recSimColl,
0525 simRecColl,
0526 rechitManager);
0527
0528
0529 LogTrace("HGCalValidator") << "\n# of SimClusters: " << nSimClusters
0530 << ", layerClusters mask label: " << label_clustersmask[ws].label() << "\n";
0531 }
0532 }
0533
0534
0535
0536
0537 int w = 0;
0538 if (doLayerClustersPlots_) {
0539 histoProducerAlgo_->fill_generic_cluster_histos(histograms.histoProducerAlgo,
0540 w,
0541 clusterHandle,
0542 clusters,
0543 caloParticleHandle,
0544 caloParticles,
0545 cPIndices,
0546 selected_cPeff,
0547 hitMap,
0548 cumulative_material_budget,
0549 totallayers_to_monitor_,
0550 thicknesses_to_monitor_,
0551 recSimColl,
0552 simRecColl,
0553 rechitManager);
0554
0555 for (unsigned int layerclusterIndex = 0; layerclusterIndex < clusters.size(); layerclusterIndex++) {
0556 histoProducerAlgo_->fill_cluster_histos(histograms.histoProducerAlgo, w, clusters[layerclusterIndex]);
0557 }
0558
0559
0560 LogTrace("HGCalValidator") << "\n# of layer clusters with " << label_lcl.process() << ":" << label_lcl.label()
0561 << ":" << label_lcl.instance() << ": " << clusters.size() << "\n";
0562 }
0563
0564
0565
0566
0567 for (unsigned int wml = 0; wml < label_tstTokens.size(); wml++) {
0568 if (doTrackstersPlots_) {
0569 edm::Handle<ticl::TracksterCollection> tracksterHandle;
0570 event.getByToken(label_tstTokens[wml], tracksterHandle);
0571
0572 if (!tracksterHandle.isValid()) {
0573 edm::LogWarning("MissinInput") << "Failed to retrieve tracksters for wml index: " << wml;
0574 continue;
0575 }
0576
0577 const ticl::TracksterCollection& tracksters = *tracksterHandle;
0578 edm::Handle<TracksterToTracksterMap> trackstersToSimTrackstersMapH, simTrackstersToTrackstersMapH,
0579 trackstersToSimTrackstersFromCPsMapH, simTrackstersFromCPsToTrackstersMapH,
0580 trackstersToSimTrackstersByHitsMapH, simTrackstersToTrackstersByHitsMapH,
0581 trackstersToSimTrackstersFromCPsByHitsMapH, simTrackstersFromCPsToTrackstersByHitsMapH;
0582
0583 bool mapsFound = assignTracksterMaps(tracksterHandle,
0584 simTracksterHandle,
0585 simTracksterFromCPHandle,
0586 tracksterToTracksterMapsHandles,
0587 trackstersToSimTrackstersMapH,
0588 simTrackstersToTrackstersMapH,
0589 trackstersToSimTrackstersFromCPsMapH,
0590 simTrackstersFromCPsToTrackstersMapH);
0591
0592 mapsFound = mapsFound and assignTracksterMaps(tracksterHandle,
0593 simTracksterHandle,
0594 simTracksterFromCPHandle,
0595 tracksterToTracksterByHitsMapsHandles,
0596 trackstersToSimTrackstersByHitsMapH,
0597 simTrackstersToTrackstersByHitsMapH,
0598 trackstersToSimTrackstersFromCPsByHitsMapH,
0599 simTrackstersFromCPsToTrackstersByHitsMapH);
0600
0601 histoProducerAlgo_->fill_trackster_histos(histograms.histoProducerAlgo,
0602 wml,
0603 tracksters,
0604 clusters,
0605 simTracksters,
0606 simTrackstersFromCPs,
0607 cpToSc_SimTrackstersMap,
0608 simClusters,
0609 caloParticleHandle.id(),
0610 caloParticles,
0611 cPIndices,
0612 selected_cPeff,
0613 hitMap,
0614 totallayers_to_monitor_,
0615 rechitManager,
0616 mapsFound,
0617 trackstersToSimTrackstersMapH,
0618 simTrackstersToTrackstersMapH,
0619 trackstersToSimTrackstersFromCPsMapH,
0620 simTrackstersFromCPsToTrackstersMapH,
0621 trackstersToSimTrackstersByHitsMapH,
0622 simTrackstersToTrackstersByHitsMapH,
0623 trackstersToSimTrackstersFromCPsByHitsMapH,
0624 simTrackstersFromCPsToTrackstersByHitsMapH,
0625 scToCpMap);
0626 }
0627 }
0628
0629
0630 if (doCandidatesPlots_) {
0631 candidateVal_->fillCandidateHistos(event, histograms.histoTICLCandidates, simTracksterFromCPHandle);
0632 }
0633 }
0634
0635 void HGCalValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0636
0637 edm::ParameterSetDescription desc;
0638 desc.add<double>("ptMinCP", 0.5);
0639 desc.add<double>("ptMaxCP", 300.0);
0640 desc.add<double>("minRapidityCP", -3.1);
0641 desc.add<double>("maxRapidityCP", 3.1);
0642 desc.add<double>("lipCP", 30.0);
0643 desc.add<double>("tipCP", 60);
0644 desc.add<bool>("chargedOnlyCP", false);
0645 desc.add<bool>("stableOnlyCP", false);
0646 desc.add<bool>("notConvertedOnlyCP", true);
0647 desc.add<std::vector<int>>("pdgIdCP",
0648 {
0649 11,
0650 -11,
0651 13,
0652 -13,
0653 22,
0654 111,
0655 211,
0656 -211,
0657 321,
0658 -321,
0659 311,
0660 130,
0661 310,
0662 });
0663 desc.add<bool>("signalOnlyCP", true);
0664 desc.add<bool>("intimeOnlyCP", true);
0665 desc.add<int>("minHitCP", 0);
0666 desc.add<int>("maxSimClustersCP", -1);
0667 {
0668 edm::ParameterSetDescription psd1;
0669 psd1.add<double>("minEta", -4.5);
0670 psd1.add<double>("maxEta", 4.5);
0671 psd1.add<int>("nintEta", 100);
0672 psd1.add<bool>("useFabsEta", false);
0673 psd1.add<double>("minEne", 0.0);
0674 psd1.add<double>("maxEne", 500.0);
0675 psd1.add<int>("nintEne", 250);
0676 psd1.add<double>("minPt", 0.0);
0677 psd1.add<double>("maxPt", 100.0);
0678 psd1.add<int>("nintPt", 100);
0679 psd1.add<double>("minPhi", -3.2);
0680 psd1.add<double>("maxPhi", 3.2);
0681 psd1.add<int>("nintPhi", 80);
0682 psd1.add<double>("minMixedHitsSimCluster", 0.0);
0683 psd1.add<double>("maxMixedHitsSimCluster", 800.0);
0684 psd1.add<int>("nintMixedHitsSimCluster", 100);
0685 psd1.add<double>("minMixedHitsCluster", 0.0);
0686 psd1.add<double>("maxMixedHitsCluster", 800.0);
0687 psd1.add<int>("nintMixedHitsCluster", 100);
0688 psd1.add<double>("minEneCl", 0.0);
0689 psd1.add<double>("maxEneCl", 110.0);
0690 psd1.add<int>("nintEneCl", 110);
0691 psd1.add<double>("minLongDepBary", 0.0);
0692 psd1.add<double>("maxLongDepBary", 110.0);
0693 psd1.add<int>("nintLongDepBary", 110);
0694 psd1.add<double>("minZpos", -550.0);
0695 psd1.add<double>("maxZpos", 550.0);
0696 psd1.add<int>("nintZpos", 1100);
0697 psd1.add<double>("minTotNsimClsperlay", 0.0);
0698 psd1.add<double>("maxTotNsimClsperlay", 50.0);
0699 psd1.add<int>("nintTotNsimClsperlay", 50);
0700 psd1.add<double>("minTotNClsperlay", 0.0);
0701 psd1.add<double>("maxTotNClsperlay", 50.0);
0702 psd1.add<int>("nintTotNClsperlay", 50);
0703 psd1.add<double>("minEneClperlay", 0.0);
0704 psd1.add<double>("maxEneClperlay", 110.0);
0705 psd1.add<int>("nintEneClperlay", 110);
0706 psd1.add<double>("minScore", 0.0);
0707 psd1.add<double>("maxScore", 1.02);
0708 psd1.add<int>("nintScore", 51);
0709 psd1.add<double>("minSharedEneFrac", 0.0);
0710 psd1.add<double>("maxSharedEneFrac", 1.02);
0711 psd1.add<int>("nintSharedEneFrac", 51);
0712 psd1.add<double>("minTSTSharedEneFracEfficiency", 0.5);
0713 psd1.add<double>("minTSTSharedEneFrac", 0.0);
0714 psd1.add<double>("maxTSTSharedEneFrac", 1.01);
0715 psd1.add<int>("nintTSTSharedEneFrac", 101);
0716 psd1.add<double>("minTotNsimClsperthick", 0.0);
0717 psd1.add<double>("maxTotNsimClsperthick", 800.0);
0718 psd1.add<int>("nintTotNsimClsperthick", 100);
0719 psd1.add<double>("minTotNClsperthick", 0.0);
0720 psd1.add<double>("maxTotNClsperthick", 800.0);
0721 psd1.add<int>("nintTotNClsperthick", 100);
0722 psd1.add<double>("minTotNcellsperthickperlayer", 0.0);
0723 psd1.add<double>("maxTotNcellsperthickperlayer", 500.0);
0724 psd1.add<int>("nintTotNcellsperthickperlayer", 100);
0725 psd1.add<double>("minDisToSeedperthickperlayer", 0.0);
0726 psd1.add<double>("maxDisToSeedperthickperlayer", 300.0);
0727 psd1.add<int>("nintDisToSeedperthickperlayer", 100);
0728 psd1.add<double>("minDisToSeedperthickperlayerenewei", 0.0);
0729 psd1.add<double>("maxDisToSeedperthickperlayerenewei", 10.0);
0730 psd1.add<int>("nintDisToSeedperthickperlayerenewei", 50);
0731 psd1.add<double>("minDisToMaxperthickperlayer", 0.0);
0732 psd1.add<double>("maxDisToMaxperthickperlayer", 300.0);
0733 psd1.add<int>("nintDisToMaxperthickperlayer", 100);
0734 psd1.add<double>("minDisToMaxperthickperlayerenewei", 0.0);
0735 psd1.add<double>("maxDisToMaxperthickperlayerenewei", 50.0);
0736 psd1.add<int>("nintDisToMaxperthickperlayerenewei", 50);
0737 psd1.add<double>("minDisSeedToMaxperthickperlayer", 0.0);
0738 psd1.add<double>("maxDisSeedToMaxperthickperlayer", 300.0);
0739 psd1.add<int>("nintDisSeedToMaxperthickperlayer", 100);
0740 psd1.add<double>("minClEneperthickperlayer", 0.0);
0741 psd1.add<double>("maxClEneperthickperlayer", 10.0);
0742 psd1.add<int>("nintClEneperthickperlayer", 100);
0743 psd1.add<double>("minCellsEneDensperthick", 0.0);
0744 psd1.add<double>("maxCellsEneDensperthick", 100.0);
0745 psd1.add<int>("nintCellsEneDensperthick", 200);
0746 psd1.add<double>("minTotNTSTs", 0.0);
0747 psd1.add<double>("maxTotNTSTs", 50.0);
0748 psd1.add<int>("nintTotNTSTs", 50);
0749 psd1.add<double>("minTotNClsinTSTs", 0.0);
0750 psd1.add<double>("maxTotNClsinTSTs", 400.0);
0751 psd1.add<int>("nintTotNClsinTSTs", 100);
0752
0753 psd1.add<double>("minTotNClsinTSTsperlayer", 0.0);
0754 psd1.add<double>("maxTotNClsinTSTsperlayer", 50.0);
0755 psd1.add<int>("nintTotNClsinTSTsperlayer", 50);
0756 psd1.add<double>("minMplofLCs", 0.0);
0757 psd1.add<double>("maxMplofLCs", 20.0);
0758 psd1.add<int>("nintMplofLCs", 20);
0759 psd1.add<double>("minSizeCLsinTSTs", 0.0);
0760 psd1.add<double>("maxSizeCLsinTSTs", 50.0);
0761 psd1.add<int>("nintSizeCLsinTSTs", 50);
0762 psd1.add<double>("minClEnepermultiplicity", 0.0);
0763 psd1.add<double>("maxClEnepermultiplicity", 10.0);
0764 psd1.add<int>("nintClEnepermultiplicity", 10);
0765 psd1.add<double>("minX", -300.0);
0766 psd1.add<double>("maxX", 300.0);
0767 psd1.add<int>("nintX", 100);
0768 psd1.add<double>("minY", -300.0);
0769 psd1.add<double>("maxY", 300.0);
0770 psd1.add<int>("nintY", 100);
0771 psd1.add<double>("minZ", -550.0);
0772 psd1.add<double>("maxZ", 550.0);
0773 psd1.add<int>("nintZ", 1100);
0774 desc.add<edm::ParameterSetDescription>("histoProducerAlgoBlock", psd1);
0775 }
0776 desc.add<std::vector<edm::InputTag>>("hits",
0777 {
0778 edm::InputTag("HGCalRecHit", "HGCEERecHits"),
0779 edm::InputTag("HGCalRecHit", "HGCHEFRecHits"),
0780 edm::InputTag("HGCalRecHit", "HGCHEBRecHits"),
0781 });
0782 desc.add<edm::InputTag>("label_lcl", edm::InputTag("hgcalMergeLayerClusters"));
0783 desc.add<std::vector<edm::InputTag>>("label_tst",
0784 {
0785 edm::InputTag("ticlTrackstersCLUE3DHigh"),
0786 edm::InputTag("ticlTrackstersMerge"),
0787 edm::InputTag("ticlSimTracksters", "fromCPs"),
0788 edm::InputTag("ticlSimTracksters"),
0789 });
0790 desc.add<edm::InputTag>("label_simTS", edm::InputTag("ticlSimTracksters"));
0791 desc.add<edm::InputTag>("label_simTSFromCP", edm::InputTag("ticlSimTracksters", "fromCPs"));
0792 desc.addUntracked<edm::InputTag>("associator", edm::InputTag("layerClusterCaloParticleAssociationProducer"));
0793 desc.addUntracked<edm::InputTag>("associatorSim", edm::InputTag("layerClusterSimClusterAssociationProducer"));
0794 desc.addUntracked<bool>("SaveGeneralInfo", true);
0795 desc.addUntracked<bool>("doCaloParticlePlots", true);
0796 desc.addUntracked<bool>("doCaloParticleSelection", true);
0797 desc.addUntracked<bool>("doSimClustersPlots", true);
0798 desc.add<edm::InputTag>("label_SimClusters", edm::InputTag("SimClusters"));
0799 desc.add<edm::InputTag>("label_SimClustersLevel", edm::InputTag("ClusterLevel"));
0800 desc.addUntracked<bool>("doLayerClustersPlots", true);
0801 desc.add<edm::InputTag>("label_layerClusterPlots", edm::InputTag("hgcalMergeLayerClusters"));
0802 desc.add<edm::InputTag>("label_LCToCPLinking", edm::InputTag("LCToCP_association"));
0803 desc.addUntracked<bool>("doTrackstersPlots", true);
0804 desc.add<std::string>("label_TS", "Morphology");
0805 desc.add<std::string>("label_TSbyHitsCP", "TSbyHits_CP");
0806 desc.add<std::string>("label_TSbyHits", "TSbyHits");
0807 desc.add<std::string>("label_TSbyLCs", "TSbyLCs");
0808 desc.add<std::string>("label_TSbyLCsCP", "TSbyLCs_CP");
0809 desc.add<edm::InputTag>("simClustersToCaloParticlesMap",
0810 edm::InputTag("SimClusterToCaloParticleAssociation", "simClusterToCaloParticleMap"));
0811 desc.add<std::vector<edm::InputTag>>(
0812 "allTracksterTracksterAssociatorsLabels",
0813 {
0814 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlTrackstersCLUE3DHighToticlSimTracksters"),
0815 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersToticlTrackstersCLUE3DHigh"),
0816 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs",
0817 "ticlTrackstersCLUE3DHighToticlSimTrackstersfromCPs"),
0818 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs",
0819 "ticlSimTrackstersfromCPsToticlTrackstersCLUE3DHigh"),
0820 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlTracksterLinksToticlSimTracksters"),
0821 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersToticlTracksterLinks"),
0822 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs",
0823 "ticlTracksterLinksToticlSimTrackstersfromCPs"),
0824 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs",
0825 "ticlSimTrackstersfromCPsToticlTracksterLinks"),
0826 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlCandidateToticlSimTracksters"),
0827 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersToticlCandidate"),
0828 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlCandidateToticlSimTrackstersfromCPs"),
0829 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersfromCPsToticlCandidate"),
0830 });
0831 desc.add<std::vector<edm::InputTag>>(
0832 "allTracksterTracksterByHitsAssociatorsLabels",
0833 {
0834 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits",
0835 "ticlTrackstersCLUE3DHighToticlSimTracksters"),
0836 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits",
0837 "ticlSimTrackstersToticlTrackstersCLUE3DHigh"),
0838 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits",
0839 "ticlTrackstersCLUE3DHighToticlSimTrackstersfromCPs"),
0840 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits",
0841 "ticlSimTrackstersfromCPsToticlTrackstersCLUE3DHigh"),
0842 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlTracksterLinksToticlSimTracksters"),
0843 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlSimTrackstersToticlTracksterLinks"),
0844 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits",
0845 "ticlTracksterLinksToticlSimTrackstersfromCPs"),
0846 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits",
0847 "ticlSimTrackstersfromCPsToticlTracksterLinks"),
0848 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlCandidateToticlSimTracksters"),
0849 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlSimTrackstersToticlCandidate"),
0850 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlCandidateToticlSimTrackstersfromCPs"),
0851 edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlSimTrackstersfromCPsToticlCandidate"),
0852 });
0853 desc.addUntracked<bool>("doCandidatesPlots", true);
0854 desc.add<std::string>("ticlCandidates", "ticlCandidates");
0855 desc.add<edm::InputTag>("ticlTrackstersMerge", edm::InputTag("ticlTrackstersMerge"));
0856 desc.add<edm::InputTag>("simTiclCandidates", edm::InputTag("ticlSimTracksters"));
0857 desc.add<edm::InputTag>("recoTracks", edm::InputTag("generalTracks"));
0858 desc.add<edm::InputTag>(
0859 "mergeRecoToSimAssociator",
0860 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlTrackstersMergeToticlSimTrackstersfromCPs"));
0861 desc.add<edm::InputTag>(
0862 "mergeSimToRecoAssociator",
0863 edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersfromCPsToticlTrackstersMerge"));
0864 desc.add<edm::FileInPath>("cummatbudinxo", edm::FileInPath("Validation/HGCalValidation/data/D41.cumulative.xo"));
0865 desc.add<edm::InputTag>("label_cp_effic", edm::InputTag("mix", "MergedCaloTruth"));
0866 desc.add<edm::InputTag>("label_cp_fake", edm::InputTag("mix", "MergedCaloTruth"));
0867 desc.add<edm::InputTag>("label_scl", edm::InputTag("mix", "MergedCaloTruth"));
0868 desc.add<edm::InputTag>("simVertices", edm::InputTag("g4SimHits"));
0869 desc.add<edm::InputTag>("simTrackstersMap", edm::InputTag("ticlSimTracksters"));
0870 desc.add<edm::InputTag>("hitMap", edm::InputTag("recHitMapProducer", "hgcalRecHitMap"));
0871 desc.add<std::vector<edm::InputTag>>("LayerClustersInputMask",
0872 {
0873 edm::InputTag("ticlTrackstersCLUE3DHigh"),
0874 edm::InputTag("ticlSimTracksters", "fromCPs"),
0875 edm::InputTag("ticlSimTracksters"),
0876 });
0877 desc.add<int>("totallayers_to_monitor", 52);
0878 desc.add<std::vector<int>>("thicknesses_to_monitor",
0879 {
0880 120,
0881 200,
0882 300,
0883 -1,
0884 });
0885 desc.add<std::string>("dirName", "HGCAL/HGCalValidator/");
0886 desc.addUntracked<bool>("isticlv5", false);
0887 descriptions.add("hgcalValidator", desc);
0888 }