Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-07-09 05:00:38 

0001 #include <memory>
0002 
0003 #include "Validation/HGCalValidation/interface/BarrelValidator.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 bool assignTracksterMaps(const edm::Handle<std::vector<ticl::Trackster>>& tracksterHandle,
0018                          const edm::Handle<std::vector<ticl::Trackster>>& simTracksterHandle,
0019                          const edm::Handle<std::vector<ticl::Trackster>>& simTracksterFromCPHandle,
0020                          const std::vector<edm::Handle<TracksterToTracksterMap>>& tracksterToTracksterMapsHandles,
0021                          edm::Handle<TracksterToTracksterMap>& trackstersToSimTrackstersMap,
0022                          edm::Handle<TracksterToTracksterMap>& simTrackstersToTrackstersMap,
0023                          edm::Handle<TracksterToTracksterMap>& trackstersToSimTrackstersFromCPsMap,
0024                          edm::Handle<TracksterToTracksterMap>& simTrackstersFromCPsToTrackstersMap) {
0025   const auto recoTrackstersProductId = tracksterHandle.id();
0026   const auto simTrackstersProductId = simTracksterHandle.id();
0027   const auto simTrackstersFromCPsProductId = simTracksterFromCPHandle.id();
0028   if (recoTrackstersProductId == simTrackstersProductId or recoTrackstersProductId == simTrackstersFromCPsProductId) {
0029     edm::LogInfo("MissingProduct") << "no SimTrackster to Simtrackster map available.";
0030     return false;
0031   }
0032   for (const auto& handle : tracksterToTracksterMapsHandles) {
0033     const auto& firstID = handle->getCollectionIDs().first.id();
0034     const auto& secondID = handle->getCollectionIDs().second.id();
0035 
0036     if (firstID == recoTrackstersProductId && secondID == simTrackstersProductId) {
0037       trackstersToSimTrackstersMap = handle;
0038     } else if (firstID == simTrackstersProductId && secondID == recoTrackstersProductId) {
0039       simTrackstersToTrackstersMap = handle;
0040     } else if (firstID == recoTrackstersProductId && secondID == simTrackstersFromCPsProductId) {
0041       trackstersToSimTrackstersFromCPsMap = handle;
0042     } else if (firstID == simTrackstersFromCPsProductId && secondID == recoTrackstersProductId) {
0043       simTrackstersFromCPsToTrackstersMap = handle;
0044     }
0045   }
0046   if (not trackstersToSimTrackstersMap.isValid()) {
0047     edm::LogError("MissingProduct") << "trackstersToSimTrackstersMap is not valid";
0048     return false;
0049   }
0050   if (not simTrackstersToTrackstersMap.isValid()) {
0051     edm::LogError("MissingProduct") << "simTrackstersToTrackstersMap is not valid";
0052     return false;
0053   }
0054   if (not trackstersToSimTrackstersFromCPsMap.isValid()) {
0055     edm::LogError("MissingProduct") << "trackstersToSimTrackstersFromCPsMap is not valid";
0056     return false;
0057   }
0058   if (not simTrackstersFromCPsToTrackstersMap.isValid()) {
0059     edm::LogError("MissingProduct") << "simTrackstersFromCPsToTrackstersMap is not valid";
0060     return false;
0061   }
0062   return true;
0063 }
0064 
0065 BarrelValidator::BarrelValidator(const edm::ParameterSet& pset)
0066     : caloGeomToken_(esConsumes<CaloGeometry, CaloGeometryRecord>()),
0067       label_lcl(pset.getParameter<edm::InputTag>("label_lcl")),
0068       associator_(pset.getUntrackedParameter<std::vector<edm::InputTag>>("associator")),
0069       associatorSim_(pset.getUntrackedParameter<std::vector<edm::InputTag>>("associatorSim")),
0070       SaveGeneralInfo_(pset.getUntrackedParameter<bool>("SaveGeneralInfo")),
0071       doCaloParticlePlots_(pset.getUntrackedParameter<bool>("doCaloParticlePlots")),
0072       doCaloParticleSelection_(pset.getUntrackedParameter<bool>("doCaloParticleSelection")),
0073       doSimClustersPlots_(pset.getUntrackedParameter<bool>("doSimClustersPlots")),
0074       label_SimClustersPlots_(pset.getParameter<edm::InputTag>("label_SimClusters")),
0075       label_SimClustersLevel_(pset.getParameter<edm::InputTag>("label_SimClustersLevel")),
0076       doLayerClustersPlots_(pset.getUntrackedParameter<bool>("doLayerClustersPlots")),
0077       label_layerClustersPlots_(pset.getParameter<edm::InputTag>("label_layerClusterPlots")),
0078       label_LCToCPLinking_(pset.getParameter<edm::InputTag>("label_LCToCPLinking")),
0079       barrel_hits_label_(pset.getParameter<std::vector<edm::InputTag>>("barrel_hits")),
0080       scToCpMapToken_(
0081           consumes<SimClusterToCaloParticleMap>(pset.getParameter<edm::InputTag>("simClustersToCaloParticlesMap"))) {
0082   //In this way we can easily generalize to associations between other objects also.
0083   const edm::InputTag& label_cp_effic_tag = pset.getParameter<edm::InputTag>("label_cp_effic");
0084   const edm::InputTag& label_cp_fake_tag = pset.getParameter<edm::InputTag>("label_cp_fake");
0085 
0086   for (auto& label : barrel_hits_label_) {
0087     barrel_hits_tokens_.push_back(consumes<std::vector<reco::PFRecHit>>(label));
0088   }
0089 
0090   label_cp_effic = consumes<std::vector<CaloParticle>>(label_cp_effic_tag);
0091   label_cp_fake = consumes<std::vector<CaloParticle>>(label_cp_fake_tag);
0092 
0093   simVertices_ = consumes<std::vector<SimVertex>>(pset.getParameter<edm::InputTag>("simVertices"));
0094 
0095   for (auto& itag : label_clustersmask) {
0096     clustersMaskTokens_.push_back(consumes<std::vector<float>>(itag));
0097   }
0098 
0099   for (auto& itag : associatorSim_) {
0100     associatorMapRtSim.push_back(consumes<ticl::RecoToSimCollectionWithSimClusters>(itag));
0101   }
0102   for (auto& itag : associatorSim_) {
0103     associatorMapSimtR.push_back(consumes<ticl::SimToRecoCollectionWithSimClusters>(itag));
0104   }
0105 
0106   barrelHitMap_ =
0107       consumes<std::unordered_map<DetId, const unsigned int>>(edm::InputTag("recHitMapProducer", "barrelRecHitMap"));
0108 
0109   simClusters_ = consumes<std::vector<SimCluster>>(pset.getParameter<edm::InputTag>("label_scl"));
0110 
0111   layerclusters_ = consumes<reco::CaloClusterCollection>(label_lcl);
0112 
0113   for (auto& itag : associator_) {
0114     associatorMapRtS.push_back(consumes<ticl::RecoToSimCollection>(itag));
0115   }
0116   for (auto& itag : associator_) {
0117     associatorMapStR.push_back(consumes<ticl::SimToRecoCollection>(itag));
0118   }
0119 
0120   cpSelector = CaloParticleSelector(pset.getParameter<double>("ptMinCP"),
0121                                     pset.getParameter<double>("ptMaxCP"),
0122                                     pset.getParameter<double>("minRapidityCP"),
0123                                     pset.getParameter<double>("maxRapidityCP"),
0124                                     pset.getParameter<double>("lipCP"),
0125                                     pset.getParameter<double>("tipCP"),
0126                                     pset.getParameter<int>("minHitCP"),
0127                                     pset.getParameter<int>("maxSimClustersCP"),
0128                                     pset.getParameter<bool>("signalOnlyCP"),
0129                                     pset.getParameter<bool>("intimeOnlyCP"),
0130                                     pset.getParameter<bool>("chargedOnlyCP"),
0131                                     pset.getParameter<bool>("stableOnlyCP"),
0132                                     pset.getParameter<bool>("notConvertedOnlyCP"),
0133                                     pset.getParameter<std::vector<int>>("pdgIdCP"));
0134 
0135   tools_ = std::make_shared<hgcal::RecHitTools>();
0136 
0137   particles_to_monitor_ = pset.getParameter<std::vector<int>>("pdgIdCP");
0138   totallayers_to_monitor_ = pset.getParameter<int>("totallayers_to_monitor");
0139 
0140   ParameterSet psetForHistoProducerAlgo = pset.getParameter<ParameterSet>("histoProducerAlgoBlock");
0141   histoProducerAlgo_ = std::make_unique<BarrelVHistoProducerAlgo>(psetForHistoProducerAlgo);
0142 
0143   dirName_ = pset.getParameter<std::string>("dirName");
0144 }
0145 
0146 BarrelValidator::~BarrelValidator() {}
0147 
0148 void BarrelValidator::bookHistograms(DQMStore::IBooker& ibook,
0149                                      edm::Run const&,
0150                                      edm::EventSetup const& setup,
0151                                      Histograms& histograms) const {
0152   if (SaveGeneralInfo_) {
0153     ibook.cd();
0154     ibook.setCurrentFolder(dirName_ + "GeneralInfo");
0155     histoProducerAlgo_->bookInfo(ibook, histograms.histoProducerAlgo);
0156   }
0157 
0158   if (doCaloParticlePlots_) {
0159     ibook.cd();
0160 
0161     for (auto const particle : particles_to_monitor_) {
0162       ibook.setCurrentFolder(dirName_ + "SelectedCaloParticles/" + std::to_string(particle));
0163       histoProducerAlgo_->bookCaloParticleHistos(
0164           ibook, histograms.histoProducerAlgo, particle, totallayers_to_monitor_);
0165     }
0166     ibook.cd();
0167     ibook.setCurrentFolder(dirName_);
0168   }
0169 
0170   //Booking histograms concerning with simClusters
0171   if (doSimClustersPlots_) {
0172     ibook.cd();
0173     ibook.setCurrentFolder(dirName_ + label_SimClustersPlots_.label() + "/" + label_SimClustersLevel_.label());
0174     histoProducerAlgo_->bookSimClusterHistos(ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0175 
0176     for (unsigned int ws = 0; ws < label_clustersmask.size(); ws++) {
0177       ibook.cd();
0178       InputTag algo = label_clustersmask[ws];
0179       string dirName = dirName_ + label_SimClustersPlots_.label() + "/";
0180       if (!algo.process().empty())
0181         dirName += algo.process() + "_";
0182       LogDebug("BarrelValidator") << dirName << "\n";
0183       if (!algo.label().empty())
0184         dirName += algo.label() + "_";
0185       LogDebug("BarrelValidator") << dirName << "\n";
0186       if (!algo.instance().empty())
0187         dirName += algo.instance() + "_";
0188       LogDebug("BarrelValidator") << dirName << "\n";
0189 
0190       if (!dirName.empty()) {
0191         dirName.resize(dirName.size() - 1);
0192       }
0193 
0194       LogDebug("BarrelValidator") << dirName << "\n";
0195 
0196       ibook.setCurrentFolder(dirName);
0197 
0198       histoProducerAlgo_->bookSimClusterAssociationHistos(ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0199     }  //end of loop over masks
0200   }  //if for simCluster plots
0201 
0202   //Booking histograms concerning with hgcal layer clusters
0203   if (doLayerClustersPlots_) {
0204     ibook.cd();
0205     ibook.setCurrentFolder(dirName_ + label_layerClustersPlots_.label() + "/ClusterLevel");
0206     histoProducerAlgo_->bookClusterHistos_ClusterLevel(ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0207     ibook.cd();
0208     ibook.setCurrentFolder(dirName_ + label_layerClustersPlots_.label() + "/" + label_LCToCPLinking_.label());
0209     histoProducerAlgo_->bookClusterHistos_LCtoCP_association(
0210         ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0211 
0212     ibook.cd();
0213     ibook.setCurrentFolder(dirName_ + label_layerClustersPlots_.label() + "/CellLevel");
0214     histoProducerAlgo_->bookClusterHistos_CellLevel(ibook, histograms.histoProducerAlgo, totallayers_to_monitor_);
0215   }
0216 }
0217 
0218 void BarrelValidator::cpParametersAndSelection(const Histograms& histograms,
0219                                                std::vector<CaloParticle> const& cPeff,
0220                                                std::vector<SimVertex> const& simVertices,
0221                                                std::vector<size_t>& selected_cPeff,
0222                                                unsigned int layers,
0223                                                std::unordered_map<DetId, const unsigned int> const& barrelHitMap,
0224                                                MultiVectorManager<reco::PFRecHit> const& barrelHits) const {
0225   selected_cPeff.reserve(cPeff.size());
0226 
0227   size_t j = 0;
0228   for (auto const& caloParticle : cPeff) {
0229     int id = caloParticle.pdgId();
0230 
0231     if (!doCaloParticleSelection_ || (doCaloParticleSelection_ && cpSelector(caloParticle, simVertices))) {
0232       selected_cPeff.push_back(j);
0233       if (doCaloParticlePlots_) {
0234         histoProducerAlgo_->fill_caloparticle_histos(
0235             histograms.histoProducerAlgo, id, caloParticle, simVertices, layers, barrelHitMap, barrelHits);
0236       }
0237     }
0238     ++j;
0239   }  //end of loop over caloparticles
0240 }
0241 
0242 void BarrelValidator::dqmAnalyze(const edm::Event& event,
0243                                  const edm::EventSetup& setup,
0244                                  const Histograms& histograms) const {
0245   using namespace reco;
0246 
0247   LogDebug("BarrelValidator") << "\n===================================================="
0248                               << "\n"
0249                               << "Analyzing new event"
0250                               << "\n"
0251                               << "====================================================\n"
0252                               << "\n";
0253 
0254   edm::Handle<std::vector<SimVertex>> simVerticesHandle;
0255   event.getByToken(simVertices_, simVerticesHandle);
0256   std::vector<SimVertex> const& simVertices = *simVerticesHandle;
0257 
0258   edm::Handle<std::vector<CaloParticle>> caloParticleHandle;
0259   event.getByToken(label_cp_effic, caloParticleHandle);
0260   std::vector<CaloParticle> const& caloParticles = *caloParticleHandle;
0261 
0262   edm::ESHandle<CaloGeometry> geom = setup.getHandle(caloGeomToken_);
0263   tools_->setGeometry(*geom);
0264   histoProducerAlgo_->setRecHitTools(tools_);
0265 
0266   std::vector<ticl::RecoToSimCollection> recSimColl;
0267   std::vector<ticl::SimToRecoCollection> simRecColl;
0268   for (unsigned int i = 0; i < associatorMapRtS.size(); ++i) {
0269     edm::Handle<ticl::SimToRecoCollection> simToRecoCollectionH;
0270     event.getByToken(associatorMapStR[i], simToRecoCollectionH);
0271     simRecColl.push_back(*simToRecoCollectionH);
0272     edm::Handle<ticl::RecoToSimCollection> recoToSimCollectionH;
0273     event.getByToken(associatorMapRtS[i], recoToSimCollectionH);
0274     recSimColl.push_back(*recoToSimCollectionH);
0275   }
0276 
0277   edm::Handle<std::unordered_map<DetId, const unsigned int>> barrelHitMapHandle;
0278   event.getByToken(barrelHitMap_, barrelHitMapHandle);
0279   const std::unordered_map<DetId, const unsigned int>& barrelHitMap = *barrelHitMapHandle;
0280 
0281   MultiVectorManager<reco::PFRecHit> barrelRechitManager;
0282   for (const auto& token : barrel_hits_tokens_) {
0283     Handle<std::vector<reco::PFRecHit>> hitsHandle;
0284     event.getByToken(token, hitsHandle);
0285     barrelRechitManager.addVector(*hitsHandle);
0286   }
0287 
0288   //Some general info on layers etc.
0289   if (SaveGeneralInfo_) {
0290     histoProducerAlgo_->fill_info_histos(histograms.histoProducerAlgo, totallayers_to_monitor_);
0291   }
0292 
0293   std::vector<size_t> cPIndices;
0294   //Consider CaloParticles coming from the hard scatterer
0295   //excluding the PU contribution and save the indices.
0296   removeCPFromPU(caloParticles, cPIndices);
0297 
0298   // ##############################################
0299   // Fill caloparticles histograms
0300   // ##############################################
0301   // HGCRecHit are given to select the SimHits which are also reconstructed
0302   LogTrace("BarrelValidator") << "\n# of CaloParticles: " << caloParticles.size() << "\n" << std::endl;
0303   std::vector<size_t> selected_cPeff;
0304   cpParametersAndSelection(histograms,
0305                            caloParticles,
0306                            simVertices,
0307                            selected_cPeff,
0308                            totallayers_to_monitor_,
0309                            barrelHitMap,
0310                            barrelRechitManager);
0311 
0312   //get collections from the event
0313   //simClusters
0314   edm::Handle<std::vector<SimCluster>> simClustersHandle;
0315   event.getByToken(simClusters_, simClustersHandle);
0316   std::vector<SimCluster> const& simClusters = *simClustersHandle;
0317 
0318   //Layer clusters
0319   edm::Handle<reco::CaloClusterCollection> clusterHandle;
0320   event.getByToken(layerclusters_, clusterHandle);
0321   const reco::CaloClusterCollection& clusters = *clusterHandle;
0322 
0323   auto nSimClusters = simClusters.size();
0324   std::vector<size_t> sCIndices;
0325   //There shouldn't be any SimTracks from different crossings, but maybe they will be added later.
0326   //At the moment there should be one SimTrack in each SimCluster.
0327   for (unsigned int scId = 0; scId < nSimClusters; ++scId) {
0328     if (simClusters[scId].g4Tracks()[0].eventId().event() != 0 or
0329         simClusters[scId].g4Tracks()[0].eventId().bunchCrossing() != 0) {
0330       LogDebug("BarrelValidator") << "Excluding SimClusters from event: "
0331                                   << simClusters[scId].g4Tracks()[0].eventId().event()
0332                                   << " with BX: " << simClusters[scId].g4Tracks()[0].eventId().bunchCrossing()
0333                                   << std::endl;
0334       continue;
0335     }
0336     sCIndices.emplace_back(scId);
0337   }
0338 
0339   // ##############################################
0340   // Fill simCluster histograms
0341   // ##############################################
0342   if (doSimClustersPlots_) {
0343     histoProducerAlgo_->fill_simCluster_histos(histograms.histoProducerAlgo, simClusters, totallayers_to_monitor_);
0344 
0345     for (unsigned int ws = 0; ws < label_clustersmask.size(); ws++) {
0346       const auto& inputClusterMask = event.get(clustersMaskTokens_[ws]);
0347 
0348       std::vector<ticl::RecoToSimCollectionWithSimClusters> recSimColl;
0349       std::vector<ticl::SimToRecoCollectionWithSimClusters> simRecColl;
0350       for (unsigned int i = 0; i < associatorMapRtSim.size(); ++i) {
0351         edm::Handle<ticl::SimToRecoCollectionWithSimClusters> simtorecoCollectionH;
0352         event.getByToken(associatorMapSimtR[i], simtorecoCollectionH);
0353         simRecColl.push_back(*simtorecoCollectionH);
0354         edm::Handle<ticl::RecoToSimCollectionWithSimClusters> recotosimCollectionH;
0355         event.getByToken(associatorMapRtSim[i], recotosimCollectionH);
0356         recSimColl.push_back(*recotosimCollectionH);
0357       }
0358 
0359       histoProducerAlgo_->fill_simClusterAssociation_histos(histograms.histoProducerAlgo,
0360                                                             ws,
0361                                                             clusterHandle,
0362                                                             clusters,
0363                                                             simClustersHandle,
0364                                                             simClusters,
0365                                                             sCIndices,
0366                                                             inputClusterMask,
0367                                                             barrelHitMap,
0368                                                             totallayers_to_monitor_,
0369                                                             recSimColl[0],
0370                                                             simRecColl[0],
0371                                                             barrelRechitManager);
0372 
0373       //General Info on simClusters
0374       LogTrace("BarrelValidator") << "\n# of SimClusters: " << nSimClusters
0375                                   << ", layerClusters mask label: " << label_clustersmask[ws].label() << "\n";
0376     }  //end of loop overs masks
0377   }
0378 
0379   // ##############################################
0380   // Fill layercluster histograms
0381   // ##############################################
0382   int w = 0;  //counter counting the number of sets of histograms
0383   if (doLayerClustersPlots_) {
0384     histoProducerAlgo_->fill_generic_cluster_histos(histograms.histoProducerAlgo,
0385                                                     w,
0386                                                     clusterHandle,
0387                                                     clusters,
0388                                                     caloParticleHandle,
0389                                                     caloParticles,
0390                                                     cPIndices,
0391                                                     selected_cPeff,
0392                                                     barrelHitMap,
0393                                                     totallayers_to_monitor_,
0394                                                     recSimColl[0],
0395                                                     simRecColl[0],
0396                                                     barrelRechitManager);
0397 
0398     for (unsigned int layerclusterIndex = 0; layerclusterIndex < clusters.size(); layerclusterIndex++) {
0399       histoProducerAlgo_->fill_cluster_histos(histograms.histoProducerAlgo, w, clusters[layerclusterIndex]);
0400     }
0401 
0402     //General Info on hgcalLayerClusters
0403     LogTrace("BarrelValidator") << "\n# of layer clusters with " << label_lcl.process() << ":" << label_lcl.label()
0404                                 << ":" << label_lcl.instance() << ": " << clusters.size() << "\n";
0405   }
0406 }
0407 
0408 void BarrelValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
0409   // hgcalValidator
0410   edm::ParameterSetDescription desc;
0411   desc.add<double>("ptMinCP", 0.5);
0412   desc.add<double>("ptMaxCP", 300.0);
0413   desc.add<double>("minRapidityCP", -3.1);
0414   desc.add<double>("maxRapidityCP", 3.1);
0415   desc.add<double>("lipCP", 30.0);
0416   desc.add<double>("tipCP", 60);
0417   desc.add<bool>("chargedOnlyCP", false);
0418   desc.add<bool>("stableOnlyCP", false);
0419   desc.add<bool>("notConvertedOnlyCP", true);
0420   desc.add<std::vector<int>>("pdgIdCP",
0421                              {
0422                                  11,
0423                                  -11,
0424                                  13,
0425                                  -13,
0426                                  22,
0427                                  111,
0428                                  211,
0429                                  -211,
0430                                  321,
0431                                  -321,
0432                                  311,
0433                                  130,
0434                                  310,
0435                              });
0436   desc.add<bool>("signalOnlyCP", true);
0437   desc.add<bool>("intimeOnlyCP", true);
0438   desc.add<int>("minHitCP", 0);
0439   desc.add<int>("maxSimClustersCP", -1);
0440   {
0441     edm::ParameterSetDescription psd1;
0442     psd1.add<double>("minEta", -4.5);
0443     psd1.add<double>("maxEta", 4.5);
0444     psd1.add<int>("nintEta", 100);
0445     psd1.add<bool>("useFabsEta", false);
0446     psd1.add<double>("minEne", 0.0);
0447     psd1.add<double>("maxEne", 500.0);
0448     psd1.add<int>("nintEne", 250);
0449     psd1.add<double>("minPt", 0.0);
0450     psd1.add<double>("maxPt", 100.0);
0451     psd1.add<int>("nintPt", 100);
0452     psd1.add<double>("minPhi", -3.2);
0453     psd1.add<double>("maxPhi", 3.2);
0454     psd1.add<int>("nintPhi", 80);
0455     psd1.add<double>("minMixedHitsSimCluster", 0.0);
0456     psd1.add<double>("maxMixedHitsSimCluster", 800.0);
0457     psd1.add<int>("nintMixedHitsSimCluster", 100);
0458     psd1.add<double>("minMixedHitsCluster", 0.0);
0459     psd1.add<double>("maxMixedHitsCluster", 800.0);
0460     psd1.add<int>("nintMixedHitsCluster", 100);
0461     psd1.add<double>("minEneCl", 0.0);
0462     psd1.add<double>("maxEneCl", 110.0);
0463     psd1.add<int>("nintEneCl", 110);
0464     psd1.add<double>("minLongDepBary", 0.0);
0465     psd1.add<double>("maxLongDepBary", 110.0);
0466     psd1.add<int>("nintLongDepBary", 110);
0467     psd1.add<double>("minZpos", -550.0);
0468     psd1.add<double>("maxZpos", 550.0);
0469     psd1.add<int>("nintZpos", 1100);
0470     psd1.add<double>("minTotNsimClsperlay", 0.0);
0471     psd1.add<double>("maxTotNsimClsperlay", 50.0);
0472     psd1.add<int>("nintTotNsimClsperlay", 50);
0473     psd1.add<double>("minTotNClsperlay", 0.0);
0474     psd1.add<double>("maxTotNClsperlay", 1000.0);
0475     psd1.add<int>("nintTotNClsperlay", 50);
0476     psd1.add<double>("minEneClperlay", 0.0);
0477     psd1.add<double>("maxEneClperlay", 1000.0);
0478     psd1.add<int>("nintEneClperlay", 110);
0479     psd1.add<double>("minScore", 0.0);
0480     psd1.add<double>("maxScore", 1.02);
0481     psd1.add<int>("nintScore", 51);
0482     psd1.add<double>("minSharedEneFrac", 0.0);
0483     psd1.add<double>("maxSharedEneFrac", 1.02);
0484     psd1.add<int>("nintSharedEneFrac", 51);
0485     psd1.add<double>("minTSTSharedEneFracEfficiency", 0.5);
0486     psd1.add<double>("minTSTSharedEneFrac", 0.0);
0487     psd1.add<double>("maxTSTSharedEneFrac", 1.01);
0488     psd1.add<int>("nintTSTSharedEneFrac", 101);
0489     psd1.add<double>("minTotNTSTs", 0.0);
0490     psd1.add<double>("maxTotNTSTs", 50.0);
0491     psd1.add<int>("nintTotNTSTs", 50);
0492     psd1.add<double>("minTotNClsinTSTs", 0.0);
0493     psd1.add<double>("maxTotNClsinTSTs", 400.0);
0494     psd1.add<int>("nintTotNClsinTSTs", 100);
0495 
0496     psd1.add<double>("minTotNClsinTSTsperlayer", 0.0);
0497     psd1.add<double>("maxTotNClsinTSTsperlayer", 50.0);
0498     psd1.add<int>("nintTotNClsinTSTsperlayer", 50);
0499     psd1.add<double>("minMplofLCs", 0.0);
0500     psd1.add<double>("maxMplofLCs", 20.0);
0501     psd1.add<int>("nintMplofLCs", 20);
0502     psd1.add<double>("minSizeCLsinTSTs", 0.0);
0503     psd1.add<double>("maxSizeCLsinTSTs", 50.0);
0504     psd1.add<int>("nintSizeCLsinTSTs", 50);
0505     psd1.add<double>("minClEnepermultiplicity", 0.0);
0506     psd1.add<double>("maxClEnepermultiplicity", 10.0);
0507     psd1.add<int>("nintClEnepermultiplicity", 10);
0508     psd1.add<double>("minX", -300.0);
0509     psd1.add<double>("maxX", 300.0);
0510     psd1.add<int>("nintX", 100);
0511     psd1.add<double>("minY", -300.0);
0512     psd1.add<double>("maxY", 300.0);
0513     psd1.add<int>("nintY", 100);
0514     psd1.add<double>("minZ", -550.0);
0515     psd1.add<double>("maxZ", 550.0);
0516     psd1.add<int>("nintZ", 1100);
0517     desc.add<edm::ParameterSetDescription>("histoProducerAlgoBlock", psd1);
0518   }
0519   desc.add<std::vector<edm::InputTag>>("hgcal_hits",
0520                                        {
0521                                            edm::InputTag("HGCalRecHit", "HGCEERecHits"),
0522                                            edm::InputTag("HGCalRecHit", "HGCHEFRecHits"),
0523                                            edm::InputTag("HGCalRecHit", "HGCHEBRecHits"),
0524                                        });
0525   desc.add<std::vector<edm::InputTag>>("barrel_hits",
0526                                        {
0527                                            edm::InputTag("particleFlowRecHitECAL"),
0528                                            edm::InputTag("particleFlowRecHitHBHE"),
0529                                        });
0530 
0531   desc.add<edm::InputTag>("label_lcl", edm::InputTag("hgcalMergeLayerClusters"));
0532   desc.add<std::vector<edm::InputTag>>("label_tst",
0533                                        {
0534                                            edm::InputTag("ticlTrackstersCLUE3DHigh"),
0535                                            edm::InputTag("ticlTrackstersMerge"),
0536                                            edm::InputTag("ticlSimTracksters", "fromCPs"),
0537                                            edm::InputTag("ticlSimTracksters"),
0538                                        });
0539   desc.add<edm::InputTag>("label_simTS", edm::InputTag("ticlSimTracksters"));
0540   desc.add<edm::InputTag>("label_simTSFromCP", edm::InputTag("ticlSimTracksters", "fromCPs"));
0541   desc.addUntracked<std::vector<edm::InputTag>>("associator",
0542                                                 {edm::InputTag("barrelLayerClusterCaloParticleAssociation")});
0543   desc.addUntracked<std::vector<edm::InputTag>>("associatorSim",
0544                                                 {edm::InputTag("barrelLayerClusterSimClusterAssociation")});
0545   desc.addUntracked<bool>("SaveGeneralInfo", true);
0546   desc.addUntracked<bool>("doCaloParticlePlots", true);
0547   desc.addUntracked<bool>("doCaloParticleSelection", true);
0548   desc.addUntracked<bool>("doSimClustersPlots", true);
0549   desc.add<edm::InputTag>("label_SimClusters", edm::InputTag("SimClusters"));
0550   desc.add<edm::InputTag>("label_SimClustersLevel", edm::InputTag("ClusterLevel"));
0551   desc.addUntracked<bool>("doLayerClustersPlots", true);
0552   desc.add<edm::InputTag>("label_layerClusterPlots", edm::InputTag("hgcalMergeLayerClusters"));
0553   desc.add<edm::InputTag>("label_LCToCPLinking", edm::InputTag("LCToCP_association"));
0554   desc.add<edm::InputTag>("simClustersToCaloParticlesMap",
0555                           edm::InputTag("SimClusterToCaloParticleAssociation", "simClusterToCaloParticleMap"));
0556   desc.add<edm::InputTag>("label_cp_effic", edm::InputTag("mix", "MergedCaloTruth"));
0557   desc.add<edm::InputTag>("label_cp_fake", edm::InputTag("mix", "MergedCaloTruth"));
0558   desc.add<edm::InputTag>("label_scl", edm::InputTag("mix", "MergedCaloTruth"));
0559   desc.add<edm::InputTag>("simVertices", edm::InputTag("g4SimHits"));
0560   desc.add<int>("totallayers_to_monitor", 5);
0561   desc.add<std::string>("dirName", "BarrelCalorimeters/BarrelValidator/");
0562   descriptions.add("barrelValidator", desc);
0563 }
[ 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!