Back to home page

Project CMSSW displayed by LXR
 
 

    

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 }  // namespace
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   //In this way we can easily generalize to associations between other objects also.
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   //For the material budget file here
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   //Booking histograms concerning with simClusters
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     }  //end of loop over masks
0264   }  //if for simCluster plots
0265 
0266   //Booking histograms concerning with hgcal layer clusters
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   //Booking histograms for Tracksters
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     // Booking histograms concerning HGCal tracksters
0308     if (doTrackstersPlots_) {
0309       // Generic histos
0310       ibook.setCurrentFolder(dirName + "/" + label_TS_);
0311       histoProducerAlgo_->bookTracksterHistos(ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0312       // CP Linking by Hits
0313       ibook.setCurrentFolder(dirName + "/" + label_TSbyHitsCP_);
0314       histoProducerAlgo_->bookTracksterSTSHistos(
0315           ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byHits_CP);
0316       // CP Linking by LCs
0317       ibook.setCurrentFolder(dirName + "/" + label_TSbyLCsCP_);
0318 
0319       histoProducerAlgo_->bookTracksterSTSHistos(
0320           ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byLCs_CP);
0321       // SimTracksters Linking by Hits
0322       ibook.setCurrentFolder(dirName + "/" + label_TSbyHits_);
0323       histoProducerAlgo_->bookTracksterSTSHistos(
0324           ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byHits);
0325       // SimTracksters Linking by LCs
0326       ibook.setCurrentFolder(dirName + "/" + label_TSbyLCs_);
0327       histoProducerAlgo_->bookTracksterSTSHistos(
0328           ibook, histograms.histoProducerAlgo, HGVHistoProducerAlgo::validationType::byLCs);
0329     }
0330   }  //end of booking Tracksters loop
0331 
0332   // Booking histograms concerning TICL candidates
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   }  //end of loop over caloparticles
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   //Some general info on layers etc.
0427   if (SaveGeneralInfo_) {
0428     histoProducerAlgo_->fill_info_histos(histograms.histoProducerAlgo, totallayers_to_monitor_);
0429   }
0430 
0431   std::vector<size_t> cPIndices;
0432   //Consider CaloParticles coming from the hard scatterer
0433   //excluding the PU contribution and save the indices.
0434   removeCPFromPU(caloParticles, cPIndices);
0435 
0436   // ##############################################
0437   // Fill caloparticles histograms
0438   // ##############################################
0439   // HGCRecHit are given to select the SimHits which are also reconstructed
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   //get collections from the event
0446   //simClusters
0447   edm::Handle<std::vector<SimCluster>> simClustersHandle;
0448   event.getByToken(simClusters_, simClustersHandle);
0449   std::vector<SimCluster> const& simClusters = *simClustersHandle;
0450 
0451   //Layer clusters
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   //There shouldn't be any SimTracks from different crossings, but maybe they will be added later.
0477   //At the moment there should be one SimTrack in each SimCluster.
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   // Fill simCluster histograms
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;  // Or handle the error appropriately
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       //General Info on simClusters
0529       LogTrace("HGCalValidator") << "\n# of SimClusters: " << nSimClusters
0530                                  << ", layerClusters mask label: " << label_clustersmask[ws].label() << "\n";
0531     }  //end of loop overs masks
0532   }
0533 
0534   // ##############################################
0535   // Fill layercluster histograms
0536   // ##############################################
0537   int w = 0;  //counter counting the number of sets of histograms
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     //General Info on hgcalLayerClusters
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   // Fill Trackster histograms
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;  // Or handle the error as needed
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   }  //end of loop over Trackster input labels
0628 
0629   // tracksters histograms
0630   if (doCandidatesPlots_) {
0631     candidateVal_->fillCandidateHistos(event, histograms.histoTICLCandidates, simTracksterFromCPHandle);
0632   }
0633 }
0634 
0635 void HGCalValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0636   // hgcalValidator
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 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!