From 8dc6c2a99d9e2eb68f0db2c0df61b8f58bc70752 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Cuisset?= Date: Sun, 24 May 2026 17:28:40 +0200 Subject: [PATCH 1/3] Use SimCluster dataformat only for HGCAL and TICL validation CaloParticle dataformat is not used anymore, replaced with new collection of "CaloParticle" SimClusters Associators with CaloParticle are removed (SimCluster associators are used for the "CaloParticle" SimCluster collection) TICL validation code is updated in consequence SimTrackstersProducer is split into two producers : SimTrackstersProducers (only for simtracksters) and SimTICLCandidateProducer (produces SimTICLCandidates) --- DataFormats/HGCalReco/interface/Trackster.h | 4 +- .../plugins/SimTracksterTableProducer.cc | 76 +- .../python/hltSimTracksters_cfi.py | 134 ++-- .../python/hltTICLCandidates_cfi.py | 4 +- .../NGTScouting/python/hltTracksters_cfi.py | 54 +- .../python/RecoHGCal_EventContent_cff.py | 6 +- .../TICL/plugins/SimTICLCandidateProducer.cc | 308 ++++++++ .../TICL/plugins/SimTrackstersProducer.cc | 740 +++++++----------- RecoHGCal/TICL/plugins/TICLDumper.cc | 11 +- RecoHGCal/TICL/python/HLTSimTracksters_cff.py | 70 +- RecoHGCal/TICL/python/SimTracksters_cff.py | 102 ++- RecoHGCal/TICL/python/iterativeTICL_cff.py | 6 +- RecoHGCal/TICL/python/ticlDumper_cff.py | 52 +- ...ToSimTracksterAssociatorsByHitsProducer.cc | 171 ++-- ...imClusterCaloParticleAssociatorProducer.cc | 70 +- ...SimClusterCaloParticleAssociatorProducer.h | 45 -- .../LCToCPAssociatorByEnergyScoreImpl.cc | 575 -------------- .../LCToCPAssociatorByEnergyScoreImpl.h | 108 --- .../LCToCPAssociatorByEnergyScoreProducer.cc | 81 -- .../LCToCPAssociatorByEnergyScoreProducer.h | 61 -- .../plugins/LCToCPAssociatorEDProducer.cc | 137 ---- .../LCToSimTSAssociatorByEnergyScoreImpl.cc | 184 ++--- .../LCToSimTSAssociatorByEnergyScoreImpl.h | 4 - .../plugins/LCToSimTSAssociatorEDProducer.cc | 26 +- .../python/HitToSimClusterAssociation_cff.py | 29 + .../python/HitToTracksterAssociation_cfi.py | 27 +- .../python/LCToCPAssociation_cfi.py | 22 - .../python/LCToSCAssociation_cff.py | 53 ++ .../python/LCToSCAssociation_cfi.py | 22 - .../python/LCToSimTSAssociation_cfi.py | 8 +- .../python/LCToTSAssociator_cfi.py | 17 +- .../python/TSToSimTSAssociationByHits_cfi.py | 46 +- .../python/TSToSimTSAssociation_cfi.py | 8 +- .../python/hltLCToCPAssociation_cfi.py | 25 - .../python/hltLCToSCAssociation_cfi.py | 40 +- .../python/hgcHitAssociation_cfi.py | 11 - .../LayerClusterToSimTracksterAssociator.h | 8 +- ...rClusterToSimTracksterAssociatorBaseImpl.h | 5 - ...ClusterToSimTracksterAssociatorBaseImpl.cc | 4 - .../plugins/PreMixingCaloParticleWorker.cc | 298 +++++-- .../python/barrelSimValid_cff.py | 12 +- .../Configuration/python/hgcalSimValid_cff.py | 17 +- .../python/hltBarrelSimValid_cff.py | 6 +- .../python/hltHGCalSimValid_cff.py | 61 +- .../interface/BarrelVHistoProducerAlgo.h | 59 +- .../interface/BarrelValidator.h | 6 +- .../interface/HGCalValidator.h | 15 +- .../interface/HGVHistoProducerAlgo.h | 65 +- .../plugins/BarrelValidator.cc | 82 +- .../HGCalValidation/plugins/HGCalValidator.cc | 157 ++-- .../python/HGCalValidator_cff.py | 11 +- .../python/HLTBarrelValidator_cff.py | 3 +- .../python/HLTHGCalValidator_cff.py | 19 +- .../python/ticlSuperclusterValidation_cff.py | 2 +- .../scripts/makeHGCalValidationPlots.py | 2 +- .../src/BarrelVHistoProducerAlgo.cc | 45 +- .../src/HGVHistoProducerAlgo.cc | 39 +- .../src/TICLCandidateValidator.cc | 11 +- 58 files changed, 1828 insertions(+), 2436 deletions(-) create mode 100644 RecoHGCal/TICL/plugins/SimTICLCandidateProducer.cc delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.h delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc create mode 100644 SimCalorimetry/HGCalAssociatorProducers/python/HitToSimClusterAssociation_cff.py delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/python/LCToCPAssociation_cfi.py create mode 100644 SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cff.py delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cfi.py delete mode 100644 SimCalorimetry/HGCalAssociatorProducers/python/hltLCToCPAssociation_cfi.py delete mode 100644 SimCalorimetry/HGCalSimProducers/python/hgcHitAssociation_cfi.py diff --git a/DataFormats/HGCalReco/interface/Trackster.h b/DataFormats/HGCalReco/interface/Trackster.h index 3b7f0d97ad2c6..4685c07445323 100644 --- a/DataFormats/HGCalReco/interface/Trackster.h +++ b/DataFormats/HGCalReco/interface/Trackster.h @@ -36,6 +36,8 @@ namespace ticl { ambiguous, unknown, }; + /// Length of id_probabilities : to keep same length as enum ParticleType + static constexpr std::size_t kParticleTypeLength = 8; enum class PCAOrdering { ascending = 0, descending }; @@ -217,7 +219,7 @@ namespace ticl { float timeError_; // trackster ID probabilities - std::array id_probabilities_; + std::array id_probabilities_; // The vertices of the DAG are the indices of the // 2d objects in the global collection diff --git a/HLTrigger/NGTScouting/plugins/SimTracksterTableProducer.cc b/HLTrigger/NGTScouting/plugins/SimTracksterTableProducer.cc index 03134e1c0d065..5c097646402fd 100644 --- a/HLTrigger/NGTScouting/plugins/SimTracksterTableProducer.cc +++ b/HLTrigger/NGTScouting/plugins/SimTracksterTableProducer.cc @@ -1,7 +1,11 @@ -#include +#include +#include +#include +#include #include "DataFormats/NanoAOD/interface/FlatTable.h" #include "DataFormats/HGCalReco/interface/Trackster.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" +#include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/Framework/interface/Event.h" @@ -16,11 +20,13 @@ class SimTracksterTableProducer : public edm::global::EDProducer<> { : tableName_(cfg.getParameter("tableName")), skipNonExistingSrc_(cfg.getParameter("skipNonExistingSrc")), simTrackstersToken_(mayConsume>(cfg.getParameter("simTracksters"))), - caloParticlesToken_(mayConsume>(cfg.getParameter("caloParticles"))), - simClustersToken_(mayConsume>(cfg.getParameter("simClusters"))), - caloParticleToSimClustersMap_token_(mayConsume>>( - cfg.getParameter("caloParticleToSimClustersMap"))), + simTracksterToSimClusterMap_token_( + mayConsume(cfg.getParameter("simTracksterToSimClusterMap"))), + simTracksterToCaloParticleMap_token_( + mayConsume(cfg.getParameter("simTracksterToCaloParticleMap"))), precision_(cfg.getParameter("precision")) { + mayConsume>(cfg.getParameter("simClusters")); + mayConsume>(cfg.getParameter("caloParticles")); produces(tableName_); } @@ -31,9 +37,14 @@ class SimTracksterTableProducer : public edm::global::EDProducer<> { desc.add("skipNonExistingSrc", false) ->setComment("whether or not to skip producing the table on absent input product"); desc.add("simTracksters", edm::InputTag("hltTiclSimTracksters")); - desc.add("caloParticles", edm::InputTag("mix", "MergedCaloTruth")); - desc.add("simClusters", edm::InputTag("mix", "MergedCaloTruth")); - desc.add("caloParticleToSimClustersMap", edm::InputTag("hltTiclSimTracksters")); + desc.add("simClusters", edm::InputTag("mix", "MergedCaloTruth")) + ->setComment("SimCluster collection used to build simTracksters"); + desc.add("caloParticles", edm::InputTag("mix", "MergedCaloTruth")) + ->setComment("CaloParticle collection (pointed to by caloParticleToSimClustersMap)"); + desc.add("simTracksterToSimClusterMap", edm::InputTag("hltTiclSimTracksters")) + ->setComment("DMap SimTrackster -> SimCluster it was made from (map produced by SimTrackstersProducer)"); + desc.add("simTracksterToCaloParticleMap", edm::InputTag("hltTiclSimTracksters")) + ->setComment("Direct map SimTrackster -> CaloParticle (map produced by SimTrackstersProducer)"); desc.add("precision", 7); descriptions.addWithDefaultLabel(desc); } @@ -41,10 +52,10 @@ class SimTracksterTableProducer : public edm::global::EDProducer<> { private: void produce(edm::StreamID id, edm::Event& event, const edm::EventSetup& setup) const override { const auto simTrackstersHandle = event.getHandle(simTrackstersToken_); - const auto caloParticlesHandle = event.getHandle(caloParticlesToken_); - const auto simClustersHandle = event.getHandle(simClustersToken_); - const auto cpToSCMapHandle = event.getHandle(caloParticleToSimClustersMap_token_); - + edm::Handle simTracksterToSimCluster_map_handle = + event.getHandle(simTracksterToSimClusterMap_token_); + edm::Handle simTracksterToCaloParticle_map_handle = + event.getHandle(simTracksterToCaloParticleMap_token_); const size_t nSimTracksters = simTrackstersHandle.isValid() ? simTrackstersHandle->size() : 0; static constexpr float default_value = std::numeric_limits::quiet_NaN(); @@ -62,13 +73,12 @@ class SimTracksterTableProducer : public edm::global::EDProducer<> { std::vector genPt(nSimTracksters, default_value); std::vector mass(nSimTracksters, default_value); - if ((simTrackstersHandle.isValid() && caloParticlesHandle.isValid() && simClustersHandle.isValid() && - cpToSCMapHandle.isValid()) || + if ((simTrackstersHandle.isValid() && simTracksterToSimCluster_map_handle.isValid() && + simTracksterToCaloParticle_map_handle.isValid()) || !(this->skipNonExistingSrc_)) { const auto& simTracksters = *simTrackstersHandle; - const auto& caloParticles = *caloParticlesHandle; - const auto& simClusters = *simClustersHandle; - const auto& cpToSCMap = *cpToSCMapHandle; + SimClusterRefVector const& simTracksterToSimCluster_map = *simTracksterToSimCluster_map_handle; + CaloParticleRefVector const& simTracksterToCaloParticle_map = *simTracksterToCaloParticle_map_handle; //utility lambda for filling vectors auto fillVectors = [&](const auto& obj, size_t iSim, float time) { @@ -94,26 +104,14 @@ class SimTracksterTableProducer : public edm::global::EDProducer<> { for (size_t iSim = 0; iSim < simTracksters.size(); ++iSim) { const auto& simT = simTracksters[iSim]; - float time = default_value; - - if (simT.seedID() == caloParticlesHandle.id()) { - const auto& cp = caloParticles[simT.seedIndex()]; - time = cp.simTime(); - fillVectors(cp, iSim, time); - } else { - const auto& sc = simClusters[simT.seedIndex()]; - //SCtoCP map not availalbe, use CPtoSC map instead - for (const auto& [cpIdx, scVec] : cpToSCMap) { - if (std::ranges::find(scVec, simT.seedIndex()) != scVec.end()) { - time = caloParticles[cpIdx].simTime(); - break; //dont need to check further - } - } - fillVectors(sc, iSim, time); - } + assert(simT.seedID() == simTracksterToSimCluster_map.id()); + + SimCluster const& simCluster = *simTracksterToSimCluster_map[iSim]; + CaloParticle const& caloParticle = *simTracksterToCaloParticle_map[iSim]; + + fillVectors(simCluster, iSim, caloParticle.simTime()); } } - auto simTrackstersTable = std::make_unique(nSimTracksters, tableName_, /*singleton*/ false, /*extension*/ true); simTrackstersTable->addColumn( @@ -143,9 +141,11 @@ class SimTracksterTableProducer : public edm::global::EDProducer<> { const std::string tableName_; const bool skipNonExistingSrc_; const edm::EDGetTokenT> simTrackstersToken_; - const edm::EDGetTokenT> caloParticlesToken_; - const edm::EDGetTokenT> simClustersToken_; - const edm::EDGetTokenT>> caloParticleToSimClustersMap_token_; + const edm::EDGetTokenT>> simTracksterToSimClusterMap_token_; + ///< Map from SimTrackster to SimCluster used to make it + const edm::EDGetTokenT simTracksterToCaloParticleMap_token_; + ///< Direct map SimTrackster -> CaloParticle (works also for SimTs from SimCluster) + const unsigned int precision_; }; diff --git a/HLTrigger/NGTScouting/python/hltSimTracksters_cfi.py b/HLTrigger/NGTScouting/python/hltSimTracksters_cfi.py index 1b0d1e33a515c..0067cd36cf40f 100644 --- a/HLTrigger/NGTScouting/python/hltSimTracksters_cfi.py +++ b/HLTrigger/NGTScouting/python/hltSimTracksters_cfi.py @@ -5,49 +5,51 @@ hltUpgradeNanoTask = cms.Task(nanoMetadata) +_variables_simTracksters = cms.PSet( + raw_energy=Var("raw_energy", "float", + doc="Raw Energy of the trackster [GeV]"), + raw_em_energy=Var("raw_em_energy", "float", + doc="EM raw Energy of the trackster [GeV]"), + raw_pt=Var( + "raw_pt", "float", doc="Trackster raw pT, computed from trackster raw energy and direction [GeV]"), + regressed_energy=Var("regressed_energy", "float", + doc="Regressed Energy of the trackster, for the SimTrackster it corresponds to the GEN-energy"), + barycenter_x=Var("barycenter.x", "float", + doc="Trackster barycenter x [cm]"), + barycenter_y=Var("barycenter.y", "float", + doc="Trackster barycenter y [cm]"), + barycenter_z=Var("barycenter.z", "float", + doc="Trackster barycenter z [cm]"), + barycenter_eta=Var("barycenter.eta", "float", + doc="Trackster barycenter pseudorapidity"), + barycenter_phi=Var("barycenter.phi", "float", + doc="Trackster barycenter phi"), + EV1=Var("eigenvalues()[0]", "float", + doc="Trackster PCA eigenvalues 0"), + EV2=Var("eigenvalues()[1]", "float", + doc="Trackster PCA eigenvalues 1"), + EV3=Var("eigenvalues()[2]", "float", + doc="Trackster PCA eigenvalues 2"), + eVector0_x=Var( + "eigenvectors()[0].x", "float", doc="Trackster PCA principal axis, x component"), + eVector0_y=Var( + "eigenvectors()[0].z", "float", doc="Trackster PCA principal axis, y component"), + eVector0_z=Var( + "eigenvectors()[0].y", "float", doc="Trackster PCA principal axis, z component"), + time=Var("time", "float", doc="Trackster HGCAL time"), + timeError=Var("timeError", "float", + doc="Trackster HGCAL time error") +) + hltSimTracksterTable = cms.EDProducer( "TracksterCollectionTableProducer", skipNonExistingSrc=cms.bool(True), - src=cms.InputTag("hltTiclSimTracksters"), + src=cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), cut=cms.string(""), name=cms.string("hltTiclSimTracksters"), doc=cms.string("hltTiclSimTracksters"), singleton=cms.bool(False), # the number of entries is variable - variables=cms.PSet( - raw_energy=Var("raw_energy", "float", - doc="Raw Energy of the trackster [GeV]"), - raw_em_energy=Var("raw_em_energy", "float", - doc="EM raw Energy of the trackster [GeV]"), - raw_pt=Var( - "raw_pt", "float", doc="Trackster raw pT, computed from trackster raw energy and direction [GeV]"), - regressed_energy=Var("regressed_energy", "float", - doc="Regressed Energy of the trackster, for the SimTrackster it corresponds to the GEN-energy"), - barycenter_x=Var("barycenter.x", "float", - doc="Trackster barycenter x [cm]"), - barycenter_y=Var("barycenter.y", "float", - doc="Trackster barycenter y [cm]"), - barycenter_z=Var("barycenter.z", "float", - doc="Trackster barycenter z [cm]"), - barycenter_eta=Var("barycenter.eta", "float", - doc="Trackster barycenter pseudorapidity"), - barycenter_phi=Var("barycenter.phi", "float", - doc="Trackster barycenter phi"), - EV1=Var("eigenvalues()[0]", "float", - doc="Trackster PCA eigenvalues 0"), - EV2=Var("eigenvalues()[1]", "float", - doc="Trackster PCA eigenvalues 1"), - EV3=Var("eigenvalues()[2]", "float", - doc="Trackster PCA eigenvalues 2"), - eVector0_x=Var( - "eigenvectors()[0].x", "float", doc="Trackster PCA principal axis, x component"), - eVector0_y=Var( - "eigenvectors()[0].z", "float", doc="Trackster PCA principal axis, y component"), - eVector0_z=Var( - "eigenvectors()[0].y", "float", doc="Trackster PCA principal axis, z component"), - time=Var("time", "float", doc="Trackster HGCAL time"), - timeError=Var("timeError", "float", - doc="Trackster HGCAL time error") - ), + variables=_variables_simTracksters, collectionVariables=cms.PSet( tracksterVertices=cms.PSet( name=cms.string(f"hltTiclSimTrackstersvertices"), @@ -70,46 +72,12 @@ hltSimTracksterFromCPsTable = cms.EDProducer( "TracksterCollectionTableProducer", skipNonExistingSrc=cms.bool(True), - src=cms.InputTag("hltTiclSimTracksters", "fromCPs"), + src=cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), cut=cms.string(""), name=cms.string("hltTiclSimTrackstersFromCPs"), doc=cms.string("hltTiclSimTrackstersFromCPs"), singleton=cms.bool(False), # the number of entries is variable - variables=cms.PSet( - raw_energy=Var("raw_energy", "float", - doc="Raw Energy of the trackster [GeV]"), - raw_em_energy=Var("raw_em_energy", "float", - doc="EM raw Energy of the trackster [GeV]"), - raw_pt=Var( - "raw_pt", "float", doc="Trackster raw pT, computed from trackster raw energy and direction [GeV]"), - regressed_energy=Var("regressed_energy", "float", - doc="Regressed Energy of the trackster, for the SimTrackster it corresponds to the GEN-energy"), - barycenter_x=Var("barycenter.x", "float", - doc="Trackster barycenter x [cm]"), - barycenter_y=Var("barycenter.y", "float", - doc="Trackster barycenter y [cm]"), - barycenter_z=Var("barycenter.z", "float", - doc="Trackster barycenter z [cm]"), - barycenter_eta=Var("barycenter.eta", "float", - doc="Trackster barycenter pseudorapidity"), - barycenter_phi=Var("barycenter.phi", "float", - doc="Trackster barycenter phi"), - EV1=Var("eigenvalues()[0]", "float", - doc="Trackster PCA eigenvalues 0"), - EV2=Var("eigenvalues()[1]", "float", - doc="Trackster PCA eigenvalues 1"), - EV3=Var("eigenvalues()[2]", "float", - doc="Trackster PCA eigenvalues 2"), - eVector0_x=Var( - "eigenvectors()[0].x", "float", doc="Trackster PCA principal axis, x component"), - eVector0_y=Var( - "eigenvectors()[0].z", "float", doc="Trackster PCA principal axis, y component"), - eVector0_z=Var( - "eigenvectors()[0].y", "float", doc="Trackster PCA principal axis, z component"), - time=Var("time", "float", doc="Trackster HGCAL time"), - timeError=Var("timeError", "float", - doc="Trackster HGCAL time error") - ), + variables=_variables_simTracksters, collectionVariables=cms.PSet( tracksterVertices=cms.PSet( name=cms.string(f"hltTiclSimTrackstersFromCPsvertices"), @@ -132,21 +100,23 @@ # Extra tables for SimTracksters using information from SimClusters and CaloParticles # Might be replaced in case we save CaloParticles and SimClusters, in that case we just need adding the corresponding SimObject indices in the SimTrackster tables hltTiclSimTrackstersExtraTable = cms.EDProducer("SimTracksterTableProducer", - tableName = cms.string("hltTiclSimTracksters"), + tableName = hltSimTracksterTable.name, skipNonExistingSrc = cms.bool(True), - simTracksters = cms.InputTag( "hltTiclSimTracksters" ), - caloParticles = cms.InputTag( "mix", "MergedCaloTruth" ), - simClusters = cms.InputTag( "mix", "MergedCaloTruth" ), - caloParticleToSimClustersMap = cms.InputTag("hltTiclSimTracksters"), + simTracksters = hltSimTracksterTable.src, + caloParticles = cms.InputTag( "mix", "MergedCaloTruth"), + simClusters = cms.InputTag( "mix", "MergedCaloTruthBoundaryTrackSimCluster"), # this has to be the same that was used for hltTiclSimTracksters + simTracksterToSimClusterMap = hltSimTracksterTable.src, + simTracksterToCaloParticleMap = hltSimTracksterTable.src, precision = cms.int32(7), ) hltTiclSimTrackstersFromCPsExtraTable = cms.EDProducer("SimTracksterTableProducer", - tableName = cms.string("hltTiclSimTrackstersFromCPs"), + tableName = hltSimTracksterFromCPsTable.name, skipNonExistingSrc = cms.bool(True), - simTracksters = cms.InputTag( "hltTiclSimTracksters", "fromCPs"), - caloParticles = cms.InputTag( "mix", "MergedCaloTruth" ), - simClusters = cms.InputTag( "mix", "MergedCaloTruth" ), - caloParticleToSimClustersMap = cms.InputTag("hltTiclSimTracksters"), + simTracksters = hltSimTracksterFromCPsTable.src, + caloParticles = cms.InputTag( "mix", "MergedCaloTruth"), + simClusters = cms.InputTag( "mix", "MergedCaloTruthCaloParticle"), # this has to be the same that was used for hltTiclSimTracksters + simTracksterToSimClusterMap = hltSimTracksterFromCPsTable.src, + simTracksterToCaloParticleMap = hltSimTracksterFromCPsTable.src, precision = cms.int32(7), ) diff --git a/HLTrigger/NGTScouting/python/hltTICLCandidates_cfi.py b/HLTrigger/NGTScouting/python/hltTICLCandidates_cfi.py index b42a4aaa81e61..170cbd2f4a31b 100644 --- a/HLTrigger/NGTScouting/python/hltTICLCandidates_cfi.py +++ b/HLTrigger/NGTScouting/python/hltTICLCandidates_cfi.py @@ -53,7 +53,7 @@ hltSimTiclCandidateTable = cms.EDProducer( "TICLCandidateTableProducer", skipNonExistingSrc=cms.bool(True), - src=cms.InputTag("hltTiclSimTracksters"), + src=cms.InputTag("hltTiclSimTICLCandidatesFromBoundary"), cut=cms.string(""), name=cms.string("hltSimTICLCandidates"), doc=cms.string("SimTICLCandidates"), @@ -113,7 +113,7 @@ hltSimTiclCandidateExtraTable = cms.EDProducer( "TICLCandidateExtraTableProducer", - src = cms.InputTag("hltTiclSimTracksters"), + src = cms.InputTag("hltTiclSimTICLCandidatesFromBoundary"), name = cms.string("SimCandidate2Tracksters"), skipNonExistingSrc = cms.bool(True), doc = cms.string("TICLCandidates extra table with linked Tracksters"), diff --git a/HLTrigger/NGTScouting/python/hltTracksters_cfi.py b/HLTrigger/NGTScouting/python/hltTracksters_cfi.py index 56f28222f665c..59e9aedeccee0 100644 --- a/HLTrigger/NGTScouting/python/hltTracksters_cfi.py +++ b/HLTrigger/NGTScouting/python/hltTracksters_cfi.py @@ -4,7 +4,11 @@ from Validation.HGCalValidation.HLT_TICLIterLabels_cff import hltTiclIterLabelsPSet hltUpgradeNanoTask = cms.Task(nanoMetadata) -hltSimTrackstersLabels = ['hltTiclSimTracksters', 'hltTiclSimTrackstersfromCPs'] +hltSimTrackstersLabels = [ + cms.InputTag('hltTiclSimTracksters', 'fromBoundarySimCluster'), cms.InputTag('hltTiclSimTracksters', 'fromCaloParticle')] +hltSimTracksters_sourceSimClusterLabels = [ # SimCluster collections that were used to make SimTrackster (to be kept in sync) + cms.InputTag( "mix", "MergedCaloTruthBoundaryTrackSimCluster"), cms.InputTag( "mix", "MergedCaloTruthCaloParticle")] +assert len(hltSimTrackstersLabels)==len(hltSimTracksters_sourceSimClusterLabels) # Tracksters hltTrackstersTable = [] hltSimTrackstersTable = [] @@ -58,10 +62,10 @@ globals()[label] = tracksterTable.clone() tracksterTableProducers.append(globals()[label]) for iterLabelSim in hltSimTrackstersLabels: - CP_SC_label = "CP" if "CP" in iterLabelSim else "SC" + CP_SC_label = "CP" if ("CP" in iterLabelSim.productInstanceLabel or "CaloParticle" in iterLabelSim.productInstanceLabel) else "SC" trackstersAssociationOneToManyS2RTable = cms.EDProducer( "TracksterTracksterEnergyScoreFlatTableProducer", - src=cms.InputTag(f"hltAllTrackstersToSimTrackstersAssociationsByHits:{iterLabelSim}To{iterLabel}"), + src=cms.InputTag(f"hltAllTrackstersToSimTrackstersAssociationsByHits:{iterLabelSim.moduleLabel}{iterLabelSim.productInstanceLabel}To{iterLabel}"), skipNonExistingSrc=cms.bool(True), name=cms.string(f"Sim{CP_SC_label}2{iterLabel}ByHits"), doc=cms.string(f"Association between SimTracksters and {iterLabel}, by hits."), @@ -78,13 +82,13 @@ ) ), ) - labelAssociation = f"{iterLabelSim}To{iterLabel}AssociationTableProducer" + labelAssociation = f"{iterLabelSim.moduleLabel}{iterLabelSim.productInstanceLabel}To{iterLabel}AssociationTableProducer" globals()[labelAssociation] = trackstersAssociationOneToManyS2RTable.clone() hltTrackstersAssociationOneToManyTableProducers.append( globals()[labelAssociation]) trackstersAssociationOneToManyR2STable = cms.EDProducer("TracksterTracksterEnergyScoreFlatTableProducer", - src=cms.InputTag(f"hltAllTrackstersToSimTrackstersAssociationsByHits:{iterLabel}To{iterLabelSim}"), + src=cms.InputTag(f"hltAllTrackstersToSimTrackstersAssociationsByHits:{iterLabel}To{iterLabelSim.moduleLabel}{iterLabelSim.productInstanceLabel}"), skipNonExistingSrc=cms.bool(True), name=cms.string(f"Reco{iterLabel}2Sim{CP_SC_label}ByHits"), doc=cms.string(f"Association between {iterLabel} and SimTracksters, by hits."), @@ -101,7 +105,7 @@ ) ), ) - labelAssociation = f"{iterLabel}To{iterLabelSim}AssociationTableProducer" + labelAssociation = f"{iterLabel}To{iterLabelSim.moduleLabel}{iterLabelSim.productInstanceLabel}AssociationTableProducer" globals()[labelAssociation] = trackstersAssociationOneToManyR2STable.clone() hltTrackstersAssociationOneToManyTableProducers.append( globals()[labelAssociation]) @@ -109,17 +113,18 @@ hltTrackstersTableSequence = cms.Sequence(sum(tracksterTableProducers, cms.Sequence())) hltTiclAssociationsTableSequence = cms.Sequence(sum(hltTrackstersAssociationOneToManyTableProducers, cms.Sequence())) simTracksterTableProducers = [] -for iterLabel in hltSimTrackstersLabels: - label = iterLabel - objName = "" - if ("CP" in iterLabel): - label, objName = iterLabel.split("hltTiclSimTracksters") - hltSimTracksterTable = cms.EDProducer("TracksterCollectionTableProducer", +for iterLabel, sourceSimClusterIterLabel in zip(hltSimTrackstersLabels, hltSimTracksters_sourceSimClusterLabels): + if ("CP" in iterLabel.productInstanceLabel or "CaloParticle" in iterLabel.productInstanceLabel): + outputLabel = f"{iterLabel.moduleLabel}fromCPs" + else: + outputLabel = iterLabel.moduleLabel + hltSimTracksterTable = cms.EDProducer( + "TracksterCollectionTableProducer", skipNonExistingSrc=cms.bool(True), - src=cms.InputTag(f"hltTiclSimTracksters", objName), + src=iterLabel, cut=cms.string(""), - name=cms.string(f"{iterLabel}"), - doc=cms.string(f"{iterLabel}"), + name=cms.string(outputLabel), + doc=cms.string(outputLabel), singleton=cms.bool(False), # the number of entries is variable variables=cms.PSet( raw_energy=Var("raw_energy", "float", doc="Raw Energy of the trackster [GeV]"), @@ -142,7 +147,7 @@ ), collectionVariables=cms.PSet( tracksterVertices=cms.PSet( - name=cms.string(f"{iterLabel}vertices"), + name=cms.string(f"{outputLabel}vertices"), doc=cms.string("Vertex properties"), useCount=cms.bool(True), useOffset=cms.bool(True), @@ -153,26 +158,31 @@ ) ), ) - label = f"{iterLabel}TableProducer" + label = f"{outputLabel}TableProducer" globals()[label] = hltSimTracksterTable.clone() simTracksterTableProducers.append(globals()[label]) hltTiclSimTrackstersExtraTable = cms.EDProducer("SimTracksterTableProducer", - tableName=cms.string(f"{iterLabel}"), + tableName=cms.string(outputLabel), skipNonExistingSrc=cms.bool(True), - simTracksters=cms.InputTag("hltTiclSimTracksters", objName), + simTracksters=iterLabel, caloParticles=cms.InputTag("mix", "MergedCaloTruth"), - simClusters=cms.InputTag("mix", "MergedCaloTruth"), - caloParticleToSimClustersMap=cms.InputTag("hltTiclSimTracksters"), + simClusters=sourceSimClusterIterLabel, # this has to be the same that was used for SimTrackster building in hltTiclSimTracksters + simTracksterToSimClusterMap=iterLabel, + simTracksterToCaloParticleMap=iterLabel, precision=cms.int32(7), ) - labelExtra = f"{iterLabel}TableExtraProducer" + labelExtra = f"{outputLabel}TableExtraProducer" globals()[labelExtra] = hltTiclSimTrackstersExtraTable.clone() simTracksterTableProducers.append(globals()[labelExtra]) hltSimTracksterSequence = cms.Sequence( sum(simTracksterTableProducers, cms.Sequence())) + # Tracksters Associators +# this map is from "legacy" SimCluster collection to CaloParticle (it could be updated to "boundary" SimCluster to match SimTrackster above). +# Note that it cannot be used in relation to the (Sim)Trackster tables, as the indices are not the same +# (the SimCluster->SimTrackster conversion removes SimCluster that lead to empty tracksters, because for ex. all simhits were "outliers" in CLUE, thus simTracksters.size() <= simClusters.size()) hltSimCl2CPOneToOneFlatTable = cms.EDProducer( "SimClusterCaloParticleFractionFlatTableProducer", src=cms.InputTag("SimClusterToCaloParticleAssociation:simClusterToCaloParticleMap"), diff --git a/RecoHGCal/Configuration/python/RecoHGCal_EventContent_cff.py b/RecoHGCal/Configuration/python/RecoHGCal_EventContent_cff.py index eb43f21d538c3..e21dfeecb1e0c 100644 --- a/RecoHGCal/Configuration/python/RecoHGCal_EventContent_cff.py +++ b/RecoHGCal/Configuration/python/RecoHGCal_EventContent_cff.py @@ -23,9 +23,10 @@ 'keep *_pfTICL_*_*', 'keep CaloParticles_mix_*_*', 'keep SimClusters_mix_*_*', + 'keep SimClustersRefs_mix_*_*', 'keep *_SimClusterToCaloParticleAssociation*_*_*', 'keep *_layerClusterSimClusterAssociationProducer_*_*', - 'keep *_layerClusterCaloParticleAssociationProducer_*_*', + 'keep *_layerClusterCaloParticleSimClusterAssociationProducer_*_*', 'keep *_layerClusterSimTracksterAssociationProducer_*_*', 'keep *_allTrackstersToSimTrackstersAssociations*_*_*' ] @@ -65,12 +66,13 @@ def cleanOutputAndSet(outputModule, ticl_outputCommands): 'keep *_hgcalMergeLayerClusters_*_*', 'keep CaloParticles_mix_*_*', 'keep SimClusters_mix_*_*', + 'keep SimClustersRefs_mix_*_*', 'keep recoTracks_generalTracks_*_*', 'keep recoTrackExtras_generalTracks_*_*', 'keep SimTracks_g4SimHits_*_*', 'keep SimVertexs_g4SimHits_*_*', 'keep *_layerClusterSimClusterAssociationProducer_*_*', - 'keep *_layerClusterCaloParticleAssociationProducer_*_*', + 'keep *_layerClusterCaloParticleSimClusterAssociationProducer_*_*', 'keep *_randomEngineStateProducer_*_*', 'keep *_layerClusterSimTracksterAssociationProducer_*_*', 'keep *_SimClusterToCaloParticleAssociation*_*_*', diff --git a/RecoHGCal/TICL/plugins/SimTICLCandidateProducer.cc b/RecoHGCal/TICL/plugins/SimTICLCandidateProducer.cc new file mode 100644 index 0000000000000..84bc903fc7ed6 --- /dev/null +++ b/RecoHGCal/TICL/plugins/SimTICLCandidateProducer.cc @@ -0,0 +1,308 @@ +// Author: Felice Pantaleo, Leonardo Cristella - felice.pantaleo@cern.ch, leonardo.cristella@cern.ch +// Date: 09/2021 +// Refactored : Theo Cuisset - theo.cuisset@polytechnique.edu + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/global/EDProducer.h" +#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" +#include "FWCore/ParameterSet/interface/ParameterSetDescription.h" + +#include "DataFormats/HGCalReco/interface/Trackster.h" +#include "DataFormats/HGCalReco/interface/TICLCandidate.h" +#include "DataFormats/TrackReco/interface/Track.h" +#include "DataFormats/TrackReco/interface/TrackFwd.h" + +#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" +#include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" +#include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimTrackster.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimTracksterFwd.h" + +#include "DataFormats/HGCalReco/interface/Common.h" + +#include + +using namespace ticl; + +/** +* @brief Produces TICLCandidates using MC truth +* Uses two sim collections (each with the Calorimeter truth object as well as corresponding tracksters) : the "base" collections (usually CaloParticle) and "sub" collections (typically SimCluster from crossedBoundary SimTracks) +* TICLCandidate recoTrack pointers are set from "base" SimTrackster matched reco tracks. +* MTD time is set to MtdSimTrackster time (matched by shared SimTrack to "base" sim object) +* 4-momentum for neutral is set from "base" simTrackster energy (for charged from sim true energy & reco track direction) +* +* There is a 1-1 mapping between SimTICLCandidate and "base" SimTrackster +*/ +template +class SimTICLCandidateProducerT : public edm::global::EDProducer<> { +public: + explicit SimTICLCandidateProducerT(const edm::ParameterSet&); + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + + void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override; + +private: + const edm::EDGetTokenT> baseCaloSimObjects_token_; + const edm::EDGetTokenT> subCaloSimObjects_token_; + const edm::EDGetTokenT>> subToBaseSimObject_map_token_; + + const edm::EDGetTokenT> baseSimTracksters_token_; + const edm::EDGetTokenT> subSimTracksters_token_; + const edm::EDGetTokenT>> baseSimTracksterToBaseSimObject_map_token_; + const edm::EDGetTokenT>> subSimTracksterToSubSimObject_map_token_; + const edm::EDGetTokenT baseSimTracksterToCaloParticle_map_token_; + + const edm::EDGetTokenT MTDSimTrackstersToken_; + const edm::EDGetTokenT> recoTracksToken_; + + const edm::EDPutTokenT> SimTICLCandidates_token_; +}; + +template class SimTICLCandidateProducerT; +template class SimTICLCandidateProducerT; + +using SimTICLCandidateProducerUsingCaloParticle = SimTICLCandidateProducerT; +DEFINE_FWK_MODULE(SimTICLCandidateProducerUsingCaloParticle); +using SimTICLCandidateProducerUsingSimCluster = SimTICLCandidateProducerT; +DEFINE_FWK_MODULE(SimTICLCandidateProducerUsingSimCluster); + +template +SimTICLCandidateProducerT::SimTICLCandidateProducerT(const edm::ParameterSet& ps) + : baseCaloSimObjects_token_(consumes(ps.getParameter("baseCaloSimObjects"))), + subCaloSimObjects_token_(consumes(ps.getParameter("subCaloSimObjects"))), + subToBaseSimObject_map_token_(consumes(ps.getParameter("subToBaseMap"))), + + baseSimTracksters_token_(consumes(ps.getParameter("baseSimTracksters"))), + subSimTracksters_token_(consumes(ps.getParameter("subSimTracksters"))), + + baseSimTracksterToBaseSimObject_map_token_( + consumes(ps.getParameter("baseSimTracksterToBaseSimObject_map"))), + subSimTracksterToSubSimObject_map_token_( + consumes(ps.getParameter("subSimTracksterToSubSimObject_map"))), + baseSimTracksterToCaloParticle_map_token_( + consumes(ps.getParameter("baseSimTracksterToCaloParticle_map"))), + + MTDSimTrackstersToken_(consumes(ps.getParameter("MtdSimTracksters"))), + recoTracksToken_(consumes>(ps.getParameter("recoTracks"))), + + SimTICLCandidates_token_(produces>()) {} + +template +void SimTICLCandidateProducerT::fillDescriptions( + edm::ConfigurationDescriptions& descriptions) { + edm::ParameterSetDescription desc; + + desc.add("baseCaloSimObjects", edm::InputTag("mix", "MergedCaloTruth")) + ->setComment( + "Base sim object collection (=CaloParticle) as SimCluster dataformat (one base sim object = one " + "SimTICLCandidate)"); + desc.add("subCaloSimObjects", edm::InputTag("mix", "MergedCaloTruth")) + ->setComment("'Sub' calo sim object collection. Currently unused."); + desc.add("subToBaseMap", edm::InputTag("mix", "MergedCaloTruth")) + ->setComment( + "Map (edm::RefVector) from 'subCaloSimObjects' collection to 'baseCaloSimObjects' collections (ie SimCluster " + "-> CaloParticle map)"); + + desc.add("baseSimTracksters") + ->setComment( + "'Base' trackster collection (typically SimTrackster from CaloParticle). Used for adding reco tracks to " + "TICLCandidate. One base simTracksters makes one SimTICLCandidate"); + desc.add("baseSimTracksterToBaseSimObject_map") + ->setComment("Map 'baseSimTracksters' collection -> 'baseCaloSimObjects' collection "); + desc.add("baseSimTracksterToCaloParticle_map") + ->setComment( + "Map 'baseSimTracksters' collection -> CaloParticle (used only to get the vertex time of CaloParticle)"); + + desc.add("subSimTracksters") + ->setComment( + "'Sub' trackster collection : tracksters whose references are added to TICLCandidate object (usually " + "SimTrackster from boundary SimCluster)"); + desc.add("subSimTracksterToSubSimObject_map"); + + desc.add("MtdSimTracksters", edm::InputTag("mix", "MergedMtdTruthST")); + desc.add("recoTracks", edm::InputTag("generalTracks")); + + descriptions.addWithDefaultLabel(desc); +} + +template +void SimTICLCandidateProducerT::produce(edm::StreamID, + edm::Event& evt, + const edm::EventSetup& es) const { + edm::Handle> baseCaloSimObjects_h = evt.getHandle(baseCaloSimObjects_token_); + // not needed currently but kept in case of future need + edm::Handle> subCaloSimObjects_h = evt.getHandle(subCaloSimObjects_token_); + + edm::RefVector> const& subToBaseSimObject_map = evt.get(subToBaseSimObject_map_token_); + edm::RefVector> const& baseSimTracksterToBaseSimObject_map = + evt.get(baseSimTracksterToBaseSimObject_map_token_); + edm::RefVector> const& subSimTracksterToSubSimObject_map = + evt.get(subSimTracksterToSubSimObject_map_token_); + CaloParticleRefVector const& baseSimTracksterToCaloParticle_map = evt.get(baseSimTracksterToCaloParticle_map_token_); + + if (!baseCaloSimObjects_h.isValid() || !baseSimTracksterToBaseSimObject_map.id().isValid()) { + edm::LogWarning("SimTICLCandidateProducer") << "Missing input collections. Producing empty outputs."; + evt.emplace(SimTICLCandidates_token_); + return; + } + + TracksterCollection const& baseSimTracksters = evt.get(baseSimTracksters_token_); + // Need handle for TICLCandidate::addTrackster + edm::Handle subSimTracksters_h = evt.getHandle(subSimTracksters_token_); + TracksterCollection const& subSimTracksters = *subSimTracksters_h; + + assert(subToBaseSimObject_map.id() == baseCaloSimObjects_h.id()); + assert(subToBaseSimObject_map.size() == subCaloSimObjects_h->size()); + assert(baseSimTracksterToBaseSimObject_map.id() == baseCaloSimObjects_h.id()); + assert(baseSimTracksterToBaseSimObject_map.size() == baseSimTracksters.size()); + assert(subSimTracksterToSubSimObject_map.id() == subCaloSimObjects_h.id()); + assert(subSimTracksterToSubSimObject_map.size() == subSimTracksters.size()); + + auto result_ticlCandidates = std::vector(baseSimTracksters.size()); + + auto mapBaseSimTracksterToBaseSimObject = + [&](TracksterCollection::size_type baseSimTs_i) -> edm::Ref> { + return baseSimTracksterToBaseSimObject_map[baseSimTs_i]; + }; // returns edm::Ref + auto mapBaseSimTsToTICLCandidate = [&](TracksterCollection::size_type baseSimTs_i) -> TICLCandidate& { + return result_ticlCandidates[baseSimTs_i]; + }; // 1-1 mapping (but kept as a function in case it needs to be changed) + auto mapTICLCandidateToBaseSimTsIndex = + [&](TracksterCollection::size_type ticlCand_i) -> TracksterCollection::size_type { + return ticlCand_i; + }; // 1-1 mapping (but kept as a function in case it needs to be changed) + auto mapTICLCandidateToBaseSimObject = [&](TracksterCollection::size_type ticlCand_i) -> BaseSimObject_t const& { + return *baseSimTracksterToBaseSimObject_map[ticlCand_i]; + }; + + // Map from "base" SimObject to the SimTrackster corresponding. Reverse the RefVector. There is no check that the SimObject actually has a SimTrackster (in that case it will return an out of range index) + auto mapBaseSimObjectToBaseSimTs = [&](std::size_t baseSimObject_i) -> TracksterCollection::size_type { + return std::ranges::find_if(baseSimTracksterToBaseSimObject_map, + [baseSimObject_i](auto const& elem) { return elem.key() == baseSimObject_i; }) - + baseSimTracksterToBaseSimObject_map.begin(); + }; + auto mapSubSimTsToTICLCandidate = [&](TracksterCollection::size_type subSimTs_i) -> TICLCandidate& { + return mapBaseSimTsToTICLCandidate( + mapBaseSimObjectToBaseSimTs(subToBaseSimObject_map[subSimTracksterToSubSimObject_map[subSimTs_i].key()].key())); + }; // return TICLCandidate& + + MtdSimTracksterCollection const& MTDSimTracksters = evt.get(MTDSimTrackstersToken_); + + edm::Handle> recoTracks_h = evt.getHandle(recoTracksToken_); + + // map between simTrack and Mtd SimTracksters to loop on them only one + std::unordered_map SimTrackToMtdST; + for (unsigned int i = 0; i < MTDSimTracksters.size(); ++i) { + const auto& simTrack = MTDSimTracksters[i].g4Tracks()[0]; + SimTrackToMtdST[simTrack.trackId()] = &(MTDSimTracksters[i]); + } + + /* ----- Step 1 : Add tracksters from "sub" collection */ + for (size_t subSimTrackster_i = 0; subSimTrackster_i < subSimTracksters.size(); ++subSimTrackster_i) { + TICLCandidate& cand = mapSubSimTsToTICLCandidate(subSimTrackster_i); + cand.addTrackster(edm::Ptr(subSimTracksters_h, subSimTrackster_i)); + } + + /* ----- Step 2 : Add tracks from "base" collection of tracksters */ + for (size_t baseSimTrackster_i = 0; baseSimTrackster_i < baseSimTracksters.size(); ++baseSimTrackster_i) { + ticl::Trackster const& baseSimTrackster = baseSimTracksters[baseSimTrackster_i]; + BaseSimObject_t const& baseSimObject = *mapBaseSimTracksterToBaseSimObject(baseSimTrackster_i); + + if (!baseSimTrackster.vertices().empty()) { + auto trackIndices = baseSimTrackster.trackIdxs(); + + TICLCandidate& cand = mapBaseSimTsToTICLCandidate(baseSimTrackster_i); + if (baseSimObject.charge() != 0) { + for (const auto trackIndex : trackIndices) { + cand.addTrackPtr(edm::Ptr(recoTracks_h, trackIndex)); + } + } + } + } + + /* ----- Step 3 : Set pdgId, time, momentum + Time : from BaseSimObject simTime + MtdTime : from MtdSimTrackster built from the SimTrack of the genParticle (probably this needs to be clarified, not clear what happens if that simtrack never reaches MTD) + Then : + * if there is a matched reco track to SimTICLCandidate (= if base sim object is charged && there is a recotrack matched to TrackingParticle corresponding to first SimTrack, cf SimTrackstersProducer) + - energies : from subSimTracksters energies (momentum at boundary of SimTracks) + - PdgID : from baseSimObject + - charge : from baseSimObject + * if there is no matched reco track (= neutral at sim level or charged where track is not recoed good enough) + - energies : from baseSimTrackster energy (= momentum at boundary if baseSimObj SimTrack crossed boundary, otherwise SimObject energy) + - pdgId : from baseSimObject + - charge : always 0 (even if baseSimObject was charged, in this case check pdgId to get "sim" charge) + */ + auto isHad = [](int pdgId) { + pdgId = std::abs(pdgId); + if (pdgId == 111) + return false; + return (pdgId > 100 and pdgId < 900) or (pdgId > 1000 and pdgId < 9000); + }; + + for (size_t i = 0; i < result_ticlCandidates.size(); ++i) { + BaseSimObject_t const& baseSimObject = mapTICLCandidateToBaseSimObject(i); + TICLCandidate& cand = result_ticlCandidates[i]; + float rawEnergy = 0.f; + float regressedEnergy = 0.f; + + const auto& simTrack = baseSimObject.g4Tracks()[0]; + auto pos = SimTrackToMtdST.find(simTrack.trackId()); + if (pos != SimTrackToMtdST.end()) { + auto MTDst = pos->second; + // TODO: once the associators have been implemented check if the MTDst is associated with a reco before adding the MTD time + cand.setMTDTime(MTDst->time(), 0); + } + + // Time of SimVertex of genParticle + cand.setTime(baseSimTracksterToCaloParticle_map[mapTICLCandidateToBaseSimTsIndex(i)]->simTime(), 0); + + for (const auto& trackster : cand.tracksters()) { + rawEnergy += trackster->raw_energy(); + regressedEnergy += trackster->regressed_energy(); + } + cand.setRawEnergy(rawEnergy); + + auto pdgId = baseSimObject.pdgId(); + auto charge = baseSimObject.charge(); + if (cand.trackPtr().isNonnull()) { + auto const& track = cand.trackPtr().get(); + if (std::abs(pdgId) == 13) { + cand.setPdgId(pdgId); + } else { + cand.setPdgId((isHad(pdgId) ? 211 : 11) * charge); + } + cand.setCharge(charge); + math::XYZTLorentzVector p4(regressedEnergy * track->momentum().unit().x(), + regressedEnergy * track->momentum().unit().y(), + regressedEnergy * track->momentum().unit().z(), + regressedEnergy); + cand.setP4(p4); + } else { // neutral candidates + // a neutral candidate with a charged CaloParticle is charged without a reco track associated with it + // set the charge = 0, but keep the real pdgId to keep track of that + if (charge != 0) + cand.setPdgId(isHad(pdgId) ? 211 : 11); + else if (pdgId == 111) + cand.setPdgId(pdgId); + else + cand.setPdgId(isHad(pdgId) ? 130 : 22); + cand.setCharge(0); + + auto particleType = tracksterParticleTypeFromPdgId(cand.pdgId(), 1); + cand.setIdProbability(particleType, 1.f); + + const Trackster& baseSimTrackster = baseSimTracksters[mapTICLCandidateToBaseSimTsIndex(i)]; + float regressedEnergy = baseSimTrackster.regressed_energy(); + math::XYZTLorentzVector p4(regressedEnergy * baseSimTrackster.barycenter().unit().x(), + regressedEnergy * baseSimTrackster.barycenter().unit().y(), + regressedEnergy * baseSimTrackster.barycenter().unit().z(), + regressedEnergy); + cand.setP4(p4); + } + } + + evt.emplace(SimTICLCandidates_token_, std::move(result_ticlCandidates)); +} diff --git a/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc b/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc index b2af9c6774453..d193e132031ae 100644 --- a/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc +++ b/RecoHGCal/TICL/plugins/SimTrackstersProducer.cc @@ -1,85 +1,159 @@ -// Author: Felice Pantaleo, Leonardo Cristella - felice.pantaleo@cern.ch, leonardo.cristella@cern.ch -// Date: 09/2021 +/** +* Produce tracksters (in reco ticl::Trackster dataformat) from simulation truth objects. +* Multiple simTrackster collections can be built, from different simulation truth collections -// user include files +* Author: Felice Pantaleo, Leonardo Cristella - felice.pantaleo@cern.ch, leonardo.cristella@cern.ch +* Date: 09/2021 +*/ -#include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/Frameworkfwd.h" #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/Framework/interface/stream/EDProducer.h" +#include "FWCore/Framework/interface/ConsumesCollector.h" +#include "FWCore/Framework/interface/ProducesCollector.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" #include "FWCore/ParameterSet/interface/ParameterSetDescription.h" -#include "DataFormats/Common/interface/OrphanHandle.h" +#include "FWCore/ParameterSet/interface/allowedValues.h" #include "DataFormats/CaloRecHit/interface/CaloCluster.h" -#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" +#include "DataFormats/CaloRecHit/interface/CaloClusterCollection.h" #include "DataFormats/HGCalReco/interface/Trackster.h" -#include "DataFormats/HGCalReco/interface/TICLCandidate.h" #include "DataFormats/TrackReco/interface/Track.h" #include "DataFormats/TrackReco/interface/TrackFwd.h" #include "CommonTools/Utils/interface/StringCutObjectSelector.h" #include "DataFormats/Common/interface/ValueMap.h" -#include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h" -#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" +#include "DataFormats/Common/interface/AssociationMap.h" +#include "SimDataFormats/Associations/interface/TrackAssociation.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" +#include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" -#include "SimDataFormats/CaloAnalysis/interface/MtdSimTrackster.h" -#include "SimDataFormats/CaloAnalysis/interface/MtdSimTracksterFwd.h" +#include "SimDataFormats/CaloAnalysis/interface/SimClusterFwd.h" #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h" #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" #include "SimDataFormats/TrackingAnalysis/interface/UniqueSimTrackId.h" -#include "SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h" - #include "DataFormats/HGCalReco/interface/Common.h" #include #include "TrackstersPCA.h" + +#include #include -#include -#include #include -#include using namespace ticl; +namespace { + /** Association map from SimCluster/CaloParticle to layer cluster (with (score, sharedEnergy) pair) */ + template + using SimToRecoLCAssociation = edm::AssociationMap, + reco::CaloClusterCollection, + std::pair>>; + + /** Defines what is stored in a SimTrackster boundaryTime field. */ + enum class BoundaryTimeMode { + none, ///< nothing is stored + simVertexTime, ///< time of the SimVertex that created the GenParticle + boundaryTime ///< time of the SimTrack as it crossed calorimeter boundary + }; + BoundaryTimeMode stringBoundaryTimeModeToEnum(std::string s) { + if (s == "none") + return BoundaryTimeMode::none; + if (s == "simVertexTime") + return BoundaryTimeMode::simVertexTime; + if (s == "boundaryTime") + return BoundaryTimeMode::boundaryTime; + throw cms::Exception("Configuration") << "Unkown BoundaryTimeMode"; + } + + /** Configuration for producing one SimTrackster collection */ + struct SimTsConfig { + /// Simulation truth calorimeter object type (here hardcoded to SimCluster but could be updated/templated) + using SimCaloObject_t = SimCluster; + using SimCaloObjectCollection_t = SimClusterCollection; + + SimTsConfig(edm::ParameterSet const& ps, + edm::ConsumesCollector consumesCollector, + edm::ProducesCollector prodCollector) + : simclusters_token(consumesCollector.consumes( + ps.getParameter("simClusterCollection"))), + + associatorMapSimClusterToReco_token(consumesCollector.consumes>( + ps.getParameter("simClusterToLayerClusterAssociationMap"))), + simClusterToCaloParticleSC_map_token( + consumesCollector.consumes(ps.getParameter("simClusterCollection"))), + + simTrackster_token( + prodCollector.produces(ps.getParameter("outputProductLabel"))), + outputMask_token( + prodCollector.produces>(ps.getParameter("outputProductLabel"))), + simTracksterToSimCluster_map_token(prodCollector.produces>>( + ps.getParameter("outputProductLabel"))), + simTracksterToCaloParticle_map_token( + prodCollector.produces(ps.getParameter("outputProductLabel"))), + + simTracksterBoundaryTime( + stringBoundaryTimeModeToEnum(ps.getParameter("simTracksterBoundaryTime"))), + tracksterIterationIndex( + static_cast(ps.getParameter("tracksterIterationIndex"))) {} + + const edm::EDGetTokenT simclusters_token; + const edm::EDGetTokenT> associatorMapSimClusterToReco_token; + /// Map from simclusters_token collection to CaloParticle collection (here as SimCluster dataformat but 1-1 mapping to CaloParticle) + const edm::EDGetTokenT simClusterToCaloParticleSC_map_token; + + const edm::EDPutTokenT simTrackster_token; ///< output collection + /// output layer cluster mask after masking LCs from SimCluster + const edm::EDPutTokenT> outputMask_token; + // output map from SimTrackster to SimCluster it was made from (1-1 mapping except when empty simts are removed) + const edm::EDPutTokenT>> simTracksterToSimCluster_map_token; + /// output Map from SimTrackster to CaloParticle (for convenience, can be recomputed by chaining maps SimTs->SimCluster->CaloParticle) + const edm::EDPutTokenT simTracksterToCaloParticle_map_token; + + const BoundaryTimeMode simTracksterBoundaryTime; ///< configuration for setting boundary time + const ticl::Trackster::IterationIndex tracksterIterationIndex; ///< to be set in each output trackster + }; +}; // namespace + class SimTrackstersProducer : public edm::stream::EDProducer<> { public: explicit SimTrackstersProducer(const edm::ParameterSet&); static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); void produce(edm::Event&, const edm::EventSetup&) override; - void makePUTrackster(const std::vector& inputClusterMask, - std::vector& output_mask, - std::vector& result, - const edm::ProductID seed, - int loop_index); - - void addTrackster(const int index, - const std::vector, std::pair>>& lcVec, - const std::vector& inputClusterMask, - const float fractionCut_, - const float energy, - const int pdgId, - const int charge, - const float time, - const edm::ProductID seed, - const Trackster::IterationIndex iter, - std::vector& output_mask, - std::vector& result, - int& loop_index, - const bool add = false); private: + /** Holds input collection, convenience struct */ + struct InputHolder { + std::vector const& layerClusters; + edm::ValueMap> const& layerClustersTimes; + std::vector const& filtered_layerclusters_mask; + + std::vector const& trackingParticle; + + std::vector const& recoTracks; + + // Maps between reco tracks, SimTrack (=Geant4 track) and TrackingParticle (=tracking truth object for tracks) + reco::SimToRecoCollection const& TPtoRecoTrackMap; + SimTrackToTPMap const& simTrackToTPMap; + + edm::Handle caloParticles_h; + }; + + template + void produceOne(edm::Event& evt, const edm::EventSetup& es, InputHolder const& holder, SimTsConfig const& config); + + /** For HLT not all collections are always present, put empty collections in event in this case */ void returnEmptyCollections(edm::Event& e, const int lcSize); - std::string detector_; + + const std::string detector_; const bool doNose_ = false; const bool doBarrel_ = false; const bool computeLocalTime_; @@ -87,13 +161,6 @@ class SimTrackstersProducer : public edm::stream::EDProducer<> { const edm::EDGetTokenT>> clustersTime_token_; const edm::EDGetTokenT> filtered_layerclusters_mask_token_; - const edm::EDGetTokenT> simclusters_token_; - const edm::EDGetTokenT> caloparticles_token_; - const edm::EDGetTokenT MTDSimTrackstersToken_; - - const edm::EDGetTokenT> - associatorMapSimClusterToReco_token_; - const edm::EDGetTokenT> associatorMapCaloParticleToReco_token_; const edm::ESGetToken geom_token_; hgcal::RecHitTools rhtools_; const float fractionCut_; @@ -103,9 +170,13 @@ class SimTrackstersProducer : public edm::stream::EDProducer<> { const edm::EDGetTokenT> recoTracksToken_; const StringCutObjectSelector cutTk_; + // Maps between reco tracks, SimTrack (=Geant4 track) and TrackingParticle (=tracking truth object for tracks) const edm::EDGetTokenT associatormapStRsToken_; const edm::EDGetTokenT associatormapRtSsToken_; const edm::EDGetTokenT associationSimTrackToTPToken_; + + const edm::EDGetTokenT caloParticles_token_; + std::vector simTsConfigs_; }; DEFINE_FWK_MODULE(SimTrackstersProducer); @@ -118,13 +189,6 @@ SimTrackstersProducer::SimTrackstersProducer(const edm::ParameterSet& ps) clusters_token_(consumes(ps.getParameter("layer_clusters"))), clustersTime_token_(consumes(ps.getParameter("time_layerclusters"))), filtered_layerclusters_mask_token_(consumes(ps.getParameter("filtered_mask"))), - simclusters_token_(consumes(ps.getParameter("simclusters"))), - caloparticles_token_(consumes(ps.getParameter("caloparticles"))), - MTDSimTrackstersToken_(consumes(ps.getParameter("MtdSimTracksters"))), - associatorMapSimClusterToReco_token_( - consumes(ps.getParameter("layerClusterSimClusterAssociator"))), - associatorMapCaloParticleToReco_token_( - consumes(ps.getParameter("layerClusterCaloParticleAssociator"))), geom_token_(esConsumes()), fractionCut_(ps.getParameter("fractionCut")), qualityCutTrack_(ps.getParameter("qualityCutTrack")), @@ -133,14 +197,15 @@ SimTrackstersProducer::SimTrackstersProducer(const edm::ParameterSet& ps) recoTracksToken_(consumes>(ps.getParameter("recoTracks"))), cutTk_(ps.getParameter("cutTk")), associatormapStRsToken_(consumes(ps.getParameter("tpToTrack"))), - associationSimTrackToTPToken_(consumes(ps.getParameter("simTrackToTPMap"))) { - produces(); - produces>(); - produces("fromCPs"); - produces("PU"); - produces>("fromCPs"); - produces>>(); - produces>(); + associationSimTrackToTPToken_(consumes(ps.getParameter("simTrackToTPMap"))), + caloParticles_token_(consumes(ps.getParameter("caloParticles"))) { + auto const& configsParameterSets = ps.getParameter>("simClusterCollections"); + if (configsParameterSets.empty()) + edm::LogWarning("EmptyConfig") + << "No config for input SimCluster collections. SimTrackstersProducer will not produce anything "; + for (edm::ParameterSet const& configPs : configsParameterSets) { + simTsConfigs_.emplace_back(configPs, consumesCollector(), producesCollector()); + } } void SimTrackstersProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { @@ -150,13 +215,6 @@ void SimTrackstersProducer::fillDescriptions(edm::ConfigurationDescriptions& des desc.add("layer_clusters", edm::InputTag("hgcalMergeLayerClusters")); desc.add("time_layerclusters", edm::InputTag("hgcalMergeLayerClusters", "timeLayerCluster")); desc.add("filtered_mask", edm::InputTag("filteredLayerClustersSimTracksters", "ticlSimTracksters")); - desc.add("simclusters", edm::InputTag("mix", "MergedCaloTruth")); - desc.add("caloparticles", edm::InputTag("mix", "MergedCaloTruth")); - desc.add("MtdSimTracksters", edm::InputTag("mix", "MergedMtdTruthST")); - desc.add("layerClusterSimClusterAssociator", - edm::InputTag("layerClusterSimClusterAssociationProducer")); - desc.add("layerClusterCaloParticleAssociator", - edm::InputTag("layerClusterCaloParticleAssociationProducer")); desc.add("recoTracks", edm::InputTag("generalTracks")); desc.add("cutTk", "1.48 < abs(eta) < 3.0 && pt > 1. && quality(\"highPurity\") && " @@ -169,292 +227,202 @@ void SimTrackstersProducer::fillDescriptions(edm::ConfigurationDescriptions& des desc.add("fractionCut", 0.); desc.add("qualityCutTrack", 0.75); + desc.add("caloParticles", edm::InputTag("mix", "MergedCaloTruth")) + ->setComment("CaloParticle collection (only used to build 'direct' convenience map SimTrackster->CaloParticle)"); + + // Settings for individual SimCluster collections + edm::ParameterSetDescription simClusterDescValidator; + simClusterDescValidator.add("simClusterCollection") + ->setComment("Input tag for the SimCluster collection to use"); + simClusterDescValidator.add("simClusterToLayerClusterAssociationMap") + ->setComment( + "Association map simToReco mapping SimCluster (same collection as simClusterCollection) to layer cluster. " + "Type : ticl::SimToRecoCollectionWithSimClustersT for SimCluster"); + simClusterDescValidator.add("outputProductLabel") + ->setComment("Product label for output SimTrackster collection"); + simClusterDescValidator + .ifValue(edm::ParameterDescription("simTracksterBoundaryTime", "none", true), + edm::allowedValues("none", "simVertexTime", "boundaryTime")) + ->setComment( + "Set what SimTrackster timeAtBoundary is set to (note that ts.time is always set to reco time from LCs). Can " + "be 'none' (not set), 'simVertexTime' (SimVertex time of the SimTrack, aka CaloParticle.simTime(), only for " + "CaloParticle) or 'boundaryTime' (time of SimTrack at boundary) "); + simClusterDescValidator.add("tracksterIterationIndex") + ->setComment( + "IterationIndex to use for Trackster output collection. See Trackster.h (ticl::Trackster::IterationIndex " + "enum). 5=SIM (ie from SimCluster), 6=SIM_CP (ie from CaloParticle)"); + + desc.addVPSet("simClusterCollections", simClusterDescValidator, {}) // default is set in python + ->setComment("SimCluster collections to use for making SimTracksters"); + descriptions.addWithDefaultLabel(desc); } -void SimTrackstersProducer::makePUTrackster(const std::vector& inputClusterMask, - std::vector& output_mask, - std::vector& result, - const edm::ProductID seed, - int loop_index) { - Trackster tmpTrackster; - for (size_t i = 0; i < output_mask.size(); i++) { - const float remaining_fraction = output_mask[i]; - if (remaining_fraction > std::numeric_limits::epsilon()) { - tmpTrackster.vertices().push_back(i); - tmpTrackster.vertex_multiplicity().push_back(1. / remaining_fraction); - } - } - tmpTrackster.setSeed(seed, 0); - result.push_back(tmpTrackster); -} - -void SimTrackstersProducer::addTrackster( - const int index, - const std::vector, std::pair>>& lcVec, - const std::vector& inputClusterMask, - const float fractionCut_, - const float energy, - const int pdgId, - const int charge, - const float time, - const edm::ProductID seed, - const Trackster::IterationIndex iter, - std::vector& output_mask, - std::vector& result, - int& loop_index, - const bool add) { - Trackster tmpTrackster; - if (lcVec.empty()) { - result[index] = tmpTrackster; - return; - } - tmpTrackster.vertices().reserve(lcVec.size()); - tmpTrackster.vertex_multiplicity().reserve(lcVec.size()); - for (auto const& [lc, energyScorePair] : lcVec) { - if (inputClusterMask[lc.index()] > 0) { - float fraction = energyScorePair.first / lc->energy(); - if (fraction < fractionCut_) - continue; - tmpTrackster.vertices().push_back(lc.index()); - output_mask[lc.index()] -= fraction; - tmpTrackster.vertex_multiplicity().push_back(1. / fraction); +namespace { + /** Create a trackster from the given layer cluster association elements. Also updates the layer cluster mask */ + template + Trackster createTrackster( + std::vector>, std::pair>> const& lcVec, + const std::vector& inputClusterMask, + std::vector& output_mask, + float fractionCut_) { + Trackster tmpTrackster; + + tmpTrackster.vertices().reserve(lcVec.size()); + tmpTrackster.vertex_multiplicity().reserve(lcVec.size()); + for (auto const& [lcRef, energyScorePair] : lcVec) { + // lcRef is edm::Ref to CaloCluster, energyScorePair is pair + if (inputClusterMask[lcRef.index()] > 0) { + float fraction = energyScorePair.first / lcRef->energy(); + if (fraction < fractionCut_) + continue; + tmpTrackster.vertices().push_back(lcRef.index()); + output_mask[lcRef.index()] -= fraction; + tmpTrackster.vertex_multiplicity().push_back(1. / fraction); + } } + return tmpTrackster; } - - tmpTrackster.setIdProbability(tracksterParticleTypeFromPdgId(pdgId, charge), 1.f); - tmpTrackster.setRegressedEnergy(energy); - tmpTrackster.setIteration(iter); - tmpTrackster.setSeed(seed, index); - tmpTrackster.setBoundaryTime(time); - if (add) { - result[index] = tmpTrackster; - loop_index += 1; - } else { - result.push_back(tmpTrackster); - } -} - -void SimTrackstersProducer::returnEmptyCollections(edm::Event& evt, const int lcSize) { - // put into the event empty collections - auto e_result = std::make_unique(); - evt.put(std::move(e_result)); - - auto e_result_ticlCandidates = std::make_unique>(); - evt.put(std::move(e_result_ticlCandidates)); - - auto e_output_mask = std::make_unique>(); - e_output_mask->resize(lcSize, 1.f); - evt.put(std::move(e_output_mask)); - - auto e_result_fromCP = std::make_unique(); - evt.put(std::move(e_result_fromCP), "fromCPs"); - - auto e_resultPU = std::make_unique(); - evt.put(std::move(e_resultPU), "PU"); - - auto e_output_mask_fromCP = std::make_unique>(); - e_output_mask_fromCP->resize(lcSize, 1.f); - evt.put(std::move(e_output_mask_fromCP), "fromCPs"); - - auto e_cpToSc_SimTrackstersMap = std::make_unique>>(); - evt.put(std::move(e_cpToSc_SimTrackstersMap)); - - return; -} +}; // namespace void SimTrackstersProducer::produce(edm::Event& evt, const edm::EventSetup& es) { - auto result = std::make_unique(); - auto output_mask = std::make_unique>(); - auto result_fromCP = std::make_unique(); - auto resultPU = std::make_unique(); - auto output_mask_fromCP = std::make_unique>(); - auto cpToSc_SimTrackstersMap = std::make_unique>>(); - auto result_ticlCandidates = std::make_unique>(); - const auto& layerClustersHandle = evt.getHandle(clusters_token_); const auto& layerClustersTimesHandle = evt.getHandle(clustersTime_token_); const auto& inputClusterMaskHandle = evt.getHandle(filtered_layerclusters_mask_token_); - // Validate input collections if (!layerClustersHandle.isValid() || !layerClustersTimesHandle.isValid() || !inputClusterMaskHandle.isValid()) { - edm::LogWarning("SimTrackstersProducer") << "Missing input collections. Producing empty outputs."; - this->returnEmptyCollections(evt, 0); + returnEmptyCollections(evt, 0); return; } - // Proceed if inputs are valid - const auto& layerClusters = *layerClustersHandle; - const auto& layerClustersTimes = *layerClustersTimesHandle; - const auto& inputClusterMask = *inputClusterMaskHandle; - - output_mask->resize(layerClusters.size(), 1.f); - output_mask_fromCP->resize(layerClusters.size(), 1.f); - - const auto& simclusters = evt.get(simclusters_token_); - edm::Handle> caloParticles_h; - evt.getByToken(caloparticles_token_, caloParticles_h); - if (!caloParticles_h.isValid()) { - edm::LogWarning("SimTrackstersProducer") << "Missing CaloParticles."; - this->returnEmptyCollections(evt, layerClusters.size()); - return; - } - const auto& caloparticles = *caloParticles_h; - - edm::Handle MTDSimTracksters_h; - evt.getByToken(MTDSimTrackstersToken_, MTDSimTracksters_h); - - const auto& simClustersToRecoColl = evt.get(associatorMapSimClusterToReco_token_); - const auto& caloParticlesToRecoColl = evt.get(associatorMapCaloParticleToReco_token_); - edm::Handle> trackingParticles_h; evt.getByToken(trackingParticleToken_, trackingParticles_h); edm::Handle> recoTracks_h; evt.getByToken(recoTracksToken_, recoTracks_h); - //TP to reco track map + //TrackingParticle to reco track map const auto TPtoRecoTrackMapHandle = evt.getHandle(associatormapStRsToken_); + if (!TPtoRecoTrackMapHandle.isValid()) { - edm::LogWarning("SimTrackstersProducer") << "Missing TP->RecoTrack association."; - this->returnEmptyCollections(evt, layerClusters.size()); + returnEmptyCollections(evt, layerClustersHandle->size()); return; } - const auto& TPtoRecoTrackMap = *TPtoRecoTrackMapHandle; - - const auto& simTrackToTPMap = evt.get(associationSimTrackToTPToken_); - const auto& recoTracks = *recoTracks_h; const auto& geom = es.getData(geom_token_); rhtools_.setGeometry(geom); - const auto num_simclusters = simclusters.size(); - result->reserve(num_simclusters); // Conservative size, will call shrink_to_fit later - const auto num_caloparticles = caloparticles.size(); - result_fromCP->resize(num_caloparticles); - std::map SimClusterToCaloParticleMap; - int loop_index = 0; - for (const auto& [key, lcVec] : caloParticlesToRecoColl) { - auto const& cp = *(key); - auto cpIndex = &cp - &caloparticles[0]; - for (const auto& scRef : cp.simClusters()) { - auto const& sc = *(scRef); - auto const scIndex = &sc - &simclusters[0]; - SimClusterToCaloParticleMap[scIndex] = cpIndex; - } - auto regr_energy = cp.energy(); - std::vector scSimTracksterIdx; - scSimTracksterIdx.reserve(cp.simClusters().size()); - - // Create a Trackster from the object entering HGCal - if (cp.g4Tracks()[0].crossedBoundary()) { - regr_energy = cp.g4Tracks()[0].getMomentumAtBoundary().energy(); - float time = cp.g4Tracks()[0].getPositionAtBoundary().t() * - CLHEP::s; // Geant4 time is in seconds, convert to ns (CLHEP::s = 1e9) - addTrackster(cpIndex, - lcVec, - inputClusterMask, - fractionCut_, - regr_energy, - cp.pdgId(), - cp.charge(), - time, - key.id(), - ticl::Trackster::SIM, - *output_mask, - *result, - loop_index); - } else { - for (const auto& scRef : cp.simClusters()) { - const auto& it = simClustersToRecoColl.find(scRef); - if (it == simClustersToRecoColl.end()) - continue; - const auto& lcVec = it->val; - auto const& sc = *(scRef); - auto const scIndex = &sc - &simclusters[0]; - - addTrackster(scIndex, - lcVec, - inputClusterMask, - fractionCut_, - sc.g4Tracks()[0].getMomentumAtBoundary().energy(), - sc.pdgId(), - sc.charge(), - sc.g4Tracks()[0].getPositionAtBoundary().t() * - CLHEP::s, // Geant4 time is in seconds, convert to ns (CLHEP::s = 1e9) - scRef.id(), - ticl::Trackster::SIM, - *output_mask, - *result, - loop_index); - - if (result->empty()) - continue; - const auto index = result->size() - 1; - if (std::find(scSimTracksterIdx.begin(), scSimTracksterIdx.end(), index) == scSimTracksterIdx.end()) { - scSimTracksterIdx.emplace_back(index); - } - } - scSimTracksterIdx.shrink_to_fit(); - } - float time = cp.simTime(); - // Create a Trackster from any CP - addTrackster(cpIndex, - lcVec, - inputClusterMask, - fractionCut_, - regr_energy, - cp.pdgId(), - cp.charge(), - time, - key.id(), - ticl::Trackster::SIM_CP, - *output_mask_fromCP, - *result_fromCP, - loop_index, - true); - - if (result_fromCP->empty()) + InputHolder inps = InputHolder{*layerClustersHandle, + *layerClustersTimesHandle, + *inputClusterMaskHandle, + *trackingParticles_h, + *recoTracks_h, + evt.get(associatormapStRsToken_), + evt.get(associationSimTrackToTPToken_), + evt.getHandle(caloParticles_token_)}; + for (SimTsConfig const& conf : simTsConfigs_) { + produceOne(evt, es, inps, conf); + } +} + +template +void SimTrackstersProducer::produceOne(edm::Event& evt, + const edm::EventSetup& es, + InputHolder const& holder, + SimTsConfig const& config) { + edm::Handle> simclusters_h; + evt.getByToken(config.simclusters_token, simclusters_h); + const auto& simclusters = *simclusters_h; + + auto const& simClusterToCaloParticleSC_map = evt.get(config.simClusterToCaloParticleSC_map_token); + + const SimToRecoLCAssociation& simClustersToRecoColl = + evt.get(config.associatorMapSimClusterToReco_token); //*associatorMapSimClusterToReco_h; + + TracksterCollection simTracksters; // output + simTracksters.reserve(simclusters.size()); + + std::vector output_mask; + output_mask.resize(holder.layerClusters.size(), 1.f); + + /// Output map : SimTrackster -> SimCluster used to build it + edm::RefVector> simTracksterToSimObject_map(simclusters_h.id()); + simTracksterToSimObject_map.reserve(simclusters.size()); + CaloParticleRefVector simTracksterToCaloParticle_map(holder.caloParticles_h.id()); + simTracksterToCaloParticle_map.reserve(simclusters.size()); + + for (const auto& [simClusterKey, lcVec] : simClustersToRecoColl) { + // simClustersToRecoColl is ticl::SimToRecoCollectionWithSimClustersT (aka AssociationMap OneToManyWithQuality SimCluster -> many LayerCluster along with score,sharedE) + // simClusterKey is simCluster ref, lcVec is std::vector, std::pair>>& + SimCaloObject_t const& simCluster = *simClusterKey; + + if (lcVec.empty()) continue; - const auto index = loop_index - 1; - if (cpToSc_SimTrackstersMap->find(index) == cpToSc_SimTrackstersMap->end()) { - (*cpToSc_SimTrackstersMap)[index] = scSimTracksterIdx; + + Trackster simTrackster = createTrackster(lcVec, holder.filtered_layerclusters_mask, output_mask, fractionCut_); + if (simTrackster.vertices().empty()) + continue; // The sim->reco associators expect non-empty tracksters + + if (simCluster.genParticles().empty()) { + // Generic SimCluster case : encode SimTrack composition in id_probabilities of the SimTrackster (energy-weighted) + std::array id_probs{}; + for (SimTrack const& simTrack : simCluster.g4Tracks()) + id_probs[static_cast(tracksterParticleTypeFromPdgId(simTrack.type(), simTrack.charge()))] += + simTrack.momentum().E(); + float norm = 1. / std::accumulate(id_probs.begin(), id_probs.end(), 0.f); + for (std::size_t i = 0; i < id_probs.size(); i++) + id_probs[i] *= norm; + simTrackster.setProbabilities(id_probs.data()); + } else { + // In case SimCluster is linked to a genParticle (ie CaloParticle case): take info from there + simTrackster.setIdProbability( + tracksterParticleTypeFromPdgId(simCluster.genParticles()[0]->pdgId(), simCluster.genParticles()[0]->charge()), + 1.f); } + + if (simCluster.g4Tracks().at(0).crossedBoundary()) + simTrackster.setRegressedEnergy(simCluster.g4Tracks()[0].getMomentumAtBoundary().energy()); + else + simTrackster.setRegressedEnergy(simCluster.energy()); // Taken from the momentum of first simTrack of SimCluster + + simTrackster.setIteration(config.tracksterIterationIndex); + simTrackster.setSeed(simClusterKey.id(), simClusterKey.index()); + if (config.simTracksterBoundaryTime == BoundaryTimeMode::simVertexTime) { + // SimCluster dataformat does not have SimTime so we rather take it from the CaloParticle + // We use the 1-1 mapping between the SimCluster "CaloParticle" collection and the CaloParticle collection + // TODO this could be simplified eg by adding simTime field in SimCluster ? + simTrackster.setBoundaryTime( + (*holder.caloParticles_h)[simClusterToCaloParticleSC_map[simClusterKey.index()].index()].simTime()); + } else if (config.simTracksterBoundaryTime == BoundaryTimeMode::boundaryTime) + simTrackster.setBoundaryTime(simCluster.g4Tracks().at(0).getPositionAtBoundary().t() * CLHEP::s); + + simTracksters.emplace_back(std::move(simTrackster)); + simTracksterToSimObject_map.push_back(simClusterKey); + simTracksterToCaloParticle_map.push_back(edm::Ref( + holder.caloParticles_h, simClusterToCaloParticleSC_map[simClusterKey.index()].index())); } // TODO: remove time computation from PCA calculation and // store time from boundary position in simTracksters - ticl::assignPCAtoTracksters(*result, - layerClusters, - layerClustersTimes, + ticl::assignPCAtoTracksters(simTracksters, + holder.layerClusters, + holder.layerClustersTimes, rhtools_.getPositionLayer(rhtools_.lastLayerEE(doNose_)).z(), rhtools_, computeLocalTime_, true, false, doBarrel_); - result->shrink_to_fit(); - ticl::assignPCAtoTracksters(*result_fromCP, - layerClusters, - layerClustersTimes, - rhtools_.getPositionLayer(rhtools_.lastLayerEE(doNose_)).z(), - rhtools_, - computeLocalTime_, - true, - false, - doBarrel_); - - makePUTrackster(inputClusterMask, *output_mask, *resultPU, caloParticles_h.id(), 0); auto simTrackToRecoTrack = [&](UniqueSimTrackId simTkId) -> std::vector { std::vector trackIdx; - auto ipos = simTrackToTPMap.mapping.find(simTkId); - if (ipos != simTrackToTPMap.mapping.end()) { - auto jpos = TPtoRecoTrackMap.find((ipos->second)); - if (jpos != TPtoRecoTrackMap.end()) { + auto ipos = holder.simTrackToTPMap.mapping.find(simTkId); + if (ipos != holder.simTrackToTPMap.mapping.end()) { + auto jpos = holder.TPtoRecoTrackMap.find((ipos->second)); + if (jpos != holder.TPtoRecoTrackMap.end()) { auto& associatedRecoTracks = jpos->val; if (!associatedRecoTracks.empty()) { // associated reco tracks are sorted by decreasing quality if (associatedRecoTracks[0].second > qualityCutTrack_) { - trackIdx.push_back(&(*associatedRecoTracks[0].first) - &recoTracks[0]); + trackIdx.push_back(&(*associatedRecoTracks[0].first) - &holder.recoTracks[0]); } } } @@ -462,13 +430,13 @@ void SimTrackstersProducer::produce(edm::Event& evt, const edm::EventSetup& es) if (!tp.decayVertices().empty()) { const auto& iTV = tp.decayVertices()[0]; for (auto iTP = iTV->daughterTracks_begin(); iTP != iTV->daughterTracks_end(); ++iTP) { - auto kpos = TPtoRecoTrackMap.find((*iTP)); - if (kpos != TPtoRecoTrackMap.end()) { + auto kpos = holder.TPtoRecoTrackMap.find((*iTP)); + if (kpos != holder.TPtoRecoTrackMap.end()) { auto& associatedRecoTracks = kpos->val; if (!associatedRecoTracks.empty()) { // associated reco tracks are sorted by decreasing quality if (associatedRecoTracks[0].second > qualityCutTrack_) { - trackIdx.push_back(&(*associatedRecoTracks[0].first) - &recoTracks[0]); + trackIdx.push_back(&(*associatedRecoTracks[0].first) - &holder.recoTracks[0]); } } } @@ -478,150 +446,34 @@ void SimTrackstersProducer::produce(edm::Event& evt, const edm::EventSetup& es) return trackIdx; }; - // Set the reco track id to SimTrackstersFromCP - auto& simTrackstersFromCP = *result_fromCP; - for (unsigned int i = 0; i < simTrackstersFromCP.size(); ++i) { - if (simTrackstersFromCP[i].vertices().empty()) + // Set the reco track id to SimTrackster + for (unsigned int simTs_i = 0; simTs_i < simTracksters.size(); ++simTs_i) { + Trackster& simTrackster = simTracksters[simTs_i]; + if (simTrackster.vertices().empty()) continue; - const auto& simTrack = caloparticles[simTrackstersFromCP[i].seedIndex()].g4Tracks()[0]; - UniqueSimTrackId simTkIds(simTrack.trackId(), simTrack.eventId()); - auto bestAssociatedRecoTracks = simTrackToRecoTrack(simTkIds); - if (not bestAssociatedRecoTracks.empty()) { - for (auto const trackIndex : bestAssociatedRecoTracks) - simTrackstersFromCP[i].addTrackIdx(trackIndex); - } - } - - auto& simTracksters = *result; - // Set the reco track id to simTracksters - for (unsigned int i = 0; i < simTracksters.size(); ++i) { - const auto& simTrack = (simTracksters[i].seedID() == caloParticles_h.id()) - ? caloparticles[simTracksters[i].seedIndex()].g4Tracks()[0] - : simclusters[simTracksters[i].seedIndex()].g4Tracks()[0]; + const auto& simTrack = simTracksterToSimObject_map[simTs_i]->g4Tracks()[0]; UniqueSimTrackId simTkIds(simTrack.trackId(), simTrack.eventId()); auto bestAssociatedRecoTracks = simTrackToRecoTrack(simTkIds); if (not bestAssociatedRecoTracks.empty()) { for (auto const trackIndex : bestAssociatedRecoTracks) - simTracksters[i].addTrackIdx(trackIndex); - } - } - - edm::OrphanHandle> simTracksters_h = evt.put(std::move(result)); - - // map between simTrack and Mtd SimTracksters to loop on them only one - std::unordered_map SimTrackToMtdST; - for (unsigned int i = 0; i < MTDSimTracksters_h->size(); ++i) { - const auto& simTrack = (*MTDSimTracksters_h)[i].g4Tracks()[0]; - SimTrackToMtdST[simTrack.trackId()] = &((*MTDSimTracksters_h)[i]); - } - - result_ticlCandidates->resize(result_fromCP->size()); - std::vector toKeep; - for (size_t i = 0; i < simTracksters_h->size(); ++i) { - const auto& simTrackster = (*simTracksters_h)[i]; - int cp_index = (simTrackster.seedID() == caloParticles_h.id()) - ? simTrackster.seedIndex() - : SimClusterToCaloParticleMap[simTrackster.seedIndex()]; - auto const& tCP = (*result_fromCP)[cp_index]; - if (!tCP.vertices().empty()) { - auto trackIndices = tCP.trackIdxs(); - - auto& cand = (*result_ticlCandidates)[cp_index]; - cand.addTrackster(edm::Ptr(simTracksters_h, i)); - if (cand.trackPtrs().empty() and not trackIndices.empty() and caloparticles[cp_index].charge() != 0) { - for (const auto trackIndex : trackIndices) { - cand.addTrackPtr(edm::Ptr(recoTracks_h, trackIndex)); - } - } - toKeep.push_back(cp_index); + simTrackster.addTrackIdx(trackIndex); } } - auto isHad = [](int pdgId) { - pdgId = std::abs(pdgId); - if (pdgId == 111) - return false; - return (pdgId > 100 and pdgId < 900) or (pdgId > 1000 and pdgId < 9000); - }; - - for (size_t i = 0; i < result_ticlCandidates->size(); ++i) { - auto cp_index = (*result_fromCP)[i].seedIndex(); - if (cp_index < 0) - continue; - auto& cand = (*result_ticlCandidates)[i]; - const auto& cp = caloparticles[cp_index]; - float rawEnergy = 0.f; - float regressedEnergy = 0.f; - - const auto& simTrack = cp.g4Tracks()[0]; - auto pos = SimTrackToMtdST.find(simTrack.trackId()); - if (pos != SimTrackToMtdST.end()) { - auto MTDst = pos->second; - // TODO: once the associators have been implemented check if the MTDst is associated with a reco before adding the MTD time - cand.setMTDTime(MTDst->time(), 0); - } - - cand.setTime(cp.simTime(), 0); - - for (const auto& trackster : cand.tracksters()) { - rawEnergy += trackster->raw_energy(); - regressedEnergy += trackster->regressed_energy(); - } - cand.setRawEnergy(rawEnergy); - - auto pdgId = cp.pdgId(); - auto charge = cp.charge(); - if (cand.trackPtr().isNonnull()) { - auto const& track = cand.trackPtr().get(); - if (std::abs(pdgId) == 13) { - cand.setPdgId(pdgId); - } else { - cand.setPdgId((isHad(pdgId) ? 211 : 11) * charge); - } - cand.setCharge(charge); - math::XYZTLorentzVector p4(regressedEnergy * track->momentum().unit().x(), - regressedEnergy * track->momentum().unit().y(), - regressedEnergy * track->momentum().unit().z(), - regressedEnergy); - cand.setP4(p4); - } else { // neutral candidates - // a neutral candidate with a charged CaloParticle is charged without a reco track associated with it - // set the charge = 0, but keep the real pdgId to keep track of that - if (charge != 0) - cand.setPdgId(isHad(pdgId) ? 211 : 11); - else if (pdgId == 111) - cand.setPdgId(pdgId); - else - cand.setPdgId(isHad(pdgId) ? 130 : 22); - cand.setCharge(0); - - auto particleType = tracksterParticleTypeFromPdgId(cand.pdgId(), 1); - cand.setIdProbability(particleType, 1.f); - - const auto& simTracksterFromCP = (*result_fromCP)[i]; - float regressedEnergy = simTracksterFromCP.regressed_energy(); - math::XYZTLorentzVector p4(regressedEnergy * simTracksterFromCP.barycenter().unit().x(), - regressedEnergy * simTracksterFromCP.barycenter().unit().y(), - regressedEnergy * simTracksterFromCP.barycenter().unit().z(), - regressedEnergy); - cand.setP4(p4); - } - } + evt.emplace(config.simTrackster_token, std::move(simTracksters)); + evt.emplace(config.outputMask_token, std::move(output_mask)); + evt.emplace(config.simTracksterToSimCluster_map_token, std::move(simTracksterToSimObject_map)); + evt.emplace(config.simTracksterToCaloParticle_map_token, std::move(simTracksterToCaloParticle_map)); +} - std::vector all_nums(result_fromCP->size()); // vector containing all caloparticles indexes - std::iota(all_nums.begin(), all_nums.end(), 0); // fill the vector with consecutive numbers starting from 0 +void SimTrackstersProducer::returnEmptyCollections(edm::Event& evt, const int lcSize) { + edm::LogWarning("SimTrackstersProducer") << "Missing input collections. Producing empty outputs."; + // put into the event empty collections + for (SimTsConfig const& config : simTsConfigs_) { + evt.emplace(config.simTrackster_token); + evt.emplace(config.outputMask_token, lcSize, 1.f); - std::vector toRemove; - std::set_difference(all_nums.begin(), all_nums.end(), toKeep.begin(), toKeep.end(), std::back_inserter(toRemove)); - std::sort(toRemove.begin(), toRemove.end(), [](int x, int y) { return x > y; }); - for (auto const& r : toRemove) { - result_fromCP->erase(result_fromCP->begin() + r); - result_ticlCandidates->erase(result_ticlCandidates->begin() + r); + evt.emplace(config.simTracksterToSimCluster_map_token); + evt.emplace(config.simTracksterToCaloParticle_map_token); } - evt.put(std::move(result_ticlCandidates)); - evt.put(std::move(output_mask)); - evt.put(std::move(result_fromCP), "fromCPs"); - evt.put(std::move(resultPU), "PU"); - evt.put(std::move(output_mask_fromCP), "fromCPs"); - evt.put(std::move(cpToSc_SimTrackstersMap)); } diff --git a/RecoHGCal/TICL/plugins/TICLDumper.cc b/RecoHGCal/TICL/plugins/TICLDumper.cc index 622a28243d30f..8130f11ec0ec3 100644 --- a/RecoHGCal/TICL/plugins/TICLDumper.cc +++ b/RecoHGCal/TICL/plugins/TICLDumper.cc @@ -635,7 +635,6 @@ class TICLDumper : public edm::one::EDAnalyzer recoSuperClusters_caloClusters_token; edm::EDGetTokenT> recoSuperClusters_sourceTracksters_token; edm::ESGetToken caloGeometry_token_; - const edm::EDGetTokenT> simTracksters_SC_token_; // needed for simticlcandidate const edm::EDGetTokenT> simTICLCandidate_token_; // associators @@ -962,8 +961,6 @@ TICLDumper::TICLDumper(const edm::ParameterSet& ps) recoSuperClusters_sourceTracksters_token(consumes>( ps.getParameter("recoSuperClusters_sourceTracksterCollection"))), caloGeometry_token_(esConsumes()), - simTracksters_SC_token_( - consumes>(ps.getParameter("simtrackstersSC"))), simTICLCandidate_token_( consumes>(ps.getParameter("simTICLCandidates"))), associations_parameterSets_(ps.getParameter>("associators")), @@ -1382,7 +1379,6 @@ void TICLDumper::analyze(const edm::Event& event, const edm::EventSetup& setup) tracksters_trees[i]->Fill(); } - const auto& simTrackstersSC_h = event.getHandle(simTracksters_SC_token_); simTICLCandidate_tracks_in_candidate.resize(simTICLCandidates.size()); for (size_t i = 0; i < simTICLCandidates.size(); ++i) { auto const& cand = simTICLCandidates[i]; @@ -1397,8 +1393,7 @@ void TICLDumper::analyze(const edm::Event& event, const edm::EventSetup& setup) simTICLCandidate_eta.push_back(cand.eta()); std::vector tmpIdxVec; for (auto const& simTS : cand.tracksters()) { - auto trackster_idx = simTS.get() - (edm::Ptr(simTrackstersSC_h, 0)).get(); - tmpIdxVec.push_back(trackster_idx); + tmpIdxVec.push_back(simTS.key()); // Index of SimTrackster in its collection } simTICLCandidate_simTracksterCPIndex.push_back(tmpIdxVec); tmpIdxVec.clear(); @@ -1636,9 +1631,7 @@ void TICLDumper::fillDescriptions(edm::ConfigurationDescriptions& descriptions) "Trackster collection used to produce the reco::SuperCluster, used to provide a mapping back to the " "tracksters used in superclusters"); - desc.add("simtrackstersSC", edm::InputTag("ticlSimTracksters")) - ->setComment("SimTrackster from CaloParticle collection to use for simTICLcandidates"); - desc.add("simTICLCandidates", edm::InputTag("ticlSimTracksters")); + desc.add("simTICLCandidates", edm::InputTag("ticlSimTICLCandidatesFromBoundary")); desc.add>("label_rechits", {edm::InputTag("HGCalRecHit", "HGCEERecHits"), edm::InputTag("HGCalRecHit", "HGCHEFRecHits"), diff --git a/RecoHGCal/TICL/python/HLTSimTracksters_cff.py b/RecoHGCal/TICL/python/HLTSimTracksters_cff.py index b4e5b6e35f629..77969670b7092 100644 --- a/RecoHGCal/TICL/python/HLTSimTracksters_cff.py +++ b/RecoHGCal/TICL/python/HLTSimTracksters_cff.py @@ -20,17 +20,76 @@ ) hltTiclSimTracksters = _simTrackstersProducer.clone( - layerClusterCaloParticleAssociator = cms.InputTag("hltHGCalLayerClusterCaloParticleAssociation"), - layerClusterSimClusterAssociator = cms.InputTag("hltHGCalLayerClusterSimClusterAssociation"), filtered_mask = cms.InputTag("hltFilteredLayerClustersSimTracksters","hltTiclSimTracksters"), layer_clusters = cms.InputTag("hltMergeLayerClusters"), time_layerclusters = cms.InputTag("hltMergeLayerClusters","timeLayerCluster"), simTrackToTPMap = cms.InputTag("simHitTPAssocProducer","simTrackToTP"), recoTracks = cms.InputTag("hltGeneralTracks"), - simclusters = cms.InputTag("mix","MergedCaloTruth"), tpToTrack = cms.InputTag("tpToHltGeneralTrackAssociation"), - computeLocalTime = cms.bool(True) + computeLocalTime = cms.bool(True), + simClusterCollections = cms.VPSet( + # cms.PSet( # associator only for backwards compatibility (to emulate old behaviour where sometimes SimCluster had a SimTrack without crossedBoundary flag) + # outputProductLabel = cms.string('fromLegacySimCluster'), + # tracksterIterationIndex = cms.int32(5), # See Trackster.h (ticl::Trackster::IterationIndex enum). 5=SIM (ie from SimCluster), 6=SIM_CP (ie from CaloParticle) + # simClusterCollection = cms.InputTag('mix', 'MergedCaloTruth'), + # simTracksterBoundaryTime = cms.string("boundaryTime"), + # simClusterToLayerClusterAssociationMap = cms.InputTag('hltHGCalLayerClusterLegacySimClusterAssociation'), + # ), + cms.PSet( + outputProductLabel = cms.string('fromBoundarySimCluster'), + tracksterIterationIndex = cms.int32(5), + simClusterCollection = cms.InputTag('mix', 'MergedCaloTruthBoundaryTrackSimCluster'), + simTracksterBoundaryTime = cms.string("boundaryTime"), + simClusterToLayerClusterAssociationMap = cms.InputTag('hltHGCalLayerClusterSimClusterAssociation') + ), + cms.PSet( + outputProductLabel = cms.string('fromCaloParticle'), + tracksterIterationIndex = cms.int32(6), + simClusterCollection = cms.InputTag('mix', 'MergedCaloTruthCaloParticle'), + simTracksterBoundaryTime = cms.string("simVertexTime"), + simClusterToLayerClusterAssociationMap = cms.InputTag('hltHGCalLayerClusterCaloParticleAssociation') + ), + ), ) +from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 +premix_stage2.toModify(hltTiclSimTracksters, simClusterCollections={ + i : dict(simClusterCollection=cms.InputTag("mixData", pset.simClusterCollection.productInstanceLabel, pset.simClusterCollection.processName)) + for i, pset in enumerate(hltTiclSimTracksters.simClusterCollections) +}) + + +from RecoHGCal.TICL.simTICLCandidateProducerUsingSimCluster_cfi import simTICLCandidateProducerUsingSimCluster as _simTICLCandidateProducerUsingSimCluster + +_common_hltTiclSimTICLCandidates = dict( + baseCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruthCaloParticle'), # CaloParticle as SimCluster + baseSimTracksters = cms.InputTag('hltTiclSimTracksters', 'fromCaloParticle'), + baseSimTracksterToBaseSimObject_map = cms.InputTag('hltTiclSimTracksters', 'fromCaloParticle'), + baseSimTracksterToCaloParticle_map = cms.InputTag('hltTiclSimTracksters', 'fromCaloParticle'), + + MtdSimTracksters = cms.InputTag("mix", "MergedMtdTruthST"), + recoTracks = cms.InputTag("hltGeneralTracks"), +) +# hltTiclSimTICLCandidatesFromLegacy = _simTICLCandidateProducerUsingSimCluster.clone( +# **_common_hltTiclSimTICLCandidates, +# subCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruth'), # legacy SimCluster collection +# subToBaseMap = cms.InputTag('mix', 'MergedCaloTruth'), # map SimCluster -> CaloParticle +# subSimTracksters = cms.InputTag('hltTiclSimTracksters', 'fromLegacySimCluster'), +# subSimTracksterToSubSimObject_map = cms.InputTag('hltTiclSimTracksters', 'fromLegacySimCluster'), +# ) +hltTiclSimTICLCandidatesFromBoundary = _simTICLCandidateProducerUsingSimCluster.clone( + **_common_hltTiclSimTICLCandidates, + subCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruthBoundaryTrackSimCluster'), # legacy SimCluster collection + subToBaseMap = cms.InputTag('mix', 'MergedCaloTruthBoundaryTrackSimCluster'), # map SimCluster -> CaloParticle + subSimTracksters = cms.InputTag('hltTiclSimTracksters', 'fromBoundarySimCluster'), + subSimTracksterToSubSimObject_map = cms.InputTag('hltTiclSimTracksters', 'fromBoundarySimCluster'), +) +for _simProducer in [hltTiclSimTICLCandidatesFromBoundary]: # hltTiclSimTICLCandidatesFromLegacy + premix_stage2.toModify(_simProducer, + baseCaloSimObjects=cms.InputTag("mixData", _simProducer.baseCaloSimObjects.productInstanceLabel), + subCaloSimObjects=cms.InputTag("mixData", _simProducer.subCaloSimObjects.productInstanceLabel), + subToBaseMap=cms.InputTag("mixData", _simProducer.subToBaseMap.productInstanceLabel), + # MtdSimTracksters=cms.InputTag("mixData", _simProducer.MtdSimTracksters.productInstanceLabel) # MTD does not yet have premixing for MtdSimTracksters + ) from Validation.Configuration.hltHGCalSimValid_cff import * @@ -39,7 +98,8 @@ simHitTPAssocProducer, hltHgcalAssociatorsTask, hltFilteredLayerClustersSimTracksters, - hltTiclSimTracksters) + hltTiclSimTracksters, + hltTiclSimTICLCandidatesFromBoundary) hltTiclSimTrackstersSeq = cms.Sequence( hltTiclSimTrackstersTask diff --git a/RecoHGCal/TICL/python/SimTracksters_cff.py b/RecoHGCal/TICL/python/SimTracksters_cff.py index a0af7a863e4b8..3d840f46822c4 100644 --- a/RecoHGCal/TICL/python/SimTracksters_cff.py +++ b/RecoHGCal/TICL/python/SimTracksters_cff.py @@ -4,9 +4,6 @@ from RecoHGCal.TICL.filteredLayerClustersProducer_cfi import filteredLayerClustersProducer as _filteredLayerClustersProducer -# CA - PATTERN RECOGNITION - - filteredLayerClustersSimTracksters = _filteredLayerClustersProducer.clone( clusterFilter = "ClusterFilterByAlgoAndSize", min_cluster_size = 0, # inclusive @@ -14,16 +11,91 @@ ) ticlSimTracksters = _simTrackstersProducer.clone( - computeLocalTime = cms.bool(True) + computeLocalTime = cms.bool(True), + simClusterCollections = cms.VPSet( + cms.PSet( # creates a SimTrackster for every SimCluster. Creates a lot of SImTrackster (including backscattering etc) + outputProductLabel = cms.string('fromLegacySimCluster'), + tracksterIterationIndex = cms.int32(5), # See Trackster.h (ticl::Trackster::IterationIndex enum). 5=SIM (ie from SimCluster), 6=SIM_CP (ie from CaloParticle) + simClusterCollection = cms.InputTag('mix', 'MergedCaloTruth'), + simTracksterBoundaryTime = cms.string("boundaryTime"), + simClusterToLayerClusterAssociationMap = cms.InputTag('layerClusterSimClusterAssociationProducer'), + ), + cms.PSet( # the "fromBoundarySimCluster" output is what resembles the most the old behaviour : if CaloParticle simTrack crosses boundary, makes only one trackster (ignore any backscattering); + # else one trackster per simtrack crossing boundary (collapsing tracks that leave&reenter, different than previous behaviour that created a SimTrackster for backscattering that re-entered the calorimeter volume) + outputProductLabel = cms.string('fromBoundarySimCluster'), + tracksterIterationIndex = cms.int32(5), + simClusterCollection = cms.InputTag('mix', 'MergedCaloTruthBoundaryTrackSimCluster'), + simTracksterBoundaryTime = cms.string("boundaryTime"), + simClusterToLayerClusterAssociationMap = cms.InputTag('layerClusterBoundaryTrackSimClusterAssociationProducer') + ), + cms.PSet( + outputProductLabel = cms.string('fromMergedSimCluster'), + tracksterIterationIndex = cms.int32(5), + simClusterCollection = cms.InputTag('mix', 'MergedCaloTruthMergedSimCluster'), + simTracksterBoundaryTime = cms.string("boundaryTime"), # will pick the time of the first simtrack + simClusterToLayerClusterAssociationMap = cms.InputTag('layerClusterMergedSimClusterAssociationProducer') + ), + cms.PSet( + outputProductLabel = cms.string('fromCaloParticle'), + tracksterIterationIndex = cms.int32(6), + simClusterCollection = cms.InputTag('mix', 'MergedCaloTruthCaloParticle'), + simTracksterBoundaryTime = cms.string("simVertexTime"), + simClusterToLayerClusterAssociationMap = cms.InputTag('layerClusterCaloParticleSimClusterAssociationProducer') + ), + ), ) from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 -premix_stage2.toModify(ticlSimTracksters, - simclusters = "mixData:MergedCaloTruth", - caloparticles = "mixData:MergedCaloTruth", +premix_stage2.toModify(ticlSimTracksters, simClusterCollections={ + i : dict(simClusterCollection=cms.InputTag("mixData", pset.simClusterCollection.productInstanceLabel, pset.simClusterCollection.processName)) + for i, pset in enumerate(ticlSimTracksters.simClusterCollections) +}) +premix_stage2.toModify(ticlSimTracksters, caloParticles = "mixData:MergedCaloTruth") + +_simTrackstersCollections = [cms.InputTag("ticlSimTracksters", pset.outputProductLabel) for pset in ticlSimTracksters.simClusterCollections] + +from RecoHGCal.TICL.simTICLCandidateProducerUsingSimCluster_cfi import simTICLCandidateProducerUsingSimCluster as _simTICLCandidateProducerUsingSimCluster + +ticlSimTICLCandidatesFromLegacy = _simTICLCandidateProducerUsingSimCluster.clone( + baseCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruthCaloParticle'), # CaloParticle as SimCluster + subCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruth'), # legacy SimCluster collection + subToBaseMap = cms.InputTag('mix', 'MergedCaloTruth'), # map SimCluster -> CaloParticle + baseSimTracksters = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + baseSimTracksterToBaseSimObject_map = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + baseSimTracksterToCaloParticle_map = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + subSimTracksters = cms.InputTag('ticlSimTracksters', 'fromLegacySimCluster'), + subSimTracksterToSubSimObject_map = cms.InputTag('ticlSimTracksters', 'fromLegacySimCluster'), ) +ticlSimTICLCandidatesFromBoundary = _simTICLCandidateProducerUsingSimCluster.clone( + baseCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruthCaloParticle'), # CaloParticle as SimCluster + subCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruthBoundaryTrackSimCluster'), # legacy SimCluster collection + subToBaseMap = cms.InputTag('mix', 'MergedCaloTruthBoundaryTrackSimCluster'), # map SimCluster -> CaloParticle + baseSimTracksters = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + baseSimTracksterToBaseSimObject_map = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + baseSimTracksterToCaloParticle_map = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + subSimTracksters = cms.InputTag('ticlSimTracksters', 'fromBoundarySimCluster'), + subSimTracksterToSubSimObject_map = cms.InputTag('ticlSimTracksters', 'fromBoundarySimCluster'), +) +ticlSimTICLCandidatesFromMergedSimCluster = _simTICLCandidateProducerUsingSimCluster.clone( + baseCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruthCaloParticle'), # CaloParticle as SimCluster + subCaloSimObjects = cms.InputTag('mix', 'MergedCaloTruthMergedSimCluster'), # legacy SimCluster collection + subToBaseMap = cms.InputTag('mix', 'MergedCaloTruthMergedSimCluster'), # map SimCluster -> CaloParticle + baseSimTracksters = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + baseSimTracksterToBaseSimObject_map = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + baseSimTracksterToCaloParticle_map = cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), + subSimTracksters = cms.InputTag('ticlSimTracksters', 'fromMergedSimCluster'), + subSimTracksterToSubSimObject_map = cms.InputTag('ticlSimTracksters', 'fromMergedSimCluster'), +) + +for _simProducer in [ticlSimTICLCandidatesFromLegacy, ticlSimTICLCandidatesFromBoundary, ticlSimTICLCandidatesFromMergedSimCluster]: + premix_stage2.toModify(_simProducer, + baseCaloSimObjects=cms.InputTag("mixData", _simProducer.baseCaloSimObjects.productInstanceLabel), + subCaloSimObjects=cms.InputTag("mixData", _simProducer.subCaloSimObjects.productInstanceLabel), + subToBaseMap=cms.InputTag("mixData", _simProducer.subToBaseMap.productInstanceLabel), + # MtdSimTracksters=cms.InputTag("mixData", _simProducer.MtdSimTracksters.productInstanceLabel) # MTD SimTracksters do not have premixing for now + ) -ticlSimTrackstersTask = cms.Task(filteredLayerClustersSimTracksters, ticlSimTracksters) +ticlSimTrackstersTask = cms.Task(filteredLayerClustersSimTracksters, ticlSimTracksters, ticlSimTICLCandidatesFromLegacy, ticlSimTICLCandidatesFromBoundary, ticlSimTICLCandidatesFromMergedSimCluster) # BARREL @@ -35,17 +107,23 @@ ) -ticlSimTrackstersBarrel = _simTrackstersProducer.clone( +ticlSimTrackstersBarrel = ticlSimTracksters.clone( computeLocalTime = False, filtered_mask = "filteredLayerClustersSimTrackstersBarrel:ticlSimTrackstersBarrel", - layerClusterSimClusterAssociator = 'barrelLayerClusterSimClusterAssociation', - layerClusterCaloParticleAssociator = 'barrelLayerClusterCaloParticleAssociation', cutTk = cms.string('abs(eta) < 1.48 && pt > 1. && quality("highPurity") && hitPattern().numberOfLostHits("MISSING_OUTER_HITS") < 5') ) +ticlSimTICLCandidatesFromBoundaryBarrel = ticlSimTICLCandidatesFromBoundary.clone( + baseSimTracksters = cms.InputTag('ticlSimTrackstersBarrel', 'fromCaloParticle'), + baseSimTracksterToBaseSimObject_map = cms.InputTag('ticlSimTrackstersBarrel', 'fromCaloParticle'), + baseSimTracksterToCaloParticle_map = cms.InputTag('ticlSimTrackstersBarrel', 'fromCaloParticle'), + subSimTracksters = cms.InputTag('ticlSimTrackstersBarrel', 'fromBoundarySimCluster'), + subSimTracksterToSubSimObject_map = cms.InputTag('ticlSimTrackstersBarrel', 'fromBoundarySimCluster'), +) + from Configuration.ProcessModifiers.ticl_barrel_cff import ticl_barrel _ticlSimTrackstersTask = ticlSimTrackstersTask.copy() -_ticlSimTrackstersTask.add(filteredLayerClustersSimTrackstersBarrel, ticlSimTrackstersBarrel) +_ticlSimTrackstersTask.add(filteredLayerClustersSimTrackstersBarrel, ticlSimTrackstersBarrel, ticlSimTICLCandidatesFromBoundaryBarrel) ticl_barrel.toReplaceWith(ticlSimTrackstersTask, _ticlSimTrackstersTask) diff --git a/RecoHGCal/TICL/python/iterativeTICL_cff.py b/RecoHGCal/TICL/python/iterativeTICL_cff.py index a6e66118ee851..d3fb632c8427a 100644 --- a/RecoHGCal/TICL/python/iterativeTICL_cff.py +++ b/RecoHGCal/TICL/python/iterativeTICL_cff.py @@ -157,9 +157,9 @@ associatorsInstances = [] for labelts in ticlIterLabelsPSet.labels: - for labelsts in ["ticlSimTracksters", "ticlSimTrackstersfromCPs"]: - associatorsInstances.append(labelts + "To" + labelsts) - associatorsInstances.append(labelsts + "To" + labelts) + for labelsts in ['ticlSimTrackstersfromLegacySimCluster', 'ticlSimTrackstersfromBoundarySimCluster', 'ticlSimTrackstersfromCaloParticle', 'ticlSimTrackstersfromMergedSimCluster']: + associatorsInstances.append(labelts+'To'+labelsts) + associatorsInstances.append(labelsts+'To'+labelts) ticlTracksterLinksTask = cms.Task(ticlTracksterLinks, ticlSuperclusteringTask) diff --git a/RecoHGCal/TICL/python/ticlDumper_cff.py b/RecoHGCal/TICL/python/ticlDumper_cff.py index 08e3cdd9ef582..7d63ac238118d 100644 --- a/RecoHGCal/TICL/python/ticlDumper_cff.py +++ b/RecoHGCal/TICL/python/ticlDumper_cff.py @@ -8,32 +8,40 @@ from RecoHGCal.TICL.iterativeTICL_cff import ticlIterLabelsPSet, associatorsInstances -simTrackstersCollections = ["ticlSimTracksters", "ticlSimTrackstersfromCPs"] dumperAssociators = [] -for simTrackstersCollection in simTrackstersCollections: - for tracksterIteration in ticlIterLabelsPSet.labels: - suffix = "CP" if "fromCPs" in simTrackstersCollection else "SC" - dumperAssociators.append( - cms.PSet( - branchName=cms.string(tracksterIteration), - suffix=cms.string(suffix), - associatorRecoToSimInputTag=cms.InputTag(f"allTrackstersToSimTrackstersAssociationsByLCs:{tracksterIteration}To{simTrackstersCollection}"), - associatorSimToRecoInputTag=cms.InputTag(f"allTrackstersToSimTrackstersAssociationsByLCs:{simTrackstersCollection}To{tracksterIteration}") - ) +for tracksterIteration in ticlIterLabelsPSet.labels: + simTrackstersCollection = "ticlSimTrackstersfromCaloParticle" + dumperAssociators.append( + cms.PSet( + branchName=cms.string(tracksterIteration), + suffix=cms.string("CP"), + associatorRecoToSimInputTag=cms.InputTag(f"allTrackstersToSimTrackstersAssociationsByLCs:{tracksterIteration}To{simTrackstersCollection}"), + associatorSimToRecoInputTag=cms.InputTag(f"allTrackstersToSimTrackstersAssociationsByLCs:{simTrackstersCollection}To{tracksterIteration}") ) + ) + + simTrackstersCollection = "ticlSimTrackstersfromBoundarySimCluster" + dumperAssociators.append( + cms.PSet( + branchName=cms.string(tracksterIteration), + suffix=cms.string("SC"), + associatorRecoToSimInputTag=cms.InputTag(f"allTrackstersToSimTrackstersAssociationsByLCs:{tracksterIteration}To{simTrackstersCollection}"), + associatorSimToRecoInputTag=cms.InputTag(f"allTrackstersToSimTrackstersAssociationsByLCs:{simTrackstersCollection}To{tracksterIteration}") + ) + ) ticlDumper = ticlDumper_.clone( tracksterCollections = [*[cms.PSet(treeName=cms.string(label), inputTag=cms.InputTag(label)) for label in ticlIterLabelsPSet.labels], cms.PSet( treeName=cms.string("simtrackstersSC"), - inputTag=cms.InputTag("ticlSimTracksters"), + inputTag=cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), tracksterType=cms.string("SimTracksterSC") ), cms.PSet( treeName=cms.string("simtrackstersCP"), - inputTag=cms.InputTag("ticlSimTracksters", "fromCPs"), + inputTag=cms.InputTag("ticlSimTracksters", "fromCaloParticle"), tracksterType=cms.string("SimTracksterCP") ), ], @@ -45,13 +53,13 @@ ticl_superclustering_mustache_pf.toModify(ticlDumper, saveSuperclustering=False, recoSuperClusters_sourceTracksterCollection=cms.InputTag("ticlTrackstersCLUE3DHigh")) -simTrackstersBarrelCollections = ["ticlSimTrackstersBarrel", "ticlSimTrackstersBarrelfromCPs"] +simTrackstersBarrelCollections = ["ticlSimTrackstersBarrelfromBoundarySimCluster", "ticlSimTrackstersBarrelfromCaloParticle"] ticlBarrelIterLabels = ["ticlTrackstersCLUE3DBarrel"] dumperAssociatorsBarrel = [] for simTrackstersCollection in simTrackstersBarrelCollections: for tracksterIteration in ticlBarrelIterLabels: - suffix = "CP" if "fromCPs" in simTrackstersCollection else "SC" + suffix = "CP" if "fromCaloParticle" in simTrackstersCollection else "SC" dumperAssociatorsBarrel.append( cms.PSet( branchName=cms.string(tracksterIteration), @@ -64,15 +72,17 @@ dumperAssociators+=dumperAssociatorsBarrel ticl_barrel.toModify(ticlDumper, - tracksterCollections = [*[cms.PSet(treeName=cms.string(label), inputTag=cms.InputTag(label)) for label in ticlIterLabels+ticlBarrelIterLabels], - cms.PSet( + tracksterCollections = [ + *[cms.PSet(treeName=cms.string(label), inputTag=cms.InputTag(label)) for label in ticlIterLabelsPSet.labels], + *[cms.PSet(treeName=cms.string(label), inputTag=cms.InputTag(label)) for label in ticlBarrelIterLabels], + cms.PSet( treeName=cms.string("simtrackstersSC"), - inputTag=cms.InputTag("ticlSimTracksters"), + inputTag=cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), tracksterType=cms.string("SimTracksterSC") ), cms.PSet( treeName=cms.string("simtrackstersCP"), - inputTag=cms.InputTag("ticlSimTracksters", "fromCPs"), + inputTag=cms.InputTag("ticlSimTracksters", "fromCaloParticle"), tracksterType=cms.string("SimTracksterCP") ), cms.PSet( @@ -85,5 +95,5 @@ inputTag=cms.InputTag("ticlSimTrackstersBarrel", "fromCPs"), tracksterType=cms.string("SimTracksterCP") ) - ], - associators=dumperAssociators.copy()) + ], + associators=dumperAssociators.copy()) diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/AllTracksterToSimTracksterAssociatorsByHitsProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/AllTracksterToSimTracksterAssociatorsByHitsProducer.cc index e8d55ff7b865b..b291806f95b13 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/AllTracksterToSimTracksterAssociatorsByHitsProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/AllTracksterToSimTracksterAssociatorsByHitsProducer.cc @@ -8,14 +8,14 @@ #include "FWCore/Utilities/interface/EDGetToken.h" #include "DataFormats/HGCalReco/interface/Trackster.h" #include "SimDataFormats/Associations/interface/TICLAssociationMap.h" -#include "DataFormats/Provenance/interface/ProductID.h" #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" #include "DataFormats/Common/interface/RefProdVector.h" #include "DataFormats/Common/interface/MultiSpan.h" #include "DataFormats/ParticleFlowReco/interface/PFRecHit.h" -#include "DataFormats/CaloRecHit/interface/CaloCluster.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" -#include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" + +#include +#include +#include template class AllTracksterToSimTracksterAssociatorsByHitsProducerT : public edm::global::EDProducer<> { @@ -31,7 +31,12 @@ class AllTracksterToSimTracksterAssociatorsByHitsProducerT : public edm::global: void produce(edm::StreamID, edm::Event&, const edm::EventSetup&) const override; std::vector>>> tracksterCollectionTokens_; - std::vector>>> simTracksterCollectionTokens_; + struct SimTracksterInput { + std::string label; + edm::EDGetTokenT> simTracksterToken; + edm::EDGetTokenT> hitToSimClusterMapToken; + }; + std::vector simTracksterInputs_; std::vector>>> hitToTracksterMapTokens_; std::vector>>> @@ -43,20 +48,12 @@ class AllTracksterToSimTracksterAssociatorsByHitsProducerT : public edm::global: simTracksterToHitMapTokens_; edm::EDGetTokenT hitsToken_; - edm::EDGetTokenT> caloParticleToken_; - edm::EDGetTokenT> hitToSimClusterMapToken_; - edm::EDGetTokenT> hitToCaloParticleMapToken_; }; template AllTracksterToSimTracksterAssociatorsByHitsProducerT::AllTracksterToSimTracksterAssociatorsByHitsProducerT( const edm::ParameterSet& pset) - : hitsToken_(consumes(pset.getParameter("hits"))), - caloParticleToken_(consumes>(pset.getParameter("caloParticles"))), - hitToSimClusterMapToken_(consumes>( - pset.getParameter("hitToSimClusterMap"))), - hitToCaloParticleMapToken_(consumes>( - pset.getParameter("hitToCaloParticleMap"))) { + : hitsToken_(consumes(pset.getParameter("hits"))) { const auto& tracksterCollections = pset.getParameter>("tracksterCollections"); std::string allHitToTSAccoc = pset.getParameter("allHitToTSAccoc"); @@ -72,13 +69,16 @@ AllTracksterToSimTracksterAssociatorsByHitsProducerT::AllTracksterToSimTrac label, consumes>(edm::InputTag(allHitToTSAccoc, label + "ToHit"))); } - const auto& simTracksterCollections = pset.getParameter>("simTracksterCollections"); - for (const auto& tag : simTracksterCollections) { - std::string label = tag.label(); - if (!tag.instance().empty()) { - label += tag.instance(); + for (const auto& simTsPset : pset.getParameter>("simTracksters")) { + auto simTsTag = simTsPset.getParameter("simTracksterCollection"); + std::string label = simTsTag.label(); + if (!simTsTag.instance().empty()) { + label += simTsTag.instance(); } - simTracksterCollectionTokens_.emplace_back(label, consumes>(tag)); + simTracksterInputs_.push_back({label, + consumes>(simTsTag), + consumes>( + simTsPset.getParameter("hitToSimClusterMap"))}); hitToSimTracksterMapTokens_.emplace_back( label, consumes>(edm::InputTag(allHitToTSAccoc, "hitTo" + label))); simTracksterToHitMapTokens_.emplace_back( @@ -87,12 +87,12 @@ AllTracksterToSimTracksterAssociatorsByHitsProducerT::AllTracksterToSimTrac // Produce separate association maps for each trackster-simTrackster combination for (const auto& tracksterToken : tracksterCollectionTokens_) { - for (const auto& simTracksterToken : simTracksterCollectionTokens_) { - std::string instanceLabel = tracksterToken.first + "To" + simTracksterToken.first; + for (const auto& simTracksterInput : simTracksterInputs_) { + std::string instanceLabel = tracksterToken.first + "To" + simTracksterInput.label; produces, std::vector>>(instanceLabel); - std::string reverseInstanceLabel = simTracksterToken.first + "To" + tracksterToken.first; + std::string reverseInstanceLabel = simTracksterInput.label + "To" + tracksterToken.first; produces, std::vector>>(reverseInstanceLabel); @@ -110,15 +110,15 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str edm::LogWarning("AllTracksterToSimTracksterAssociatorsByHitsProducer") << "Missing MultiRecHitCollection. Association maps will be empty."; for (const auto& tracksterToken : tracksterCollectionTokens_) { - for (const auto& simTracksterToken : simTracksterCollectionTokens_) { + for (const auto& simTracksterInput : simTracksterInputs_) { iEvent.put(std::make_unique, std::vector>>(), - tracksterToken.first + "To" + simTracksterToken.first); + tracksterToken.first + "To" + simTracksterInput.label); iEvent.put(std::make_unique, std::vector>>(), - simTracksterToken.first + "To" + tracksterToken.first); + simTracksterInput.label + "To" + tracksterToken.first); } } return; @@ -140,31 +140,20 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str << "Only empty RecHitCollections found. Association maps will be empty."; for (const auto& tracksterToken : tracksterCollectionTokens_) { - for (const auto& simTracksterToken : simTracksterCollectionTokens_) { + for (const auto& simTracksterInput : simTracksterInputs_) { iEvent.put(std::make_unique, std::vector>>(), - tracksterToken.first + "To" + simTracksterToken.first); + tracksterToken.first + "To" + simTracksterInput.label); iEvent.put(std::make_unique, std::vector>>(), - simTracksterToken.first + "To" + tracksterToken.first); + simTracksterInput.label + "To" + tracksterToken.first); } } return; } - Handle> hitToSimClusterMapHandle; - iEvent.getByToken(hitToSimClusterMapToken_, hitToSimClusterMapHandle); - const auto& hitToSimClusterMap = *hitToSimClusterMapHandle; - - Handle> hitToCaloParticleMapHandle; - iEvent.getByToken(hitToCaloParticleMapToken_, hitToCaloParticleMapHandle); - const auto& hitToCaloParticleMap = *hitToCaloParticleMapHandle; - - Handle> caloParticlesHandle; - iEvent.getByToken(caloParticleToken_, caloParticlesHandle); - for (const auto& tracksterToken : tracksterCollectionTokens_) { Handle> recoTrackstersHandle; iEvent.getByToken(tracksterToken.second, recoTrackstersHandle); @@ -172,17 +161,17 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str if (!recoTrackstersHandle.isValid()) { LogDebug("AllTracksterToSimTracksterAssociatorsByHitsProducer") << "The collection " << tracksterToken.first << " is invalid. Association maps will be empty."; - for (const auto& simTracksterToken : simTracksterCollectionTokens_) { + for (const auto& simTracksterInput : simTracksterInputs_) { Handle> simTrackstersHandle; iEvent.put(std::make_unique, std::vector>>(), - tracksterToken.first + "To" + simTracksterToken.first); + tracksterToken.first + "To" + simTracksterInput.label); iEvent.put(std::make_unique, std::vector>>(), - simTracksterToken.first + "To" + tracksterToken.first); + simTracksterInput.label + "To" + tracksterToken.first); } continue; } @@ -217,19 +206,18 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str const auto& tracksterToHitMap = *tracksterToHitMapHandle; - for (const auto& simTracksterToken : simTracksterCollectionTokens_) { - Handle> simTrackstersHandle; - iEvent.getByToken(simTracksterToken.second, simTrackstersHandle); + for (const auto& simTracksterInput : simTracksterInputs_) { + Handle> simTrackstersHandle = iEvent.getHandle(simTracksterInput.simTracksterToken); if (!simTrackstersHandle.isValid()) { iEvent.put(std::make_unique, std::vector>>(), - tracksterToken.first + "To" + simTracksterToken.first); + tracksterToken.first + "To" + simTracksterInput.label); iEvent.put(std::make_unique, std::vector>>(), - simTracksterToken.first + "To" + tracksterToken.first); + simTracksterInput.label + "To" + tracksterToken.first); continue; } @@ -240,7 +228,7 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str auto simTracksterMapTokenIter = std::find_if(hitToSimTracksterMapTokens_.begin(), hitToSimTracksterMapTokens_.end(), - [&simTracksterToken](const auto& pair) { return pair.first == simTracksterToken.first; }); + [&simTracksterInput](const auto& pair) { return pair.first == simTracksterInput.label; }); if (simTracksterMapTokenIter != hitToSimTracksterMapTokens_.end()) { iEvent.getByToken(simTracksterMapTokenIter->second, hitToSimTracksterMapHandle); } @@ -251,12 +239,16 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str auto simTracksterToHitMapTokenIter = std::find_if(simTracksterToHitMapTokens_.begin(), simTracksterToHitMapTokens_.end(), - [&simTracksterToken](const auto& pair) { return pair.first == simTracksterToken.first; }); + [&simTracksterInput](const auto& pair) { return pair.first == simTracksterInput.label; }); if (simTracksterToHitMapTokenIter != simTracksterToHitMapTokens_.end()) { iEvent.getByToken(simTracksterToHitMapTokenIter->second, simTracksterToHitMapHandle); } const auto& simTracksterToHitMap = *simTracksterToHitMapHandle; + // Map hit -> SimCluster (with simfraction) + ticl::AssociationMap const& hitToSimClusterMap = + iEvent.get(simTracksterInput.hitToSimClusterMapToken); + // Create the association maps auto tracksterToSimTracksterMap = std::make_unique, @@ -294,26 +286,17 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str for (const auto& simTracksterElement : hitToSimTracksterVec) { auto simTracksterIndex = simTracksterElement.index(); const auto& simTrackster = simTracksters[simTracksterIndex]; - auto& seed = simTrackster.seedID(); + // There is no protection here from using the wrong SimCluster/CaloParticle collection + // simTrackster::seedID could be used for a check (checking that simTrackster.seedID() == the ProductID of the SimCluster collection used to make hitToSimClusterMap) + // which could be saved by using ticl::AssociationMap (which would save the RefProd in the associationMap) float simFraction = 0; - if (seed == caloParticlesHandle.id()) { - unsigned int caloParticleIndex = simTrackster.seedIndex(); - auto it = - std::find_if(hitToCaloParticleMap[hitIndex].begin(), - hitToCaloParticleMap[hitIndex].end(), - [caloParticleIndex](const auto& pair) { return pair.index() == caloParticleIndex; }); - if (it != hitToCaloParticleMap[hitIndex].end()) { - simFraction = it->fraction(); - } - } else { - unsigned int simClusterIndex = simTracksters[simTracksterIndex].seedIndex(); - auto it = std::find_if(hitToSimClusterMap[hitIndex].begin(), - hitToSimClusterMap[hitIndex].end(), - [simClusterIndex](const auto& pair) { return pair.index() == simClusterIndex; }); - if (it != hitToSimClusterMap[hitIndex].end()) { - simFraction = it->fraction(); - } + unsigned int simClusterIndex = simTrackster.seedIndex(); + auto it = std::find_if(hitToSimClusterMap[hitIndex].begin(), + hitToSimClusterMap[hitIndex].end(), + [simClusterIndex](const auto& pair) { return pair.index() == simClusterIndex; }); + if (it != hitToSimClusterMap[hitIndex].end()) { + simFraction = it->fraction(); } hitToAssociatedSimTracksterMap.insert(i, simTracksterIndex, simFraction); @@ -376,21 +359,17 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str simTracksterHitsAndFractions.size()); std::vector associatedRecoTracksterIndices; const auto& simTrackster = simTracksters[tracksterIndex]; - auto& seed = simTrackster.seedID(); unsigned int simObjectIndex = simTrackster.seedIndex(); - bool isSimTracksterFromCP = (seed == caloParticlesHandle.id()); std::vector simFractions(simTracksterHitsAndFractions.size(), 0.f); + /* simTracksterToHitMap is built from reco LayerCluster, thus the fractions from here are constant across a reco LC + We want to use the individual hit fractions, thus we use simTracksterToHitMap to find a superset of hits of the SimCluster from this SimTrackster + Then we use the hit->SimCluster map to get the simFraction for that hit (which could be 0) */ for (unsigned int i = 0; i < simTracksterHitsAndFractions.size(); ++i) { auto hitIndex = simTracksterHitsAndFractions[i].index(); - auto it = isSimTracksterFromCP - ? (std::find_if(hitToCaloParticleMap[hitIndex].begin(), - hitToCaloParticleMap[hitIndex].end(), - [simObjectIndex](const auto& pair) { return pair.index() == simObjectIndex; })) - : std::find_if(hitToSimClusterMap[hitIndex].begin(), - hitToSimClusterMap[hitIndex].end(), - [simObjectIndex](const auto& pair) { return pair.index() == simObjectIndex; }); - if ((isSimTracksterFromCP and it != hitToCaloParticleMap[hitIndex].end()) or - (!isSimTracksterFromCP and it != hitToSimClusterMap[hitIndex].end())) { + auto it = std::find_if(hitToSimClusterMap[hitIndex].begin(), + hitToSimClusterMap[hitIndex].end(), + [simObjectIndex](const auto& pair) { return pair.index() == simObjectIndex; }); + if (it != hitToSimClusterMap[hitIndex].end()) { simFractions[i] = it->fraction(); } float simFraction = simFractions[i]; @@ -425,6 +404,16 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str } } } + + if (simToRecoScoresDenominator <= 0.f) { + throw edm::Exception(edm::errors::InvalidReference) + << "SimTrackster with index " << tracksterIndex + << " has simToRecoScoresDenominator <= 0, which would lead to a division by zero in the score " + "calculation. " + << "This likely means that the SimTrackster is not properly associated to any hits or that the hit " + "energies are zero. " + << "Provenance of simTrackster collection : " << "label = " << *simTrackstersHandle.provenance(); + } assert(simToRecoScoresDenominator > 0.f); const float invDenominator = 1.f / simToRecoScoresDenominator; for (unsigned int i = 0; i < simTracksterHitsAndFractions.size(); ++i) { @@ -467,8 +456,8 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::produce(edm::Str simTracksterToTracksterMap->sort(sortingFunc); // After populating the maps, store them in the event - iEvent.put(std::move(tracksterToSimTracksterMap), tracksterToken.first + "To" + simTracksterToken.first); - iEvent.put(std::move(simTracksterToTracksterMap), simTracksterToken.first + "To" + tracksterToken.first); + iEvent.put(std::move(tracksterToSimTracksterMap), tracksterToken.first + "To" + simTracksterInput.label); + iEvent.put(std::move(simTracksterToTracksterMap), simTracksterInput.label + "To" + tracksterToken.first); } } } @@ -480,13 +469,19 @@ void AllTracksterToSimTracksterAssociatorsByHitsProducerT::fillDescriptions desc.add("allHitToTSAccoc", "allHitToTracksterAssociations"); desc.add>( "tracksterCollections", {edm::InputTag("ticlTrackstersCLUE3DHigh"), edm::InputTag("ticlTrackstersLinks")}); - desc.add>( - "simTracksterCollections", {edm::InputTag("ticlSimTracksters"), edm::InputTag("ticlSimTracksters", "fromCPs")}); - desc.add("hitToSimClusterMap", - edm::InputTag("hitToSimClusterCaloParticleAssociator", "hitToSimClusterMap")); - desc.add("hitToCaloParticleMap", - edm::InputTag("hitToSimClusterCaloParticleAssociator", "hitToCaloParticleMap")); - desc.add("caloParticles", edm::InputTag("mix", "MergedCaloTruth")); + + // Settings for SimTrackster collections + edm::ParameterSetDescription simTrackstersDescValidator; + simTrackstersDescValidator.add("simTracksterCollection") + ->setComment("Input tag for the SimTrackster collection to use"); + simTrackstersDescValidator.add("hitToSimClusterMap") + ->setComment( + "Association map from hit to SimCluster (with simFraction : ticl::AssociationMap). " + "Needs to map into the SimCluster collection that was used to build the SimTracksters. Produced by " + "HitToSimClusterCaloParticleAssociatorProducer"); + desc.addVPSet("simTracksters", simTrackstersDescValidator, {}) // default is set in python + ->setComment("SimTracksters collection settings"); + if constexpr (std::is_same_v) { desc.add("hits", edm::InputTag("recHitMapProducer", "RefProdVectorHGCRecHitCollection")); descriptions.add("AllTracksterToSimTracksterAssociatorsByHitsProducer", desc); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.cc index 8db7aef3bd0dd..29e710d70d718 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.cc @@ -1,30 +1,50 @@ // Author: Felice Pantaleo, felice.pantaleo@cern.ch 06/2024 -#include "HitToSimClusterCaloParticleAssociatorProducer.h" +#include "FWCore/Framework/interface/global/EDProducer.h" #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" #include "FWCore/Framework/interface/ESHandle.h" #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "FWCore/Utilities/interface/EDGetToken.h" + #include "DataFormats/HGCalReco/interface/Trackster.h" #include "DataFormats/CaloRecHit/interface/CaloCluster.h" #include "SimDataFormats/Associations/interface/TICLAssociationMap.h" #include "DataFormats/Provenance/interface/ProductID.h" #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" +#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h" #include "DataFormats/Common/interface/RefProdVector.h" #include "DataFormats/Common/interface/MultiSpan.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" +template +class HitToSimClusterCaloParticleAssociatorProducerT : public edm::global::EDProducer<> { +public: + using multiCollectionT = edm::RefProdVector>; + + explicit HitToSimClusterCaloParticleAssociatorProducerT(const edm::ParameterSet &); + ~HitToSimClusterCaloParticleAssociatorProducerT() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); + +private: + void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; + + const edm::EDGetTokenT> simClusterToken_; + const edm::EDGetTokenT> caloParticleToken_; + + const edm::EDGetTokenT> hitMapToken_; + edm::EDGetTokenT hitsToken_; +}; + template HitToSimClusterCaloParticleAssociatorProducerT::HitToSimClusterCaloParticleAssociatorProducerT( const edm::ParameterSet &pset) : simClusterToken_(consumes>(pset.getParameter("simClusters"))), - caloParticleToken_(consumes>(pset.getParameter("caloParticles"))), hitMapToken_(consumes>(pset.getParameter("hitMap"))), hitsToken_(consumes(pset.getParameter("hits"))) { - produces>("hitToSimClusterMap"); - produces>("hitToCaloParticleMap"); + produces>(); } template @@ -33,12 +53,7 @@ void HitToSimClusterCaloParticleAssociatorProducerT::produce(edm::StreamID, const edm::EventSetup &iSetup) const { using namespace edm; - Handle> caloParticlesHandle; - iEvent.getByToken(caloParticleToken_, caloParticlesHandle); - const auto &caloParticles = *caloParticlesHandle; - - Handle> simClustersHandle; - iEvent.getByToken(simClusterToken_, simClustersHandle); + std::vector simClusters = iEvent.get(simClusterToken_); Handle> hitMap; iEvent.getByToken(hitMapToken_, hitMap); @@ -46,8 +61,7 @@ void HitToSimClusterCaloParticleAssociatorProducerT::produce(edm::StreamID, edm::LogWarning("HitToSimClusterCaloParticleAssociatorProducer") << "RecHitCollections is invalid. Association maps will be empty."; // Store empty maps in the event - iEvent.put(std::make_unique>(), "hitToSimClusterMap"); - iEvent.put(std::make_unique>(), "hitToCaloParticleMap"); + iEvent.put(std::make_unique>()); return; } @@ -66,41 +80,31 @@ void HitToSimClusterCaloParticleAssociatorProducerT::produce(edm::StreamID, LogDebug("HitToSimClusterCaloParticleAssociatorProducer") << "RecHitCollection is empty. Association maps will be empty."; // Store empty maps in the event - iEvent.put(std::make_unique>(), "hitToSimClusterMap"); - iEvent.put(std::make_unique>(), "hitToCaloParticleMap"); + iEvent.put(std::make_unique>()); return; } // Create association maps auto hitToSimClusterMap = std::make_unique>(rechitSpan.size()); - auto hitToCaloParticleMap = std::make_unique>(rechitSpan.size()); - - // Loop over caloParticles - for (unsigned int cpId = 0; cpId < caloParticles.size(); ++cpId) { - const auto &caloParticle = caloParticles[cpId]; - // Loop over simClusters in caloParticle - for (const auto &simCluster : caloParticle.simClusters()) { - // Loop over hits in simCluster - for (const auto &hitAndFraction : simCluster->hits_and_fractions()) { - auto hitMapIter = hitMap->find(hitAndFraction.first); - if (hitMapIter != hitMap->end()) { - unsigned int rechitIndex = hitMapIter->second; - float fraction = hitAndFraction.second; - hitToSimClusterMap->insert(rechitIndex, simCluster.key(), fraction); - hitToCaloParticleMap->insert(rechitIndex, cpId, fraction); - } + + for (std::size_t scId = 0; scId < simClusters.size(); ++scId) { + // Loop over hits in simCluster + for (const auto &hitAndFraction : simClusters[scId].hits_and_fractions()) { + auto hitMapIter = hitMap->find(hitAndFraction.first); + if (hitMapIter != hitMap->end()) { + unsigned int rechitIndex = hitMapIter->second; + float fraction = hitAndFraction.second; + hitToSimClusterMap->insert(rechitIndex, scId, fraction); } } } - iEvent.put(std::move(hitToSimClusterMap), "hitToSimClusterMap"); - iEvent.put(std::move(hitToCaloParticleMap), "hitToCaloParticleMap"); + iEvent.put(std::move(hitToSimClusterMap)); } template void HitToSimClusterCaloParticleAssociatorProducerT::fillDescriptions( edm::ConfigurationDescriptions &descriptions) { edm::ParameterSetDescription desc; - desc.add("caloParticles", edm::InputTag("mix", "MergedCaloTruth")); desc.add("simClusters", edm::InputTag("mix", "MergedCaloTruth")); if constexpr (std::is_same_v) { diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.h deleted file mode 100644 index b3f5912de75ad..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/HitToSimClusterCaloParticleAssociatorProducer.h +++ /dev/null @@ -1,45 +0,0 @@ -#ifndef SimCalorimetry_HGCalAssociatorProducers_HitToSimClusterCaloParticleAssociatorProducerT_h -#define SimCalorimetry_HGCalAssociatorProducers_HitToSimClusterCaloParticleAssociatorProducerT_h - -// Author: Felice Pantaleo, felice.pantaleo@cern.ch 06/2024 - -// user include files -#include "FWCore/Framework/interface/global/EDProducer.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/Utilities/interface/EDGetToken.h" -#include "DataFormats/HGCalReco/interface/Trackster.h" -#include "DataFormats/CaloRecHit/interface/CaloCluster.h" -#include "SimDataFormats/Associations/interface/TICLAssociationMap.h" -#include "DataFormats/Provenance/interface/ProductID.h" -#include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" -#include "DataFormats/Common/interface/RefProdVector.h" -#include "DataFormats/Common/interface/MultiSpan.h" -#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" -#include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" - -template -class HitToSimClusterCaloParticleAssociatorProducerT : public edm::global::EDProducer<> { -public: - using multiCollectionT = edm::RefProdVector>; - - explicit HitToSimClusterCaloParticleAssociatorProducerT(const edm::ParameterSet &); - ~HitToSimClusterCaloParticleAssociatorProducerT() override = default; - - static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); - -private: - void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; - - const edm::EDGetTokenT> simClusterToken_; - const edm::EDGetTokenT> caloParticleToken_; - - const edm::EDGetTokenT> hitMapToken_; - edm::EDGetTokenT hitsToken_; -}; - -#endif diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc deleted file mode 100644 index 0eb1df76d3ec8..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.cc +++ /dev/null @@ -1,575 +0,0 @@ -// Original Author: Marco Rovere -// - -#include "LCToCPAssociatorByEnergyScoreImpl.h" -#include - -#include "DataFormats/Common/interface/MultiSpan.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" -#include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" -#include "DataFormats/CaloRecHit/interface/CaloCluster.h" -#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" -#include "SimCalorimetry/HGCalAssociatorProducers/interface/AssociatorTools.h" -#include "DataFormats/EcalDetId/interface/EBDetId.h" - -template -LCToCPAssociatorByEnergyScoreImplT::LCToCPAssociatorByEnergyScoreImplT( - edm::EDProductGetter const& productGetter, - bool hardScatterOnly, - std::shared_ptr recHitTools, - const std::unordered_map* hitMap, - const multiCollectionT& hits) - : hardScatterOnly_(hardScatterOnly), - recHitTools_(recHitTools), - hitMap_(hitMap), - productGetter_(&productGetter), - hits_(hits) { - if constexpr (std::is_same_v) - layers_ = recHitTools_->lastLayerBH(); - else - layers_ = recHitTools_->lastLayerBarrel() + 1; -} - -template -ticl::association LCToCPAssociatorByEnergyScoreImplT::makeConnections( - const edm::Handle& cCCH, const edm::Handle& cPCH) const { - // Get collections - const auto& clusters = *cCCH.product(); - const auto& caloParticles = *cPCH.product(); - auto nLayerClusters = clusters.size(); - - //Consider CaloParticles coming from the hard scatterer, excluding the PU contribution and save the indices. - std::vector cPIndices; - removeCPFromPU(caloParticles, cPIndices, hardScatterOnly_); - auto nCaloParticles = cPIndices.size(); - - // Initialize cPOnLayer. It contains the caloParticleOnLayer structure for all CaloParticles in each layer and - // among other the information to compute the CaloParticle-To-LayerCluster score. It is one of the two objects that - // build the output of the makeConnections function. - // cPOnLayer[cpId][layerId] - ticl::caloParticleToLayerCluster cPOnLayer; - cPOnLayer.resize(nCaloParticles); - for (unsigned int i = 0; i < nCaloParticles; ++i) { - unsigned int nLayers = layers_ * 2; - if constexpr (std::is_same_v) - nLayers = layers_; - cPOnLayer[i].resize(nLayers); - for (unsigned int j = 0; j < nLayers; ++j) { - cPOnLayer[i][j].caloParticleId = i; - cPOnLayer[i][j].energy = 0.f; - cPOnLayer[i][j].hits_and_fractions.clear(); - //cPOnLayer[i][j].layerClusterIdToEnergyAndScore.reserve(nLayerClusters); // Not necessary but may improve performance - } - } - - // Fill detIdToCaloParticleId_Map and update cPOnLayer - // The detIdToCaloParticleId_Map is used to connect a hit Detid (key) with all the CaloParticles that - // contributed to that hit by storing the CaloParticle id and the fraction of the hit. Observe here - // that all the different contributions of the same CaloParticle to a single hit (coming from their - // internal SimClusters) are merged into a single entry with the fractions properly summed. - std::unordered_map> detIdToCaloParticleId_Map; - edm::MultiSpan hitsMS(hits_); - - for (const auto& cpId : cPIndices) { - const SimClusterRefVector& simClusterRefVector = caloParticles[cpId].simClusters(); - for (const auto& it_sc : simClusterRefVector) { - const SimCluster& simCluster = (*(it_sc)); - std::vector> hits_and_fractions; - if constexpr (std::is_same_v) - hits_and_fractions = simCluster.filtered_hits_and_fractions( - [this](const DetId& detid) { return !recHitTools_->isBarrel(detid); }); - else - hits_and_fractions = simCluster.filtered_hits_and_fractions( - [this](const DetId& detid) { return recHitTools_->isBarrel(detid); }); - for (const auto& it_haf : hits_and_fractions) { - const auto hitid = (it_haf.first); - unsigned int cpLayerId = recHitTools_->getLayerWithOffset(hitid); - if constexpr (std::is_same_v) - cpLayerId += layers_ * ((recHitTools_->zside(hitid) + 1) >> 1) - 1; - - const auto itcheck = hitMap_->find(hitid); - - if (itcheck != hitMap_->end()) { - auto hit_find_it = detIdToCaloParticleId_Map.find(hitid); - if (hit_find_it == detIdToCaloParticleId_Map.end()) { - detIdToCaloParticleId_Map[hitid] = std::vector(); - detIdToCaloParticleId_Map[hitid].emplace_back(cpId, it_haf.second); - } else { - auto findHitIt = std::find(detIdToCaloParticleId_Map[hitid].begin(), - detIdToCaloParticleId_Map[hitid].end(), - ticl::detIdInfoInCluster{cpId, it_haf.second}); - if (findHitIt != detIdToCaloParticleId_Map[hitid].end()) { - findHitIt->fraction += it_haf.second; - } else { - detIdToCaloParticleId_Map[hitid].emplace_back(cpId, it_haf.second); - } - } - const HIT* hit = &hitsMS[itcheck->second]; - cPOnLayer[cpId][cpLayerId].energy += it_haf.second * hit->energy(); - // We need to compress the hits and fractions in order to have a - // reasonable score between CP and LC. Imagine, for example, that a - // CP has detID X used by 2 SimClusters with different fractions. If - // a single LC uses X with fraction 1 and is compared to the 2 - // contributions separately, it will be assigned a score != 0, which - // is wrong. - auto& haf = cPOnLayer[cpId][cpLayerId].hits_and_fractions; - auto found = std::find_if( - std::begin(haf), std::end(haf), [&hitid](const std::pair& v) { return v.first == hitid; }); - if (found != haf.end()) { - found->second += it_haf.second; - } else { - cPOnLayer[cpId][cpLayerId].hits_and_fractions.emplace_back(hitid, it_haf.second); - } - } - } - } - } - -#ifdef EDM_ML_DEBUG - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "cPOnLayer INFO" << std::endl; - for (size_t cp = 0; cp < cPOnLayer.size(); ++cp) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "For CaloParticle Idx: " << cp << " we have: " << std::endl; - for (size_t cpp = 0; cpp < cPOnLayer[cp].size(); ++cpp) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " On Layer: " << cpp << " we have:" << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << " CaloParticleIdx: " << cPOnLayer[cp][cpp].caloParticleId << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << " Energy: " << cPOnLayer[cp][cpp].energy << std::endl; - double tot_energy = 0.; - for (auto const& haf : cPOnLayer[cp][cpp].hits_and_fractions) { - //const HIT* hit = &(hits_[hitMap_->at(DetId(haf.first))]); - const HIT* hit = &hitsMS[hitMap_->at(haf.first)]; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" - << haf.second << "/" << haf.second * hit->energy() << std::endl; - tot_energy += haf.second * hit->energy(); - } - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Tot Sum haf: " << tot_energy << std::endl; - for (auto const& lc : cPOnLayer[cp][cpp].layerClusterIdToEnergyAndScore) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " lcIdx/energy/score: " << lc.first << "/" - << lc.second.first << "/" << lc.second.second << std::endl; - } - } - } - - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "detIdToCaloParticleId_Map INFO" << std::endl; - for (auto const& cp : detIdToCaloParticleId_Map) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << "For detId: " << (uint32_t)cp.first - << " we have found the following connections with CaloParticles:" << std::endl; - const HIT* hit = &hitsMS[hitMap_->at(cp.first)]; - for (auto const& cpp : cp.second) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << " CaloParticle Id: " << cpp.clusterId << " with fraction: " << cpp.fraction - << " and energy: " << cpp.fraction * hit->energy() << std::endl; - } - } -#endif - - // Fill detIdToLayerClusterId_Map and cpsInLayerCluster; update cPOnLayer - std::unordered_map> detIdToLayerClusterId_Map; - // this contains the ids of the caloparticles contributing with at least one - // hit to the layer cluster and the reconstruction error. To be returned - // since this contains the information to compute the - // LayerCluster-To-CaloParticle score. - ticl::layerClusterToCaloParticle cpsInLayerCluster; - cpsInLayerCluster.resize(nLayerClusters); - - for (unsigned int lcId = 0; lcId < nLayerClusters; ++lcId) { - const std::vector>& hits_and_fractions = clusters[lcId].hitsAndFractions(); - unsigned int numberOfHitsInLC = hits_and_fractions.size(); - const auto firstHitDetId = hits_and_fractions[0].first; - unsigned int lcLayerId = recHitTools_->getLayerWithOffset(firstHitDetId); - if constexpr (std::is_same_v) - lcLayerId += layers_ * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1; - for (unsigned int hitId = 0; hitId < numberOfHitsInLC; hitId++) { - const auto rh_detid = hits_and_fractions[hitId].first; - const auto rhFraction = hits_and_fractions[hitId].second; - - auto hit_find_in_LC = detIdToLayerClusterId_Map.find(rh_detid); - if (hit_find_in_LC == detIdToLayerClusterId_Map.end()) { - detIdToLayerClusterId_Map[rh_detid] = std::vector(); - } - detIdToLayerClusterId_Map[rh_detid].emplace_back(lcId, rhFraction); - - auto hit_find_in_CP = detIdToCaloParticleId_Map.find(rh_detid); - - if (hit_find_in_CP != detIdToCaloParticleId_Map.end()) { - const auto itcheck = hitMap_->find(rh_detid); - const HIT* hit = &hitsMS[itcheck->second]; - for (auto& h : hit_find_in_CP->second) { - cPOnLayer[h.clusterId][lcLayerId].layerClusterIdToEnergyAndScore[lcId].first += h.fraction * hit->energy(); - cpsInLayerCluster[lcId].emplace_back(h.clusterId, 0.f); - } - } - } // End loop over hits on a LayerCluster - } // End of loop over LayerClusters - -#ifdef EDM_ML_DEBUG - for (unsigned int lcId = 0; lcId < nLayerClusters; ++lcId) { - const auto& hits_and_fractions = clusters[lcId].hitsAndFractions(); - unsigned int numberOfHitsInLC = hits_and_fractions.size(); - const auto firstHitDetId = hits_and_fractions[0].first; - int lcLayerId = recHitTools_->getLayerWithOffset(firstHitDetId); - if constexpr (std::is_same_v) - lcLayerId += layers_ * ((recHitTools_->zside(firstHitDetId) + 1) >> 1) - 1; - // This vector will store, for each hit in the Layercluster, the index of - // the CaloParticle that contributed the most, in terms of energy, to it. - // Special values are: - // - // -2 --> the reconstruction fraction of the RecHit is 0 (used in the past to monitor Halo Hits) - // -3 --> same as before with the added condition that no CaloParticle has been linked to this RecHit - // -1 --> the reco fraction is >0, but no CaloParticle has been linked to it - // >=0 --> index of the linked CaloParticle - std::vector hitsToCaloParticleId(numberOfHitsInLC); - // This will store the index of the CaloParticle linked to the LayerCluster that has the most number of hits in common. - int maxCPId_byNumberOfHits = -1; - // This will store the maximum number of shared hits between a Layercluster andd a CaloParticle - unsigned int maxCPNumberOfHitsInLC = 0; - // This will store the index of the CaloParticle linked to the LayerCluster that has the most energy in common. - int maxCPId_byEnergy = -1; - // This will store the maximum number of shared energy between a Layercluster and a CaloParticle - float maxEnergySharedLCandCP = 0.f; - // This will store the fraction of the LayerCluster energy shared with the best(energy) CaloParticle: e_shared/lc_energy - float energyFractionOfLCinCP = 0.f; - // This will store the fraction of the CaloParticle energy shared with the LayerCluster: e_shared/cp_energy - float energyFractionOfCPinLC = 0.f; - std::unordered_map occurrencesCPinLC; - unsigned int numberOfNoiseHitsInLC = 0; - std::unordered_map CPEnergyInLC; - for (unsigned int hitId = 0; hitId < numberOfHitsInLC; hitId++) { - const auto rh_detid = hits_and_fractions[hitId].first; - const auto rhFraction = hits_and_fractions[hitId].second; - - auto hit_find_in_CP = detIdToCaloParticleId_Map.find(rh_detid); - - // if the fraction is zero or the hit does not belong to any calo - // particle, set the caloparticleId for the hit to -1 this will - // contribute to the number of noise hits - - // MR Remove the case in which the fraction is 0, since this could be a - // real hit that has been marked as halo. - if (rhFraction == 0.) { - hitsToCaloParticleId[hitId] = -2; - } - if (hit_find_in_CP == detIdToCaloParticleId_Map.end()) { - hitsToCaloParticleId[hitId] -= 1; - } else { - const HIT* hit = &hitsMS[hitMap_->at(rh_detid)]; - auto maxCPEnergyInLC = 0.f; - auto maxCPId = -1; - for (auto& h : hit_find_in_CP->second) { - CPEnergyInLC[h.clusterId] += h.fraction * hit->energy(); - // Keep track of which CaloParticle ccontributed the most, in terms - // of energy, to this specific LayerCluster. - if (CPEnergyInLC[h.clusterId] > maxCPEnergyInLC) { - maxCPEnergyInLC = CPEnergyInLC[h.clusterId]; - maxCPId = h.clusterId; - } - } - hitsToCaloParticleId[hitId] = maxCPId; - } - } // End loop over hits on a LayerCluster - for (const auto& c : hitsToCaloParticleId) { - if (c < 0) { - numberOfNoiseHitsInLC++; - } else { - occurrencesCPinLC[c]++; - } - } - - for (const auto& c : occurrencesCPinLC) { - if (c.second > maxCPNumberOfHitsInLC) { - maxCPId_byNumberOfHits = c.first; - maxCPNumberOfHitsInLC = c.second; - } - } - - for (const auto& c : CPEnergyInLC) { - if (c.second > maxEnergySharedLCandCP) { - maxCPId_byEnergy = c.first; - maxEnergySharedLCandCP = c.second; - } - } - - float totalCPEnergyOnLayer = 0.f; - if (maxCPId_byEnergy >= 0) { - totalCPEnergyOnLayer = cPOnLayer[maxCPId_byEnergy][lcLayerId].energy; - energyFractionOfCPinLC = maxEnergySharedLCandCP / totalCPEnergyOnLayer; - if (clusters[lcId].energy() > 0.f) { - energyFractionOfLCinCP = maxEnergySharedLCandCP / clusters[lcId].energy(); - } - } - - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << std::setw(10) << "LayerId:\t" << std::setw(12) << "layerCluster\t" << std::setw(10) << "lc energy\t" - << std::setw(5) << "nhits\t" << std::setw(12) << "noise hits\t" << std::setw(22) << "maxCPId_byNumberOfHits\t" - << std::setw(8) << "nhitsCP\t" << std::setw(13) << "maxCPId_byEnergy\t" << std::setw(20) - << "maxEnergySharedLCandCP\t" << std::setw(22) << "totalCPEnergyOnLayer\t" << std::setw(22) - << "energyFractionOfLCinCP\t" << std::setw(25) << "energyFractionOfCPinLC\t" - << "\n"; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << std::setw(10) << lcLayerId << "\t" << std::setw(12) << lcId << "\t" << std::setw(10) - << clusters[lcId].energy() << "\t" << std::setw(5) << numberOfHitsInLC << "\t" << std::setw(12) - << numberOfNoiseHitsInLC << "\t" << std::setw(22) << maxCPId_byNumberOfHits << "\t" << std::setw(8) - << maxCPNumberOfHitsInLC << "\t" << std::setw(13) << maxCPId_byEnergy << "\t" << std::setw(20) - << maxEnergySharedLCandCP << "\t" << std::setw(22) << totalCPEnergyOnLayer << "\t" << std::setw(22) - << energyFractionOfLCinCP << "\t" << std::setw(25) << energyFractionOfCPinLC << "\n"; - } // End of loop over LayerClusters - - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "Improved cPOnLayer INFO" << std::endl; - for (size_t cp = 0; cp < cPOnLayer.size(); ++cp) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "For CaloParticle Idx: " << cp << " we have: " << std::endl; - for (size_t cpp = 0; cpp < cPOnLayer[cp].size(); ++cpp) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " On Layer: " << cpp << " we have:" << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << " CaloParticleIdx: " << cPOnLayer[cp][cpp].caloParticleId << std::endl; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << " Energy: " << cPOnLayer[cp][cpp].energy << std::endl; - double tot_energy = 0.; - for (auto const& haf : cPOnLayer[cp][cpp].hits_and_fractions) { - const HIT* hit = &hitsMS[hitMap_->at(haf.first)]; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Hits/fraction/energy: " << (uint32_t)haf.first << "/" - << haf.second << "/" << haf.second * hit->energy() << std::endl; - tot_energy += haf.second * hit->energy(); - } - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " Tot Sum haf: " << tot_energy << std::endl; - for (auto const& lc : cPOnLayer[cp][cpp].layerClusterIdToEnergyAndScore) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << " lcIdx/energy/score: " << lc.first << "/" - << lc.second.first << "/" << lc.second.second << std::endl; - } - } - } - - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "Improved detIdToCaloParticleId_Map INFO" << std::endl; - for (auto const& cp : detIdToCaloParticleId_Map) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << "For detId: " << (uint32_t)cp.first - << " we have found the following connections with CaloParticles:" << std::endl; - const HIT* hit = &hitsMS[hitMap_->at(cp.first)]; - for (auto const& cpp : cp.second) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << " CaloParticle Id: " << cpp.clusterId << " with fraction: " << cpp.fraction - << " and energy: " << cpp.fraction * hit->energy() << std::endl; - } - } -#endif - - // Update cpsInLayerCluster; compute the score LayerCluster-to-CaloParticle, - // together with the returned AssociationMap - for (unsigned int lcId = 0; lcId < nLayerClusters; ++lcId) { - // find the unique caloparticles id contributing to the layer clusters - if constexpr (std::is_same_v) { - if (recHitTools_->isBarrel(clusters[lcId].seed())) - continue; - } else { - if (!recHitTools_->isBarrel(clusters[lcId].seed())) - continue; - } - std::sort(cpsInLayerCluster[lcId].begin(), cpsInLayerCluster[lcId].end()); - auto last = std::unique(cpsInLayerCluster[lcId].begin(), cpsInLayerCluster[lcId].end()); - cpsInLayerCluster[lcId].erase(last, cpsInLayerCluster[lcId].end()); - const auto& hits_and_fractions = clusters[lcId].hitsAndFractions(); - unsigned int numberOfHitsInLC = hits_and_fractions.size(); - // If a reconstructed LayerCluster has energy 0 but is linked to a - // CaloParticle, assigned score 1 - if (clusters[lcId].energy() == 0. && !cpsInLayerCluster[lcId].empty()) { - for (auto& cpPair : cpsInLayerCluster[lcId]) { - cpPair.second = 1.; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "layerClusterId : \t " << lcId << "\t CP id : \t" - << cpPair.first << "\t score \t " << cpPair.second << "\n"; - } - continue; - } - - // Compute the correct normalization - // It is the inverse of the denominator of the LCToCP score formula. Observe that this is the sum of the squares. - float invLayerClusterEnergyWeight = 0.f; - for (auto const& haf : hits_and_fractions) { - const HIT* hit = &hitsMS[hitMap_->at(haf.first)]; - invLayerClusterEnergyWeight += (haf.second * hit->energy()) * (haf.second * hit->energy()); - } - invLayerClusterEnergyWeight = 1.f / invLayerClusterEnergyWeight; - for (unsigned int i = 0; i < numberOfHitsInLC; ++i) { - DetId rh_detid = hits_and_fractions[i].first; - float rhFraction = hits_and_fractions[i].second; - - bool hitWithNoCP = (detIdToCaloParticleId_Map.find(rh_detid) == detIdToCaloParticleId_Map.end()); - - auto itcheck = hitMap_->find(rh_detid); - if (itcheck == hitMap_->end()) - continue; - const HIT* hit = &hitsMS[itcheck->second]; - float hitEnergyWeight = hit->energy() * hit->energy(); - - for (auto& cpPair : cpsInLayerCluster[lcId]) { - float cpFraction = 0.f; - if (!hitWithNoCP) { - auto findHitIt = std::find(detIdToCaloParticleId_Map[rh_detid].begin(), - detIdToCaloParticleId_Map[rh_detid].end(), - ticl::detIdInfoInCluster{cpPair.first, 0.f}); - if (findHitIt != detIdToCaloParticleId_Map[rh_detid].end()) - cpFraction = findHitIt->fraction; - } - cpPair.second += std::min(std::pow(rhFraction - cpFraction, 2), std::pow(rhFraction, 2)) * hitEnergyWeight * - invLayerClusterEnergyWeight; - } //End of loop over CaloParticles related the this LayerCluster. - } // End of loop over Hits within a LayerCluster -#ifdef EDM_ML_DEBUG - if (cpsInLayerCluster[lcId].empty()) - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "layerCluster Id: \t" << lcId << "\tCP id:\t-1 " - << "\t score \t-1\n"; -#endif - } // End of loop over LayerClusters - - // Compute the CaloParticle-To-LayerCluster score - for (const auto& cpId : cPIndices) { - unsigned int nLayers = layers_ * 2; - if constexpr (std::is_same_v) - nLayers = layers_; - for (unsigned int layerId = 0; layerId < nLayers; ++layerId) { - unsigned int CPNumberOfHits = cPOnLayer[cpId][layerId].hits_and_fractions.size(); - if (CPNumberOfHits == 0) - continue; -#ifdef EDM_ML_DEBUG - int lcWithMaxEnergyInCP = -1; - float maxEnergyLCinCP = 0.f; - float CPenergy = cPOnLayer[cpId][layerId].energy; - float CPEnergyFractionInLC = 0.f; - for (auto& lc : cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore) { - if (lc.second.first > maxEnergyLCinCP) { - maxEnergyLCinCP = lc.second.first; - lcWithMaxEnergyInCP = lc.first; - } - } - if (CPenergy > 0.f) - CPEnergyFractionInLC = maxEnergyLCinCP / CPenergy; - - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << std::setw(8) << "LayerId:\t" << std::setw(12) << "caloparticle\t" << std::setw(15) << "cp total energy\t" - << std::setw(15) << "cpEnergyOnLayer\t" << std::setw(14) << "CPNhitsOnLayer\t" << std::setw(18) - << "lcWithMaxEnergyInCP\t" << std::setw(15) << "maxEnergyLCinCP\t" << std::setw(20) << "CPEnergyFractionInLC" - << "\n"; - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << std::setw(8) << layerId << "\t" << std::setw(12) << cpId << "\t" << std::setw(15) - << caloParticles[cpId].energy() << "\t" << std::setw(15) << CPenergy << "\t" << std::setw(14) - << CPNumberOfHits << "\t" << std::setw(18) << lcWithMaxEnergyInCP << "\t" << std::setw(15) << maxEnergyLCinCP - << "\t" << std::setw(20) << CPEnergyFractionInLC << "\n"; -#endif - // Compute the correct normalization. Observe that this is the sum of the squares. - float invCPEnergyWeight = 0.f; - for (auto const& haf : cPOnLayer[cpId][layerId].hits_and_fractions) { - const HIT* hit = &hitsMS[hitMap_->at(haf.first)]; - invCPEnergyWeight += std::pow(haf.second * hit->energy(), 2); - } - invCPEnergyWeight = 1.f / invCPEnergyWeight; - for (unsigned int i = 0; i < CPNumberOfHits; ++i) { - auto& cp_hitDetId = cPOnLayer[cpId][layerId].hits_and_fractions[i].first; - auto& cpFraction = cPOnLayer[cpId][layerId].hits_and_fractions[i].second; - - bool hitWithNoLC = false; - if (cpFraction == 0.f) - continue; //hopefully this should never happen - auto hit_find_in_LC = detIdToLayerClusterId_Map.find(cp_hitDetId); - if (hit_find_in_LC == detIdToLayerClusterId_Map.end()) - hitWithNoLC = true; - auto itcheck = hitMap_->find(cp_hitDetId); - const HIT* hit = &hitsMS[itcheck->second]; - float hitEnergyWeight = hit->energy() * hit->energy(); - for (auto& lcPair : cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore) { - unsigned int layerClusterId = lcPair.first; - float lcFraction = 0.f; - - if (!hitWithNoLC) { - auto findHitIt = std::find(detIdToLayerClusterId_Map[cp_hitDetId].begin(), - detIdToLayerClusterId_Map[cp_hitDetId].end(), - ticl::detIdInfoInCluster{layerClusterId, 0.f}); - if (findHitIt != detIdToLayerClusterId_Map[cp_hitDetId].end()) - lcFraction = findHitIt->fraction; - } - lcPair.second.second += std::min(std::pow(lcFraction - cpFraction, 2), std::pow(cpFraction, 2)) * - hitEnergyWeight * invCPEnergyWeight; -#ifdef EDM_ML_DEBUG - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << "cpDetId:\t" << (uint32_t)cp_hitDetId << "\tlayerClusterId:\t" << layerClusterId << "\t" - << "lcfraction,cpfraction:\t" << lcFraction << ", " << cpFraction << "\t" - << "hitEnergyWeight:\t" << hitEnergyWeight << "\t" - << "current score:\t" << lcPair.second.second << "\t" - << "invCPEnergyWeight:\t" << invCPEnergyWeight << "\n"; -#endif - } // End of loop over LayerClusters linked to hits of this CaloParticle - } // End of loop over hits of CaloParticle on a Layer -#ifdef EDM_ML_DEBUG - if (cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore.empty()) - LogDebug("LCToCPAssociatorByEnergyScoreImplT") << "CP Id: \t" << cpId << "\tLC id:\t-1 " - << "\t score \t-1\n"; - - for (const auto& lcPair : cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << "CP Id: \t" << cpId << "\t LC id: \t" << lcPair.first << "\t score \t" << lcPair.second.second - << "\t shared energy:\t" << lcPair.second.first << "\t shared energy fraction:\t" - << (lcPair.second.first / CPenergy) << "\n"; - } -#endif - } // End of loop over layers - } // End of loop over CaloParticles - - return {cpsInLayerCluster, cPOnLayer}; -} - -template -ticl::RecoToSimCollectionT LCToCPAssociatorByEnergyScoreImplT::associateRecoToSim( - const edm::Handle& cCCH, const edm::Handle& cPCH) const { - ticl::RecoToSimCollectionT returnValue(productGetter_); - - if (!hitMap_ || hitMap_->empty()) { - edm::LogWarning("LCToCPAssociatorByEnergyScoreImplT") << "hitMap_ is null or empty, skipping association."; - return returnValue; // return empty collection - } - const auto& links = makeConnections(cCCH, cPCH); - - const auto& cpsInLayerCluster = std::get<0>(links); - for (size_t lcId = 0; lcId < cpsInLayerCluster.size(); ++lcId) { - for (auto& cpPair : cpsInLayerCluster[lcId]) { - LogDebug("LCToCPAssociatorByEnergyScoreImplT") - << "layerCluster Id: \t" << lcId << "\t CP id: \t" << cpPair.first << "\t score \t" << cpPair.second << "\n"; - // Fill AssociationMap - returnValue.insert(edm::Ref(cCCH, lcId), // Ref to LC - std::make_pair(edm::Ref(cPCH, cpPair.first), - cpPair.second) // Pair - ); - } - } - return returnValue; -} - -template -ticl::SimToRecoCollectionT LCToCPAssociatorByEnergyScoreImplT::associateSimToReco( - const edm::Handle& cCCH, const edm::Handle& cPCH) const { - ticl::SimToRecoCollectionT returnValue(productGetter_); - - if (!hitMap_ || hitMap_->empty()) { - edm::LogWarning("LCToCPAssociatorByEnergyScoreImplT") << "hitMap_ is null or empty, skipping association."; - return returnValue; // return empty collection - } - - const auto& links = makeConnections(cCCH, cPCH); - const auto& cPOnLayer = std::get<1>(links); - for (size_t cpId = 0; cpId < cPOnLayer.size(); ++cpId) { - for (size_t layerId = 0; layerId < cPOnLayer[cpId].size(); ++layerId) { - for (auto& lcPair : cPOnLayer[cpId][layerId].layerClusterIdToEnergyAndScore) { - returnValue.insert( - edm::Ref(cPCH, cpId), // Ref to CP - std::make_pair(edm::Ref(cCCH, lcPair.first), // Pair > - ); - } - } - } - return returnValue; -} - -template class LCToCPAssociatorByEnergyScoreImplT; -template class LCToCPAssociatorByEnergyScoreImplT; -template class LCToCPAssociatorByEnergyScoreImplT; -template class LCToCPAssociatorByEnergyScoreImplT; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h deleted file mode 100644 index cf95996c8ce3a..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreImpl.h +++ /dev/null @@ -1,108 +0,0 @@ -// Original Author: Marco Rovere - -#include -#include -#include -#include // shared_ptr - -#include "DataFormats/ForwardDetId/interface/HGCalDetId.h" -#include "DataFormats/HGCRecHit/interface/HGCRecHit.h" -#include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" -#include "DataFormats/ParticleFlowReco/interface/PFRecHit.h" -#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" -#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" -#include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h" - -namespace edm { - class EDProductGetter; -} - -namespace ticl { - // This structure is used both for LayerClusters and CaloParticles storing their id and the fraction of a hit - // that belongs to the LayerCluster or CaloParticle. The meaning of the operator is extremely important since - // this struct will be used inside maps and other containers and when searching for one particular occurence - // only the clusterId member will be used in the check, skipping the fraction part. - struct detIdInfoInCluster { - bool operator==(const detIdInfoInCluster &o) const { return clusterId == o.clusterId; }; - long unsigned int clusterId; - float fraction; - detIdInfoInCluster(long unsigned int cId, float fr) { - clusterId = cId; - fraction = fr; - } - }; - - // This introduces a CaloParticle on layer concept. For a CaloParticle it stores: - // 1. Its id: caloParticleId. - // 2. The energy that the CaloParticle deposited in a specific layer and it was reconstructed. - // 3. The hits_and_fractions that contributed to that deposition. SimHits that aren't reconstructed - // and doesn't have any matched rechits are disregarded. Keep in mind that since a CaloParticle - // should most probably have more than one SimCluster, all different contributions from the same CaloParticle - // to a single hit are merged into a single entry, with the fractions properly summed. - // 4. A map to save the LayerClusters ids (id is the key) that reconstructed at least one SimHit of the CaloParticle under study - // together with the energy that the LayerCluster reconstructed from the CaloParticle and the score. The energy - // is not the energy of the LayerCluster, but the energy of the LayerCluster coming from the CaloParticle. - // So, there will be energy of the LayerCluster that is disregarded here, since there may be LayerCluster's - // cells that the CaloParticle didn't contribute. - struct caloParticleOnLayer { - unsigned int caloParticleId; - float energy = 0; - std::vector> hits_and_fractions; - std::unordered_map> layerClusterIdToEnergyAndScore; - }; - - // This object connects a LayerCluster, identified through its id (lcId), with a vector of pairs containing all the CaloParticles - // (via their ids (cpIds)) that share at least one cell with the LayerCluster. In that pair it - // stores the score (lcId->(cpId,score)). Keep in mind that the association is not unique, since there could be several instances - // of the same CaloParticle from several related SimClusters that each contributed to the same LayerCluster. - typedef std::vector>> layerClusterToCaloParticle; - // This is used to save the caloParticleOnLayer structure for all CaloParticles in each layer. - // It is not exactly what is returned outside, but out of its entries, the output object is build. - typedef std::vector> caloParticleToLayerCluster; - //This is the output of the makeConnections function that contain all the work with CP2LC and LC2CP - //association. It will be read by the relevant associateSimToReco and associateRecoToSim functions to - //provide the final product. - typedef std::tuple association; -} // namespace ticl - -template -class LCToCPAssociatorByEnergyScoreImplT : public ticl::LayerClusterToCaloParticleAssociatorBaseImplT { -public: - using multiCollectionT = std::vector>>; - - explicit LCToCPAssociatorByEnergyScoreImplT(edm::EDProductGetter const &, - bool, - std::shared_ptr, - const std::unordered_map *, - const multiCollectionT &hits); - - ticl::RecoToSimCollectionT associateRecoToSim( - const edm::Handle &cCH, const edm::Handle &cPCH) const override; - - ticl::SimToRecoCollectionT associateSimToReco( - const edm::Handle &cCH, const edm::Handle &cPCH) const override; - -private: - const bool hardScatterOnly_; - std::shared_ptr recHitTools_; - const std::unordered_map *hitMap_; - unsigned layers_; - edm::EDProductGetter const *productGetter_; - ticl::association makeConnections(const edm::Handle &cCH, - const edm::Handle &cPCH) const; - multiCollectionT hits_; -}; - -extern template class LCToCPAssociatorByEnergyScoreImplT; -extern template class LCToCPAssociatorByEnergyScoreImplT; -extern template class LCToCPAssociatorByEnergyScoreImplT; -extern template class LCToCPAssociatorByEnergyScoreImplT; - -using HGCalLCToCPAssociatorByEnergyScoreImpl = - LCToCPAssociatorByEnergyScoreImplT; -using BarrelLCToCPAssociatorByEnergyScoreImpl = - LCToCPAssociatorByEnergyScoreImplT; -using HGCalPCToCPAssociatorByEnergyScoreImpl = - LCToCPAssociatorByEnergyScoreImplT; -using BarrelPCToCPAssociatorByEnergyScoreImpl = - LCToCPAssociatorByEnergyScoreImplT; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc deleted file mode 100644 index 29cfded8745ea..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.cc +++ /dev/null @@ -1,81 +0,0 @@ -#include "LCToCPAssociatorByEnergyScoreProducer.h" - -#include -#include - -template -LCToCPAssociatorByEnergyScoreProducerT::LCToCPAssociatorByEnergyScoreProducerT(const edm::ParameterSet &ps) - : hitMap_(consumes>(ps.getParameter("hitMapTag"))), - caloGeometry_(esConsumes()), - hardScatterOnly_(ps.getParameter("hardScatterOnly")), - hits_token_(consumes(ps.getParameter("hits"))) { - rhtools_ = std::make_shared(); - - // Register the product - produces>(); -} - -template -LCToCPAssociatorByEnergyScoreProducerT::~LCToCPAssociatorByEnergyScoreProducerT() {} - -template -void LCToCPAssociatorByEnergyScoreProducerT::produce(edm::StreamID, - edm::Event &iEvent, - const edm::EventSetup &es) const { - edm::ESHandle geom = es.getHandle(caloGeometry_); - rhtools_->setGeometry(*geom); - - if (!iEvent.getHandle(hitMap_) || !iEvent.getHandle(hits_token_)) { - if (!iEvent.getHandle(hitMap_)) { - edm::LogWarning("LCToCPAssociatorByEnergyScoreProducerT") << "Hit map not valid. Producing empty associator."; - } - if (!iEvent.getHandle(hits_token_)) { - edm::LogWarning("LCToCPAssociatorByEnergyScoreProducerT") - << "Hit RefProdVector not available. Producing empty associator."; - } - - const std::unordered_map hitMap; // empty map - const multiCollectionT hits; - auto impl = std::make_unique>( - iEvent.productGetter(), hardScatterOnly_, rhtools_, &hitMap, hits); - auto emptyAssociator = std::make_unique>(std::move(impl)); - iEvent.put(std::move(emptyAssociator)); - return; - } - - // Protection against missing HGCRecHitCollection - const auto hits = iEvent.get(hits_token_); - for (std::size_t index = 0; const auto &hgcRecHitCollection : hits) { - if (hgcRecHitCollection->empty()) { - LogDebug("LCToCPAssociatorByEnergyScoreProducerT") << "HGCRecHitCollections #" << index << " is empty."; - } - index++; - } - - const bool no_hits = - std::none_of(hits.begin(), hits.end(), [](const auto &subCollection) { return !subCollection->empty(); }); - - if (no_hits) { - edm::LogWarning("LCToCPAssociatorByEnergyScoreProducerT") << "No hits collected. Producing empty associator."; - } - - const auto hitMap = &iEvent.get(hitMap_); - auto impl = std::make_unique>( - iEvent.productGetter(), hardScatterOnly_, rhtools_, hitMap, hits); - auto toPut = std::make_unique>(std::move(impl)); - iEvent.put(std::move(toPut)); -} - -template -void LCToCPAssociatorByEnergyScoreProducerT::fillDescriptions(edm::ConfigurationDescriptions &cfg) { - edm::ParameterSetDescription desc; - desc.add("hardScatterOnly", true); - if constexpr (std::is_same_v) { - desc.add("hitMapTag", edm::InputTag("recHitMapProducer", "hgcalRecHitMap")); - desc.add("hits", edm::InputTag("recHitMapProducer", "RefProdVectorHGCRecHitCollection")); - } else { - desc.add("hitMapTag", edm::InputTag("recHitMapProducer", "barrelRecHitMap")); - desc.add("hits", edm::InputTag("recHitMapProducer", "RefProdVectorPFRecHitCollection")); - } - cfg.addWithDefaultLabel(desc); -} diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h deleted file mode 100644 index a116217fcd6c5..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorByEnergyScoreProducer.h +++ /dev/null @@ -1,61 +0,0 @@ -#ifndef SimCalorimetry_HGCalAssociatorProducers_LCToCPAssociatorByEnergyScoreProducer_H -#define SimCalorimetry_HGCalAssociatorProducers_LCToCPAssociatorByEnergyScoreProducer_H - -// Original author: Marco Rovere - -// user include files -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/global/EDProducer.h" - -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" - -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "HLTrigger/HLTcore/interface/defaultModuleLabel.h" -#include "FWCore/Utilities/interface/EDGetToken.h" -#include "FWCore/Utilities/interface/ESGetToken.h" - -#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" -#include "LCToCPAssociatorByEnergyScoreImpl.h" - -#include "DataFormats/Common/interface/RefProdVector.h" -#include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" - -template -class LCToCPAssociatorByEnergyScoreProducerT : public edm::global::EDProducer<> { -public: - using multiCollectionT = edm::RefProdVector>; - - explicit LCToCPAssociatorByEnergyScoreProducerT(const edm::ParameterSet &); - ~LCToCPAssociatorByEnergyScoreProducerT() override; - - static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); - -private: - void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; - edm::EDGetTokenT> hitMap_; - edm::ESGetToken caloGeometry_; - const bool hardScatterOnly_; - std::shared_ptr rhtools_; - edm::EDGetTokenT hits_token_; -}; - -template class LCToCPAssociatorByEnergyScoreProducerT; -template class LCToCPAssociatorByEnergyScoreProducerT; -template class LCToCPAssociatorByEnergyScoreProducerT; -template class LCToCPAssociatorByEnergyScoreProducerT; - -using HGCalLCToCPAssociatorByEnergyScoreProducer = - LCToCPAssociatorByEnergyScoreProducerT; -DEFINE_FWK_MODULE(HGCalLCToCPAssociatorByEnergyScoreProducer); -using BarrelLCToCPAssociatorByEnergyScoreProducer = - LCToCPAssociatorByEnergyScoreProducerT; -DEFINE_FWK_MODULE(BarrelLCToCPAssociatorByEnergyScoreProducer); -using HGCalPCToCPAssociatorByEnergyScoreProducer = - LCToCPAssociatorByEnergyScoreProducerT; -DEFINE_FWK_MODULE(HGCalPCToCPAssociatorByEnergyScoreProducer); -using BarrelPCToCPAssociatorByEnergyScoreProducer = - LCToCPAssociatorByEnergyScoreProducerT; -DEFINE_FWK_MODULE(BarrelPCToCPAssociatorByEnergyScoreProducer); - -#endif diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc deleted file mode 100644 index 1ab593840f0ca..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToCPAssociatorEDProducer.cc +++ /dev/null @@ -1,137 +0,0 @@ -// -// Original Author: Leonardo Cristella -// Created: Thu Dec 3 10:52:11 CET 2020 -// -// - -// system include files -#include -#include - -// user include files -#include "FWCore/Framework/interface/global/EDProducer.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" -#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" -#include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" -#include "DataFormats/CaloRecHit/interface/CaloCluster.h" -#include "DataFormats/ParticleFlowReco/interface/PFClusterFwd.h" -#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" -#include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" -#include "DataFormats/ParticleFlowReco/interface/PFRecHitFwd.h" -#include "FWCore/Utilities/interface/EDGetToken.h" - -// -// class declaration -// - -template -class LCToCPAssociatorEDProducerT : public edm::global::EDProducer<> { -public: - explicit LCToCPAssociatorEDProducerT(const edm::ParameterSet &); - ~LCToCPAssociatorEDProducerT() override = default; - - // static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); - - static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); - -private: - void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; - - edm::InputTag label_lc; - - edm::EDGetTokenT CPCollectionToken_; - edm::EDGetTokenT LCCollectionToken_; - edm::EDGetTokenT> associatorToken_; -}; - -template -LCToCPAssociatorEDProducerT::LCToCPAssociatorEDProducerT(const edm::ParameterSet &pset) { - produces>(); - produces>(); - - label_lc = pset.getParameter("label_lc"); - - CPCollectionToken_ = consumes(pset.getParameter("label_cp")); - LCCollectionToken_ = consumes(label_lc); - associatorToken_ = - consumes>(pset.getParameter("associator")); -} - -// -// member functions -// - -// ------------ method called to produce the data ------------ -template -void LCToCPAssociatorEDProducerT::produce(edm::StreamID, - edm::Event &iEvent, - const edm::EventSetup &iSetup) const { - using namespace edm; - - edm::Handle> theAssociator; - iEvent.getByToken(associatorToken_, theAssociator); - - if (!theAssociator.isValid()) { - edm::LogWarning("LCToCPAssociatorEDProducerT") << "Associator is unavailable."; - return; - } - - Handle CPCollection; - iEvent.getByToken(CPCollectionToken_, CPCollection); - if (!CPCollection.isValid()) { - edm::LogWarning("LCToCPAssociatorEDProducerT") << "CaloParticle collection is unavailable."; - return; - } - - Handle LCCollection; - iEvent.getByToken(LCCollectionToken_, LCCollection); - - // Protection against missing cluster collection - if (!LCCollection.isValid()) { - edm::LogWarning("LCToCPAssociatorEDProducerT") - << "CaloCluster collection with label " << label_lc << " is unavailable. Producing empty associations."; - - // Return empty collections - auto emptyRecSimColl = std::make_unique>(); - auto emptySimRecColl = std::make_unique>(); - - iEvent.put(std::move(emptyRecSimColl)); - iEvent.put(std::move(emptySimRecColl)); - return; - } - - // associate LC and CP - LogTrace("AssociatorValidator") << "Calling associateRecoToSim method\n"; - ticl::RecoToSimCollectionT recSimColl = theAssociator->associateRecoToSim(LCCollection, CPCollection); - - LogTrace("AssociatorValidator") << "Calling associateSimToReco method\n"; - ticl::SimToRecoCollectionT simRecColl = theAssociator->associateSimToReco(LCCollection, CPCollection); - - auto rts = std::make_unique>(recSimColl); - auto str = std::make_unique>(simRecColl); - - iEvent.put(std::move(rts)); - iEvent.put(std::move(str)); -} - -template -void LCToCPAssociatorEDProducerT::fillDescriptions(edm::ConfigurationDescriptions &descriptions) { - edm::ParameterSetDescription desc; - desc.add("label_cp", edm::InputTag("mix", "MergedCaloTruth")); - desc.add("label_lc", edm::InputTag("hgcalMergeLayerClusters")); - desc.add("associator", edm::InputTag("lcAssocByEnergyScoreProducer")); - descriptions.addWithDefaultLabel(desc); -} - -// define this as a plug-in -using LCToCPAssociatorEDProducer = LCToCPAssociatorEDProducerT; -DEFINE_FWK_MODULE(LCToCPAssociatorEDProducer); -using PCToCPAssociatorEDProducer = LCToCPAssociatorEDProducerT; -DEFINE_FWK_MODULE(PCToCPAssociatorEDProducer); diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc index 9dab14cb5e254..6ae91cadadb17 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.cc @@ -2,7 +2,6 @@ // #include "LCToSimTSAssociatorByEnergyScoreImpl.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" @@ -13,8 +12,6 @@ LCToSimTSAssociatorByEnergyScoreImpl::LCToSimTSAssociatorByEnergyScoreImpl(edm:: ticl::RecoToSimTracksterCollection LCToSimTSAssociatorByEnergyScoreImpl::associateRecoToSim( const edm::Handle& cCCH, const edm::Handle& sTCH, - const edm::Handle& cPCH, - const ticl::RecoToSimCollectionT& lCToCPs, const edm::Handle& sCCH, const ticl::RecoToSimCollectionWithSimClustersT& lCToSCs) const { ticl::RecoToSimTracksterCollection returnValue(productGetter_); @@ -24,64 +21,32 @@ ticl::RecoToSimTracksterCollection LCToSimTSAssociatorByEnergyScoreImpl::associa for (size_t lcId = 0; lcId < cCCH.product()->size(); ++lcId) { const edm::Ref lcRef(cCCH, lcId); for (size_t tsId = 0; tsId < simTracksters.size(); ++tsId) { - if (simTracksters[tsId].seedID() == cPCH.id()) { - const auto& cpIt = lCToCPs.find(lcRef); - if (cpIt == lCToCPs.end()) { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "LayerCluster Id " << lcId << " not found in CaloParticle association map\n"; - continue; - } - - const edm::Ref cpRef(cPCH, simTracksters[tsId].seedIndex()); - const auto& cps = cpIt->val; - const auto cpPair = std::find_if( - std::begin(cps), std::end(cps), [&cpRef](const std::pair, float>& p) { - return p.first == cpRef; - }); - if (cpPair == cps.end()) { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") << "CaloParticle Id " << simTracksters[tsId].seedIndex() - << " not found in LayerCluster association map\n"; - continue; - } else { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "LayerCluster Id: \t" << lcId << "\t CaloParticle Id: \t" << cpPair->first.index() << "\t score \t" - << cpPair->second << "\n"; - // Fill AssociationMap - returnValue.insert(lcRef, // Ref to LC - std::make_pair(edm::Ref(sTCH, tsId), // Pair - cpPair->second)); - } - } else if (simTracksters[tsId].seedID() == sCCH.id()) { - const auto& scIt = lCToSCs.find(lcRef); - if (scIt == lCToSCs.end()) { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "LayerCluster Id " << lcId << " not found in SimCluster association map\n"; - continue; - } + assert(simTracksters[tsId].seedID() == sCCH.id()); + const auto& scIt = lCToSCs.find(lcRef); + if (scIt == lCToSCs.end()) { + LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") + << "LayerCluster Id " << lcId << " not found in SimCluster association map\n"; + continue; + } - const edm::Ref scRef(sCCH, simTracksters[tsId].seedIndex()); - const auto& scs = scIt->val; - const auto scPair = std::find_if( - std::begin(scs), std::end(scs), [&scRef](const std::pair, float>& p) { - return p.first == scRef; - }); - if (scPair == scs.end()) { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "SimCluster Id " << simTracksters[tsId].seedIndex() << " not found in LayerCluster association map\n"; - continue; - } else { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "LayerCluster Id: \t" << lcId << "\t SimCluster Id: \t" << scPair->first.index() << "\t score \t" - << scPair->second << "\n"; - // Fill AssociationMap - returnValue.insert(lcRef, // Ref to LC - std::make_pair(edm::Ref(sTCH, tsId), // Pair - scPair->second)); - } + const edm::Ref scRef(sCCH, simTracksters[tsId].seedIndex()); + const auto& scs = scIt->val; + const auto scPair = std::find_if( + std::begin(scs), std::end(scs), [&scRef](const std::pair, float>& p) { + return p.first == scRef; + }); + if (scPair == scs.end()) { + LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") + << "SimCluster Id " << simTracksters[tsId].seedIndex() << " not found in LayerCluster association map\n"; + continue; } else { LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "The seedID " << simTracksters[tsId].seedID() << " of SimTrackster " << tsId - << " is neither a CaloParticle nor a SimCluster!\n"; + << "LayerCluster Id: \t" << lcId << "\t SimCluster Id: \t" << scPair->first.index() << "\t score \t" + << scPair->second << "\n"; + // Fill AssociationMap + returnValue.insert(lcRef, // Ref to LC + std::make_pair(edm::Ref(sTCH, tsId), // Pair + scPair->second)); } } // end loop over simTracksters } // end loop over layerClusters @@ -92,90 +57,47 @@ ticl::RecoToSimTracksterCollection LCToSimTSAssociatorByEnergyScoreImpl::associa ticl::SimTracksterToRecoCollection LCToSimTSAssociatorByEnergyScoreImpl::associateSimToReco( const edm::Handle& cCCH, const edm::Handle& sTCH, - const edm::Handle& cPCH, - const ticl::SimToRecoCollectionT& cPToLCs, const edm::Handle& sCCH, const ticl::SimToRecoCollectionWithSimClustersT& sCToLCs) const { ticl::SimTracksterToRecoCollection returnValue(productGetter_); const auto simTracksters = *sTCH.product(); for (size_t tsId = 0; tsId < simTracksters.size(); ++tsId) { - if (simTracksters[tsId].seedID() == cPCH.id()) { - const auto cpId = simTracksters[tsId].seedIndex(); - const edm::Ref cpRef(cPCH, cpId); - const auto& lcIt = cPToLCs.find(cpRef); - if (lcIt == cPToLCs.end()) { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "CaloParticle Id " << cpId << " not found in LayerCluster association map\n"; - continue; - } + assert(simTracksters[tsId].seedID() == sCCH.id()); + const auto scId = simTracksters[tsId].seedIndex(); + const edm::Ref scRef(sCCH, scId); + const auto& lcIt = sCToLCs.find(scRef); + if (lcIt == sCToLCs.end()) { + LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") + << "SimCluster Id " << scId << " not found in LayerCluster association map\n"; + continue; + } - const auto& lcs = lcIt->val; - for (size_t lcId = 0; lcId < lcs.size(); ++lcId) { - const edm::Ref lcRef(cCCH, lcId); - const auto lcPair = - std::find_if(std::begin(lcs), - std::end(lcs), - [&lcRef](const std::pair, std::pair>& p) { - return p.first == lcRef; - }); - if (lcPair == lcs.end()) { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "LayerCluster Id " << lcId << " not found in CaloParticle association map\n"; - continue; - } else { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "CaloParticle Id: \t" << cpId << "\t LayerCluster Id: \t" << lcPair->first.index() << "\t score \t" - << lcPair->second.second << "\n"; - // Fill AssociationMap - returnValue.insert( - edm::Ref(sTCH, tsId), // Ref to TS - std::make_pair(lcRef, // Pair second.first, lcPair->second.second)) // pair > - ); - } - } - } else if (simTracksters[tsId].seedID() == sCCH.id()) { - const auto scId = simTracksters[tsId].seedIndex(); - const edm::Ref scRef(sCCH, scId); - const auto& lcIt = sCToLCs.find(scRef); - if (lcIt == sCToLCs.end()) { + const auto& lcs = lcIt->val; + for (size_t lcId = 0; lcId < lcs.size(); ++lcId) { + const edm::Ref lcRef(cCCH, lcId); + const auto lcPair = + std::find_if(std::begin(lcs), + std::end(lcs), + [&lcRef](const std::pair, std::pair>& p) { + return p.first == lcRef; + }); + if (lcPair == lcs.end()) { LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "SimCluster Id " << scId << " not found in LayerCluster association map\n"; + << "LayerCluster Id " << lcId << " not found in SimCluster association map\n"; continue; + } else { + LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") + << "SimCluster Id: \t" << scId << "\t LayerCluster Id: \t" << lcPair->first.index() << "\t score \t" + << lcPair->second.second << "\n"; + // Fill AssociationMap + returnValue.insert( + edm::Ref(sTCH, tsId), // Ref to TS + std::make_pair(lcRef, // Pair second.first, lcPair->second.second)) // pair > + ); } - - const auto& lcs = lcIt->val; - for (size_t lcId = 0; lcId < lcs.size(); ++lcId) { - const edm::Ref lcRef(cCCH, lcId); - const auto lcPair = - std::find_if(std::begin(lcs), - std::end(lcs), - [&lcRef](const std::pair, std::pair>& p) { - return p.first == lcRef; - }); - if (lcPair == lcs.end()) { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "LayerCluster Id " << lcId << " not found in SimCluster association map\n"; - continue; - } else { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "SimCluster Id: \t" << scId << "\t LayerCluster Id: \t" << lcPair->first.index() << "\t score \t" - << lcPair->second.second << "\n"; - // Fill AssociationMap - returnValue.insert( - edm::Ref(sTCH, tsId), // Ref to TS - std::make_pair(lcRef, // Pair second.first, lcPair->second.second)) // pair > - ); - } - } - } else { - LogDebug("LCToSimTSAssociatorByEnergyScoreImpl") - << "The seedID " << simTracksters[tsId].seedID() << " of SimTrackster " << tsId - << " is neither a CaloParticle nor a SimCluster!\n"; } - } // end loop over simTracksters return returnValue; } diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h index 042ed12280fe3..af98cc9ff4ef6 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorByEnergyScoreImpl.h @@ -27,16 +27,12 @@ class LCToSimTSAssociatorByEnergyScoreImpl : public ticl::LayerClusterToSimTrack ticl::RecoToSimTracksterCollection associateRecoToSim( const edm::Handle &cCH, const edm::Handle &sTCH, - const edm::Handle &cPCH, - const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const override; ticl::SimTracksterToRecoCollection associateSimToReco( const edm::Handle &cCH, const edm::Handle &sTCH, - const edm::Handle &cPCH, - const ticl::SimToRecoCollectionT &cPToLCs, const edm::Handle &sCCH, const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const override; diff --git a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc index 6034920ce2101..dae0106d8c8ed 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc +++ b/SimCalorimetry/HGCalAssociatorProducers/plugins/LCToSimTSAssociatorEDProducer.cc @@ -6,7 +6,6 @@ // system include files #include -#include // user include files #include "FWCore/Framework/interface/global/EDProducer.h" @@ -14,14 +13,11 @@ #include "FWCore/Framework/interface/Event.h" #include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/Framework/interface/ESHandle.h" - #include "FWCore/ParameterSet/interface/ParameterSet.h" #include "SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" #include "FWCore/Utilities/interface/EDGetToken.h" @@ -42,11 +38,6 @@ class LCToSimTSAssociatorEDProducer : public edm::global::EDProducer<> { edm::EDGetTokenT SimTSCollectionToken_; edm::EDGetTokenT associatorToken_; - edm::EDGetTokenT CPCollectionToken_; - edm::InputTag associatorCP_; - edm::EDGetTokenT> associationMapLCToCPToken_; - edm::EDGetTokenT> associationMapCPToLCToken_; - edm::EDGetTokenT SCCollectionToken_; edm::InputTag associatorSC_; edm::EDGetTokenT> associationMapLCToSCToken_; @@ -58,10 +49,6 @@ LCToSimTSAssociatorEDProducer::LCToSimTSAssociatorEDProducer(const edm::Paramete SimTSCollectionToken_(consumes(pset.getParameter("label_simTst"))), associatorToken_( consumes(pset.getParameter("associator"))), - CPCollectionToken_(consumes(pset.getParameter("label_cp"))), - associatorCP_(pset.getParameter("associator_cp")), - associationMapLCToCPToken_(consumes>(associatorCP_)), - associationMapCPToLCToken_(consumes>(associatorCP_)), SCCollectionToken_(consumes(pset.getParameter("label_scl"))), associatorSC_(pset.getParameter("associator_sc")), associationMapLCToSCToken_( @@ -91,11 +78,6 @@ void LCToSimTSAssociatorEDProducer::produce(edm::StreamID, edm::Event &iEvent, c Handle SimTSCollection; iEvent.getByToken(SimTSCollectionToken_, SimTSCollection); - Handle CPCollection; - iEvent.getByToken(CPCollectionToken_, CPCollection); - const auto &LCToCPsColl = iEvent.get(associationMapLCToCPToken_); - const auto &CPToLCsColl = iEvent.get(associationMapCPToLCToken_); - Handle SCCollection; iEvent.getByToken(SCCollectionToken_, SCCollection); const auto &LCToSCsColl = iEvent.get(associationMapLCToSCToken_); @@ -103,12 +85,12 @@ void LCToSimTSAssociatorEDProducer::produce(edm::StreamID, edm::Event &iEvent, c // associate LC and SimTS LogTrace("AssociatorValidator") << "Calling associateRecoToSim method\n"; - ticl::RecoToSimTracksterCollection recSimColl = theAssociator->associateRecoToSim( - LCCollection, SimTSCollection, CPCollection, LCToCPsColl, SCCollection, LCToSCsColl); + ticl::RecoToSimTracksterCollection recSimColl = + theAssociator->associateRecoToSim(LCCollection, SimTSCollection, SCCollection, LCToSCsColl); LogTrace("AssociatorValidator") << "Calling associateSimToReco method\n"; - ticl::SimTracksterToRecoCollection simRecColl = theAssociator->associateSimToReco( - LCCollection, SimTSCollection, CPCollection, CPToLCsColl, SCCollection, SCToLCsColl); + ticl::SimTracksterToRecoCollection simRecColl = + theAssociator->associateSimToReco(LCCollection, SimTSCollection, SCCollection, SCToLCsColl); auto rts = std::make_unique(recSimColl); auto str = std::make_unique(simRecColl); diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/HitToSimClusterAssociation_cff.py b/SimCalorimetry/HGCalAssociatorProducers/python/HitToSimClusterAssociation_cff.py new file mode 100644 index 0000000000000..494ee5734df1f --- /dev/null +++ b/SimCalorimetry/HGCalAssociatorProducers/python/HitToSimClusterAssociation_cff.py @@ -0,0 +1,29 @@ +import FWCore.ParameterSet.Config as cms +from SimCalorimetry.HGCalAssociatorProducers.hitToSimClusterCaloParticleAssociator_cfi import hitToSimClusterCaloParticleAssociator as _hitToSimClusterCaloParticleAssociator + + +hitToLegacySimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruth") +) +hitToBoundarySimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruthBoundaryTrackSimCluster") +) +hitToMergedSimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruthMergedSimCluster") +) +hitToCPSimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruthCaloParticle") # CaloParticle but in SimCluster dataformat +) + + +from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 +for _assoc in [hitToLegacySimClusterAssociator, hitToBoundarySimClusterAssociator, hitToMergedSimClusterAssociator, hitToCPSimClusterAssociator]: + premix_stage2.toModify(_assoc, simClusters = cms.InputTag("mixData", _assoc.simClusters.productInstanceLabel)) + +from SimCalorimetry.HGCalAssociatorProducers.barrelHitToSimClusterCaloParticleAssociator_cfi import barrelHitToSimClusterCaloParticleAssociator as _barrelHitToSimClusterCaloParticleAssociator +barrelHitToBoundarySimClusterAssociator = _barrelHitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruthBoundaryTrackSimCluster") +) +barrelHitToCPSimClusterAssociator = _barrelHitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruthCaloParticle") # CaloParticle but in SimCluster dataformat +) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/HitToTracksterAssociation_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/HitToTracksterAssociation_cfi.py index 783681cfe2e04..4e64412125b72 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/python/HitToTracksterAssociation_cfi.py +++ b/SimCalorimetry/HGCalAssociatorProducers/python/HitToTracksterAssociation_cfi.py @@ -1,32 +1,35 @@ import FWCore.ParameterSet.Config as cms -from SimCalorimetry.HGCalAssociatorProducers.hitToTracksterAssociator_cfi import hitToTracksterAssociator +from SimCalorimetry.HGCalAssociatorProducers.hitToTracksterAssociator_cfi import hitToTracksterAssociator as _hitToTracksterAssociator -hitToTrackstersAssociationLinking = hitToTracksterAssociator.clone( +# the "single" hitToTrackstersAssociation are not used (only the allHitToTracksterAssociations one is used) +hitToTrackstersAssociationLinking = _hitToTracksterAssociator.clone( tracksters = cms.InputTag("ticlCandidate"), ) -hitToTrackstersAssociationPR = hitToTracksterAssociator.clone( +hitToTrackstersAssociationPR = _hitToTracksterAssociator.clone( tracksters = cms.InputTag("ticlTrackstersCLUE3DHigh"), ) -hitToSimTracksterAssociation = hitToTracksterAssociator.clone( - tracksters = cms.InputTag("ticlSimTracksters"), +hitToSimTracksterAssociation = _hitToTracksterAssociator.clone( + tracksters = cms.InputTag("ticlSimTracksters", "fromLegacySimCluster"), ) -hitToSimTracksterFromCPsAssociation = hitToTracksterAssociator.clone( - tracksters = cms.InputTag("ticlSimTracksters", "fromCPs"), +hitToSimTracksterFromCPsAssociation = _hitToTracksterAssociator.clone( + tracksters = cms.InputTag("ticlSimTracksters", "fromCaloParticle"), ) -from SimCalorimetry.HGCalAssociatorProducers.AllHitToTracksterAssociatorsProducer_cfi import AllHitToTracksterAssociatorsProducer +from SimCalorimetry.HGCalAssociatorProducers.AllHitToTracksterAssociatorsProducer_cfi import AllHitToTracksterAssociatorsProducer as _AllHitToTracksterAssociatorsProducer from RecoHGCal.TICL.iterativeTICL_cff import ticlIterLabelsPSet -allHitToTracksterAssociations = AllHitToTracksterAssociatorsProducer.clone( +allHitToTracksterAssociations = _AllHitToTracksterAssociatorsProducer.clone( tracksterCollections = cms.VInputTag( *[cms.InputTag(label) for label in ticlIterLabelsPSet.labels], - cms.InputTag("ticlSimTracksters"), - cms.InputTag("ticlSimTracksters", "fromCPs"), + cms.InputTag("ticlSimTracksters", "fromLegacySimCluster"), + cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), + cms.InputTag("ticlSimTracksters", "fromMergedSimCluster"), + cms.InputTag("ticlSimTracksters", "fromCaloParticle"), ) ) @@ -35,5 +38,5 @@ allHitToBarrelTracksterAssociations = AllHitToBarrelTracksterAssociatorsProducer.clone( layerClusters = cms.InputTag("hgcalMergeLayerClusters"), - tracksterCollections = cms.VInputTag('ticlTrackstersCLUE3DBarrel', 'ticlSimTrackstersBarrel', 'ticlSimTrackstersBarrel:fromCPs') + tracksterCollections = cms.VInputTag('ticlTrackstersCLUE3DBarrel', 'ticlSimTrackstersBarrel:fromBoundarySimCluster', 'ticlSimTrackstersBarrel:fromCaloParticle') ) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/LCToCPAssociation_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/LCToCPAssociation_cfi.py deleted file mode 100644 index 9affdcbba0a91..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/python/LCToCPAssociation_cfi.py +++ /dev/null @@ -1,22 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -layerClusterCaloParticleAssociation = cms.EDProducer("LCToCPAssociatorEDProducer", - associator = cms.InputTag('lcAssocByEnergyScoreProducer'), - label_cp = cms.InputTag("mix","MergedCaloTruth"), - label_lc = cms.InputTag("hgcalMergeLayerClusters") -) - -barrelLayerClusterCaloParticleAssociation = cms.EDProducer("LCToCPAssociatorEDProducer", - associator = cms.InputTag('barrelLCToCPAssociatorByEnergyScoreProducer'), - label_cp = cms.InputTag("mix","MergedCaloTruth"), - label_lc = cms.InputTag("hgcalMergeLayerClusters") -) - -from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 -premix_stage2.toModify(layerClusterCaloParticleAssociation, - label_cp = "mixData:MergedCaloTruth" -) - -layerClusterCaloParticleAssociationHFNose = layerClusterCaloParticleAssociation.clone( - label_lc = "hgcalLayerClustersHFNose" -) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cff.py b/SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cff.py new file mode 100644 index 0000000000000..57843519d52e5 --- /dev/null +++ b/SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cff.py @@ -0,0 +1,53 @@ +import FWCore.ParameterSet.Config as cms + +# Loads LCToSCAssociatorByEnergyScoreProducer, which is a producer that does not make the associations, rather it puts in the event an instance of ticl::LayerClusterToSimClusterAssociatorBaseImplT +# in practice an instance of : HGCalLCToSCAssociatorByEnergyScoreImpl = LCToSCAssociatorByEnergyScoreImplT +# this event data product is then used in LCToSCAssociatorEDProducer to build the actual associations and store them in the event +from SimCalorimetry.HGCalAssociatorProducers.hgCalLCToSCAssociatorByEnergyScoreProducer_cfi import hgCalLCToSCAssociatorByEnergyScoreProducer as scAssocByEnergyScoreProducer +from Configuration.ProcessModifiers.simTrackstersFromPU_cff import simTrackstersFromPU +simTrackstersFromPU.toModify(scAssocByEnergyScoreProducer, hardScatterOnly = cms.bool(False)) + +from SimCalorimetry.HGCalAssociatorProducers.barrelLCToSCAssociatorByEnergyScoreProducer_cfi import barrelLCToSCAssociatorByEnergyScoreProducer +simTrackstersFromPU.toModify(barrelLCToSCAssociatorByEnergyScoreProducer, hardScatterOnly = cms.bool(False)) + + +from SimCalorimetry.HGCalAssociatorProducers.lcToSCAssociatorEDProducer_cfi import lcToSCAssociatorEDProducer as _lcToSCAssociatorEDProducer +layerClusterSimClusterAssociationProducer = _lcToSCAssociatorEDProducer.clone( + label_scl = cms.InputTag("mix","MergedCaloTruth"), # will use associator = "scAssocByEnergyScoreProducer" +) +layerClusterBoundaryTrackSimClusterAssociationProducer = _lcToSCAssociatorEDProducer.clone( + label_scl = cms.InputTag("mix","MergedCaloTruthBoundaryTrackSimCluster"), +) +layerClusterMergedSimClusterAssociationProducer = _lcToSCAssociatorEDProducer.clone( + label_scl = cms.InputTag("mix","MergedCaloTruthMergedSimCluster"), +) +# the next associator is an associator of LCs->SimCluster dataforamt but using SimCluster collection that is a 1-1 mapping to CaloParticle. +# this way downstream code only has one dataformat (SimCluster) instead of 2 (CaloParticle & SimCluster) +# at some point layerClusterCaloParticleAssociationProducer will be removed, keeping only layerClusterBoundaryTrackSimClusterAssociationProducer (once downstream code is updated) +layerClusterCaloParticleSimClusterAssociationProducer = _lcToSCAssociatorEDProducer.clone( + label_scl = cms.InputTag("mix","MergedCaloTruthCaloParticle"), +) + +barrelLayerClusterSimClusterAssociation = _lcToSCAssociatorEDProducer.clone( + associator = cms.InputTag('barrelLCToSCAssociatorByEnergyScoreProducer'), + label_scl = cms.InputTag("mix","MergedCaloTruth"), + label_lcl = cms.InputTag("hgcalMergeLayerClusters") +) +barrelLayerClusterCaloParticleAssociation = barrelLayerClusterSimClusterAssociation.clone( + label_scl = cms.InputTag("mix","MergedCaloTruthCaloParticle"), +) + +layerClusterSimClusterAssociationProducerHFNose = layerClusterSimClusterAssociationProducer.clone( + label_lcl = "hgcalLayerClustersHFNose" +) +layerClusterCaloParticleSimClusterAssociationProducerHFNose = layerClusterCaloParticleSimClusterAssociationProducer.clone( + label_lcl = "hgcalLayerClustersHFNose" +) + +from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 +for assoc_ in [layerClusterSimClusterAssociationProducer, layerClusterBoundaryTrackSimClusterAssociationProducer, layerClusterMergedSimClusterAssociationProducer, layerClusterCaloParticleSimClusterAssociationProducer, barrelLayerClusterSimClusterAssociation, layerClusterSimClusterAssociationProducerHFNose, layerClusterCaloParticleSimClusterAssociationProducerHFNose]: + premix_stage2.toModify(assoc_, + label_scl = cms.InputTag("mixData", assoc_.label_scl.productInstanceLabel) + ) + + diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cfi.py deleted file mode 100644 index b571548ded4fe..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/python/LCToSCAssociation_cfi.py +++ /dev/null @@ -1,22 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -layerClusterSimClusterAssociation = cms.EDProducer("LCToSCAssociatorEDProducer", - associator = cms.InputTag('scAssocByEnergyScoreProducer'), - label_scl = cms.InputTag("mix","MergedCaloTruth"), - label_lcl = cms.InputTag("hgcalMergeLayerClusters") -) - -barrelLayerClusterSimClusterAssociation = cms.EDProducer("LCToSCAssociatorEDProducer", - associator = cms.InputTag('barrelLCToSCAssociatorByEnergyScoreProducer'), - label_scl = cms.InputTag("mix","MergedCaloTruth"), - label_lcl = cms.InputTag("hgcalMergeLayerClusters") -) - -from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 -premix_stage2.toModify(layerClusterSimClusterAssociation, - label_scl = "mixData:MergedCaloTruth" -) - -layerClusterSimClusterAssociationHFNose = layerClusterSimClusterAssociation.clone( - label_lcl = "hgcalLayerClustersHFNose" -) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/LCToSimTSAssociation_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/LCToSimTSAssociation_cfi.py index 45df573a39203..ff8fc0c311f86 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/python/LCToSimTSAssociation_cfi.py +++ b/SimCalorimetry/HGCalAssociatorProducers/python/LCToSimTSAssociation_cfi.py @@ -1,11 +1,9 @@ import FWCore.ParameterSet.Config as cms - +# these do not seem to be ever used anywhere layerClusterSimTracksterAssociation = cms.EDProducer("LCToSimTSAssociatorEDProducer", label_lc = cms.InputTag("hgcalMergeLayerClusters"), - label_simTst = cms.InputTag("ticlSimTracksters"), + label_simTst = cms.InputTag("ticlSimTracksters", "fromLegacySimCluster"), associator = cms.InputTag('lcSimTSAssocByEnergyScoreProducer'), - label_cp = cms.InputTag("mix","MergedCaloTruth"), - associator_cp = cms.InputTag('layerClusterCaloParticleAssociationProducer'), label_scl = cms.InputTag("mix","MergedCaloTruth"), associator_sc = cms.InputTag('layerClusterSimClusterAssociationProducer'), ) @@ -21,5 +19,5 @@ ) layerClusterSimTracksterAssociationBarrel = layerClusterSimTracksterAssociation.clone( - label_simTst = cms.InputTag("ticlSimTrackstersBarrel") + label_simTst = cms.InputTag("ticlSimTrackstersBarrel", "fromLegacySimCluster") ) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/LCToTSAssociator_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/LCToTSAssociator_cfi.py index 34a15da17148c..e71e03bc86071 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/python/LCToTSAssociator_cfi.py +++ b/SimCalorimetry/HGCalAssociatorProducers/python/LCToTSAssociator_cfi.py @@ -1,5 +1,6 @@ import FWCore.ParameterSet.Config as cms +# the "allLayerClusterToTracksterAssociations" is now used, the individual-producer version (LCToTSAssociatorProducer) is not used anymore layerClusterToTracksterAssociation = cms.EDProducer("LCToTSAssociatorProducer", layer_clusters = cms.InputTag("hgcalMergeLayerClusters"), tracksters = cms.InputTag("ticlTracksters"), @@ -16,11 +17,11 @@ ) layerClusterToSimTracksterAssociation = LCToTSAssociatorProducer.clone( - tracksters = cms.InputTag("ticlSimTracksters") + tracksters = cms.InputTag("ticlSimTracksters", "fromLegacySimCluster") ) layerClusterToSimTracksterFromCPsAssociation = LCToTSAssociatorProducer.clone( - tracksters = cms.InputTag("ticlSimTracksters", "fromCPs") + tracksters = cms.InputTag("ticlSimTracksters", "fromCaloParticle") ) ## Barrel @@ -29,11 +30,11 @@ ) barrelLayerClusterToSimTracksterAssociation = LCToTSAssociatorProducer.clone( - tracksters = cms.InputTag('ticlBarrelSimTracksters') + tracksters = cms.InputTag('ticlBarrelSimTracksters', "fromLegacySimCluster") ) barrelLayerClusterToSimTracksterFromCPsAssociation = LCToTSAssociatorProducer.clone( - tracksters = cms.InputTag('ticlBarrelSimTracksters', 'fromCPs') + tracksters = cms.InputTag('ticlBarrelSimTracksters', 'fromCaloParticle') ) from SimCalorimetry.HGCalAssociatorProducers.AllLayerClusterToTracksterAssociatorsProducer_cfi import AllLayerClusterToTracksterAssociatorsProducer @@ -42,12 +43,14 @@ allLayerClusterToTracksterAssociations = AllLayerClusterToTracksterAssociatorsProducer.clone( tracksterCollections = cms.VInputTag( *[cms.InputTag(label) for label in ticlIterLabelsPSet.labels], - cms.InputTag("ticlSimTracksters"), - cms.InputTag("ticlSimTracksters", "fromCPs"), + cms.InputTag("ticlSimTracksters", "fromLegacySimCluster"), + cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), + cms.InputTag("ticlSimTracksters", "fromMergedSimCluster"), + cms.InputTag("ticlSimTracksters", "fromCaloParticle"), ) ) allBarrelLayerClusterToTracksterAssociations = AllLayerClusterToTracksterAssociatorsProducer.clone( layer_clusters = cms.InputTag("hgcalMergeLayerClusters"), - tracksterCollections = cms.VInputTag(cms.InputTag("ticlTrackstersCLUE3DBarrel"), cms.InputTag("ticlSimTrackstersBarrel"), cms.InputTag("ticlSimTrackstersBarrel", "fromCPs")) + tracksterCollections = cms.VInputTag(cms.InputTag("ticlTrackstersCLUE3DBarrel"), cms.InputTag("ticlSimTrackstersBarrel", "fromBoundarySimCluster"), cms.InputTag("ticlSimTrackstersBarrel", "fromCaloParticle")) ) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociationByHits_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociationByHits_cfi.py index f0642af08340d..7409bdf8dd2fd 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociationByHits_cfi.py +++ b/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociationByHits_cfi.py @@ -1,35 +1,47 @@ import FWCore.ParameterSet.Config as cms from SimCalorimetry.HGCalAssociatorProducers.HitToTracksterAssociation_cfi import * -from SimCalorimetry.HGCalAssociatorProducers.AllTracksterToSimTracksterAssociatorsByHitsProducer_cfi import AllTracksterToSimTracksterAssociatorsByHitsProducer +from SimCalorimetry.HGCalAssociatorProducers.AllTracksterToSimTracksterAssociatorsByHitsProducer_cfi import AllTracksterToSimTracksterAssociatorsByHitsProducer as _AllTracksterToSimTracksterAssociatorsByHitsProducer from RecoHGCal.TICL.iterativeTICL_cff import ticlIterLabelsPSet -allTrackstersToSimTrackstersAssociationsByHits = AllTracksterToSimTracksterAssociatorsByHitsProducer.clone( +allTrackstersToSimTrackstersAssociationsByHits = _AllTracksterToSimTracksterAssociatorsByHitsProducer.clone( tracksterCollections = cms.VInputTag( *[cms.InputTag(label) for label in ticlIterLabelsPSet.labels] ), - simTracksterCollections = cms.VInputTag( - 'ticlSimTracksters', - 'ticlSimTracksters:fromCPs' - ), + simTracksters = cms.VPSet( + cms.PSet( + simTracksterCollection=cms.InputTag("ticlSimTracksters", "fromLegacySimCluster"), + hitToSimClusterMap=cms.InputTag("hitToLegacySimClusterAssociator") + ), + cms.PSet( + simTracksterCollection=cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), + hitToSimClusterMap=cms.InputTag("hitToBoundarySimClusterAssociator") + ), + cms.PSet( + simTracksterCollection=cms.InputTag("ticlSimTracksters", "fromMergedSimCluster"), + hitToSimClusterMap=cms.InputTag("hitToMergedSimClusterAssociator") + ), + cms.PSet( + simTracksterCollection=cms.InputTag("ticlSimTracksters", "fromCaloParticle"), + hitToSimClusterMap=cms.InputTag("hitToCPSimClusterAssociator") + ), + ) ) -from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 - -premix_stage2.toModify(allTrackstersToSimTrackstersAssociationsByHits, - caloParticles = "mixData:MergedCaloTruth", -) - ## Barrel from SimCalorimetry.HGCalAssociatorProducers.AllBarrelTracksterToSimTracksterAssociatorsByHitsProducer_cfi import AllBarrelTracksterToSimTracksterAssociatorsByHitsProducer allBarrelTrackstersToSimTrackstersAssociationsByHits = AllBarrelTracksterToSimTracksterAssociatorsByHitsProducer.clone( allHitToTSAccoc = cms.string('allHitToBarrelTracksterAssociations'), - hitToCaloParticleMap = cms.InputTag("barrelHitToSimClusterCaloParticleAssociator", "hitToCaloParticleMap"), - hitToSimClusterMap = cms.InputTag("barrelHitToSimClusterCaloParticleAssociator", "hitToSimClusterMap"), tracksterCollections = cms.VInputTag('ticlTrackstersCLUE3DBarrel'), - simTracksterCollections = cms.VInputTag( - 'ticlSimTrackstersBarrel', - 'ticlSimTrackstersBarrel:fromCPs' + simTracksters = cms.VPSet( + cms.PSet( + simTracksterCollection=cms.InputTag("ticlSimTrackstersBarrel", "fromBoundarySimCluster"), + hitToSimClusterMap=cms.InputTag("barrelHitToBoundarySimClusterAssociator") + ), + cms.PSet( + simTracksterCollection=cms.InputTag("ticlSimTrackstersBarrel", "fromCaloParticle"), + hitToSimClusterMap=cms.InputTag("barrelHitToCPSimClusterAssociator") + ), ) ) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociation_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociation_cfi.py index 38b3b26d2a791..13aacd36e1a28 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociation_cfi.py +++ b/SimCalorimetry/HGCalAssociatorProducers/python/TSToSimTSAssociation_cfi.py @@ -12,8 +12,10 @@ *[cms.InputTag(label) for label in ticlIterLabelsPSet.labels] ), simTracksterCollections = cms.VInputTag( - cms.InputTag('ticlSimTracksters'), - cms.InputTag('ticlSimTracksters','fromCPs') + cms.InputTag("ticlSimTracksters", "fromLegacySimCluster"), + cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), + cms.InputTag("ticlSimTracksters", "fromMergedSimCluster"), + cms.InputTag("ticlSimTracksters", "fromCaloParticle"), ), ) @@ -22,6 +24,6 @@ allLCtoTSAccoc = cms.string("allBarrelLayerClusterToTracksterAssociations"), tracksterCollections = cms.VInputTag(['ticlTrackstersCLUE3DBarrel']), layerClusters = cms.InputTag('hgcalMergeLayerClusters'), - simTracksterCollections = cms.VInputTag(['ticlSimTrackstersBarrel', 'ticlSimTrackstersBarrel:fromCPs']) + simTracksterCollections = cms.VInputTag(['ticlSimTrackstersBarrel:fromBoundarySimCluster', 'ticlSimTrackstersBarrel:fromCaloParticle']) ) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/hltLCToCPAssociation_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/hltLCToCPAssociation_cfi.py deleted file mode 100644 index 69323f441caa0..0000000000000 --- a/SimCalorimetry/HGCalAssociatorProducers/python/hltLCToCPAssociation_cfi.py +++ /dev/null @@ -1,25 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -from SimCalorimetry.HGCalAssociatorProducers.barrelLCToCPAssociatorByEnergyScoreProducer_cfi import barrelLCToCPAssociatorByEnergyScoreProducer as _barrelLCToCPAssociatorByEnergyScoreProducer -hltBarrelLCToCPAssociatorByEnergyScoreProducer = _barrelLCToCPAssociatorByEnergyScoreProducer.clone( - hitMapTag = 'hltRecHitMapProducer:barrelRecHitMap', - hits = 'hltRecHitMapProducer:RefProdVectorPFRecHitCollection' -) - -from SimCalorimetry.HGCalSimProducers.hgcHitAssociation_cfi import lcAssocByEnergyScoreProducer as _lcAssocByEnergyScoreProducer -hltHGCalLCToCPAssociatorByEnergyScoreProducer = _lcAssocByEnergyScoreProducer.clone( - hitMapTag = 'hltRecHitMapProducer:hgcalRecHitMap', - hits = 'hltRecHitMapProducer:RefProdVectorHGCRecHitCollection' -) - -from SimCalorimetry.HGCalAssociatorProducers.LCToCPAssociation_cfi import barrelLayerClusterCaloParticleAssociation as _barrelLayerClusterCaloParticleAssociation -hltBarrelLayerClusterCaloParticleAssociation = _barrelLayerClusterCaloParticleAssociation.clone( - associator = 'hltBarrelLCToCPAssociatorByEnergyScoreProducer', - label_lc = 'hltMergeLayerClusters' -) - -from SimCalorimetry.HGCalAssociatorProducers.LCToCPAssociation_cfi import layerClusterCaloParticleAssociation as _layerClusterCaloParticleAssociation -hltHGCalLayerClusterCaloParticleAssociation = _layerClusterCaloParticleAssociation.clone( - associator = 'hltHGCalLCToCPAssociatorByEnergyScoreProducer', - label_lc = 'hltMergeLayerClusters' -) diff --git a/SimCalorimetry/HGCalAssociatorProducers/python/hltLCToSCAssociation_cfi.py b/SimCalorimetry/HGCalAssociatorProducers/python/hltLCToSCAssociation_cfi.py index a75513d00d9c3..088bb89c1e4f0 100644 --- a/SimCalorimetry/HGCalAssociatorProducers/python/hltLCToSCAssociation_cfi.py +++ b/SimCalorimetry/HGCalAssociatorProducers/python/hltLCToSCAssociation_cfi.py @@ -1,24 +1,46 @@ import FWCore.ParameterSet.Config as cms -from SimCalorimetry.HGCalAssociatorProducers.barrelLCToSCAssociatorByEnergyScoreProducer_cfi import * -hltBarrelLCToSCAssociatorByEnergyScoreProducer = barrelLCToSCAssociatorByEnergyScoreProducer.clone( +### Step 1 +# Loads LCToSCAssociatorByEnergyScoreProducer, which is a producer that does not make the associations, rather it puts in the event an instance of ticl::LayerClusterToSimClusterAssociatorBaseImplT +# this event data product is then used in LCToSCAssociatorEDProducer to build the actual associations and store them in the event +from SimCalorimetry.HGCalAssociatorProducers.barrelLCToSCAssociatorByEnergyScoreProducer_cfi import barrelLCToSCAssociatorByEnergyScoreProducer as _barrelLCToSCAssociatorByEnergyScoreProducer +# using BarrelLCToSCAssociatorByEnergyScoreProducer = LCToSCAssociatorByEnergyScoreProducerT; +hltBarrelLCToSCAssociatorByEnergyScoreProducer = _barrelLCToSCAssociatorByEnergyScoreProducer.clone( hitMapTag = 'hltRecHitMapProducer:barrelRecHitMap', hits = 'hltRecHitMapProducer:RefProdVectorPFRecHitCollection' ) -from SimCalorimetry.HGCalSimProducers.hgcHitAssociation_cfi import scAssocByEnergyScoreProducer -hltHGCalLCToSCAssociatorByEnergyScoreProducer = scAssocByEnergyScoreProducer.clone( +from SimCalorimetry.HGCalAssociatorProducers.hgCalLCToSCAssociatorByEnergyScoreProducer_cfi import hgCalLCToSCAssociatorByEnergyScoreProducer as _hgCalLCToSCAssociatorByEnergyScoreProducer +hltHGCalLCToSCAssociatorByEnergyScoreProducer = _hgCalLCToSCAssociatorByEnergyScoreProducer.clone( hitMapTag = 'hltRecHitMapProducer:hgcalRecHitMap', hits = 'hltRecHitMapProducer:RefProdVectorHGCRecHitCollection' ) +from Configuration.ProcessModifiers.simTrackstersFromPU_cff import simTrackstersFromPU +simTrackstersFromPU.toModify(hltHGCalLCToSCAssociatorByEnergyScoreProducer, hardScatterOnly = cms.bool(False)) -from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cfi import barrelLayerClusterSimClusterAssociation as _barrelLayerClusterSimClusterAssociation +### Step 2: Barrel associators to SimCluster and CaloParticles +from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cff import barrelLayerClusterSimClusterAssociation as _barrelLayerClusterSimClusterAssociation +# we use boundary SimCLuster here by default for simplicity hltBarrelLayerClusterSimClusterAssociation = _barrelLayerClusterSimClusterAssociation.clone( associator = 'hltBarrelLCToSCAssociatorByEnergyScoreProducer', - label_lcl = 'hltMergeLayerClusters' + label_lcl = 'hltMergeLayerClusters', + label_scl = cms.InputTag("mix","MergedCaloTruthBoundaryTrackSimCluster") ) -from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cfi import layerClusterSimClusterAssociation as _layerClusterSimClusterAssociation -hltHGCalLayerClusterSimClusterAssociation = _layerClusterSimClusterAssociation.clone( +hltBarrelLayerClusterCaloParticleAssociation = _barrelLayerClusterSimClusterAssociation.clone( + associator = 'hltBarrelLCToSCAssociatorByEnergyScoreProducer', + label_lcl = 'hltMergeLayerClusters', + label_scl = cms.InputTag("mix","MergedCaloTruthCaloParticle") +) + +### Step 3: HGCal associators to SimCluster and CaloParticles +from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cff import layerClusterSimClusterAssociationProducer as _layerClusterSimClusterAssociationProducer +hltHGCalLayerClusterSimClusterAssociation = _layerClusterSimClusterAssociationProducer.clone( + associator = 'hltHGCalLCToSCAssociatorByEnergyScoreProducer', + label_lcl = 'hltMergeLayerClusters', + label_scl = cms.InputTag("mix","MergedCaloTruthBoundaryTrackSimCluster") +) +hltHGCalLayerClusterCaloParticleAssociation = _layerClusterSimClusterAssociationProducer.clone( associator = 'hltHGCalLCToSCAssociatorByEnergyScoreProducer', - label_lcl = 'hltMergeLayerClusters' + label_lcl = 'hltMergeLayerClusters', + label_scl = cms.InputTag("mix","MergedCaloTruthCaloParticle"), ) diff --git a/SimCalorimetry/HGCalSimProducers/python/hgcHitAssociation_cfi.py b/SimCalorimetry/HGCalSimProducers/python/hgcHitAssociation_cfi.py deleted file mode 100644 index 62e176b5bb6cd..0000000000000 --- a/SimCalorimetry/HGCalSimProducers/python/hgcHitAssociation_cfi.py +++ /dev/null @@ -1,11 +0,0 @@ -import FWCore.ParameterSet.Config as cms -from SimCalorimetry.HGCalAssociatorProducers.hgCalLCToCPAssociatorByEnergyScoreProducer_cfi import hgCalLCToCPAssociatorByEnergyScoreProducer as _lcAssocByEnergyScoreProducer -from SimCalorimetry.HGCalAssociatorProducers.hgCalLCToSCAssociatorByEnergyScoreProducer_cfi import hgCalLCToSCAssociatorByEnergyScoreProducer as _scAssocByEnergyScoreProducer - -lcAssocByEnergyScoreProducer = _lcAssocByEnergyScoreProducer.clone(hardScatterOnly = cms.bool(True)) -scAssocByEnergyScoreProducer = _scAssocByEnergyScoreProducer.clone(hardScatterOnly = cms.bool(True)) - -from Configuration.ProcessModifiers.simTrackstersFromPU_cff import simTrackstersFromPU - -simTrackstersFromPU.toModify(lcAssocByEnergyScoreProducer, hardScatterOnly = cms.bool(False)) -simTrackstersFromPU.toModify(scAssocByEnergyScoreProducer, hardScatterOnly = cms.bool(False)) diff --git a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h index 8ebcf8aa8adae..3981f472d1d19 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h +++ b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h @@ -31,22 +31,18 @@ namespace ticl { ticl::RecoToSimTracksterCollection associateRecoToSim( const edm::Handle &cCCH, const edm::Handle &stCH, - const edm::Handle &cPCH, - const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const { - return m_impl->associateRecoToSim(cCCH, stCH, cPCH, lCToCPs, sCCH, lCToSCs); + return m_impl->associateRecoToSim(cCCH, stCH, sCCH, lCToSCs); }; /// Associate a SimTrackster to LayerClusters ticl::SimTracksterToRecoCollection associateSimToReco( const edm::Handle &cCCH, const edm::Handle &sTCH, - const edm::Handle &cPCH, - const ticl::SimToRecoCollectionT &cpToLCs, const edm::Handle &sCCH, const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const { - return m_impl->associateSimToReco(cCCH, sTCH, cPCH, cpToLCs, sCCH, sCToLCs); + return m_impl->associateSimToReco(cCCH, sTCH, sCCH, sCToLCs); } private: diff --git a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h index 160df3b1ad125..36905df17f300 100644 --- a/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h +++ b/SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociatorBaseImpl.h @@ -15,7 +15,6 @@ #include "DataFormats/CaloRecHit/interface/CaloClusterFwd.h" #include "DataFormats/HGCalReco/interface/Trackster.h" -#include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" #include "LayerClusterToCaloParticleAssociatorBaseImpl.h" #include "SimDataFormats/CaloAnalysis/interface/SimClusterFwd.h" #include "LayerClusterToSimClusterAssociatorBaseImpl.h" @@ -40,8 +39,6 @@ namespace ticl { virtual ticl::RecoToSimTracksterCollection associateRecoToSim( const edm::Handle &cCH, const edm::Handle &sTCH, - const edm::Handle &cPCH, - const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const; @@ -49,8 +46,6 @@ namespace ticl { virtual ticl::SimTracksterToRecoCollection associateSimToReco( const edm::Handle &cCH, const edm::Handle &sTCH, - const edm::Handle &cPCH, - const ticl::SimToRecoCollectionT &cPToLCs, const edm::Handle &sCCH, const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const; }; diff --git a/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc b/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc index 98cc03e269a55..b1b07ea058315 100644 --- a/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc +++ b/SimDataFormats/Associations/src/LayerClusterToSimTracksterAssociatorBaseImpl.cc @@ -9,8 +9,6 @@ namespace ticl { ticl::RecoToSimTracksterCollection LayerClusterToSimTracksterAssociatorBaseImpl::associateRecoToSim( const edm::Handle &cCCH, const edm::Handle &sTCH, - const edm::Handle &cPCH, - const ticl::RecoToSimCollectionT &lCToCPs, const edm::Handle &sCCH, const ticl::RecoToSimCollectionWithSimClustersT &lCToSCs) const { return ticl::RecoToSimTracksterCollection(); @@ -19,8 +17,6 @@ namespace ticl { ticl::SimTracksterToRecoCollection LayerClusterToSimTracksterAssociatorBaseImpl::associateSimToReco( const edm::Handle &cCCH, const edm::Handle &sTCH, - const edm::Handle &cPCH, - const ticl::SimToRecoCollectionT &cPToLCs, const edm::Handle &sCCH, const ticl::SimToRecoCollectionWithSimClustersT &sCToLCs) const { return ticl::SimTracksterToRecoCollection(); diff --git a/SimGeneral/CaloAnalysis/plugins/PreMixingCaloParticleWorker.cc b/SimGeneral/CaloAnalysis/plugins/PreMixingCaloParticleWorker.cc index 2184600387969..d290136c84f15 100644 --- a/SimGeneral/CaloAnalysis/plugins/PreMixingCaloParticleWorker.cc +++ b/SimGeneral/CaloAnalysis/plugins/PreMixingCaloParticleWorker.cc @@ -6,6 +6,7 @@ #include "SimGeneral/MixingModule/interface/PileUpEventPrincipal.h" #include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Common/interface/Ref.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticleFwd.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" @@ -14,6 +15,65 @@ #include "SimGeneral/PreMixingModule/interface/PreMixingWorker.h" #include "SimGeneral/PreMixingModule/interface/PreMixingWorkerFactory.h" +#include +#include +#include +#include +#include +#include + +namespace { + /// (DetId, total simhit energy) pairs produced by CaloTruthAccumulator in premix stage1 + using EnergyMap = std::vector>; + + constexpr std::size_t kNSimClusterProducts = 4; + enum SimClusterIndex { kLegacy = 0, kBoundary = 1, kCaloParticle = 2, kMerged = 3 }; + + // One state object per CaloTruth SimCluster collection. Premixing appends + // signal and pileup collections into these outputs, so the RefProd is kept + // here to rebuild refs after indices shift. + struct SimClusterProduct { + std::string + instance; ///< productInstanceName for this SimCluster collection (eg MergedCaloTruthBoundaryTrackSimCluster) + edm::EDGetTokenT signalToken; + std::unique_ptr output; + SimClusterRefProd refProd; + }; + + // Maps produced by CaloTruthAccumulator are RefVectors whose refs point to + // another CaloTruth collection. They cannot be copied verbatim after merging + // events because each appended collection gets an index offset. + struct SimClusterMapProduct { + /// productInstanceName for this SimClusterRefVector (eg MergedCaloTruthBoundaryTrackSimCluster) + std::string instance; + edm::EDGetTokenT signalToken; + std::unique_ptr output; + }; + + struct EventProducts { + edm::Handle caloparticle_h; + edm::Handle energymap_h; + std::array, kNSimClusterProducts> simclusters_handles; + std::array, kNSimClusterProducts> simclustersToCaloparticle_map_handles; + edm::Handle boundaryToMergedSimCluster_map_h; + }; + + /// Helper function to create InputTag updating the instance name + edm::InputTag inputTagWithInstance(const edm::InputTag &tag, const std::string &instance) { + return edm::InputTag(tag.label(), instance, tag.process()); + } + + void copySimClusters(const SimClusterCollection &clusters, SimClusterProduct &product); + + void copySimClusterRefVector(const SimClusterRefVector &inputRefs, + SimClusterRefVector &outputRefs, + const SimClusterRefProd &outputRefProd, + unsigned offset); + + template + void normalize(SimCaloCollection &collection, const std::unordered_map &totalEnergy); +} // namespace + class PreMixingCaloParticleWorker : public PreMixingWorker { public: PreMixingCaloParticleWorker(const edm::ParameterSet &ps, edm::ProducesCollector, edm::ConsumesCollector &&iC); @@ -28,128 +88,222 @@ class PreMixingCaloParticleWorker : public PreMixingWorker { int bunchSpacing) override; private: - using EnergyMap = std::vector>; - - void add(const SimClusterCollection &clusters, const CaloParticleCollection &particles, const EnergyMap &energyMap); + void add(const EventProducts &products); + void copyCaloParticles(const CaloParticleCollection &particles, unsigned legacyClusterOffset); - edm::EDGetTokenT sigClusterToken_; - edm::EDGetTokenT sigParticleToken_; - edm::EDGetTokenT sigEnergyToken_; + edm::EDGetTokenT sig_caloParticle_token_; + edm::EDGetTokenT sig_energymap_token_; + std::array simClusterProducts_; + std::array clusterToCaloParticleMapProducts_; + SimClusterMapProduct boundaryToMergedMapProduct_; edm::InputTag particlePileInputTag_; - std::string particleCollectionDM_; + std::string collectionDM_; ///< name prefix of instance name for all products (usually MergedCaloTruth) + /// Keep track of the total energy per DetId on the fully mixed event. std::unordered_map totalEnergy_; - std::unique_ptr newClusters_; - std::unique_ptr newParticles_; - SimClusterRefProd clusterRef_; + std::unique_ptr newCaloParticles_; }; PreMixingCaloParticleWorker::PreMixingCaloParticleWorker(const edm::ParameterSet &ps, edm::ProducesCollector producesCollector, edm::ConsumesCollector &&iC) - : sigClusterToken_(iC.consumes(ps.getParameter("labelSig"))), - sigParticleToken_(iC.consumes(ps.getParameter("labelSig"))), - sigEnergyToken_(iC.consumes(ps.getParameter("labelSig"))), + : sig_caloParticle_token_(iC.consumes(ps.getParameter("labelSig"))), + sig_energymap_token_(iC.consumes(ps.getParameter("labelSig"))), particlePileInputTag_(ps.getParameter("pileInputTag")), - particleCollectionDM_(ps.getParameter("collectionDM")) { - producesCollector.produces(particleCollectionDM_); - producesCollector.produces(particleCollectionDM_); + collectionDM_(ps.getParameter("collectionDM")) { + const auto labelSig = ps.getParameter("labelSig"); + // Keep this list in sync with CaloTruthAccumulator output instances. + const std::array simClusterProductNames = { + collectionDM_, + collectionDM_ + "BoundaryTrackSimCluster", + collectionDM_ + "CaloParticle", + collectionDM_ + "MergedSimCluster"}; + + for (unsigned i = 0; i < simClusterProducts_.size(); ++i) { + simClusterProducts_[i].instance = simClusterProductNames[i]; + simClusterProducts_[i].signalToken = + iC.consumes(inputTagWithInstance(labelSig, simClusterProductNames[i])); + clusterToCaloParticleMapProducts_[i].instance = simClusterProductNames[i]; + clusterToCaloParticleMapProducts_[i].signalToken = + iC.consumes(inputTagWithInstance(labelSig, simClusterProductNames[i])); + + producesCollector.produces(simClusterProductNames[i]); + producesCollector.produces(simClusterProductNames[i]); + } + + boundaryToMergedMapProduct_.instance = collectionDM_ + "MergedSimClusterMapFromSubCluster"; + boundaryToMergedMapProduct_.signalToken = + iC.consumes(inputTagWithInstance(labelSig, boundaryToMergedMapProduct_.instance)); + + producesCollector.produces(collectionDM_); + producesCollector.produces(boundaryToMergedMapProduct_.instance); } void PreMixingCaloParticleWorker::initializeEvent(edm::Event const &iEvent, edm::EventSetup const &iSetup) { - newClusters_ = std::make_unique(); - newParticles_ = std::make_unique(); + for (auto &product : simClusterProducts_) { + product.output = std::make_unique(); + } + for (auto &product : clusterToCaloParticleMapProducts_) { + product.output = std::make_unique(); + } + boundaryToMergedMapProduct_.output = std::make_unique(); + newCaloParticles_ = std::make_unique(); - // need RefProds in order to re-key the CaloParticle->SimCluster refs + // need RefProds in order to re-key the refs between merged products // TODO: try to remove const_cast, requires making Event non-const in // BMixingModule::initializeEvent - clusterRef_ = const_cast(iEvent).getRefBeforePut(particleCollectionDM_); + for (auto &product : simClusterProducts_) { + product.refProd = const_cast(iEvent).getRefBeforePut(product.instance); + } } void PreMixingCaloParticleWorker::addSignals(edm::Event const &iEvent, edm::EventSetup const &iSetup) { - edm::Handle clusters; - iEvent.getByToken(sigClusterToken_, clusters); - - edm::Handle particles; - iEvent.getByToken(sigParticleToken_, particles); + EventProducts products; + for (unsigned i = 0; i < simClusterProducts_.size(); ++i) { + iEvent.getByToken(simClusterProducts_[i].signalToken, products.simclusters_handles[i]); + iEvent.getByToken(clusterToCaloParticleMapProducts_[i].signalToken, + products.simclustersToCaloparticle_map_handles[i]); + } + iEvent.getByToken(boundaryToMergedMapProduct_.signalToken, products.boundaryToMergedSimCluster_map_h); - edm::Handle energy; - iEvent.getByToken(sigEnergyToken_, energy); + iEvent.getByToken(sig_caloParticle_token_, products.caloparticle_h); + iEvent.getByToken(sig_energymap_token_, products.energymap_h); - if (clusters.isValid() && particles.isValid() && energy.isValid()) { - add(*clusters, *particles, *energy); + if (products.caloparticle_h.isValid() && products.energymap_h.isValid()) { + add(products); } } void PreMixingCaloParticleWorker::addPileups(PileUpEventPrincipal const &pep, edm::EventSetup const &iSetup) { - edm::Handle clusters; - pep.getByLabel(particlePileInputTag_, clusters); - - edm::Handle particles; - pep.getByLabel(particlePileInputTag_, particles); + EventProducts products; + for (unsigned i = 0; i < simClusterProducts_.size(); ++i) { + pep.getByLabel(inputTagWithInstance(particlePileInputTag_, simClusterProducts_[i].instance), + products.simclusters_handles[i]); + pep.getByLabel(inputTagWithInstance(particlePileInputTag_, clusterToCaloParticleMapProducts_[i].instance), + products.simclustersToCaloparticle_map_handles[i]); + } + pep.getByLabel(inputTagWithInstance(particlePileInputTag_, boundaryToMergedMapProduct_.instance), + products.boundaryToMergedSimCluster_map_h); - edm::Handle energy; - pep.getByLabel(particlePileInputTag_, energy); + pep.getByLabel(particlePileInputTag_, products.caloparticle_h); + pep.getByLabel(particlePileInputTag_, products.energymap_h); - if (clusters.isValid() && particles.isValid() && energy.isValid()) { - add(*clusters, *particles, *energy); + if (products.caloparticle_h.isValid() && products.energymap_h.isValid()) { + add(products); } } -void PreMixingCaloParticleWorker::add(const SimClusterCollection &clusters, - const CaloParticleCollection &particles, - const EnergyMap &energy) { - const size_t startingIndex = newClusters_->size(); +void PreMixingCaloParticleWorker::add(const EventProducts &products) { + // Capture sizes before appending this event. These offsets are applied to + // refs read from the input event so they point into the final mixed products. + std::array clusterOffsets; + for (unsigned i = 0; i < simClusterProducts_.size(); ++i) { + clusterOffsets[i] = static_cast(simClusterProducts_[i].output->size()); + } + + for (unsigned i = 0; i < simClusterProducts_.size(); ++i) { + if (products.simclusters_handles[i].isValid()) { + copySimClusters(*products.simclusters_handles[i], simClusterProducts_[i]); + } + if (products.simclustersToCaloparticle_map_handles[i].isValid()) { + copySimClusterRefVector(*products.simclustersToCaloparticle_map_handles[i], + *clusterToCaloParticleMapProducts_[i].output, + simClusterProducts_[kCaloParticle].refProd, + clusterOffsets[kCaloParticle]); + } + } + + if (products.boundaryToMergedSimCluster_map_h.isValid()) { + copySimClusterRefVector(*products.boundaryToMergedSimCluster_map_h, + *boundaryToMergedMapProduct_.output, + simClusterProducts_[kMerged].refProd, + clusterOffsets[kMerged]); + } - // Copy SimClusters - newClusters_->reserve(newClusters_->size() + clusters.size()); - std::copy(clusters.begin(), clusters.end(), std::back_inserter(*newClusters_)); + copyCaloParticles(*products.caloparticle_h, clusterOffsets[kLegacy]); + for (const auto &elem : *products.energymap_h) { + totalEnergy_[elem.first] += elem.second; + } +} - // Copy CaloParticles - newParticles_->reserve(newParticles_->size() + particles.size()); - for (const auto &p : particles) { - newParticles_->push_back(p); - auto &particle = newParticles_->back(); +void PreMixingCaloParticleWorker::copyCaloParticles(const CaloParticleCollection &particles, + unsigned legacyClusterOffset) { + newCaloParticles_->reserve(newCaloParticles_->size() + particles.size()); + for (const auto &inputParticle : particles) { + newCaloParticles_->push_back(inputParticle); + auto &particle = newCaloParticles_->back(); - // re-key the refs to SimClusters + // re-key the refs to legacy SimClusters particle.clearSimClusters(); - for (const auto &ref : p.simClusters()) { - particle.addSimCluster(SimClusterRef(clusterRef_, startingIndex + ref.index())); + for (const auto &ref : inputParticle.simClusters()) { + particle.addSimCluster(SimClusterRef(simClusterProducts_[kLegacy].refProd, legacyClusterOffset + ref.index())); } } +} - // Add energies - for (const auto &elem : energy) { - totalEnergy_[elem.first] += elem.second; +namespace { + void copySimClusters(const SimClusterCollection &clusters, SimClusterProduct &product) { + product.output->reserve(product.output->size() + clusters.size()); + std::copy(clusters.begin(), clusters.end(), std::back_inserter(*product.output)); } -} + + void copySimClusterRefVector(const SimClusterRefVector &inputRefs, + SimClusterRefVector &outputRefs, + const SimClusterRefProd &outputRefProd, + unsigned offset) { + outputRefs.reserve(outputRefs.size() + inputRefs.size()); + for (const auto &ref : inputRefs) { + outputRefs.push_back(SimClusterRef(outputRefProd, offset + ref.index())); + } + } +} // namespace void PreMixingCaloParticleWorker::put(edm::Event &iEvent, edm::EventSetup const &iSetup, std::vector const &ps, int bunchSpacing) { - for (auto &sc : *newClusters_) { - auto hitsAndEnergies = sc.hits_and_fractions(); - sc.clearHitsAndFractions(); - for (auto &hAndE : hitsAndEnergies) { - const float totalenergy = totalEnergy_[hAndE.first]; - float fraction = 0.; - if (totalenergy > 0) - fraction = hAndE.second / totalenergy; - else - edm::LogWarning("PreMixingParticleWorker") - << "TotalSimEnergy for hit " << hAndE.first << " is 0! The fraction for this hit cannot be computed."; - sc.addRecHitAndFraction(hAndE.first, fraction); - } + for (auto &product : simClusterProducts_) { + normalize(*product.output, totalEnergy_); } + normalize(*newCaloParticles_, totalEnergy_); // clear memory std::unordered_map{}.swap(totalEnergy_); - iEvent.put(std::move(newClusters_), particleCollectionDM_); - iEvent.put(std::move(newParticles_), particleCollectionDM_); + for (auto &product : simClusterProducts_) { + iEvent.put(std::move(product.output), product.instance); + } + iEvent.put(std::move(newCaloParticles_), collectionDM_); + for (auto &product : clusterToCaloParticleMapProducts_) { + iEvent.put(std::move(product.output), product.instance); + } + iEvent.put(std::move(boundaryToMergedMapProduct_.output), boundaryToMergedMapProduct_.instance); } +namespace { + template + void normalize(SimCaloCollection &collection, const std::unordered_map &totalEnergy) { + // Stage-1 premixing stores absolute hit energies. After all signal and + // pileup inputs have been accumulated here, convert them to fractions using + // the total energy per DetId over the fully mixed event. + for (auto &sc : collection) { + auto hitsAndEnergies = sc.hits_and_fractions(); + sc.clearHitsAndFractions(); + for (auto &hAndE : hitsAndEnergies) { + auto totalEnergyItr = totalEnergy.find(hAndE.first); + const float totalenergy = totalEnergyItr != totalEnergy.end() ? totalEnergyItr->second : 0.f; + float fraction = 0.; + if (totalenergy > 0) + fraction = hAndE.second / totalenergy; + else + edm::LogWarning("PreMixingCaloParticleWorker") + << "TotalSimEnergy for hit " << hAndE.first << " is 0! The fraction for this hit cannot be computed."; + sc.addRecHitAndFraction(hAndE.first, fraction); + } + } + } +} // namespace + DEFINE_PREMIXING_WORKER(PreMixingCaloParticleWorker); diff --git a/Validation/Configuration/python/barrelSimValid_cff.py b/Validation/Configuration/python/barrelSimValid_cff.py index 8d1247222518c..a650c0670c337 100644 --- a/Validation/Configuration/python/barrelSimValid_cff.py +++ b/Validation/Configuration/python/barrelSimValid_cff.py @@ -1,22 +1,20 @@ -from SimCalorimetry.HGCalAssociatorProducers.LCToCPAssociation_cfi import barrelLayerClusterCaloParticleAssociation -from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cfi import barrelLayerClusterSimClusterAssociation -from SimCalorimetry.HGCalAssociatorProducers.barrelLCToSCAssociatorByEnergyScoreProducer_cfi import * -from SimCalorimetry.HGCalAssociatorProducers.barrelLCToCPAssociatorByEnergyScoreProducer_cfi import * +import FWCore.ParameterSet.Config as cms + +from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cff import barrelLCToSCAssociatorByEnergyScoreProducer, barrelLayerClusterCaloParticleAssociation, barrelLayerClusterSimClusterAssociation from SimCalorimetry.HGCalAssociatorProducers.HitToTracksterAssociation_cfi import allHitToBarrelTracksterAssociations from SimCalorimetry.HGCalAssociatorProducers.LCToTSAssociator_cfi import allBarrelLayerClusterToTracksterAssociations from SimCalorimetry.HGCalAssociatorProducers.TSToSimTSAssociationByHits_cfi import allBarrelTrackstersToSimTrackstersAssociationsByHits from SimCalorimetry.HGCalAssociatorProducers.TSToSimTSAssociation_cfi import allBarrelTrackstersToSimTrackstersAssociationsByLCs -from SimCalorimetry.HGCalAssociatorProducers.barrelHitToSimClusterCaloParticleAssociator_cfi import barrelHitToSimClusterCaloParticleAssociator +from SimCalorimetry.HGCalAssociatorProducers.HitToSimClusterAssociation_cff import barrelHitToBoundarySimClusterAssociator, barrelHitToCPSimClusterAssociator from Validation.HGCalValidation.BarrelValidator_cff import barrelValidator barrelValidatorSequence = cms.Sequence(barrelValidator) barrelAssociators = cms.Task( - barrelLCToCPAssociatorByEnergyScoreProducer, barrelLCToSCAssociatorByEnergyScoreProducer, barrelLayerClusterCaloParticleAssociation, barrelLayerClusterSimClusterAssociation, - barrelHitToSimClusterCaloParticleAssociator, + barrelHitToBoundarySimClusterAssociator, barrelHitToCPSimClusterAssociator, allHitToBarrelTracksterAssociations, allBarrelLayerClusterToTracksterAssociations, allBarrelTrackstersToSimTrackstersAssociationsByHits, diff --git a/Validation/Configuration/python/hgcalSimValid_cff.py b/Validation/Configuration/python/hgcalSimValid_cff.py index 0aaee7906d15c..e1443a9ddf10e 100644 --- a/Validation/Configuration/python/hgcalSimValid_cff.py +++ b/Validation/Configuration/python/hgcalSimValid_cff.py @@ -1,10 +1,7 @@ import FWCore.ParameterSet.Config as cms -from SimCalorimetry.HGCalSimProducers.hgcHitAssociation_cfi import lcAssocByEnergyScoreProducer, scAssocByEnergyScoreProducer -from SimCalorimetry.HGCalAssociatorProducers.LCToCPAssociation_cfi import layerClusterCaloParticleAssociation as layerClusterCaloParticleAssociationProducer -from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cfi import layerClusterSimClusterAssociation as layerClusterSimClusterAssociationProducer -from SimCalorimetry.HGCalAssociatorProducers.LCToCPAssociation_cfi import layerClusterCaloParticleAssociationHFNose as layerClusterCaloParticleAssociationProducerHFNose -from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cfi import layerClusterSimClusterAssociationHFNose as layerClusterSimClusterAssociationProducerHFNose +from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cff import scAssocByEnergyScoreProducer, layerClusterSimClusterAssociationProducer, layerClusterBoundaryTrackSimClusterAssociationProducer, layerClusterMergedSimClusterAssociationProducer, layerClusterCaloParticleSimClusterAssociationProducer +from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cff import layerClusterSimClusterAssociationProducerHFNose, layerClusterCaloParticleSimClusterAssociationProducerHFNose # from SimCalorimetry.HGCalAssociatorProducers.TSToSimTSAssociation_cfi import tracksterSimTracksterAssociationLinkingSuperclustering, tracksterSimTracksterAssociationPRSuperclustering #, tracksterSimTracksterAssociationLinkingbyCLUE3DEM, tracksterSimTracksterAssociationLinkingbyCLUE3DHAD, tracksterSimTracksterAssociationPRbyCLUE3DEM, tracksterSimTracksterAssociationPRbyCLUE3DHAD from RecoHGCal.TICL.mergedTrackstersProducer_cfi import mergedTrackstersProducer as _mergedTrackstersProducer from SimCalorimetry.HGCalAssociatorProducers.SimTauProducer_cfi import * @@ -15,7 +12,7 @@ from SimCalorimetry.HGCalAssociatorProducers.HitToTracksterAssociation_cfi import allHitToTracksterAssociations from SimCalorimetry.HGCalAssociatorProducers.TSToSimTSAssociation_cfi import allTrackstersToSimTrackstersAssociationsByLCs from SimCalorimetry.HGCalAssociatorProducers.TSToSimTSAssociationByHits_cfi import allTrackstersToSimTrackstersAssociationsByHits -from SimCalorimetry.HGCalAssociatorProducers.hitToSimClusterCaloParticleAssociator_cfi import hitToSimClusterCaloParticleAssociator +from SimCalorimetry.HGCalAssociatorProducers.HitToSimClusterAssociation_cff import hitToLegacySimClusterAssociator, hitToBoundarySimClusterAssociator, hitToMergedSimClusterAssociator, hitToCPSimClusterAssociator from SimCalorimetry.HGCalAssociatorProducers.SimClusterToCaloParticleAssociation_cfi import SimClusterToCaloParticleAssociation @@ -42,8 +39,8 @@ VariablePtBins=[10., 30., 80., 120., 250., 600.], DeltaPtOvPtHistoParameter = dict(EROn=True,EREtaMax=3.0, EREtaMin=1.6, slicingOn=True)) -hgcalAssociators = cms.Task(lcAssocByEnergyScoreProducer, layerClusterCaloParticleAssociationProducer, - scAssocByEnergyScoreProducer, layerClusterSimClusterAssociationProducer, +hgcalAssociators = cms.Task(scAssocByEnergyScoreProducer, + layerClusterSimClusterAssociationProducer, layerClusterBoundaryTrackSimClusterAssociationProducer, layerClusterMergedSimClusterAssociationProducer, layerClusterCaloParticleSimClusterAssociationProducer, SimTauProducer, # FP 07/2024 new associators: # layerClusterToCLUE3DTracksterAssociation, layerClusterToTracksterMergeAssociation, @@ -51,7 +48,7 @@ allLayerClusterToTracksterAssociations, allHitToTracksterAssociations, allTrackstersToSimTrackstersAssociationsByLCs, allTrackstersToSimTrackstersAssociationsByHits, # hitToTrackstersAssociationLinking, hitToTrackstersAssociationPR, # hitToSimTracksterAssociation, hitToSimTracksterFromCPsAssociation, - hitToSimClusterCaloParticleAssociator, + hitToLegacySimClusterAssociator, hitToBoundarySimClusterAssociator, hitToMergedSimClusterAssociator, hitToCPSimClusterAssociator, SimClusterToCaloParticleAssociation, ) @@ -76,4 +73,4 @@ + hgcalPFJetValidation) _hfnose_hgcalAssociatorsTask = hgcalAssociators.copy() -_hfnose_hgcalAssociatorsTask.add(layerClusterCaloParticleAssociationProducerHFNose, layerClusterSimClusterAssociationProducerHFNose) +_hfnose_hgcalAssociatorsTask.add(layerClusterCaloParticleSimClusterAssociationProducerHFNose, layerClusterSimClusterAssociationProducerHFNose) diff --git a/Validation/Configuration/python/hltBarrelSimValid_cff.py b/Validation/Configuration/python/hltBarrelSimValid_cff.py index 0bd7f290ae848..e8b8b01e9ea61 100644 --- a/Validation/Configuration/python/hltBarrelSimValid_cff.py +++ b/Validation/Configuration/python/hltBarrelSimValid_cff.py @@ -7,13 +7,9 @@ hgcalOnly = False, ) -from SimCalorimetry.HGCalAssociatorProducers.hltLCToCPAssociation_cfi import (hltBarrelLCToCPAssociatorByEnergyScoreProducer, - hltBarrelLayerClusterCaloParticleAssociation) -from SimCalorimetry.HGCalAssociatorProducers.hltLCToSCAssociation_cfi import (hltBarrelLCToSCAssociatorByEnergyScoreProducer, - hltBarrelLayerClusterSimClusterAssociation) +from SimCalorimetry.HGCalAssociatorProducers.hltLCToSCAssociation_cfi import hltBarrelLCToSCAssociatorByEnergyScoreProducer, hltBarrelLayerClusterSimClusterAssociation, hltBarrelLayerClusterCaloParticleAssociation hltBarrelPrevalidation = cms.Sequence( - hltBarrelLCToCPAssociatorByEnergyScoreProducer * hltBarrelLCToSCAssociatorByEnergyScoreProducer * hltBarrelLayerClusterCaloParticleAssociation * hltBarrelLayerClusterSimClusterAssociation diff --git a/Validation/Configuration/python/hltHGCalSimValid_cff.py b/Validation/Configuration/python/hltHGCalSimValid_cff.py index 3ea8a210cc54d..9e2b66366ee0b 100644 --- a/Validation/Configuration/python/hltHGCalSimValid_cff.py +++ b/Validation/Configuration/python/hltHGCalSimValid_cff.py @@ -1,13 +1,9 @@ import FWCore.ParameterSet.Config as cms -from SimCalorimetry.HGCalSimProducers.hgcHitAssociation_cfi import lcAssocByEnergyScoreProducer as _lcAssocByEnergyScoreProducer -from SimCalorimetry.HGCalSimProducers.hgcHitAssociation_cfi import scAssocByEnergyScoreProducer as _scAssocByEnergyScoreProducer -from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cfi import layerClusterSimClusterAssociation as _layerClusterSimClusterAssociationProducer -from SimCalorimetry.HGCalAssociatorProducers.LCToCPAssociation_cfi import layerClusterCaloParticleAssociation as _layerClusterCaloParticleAssociationProducer +from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cff import scAssocByEnergyScoreProducer as _scAssocByEnergyScoreProducer, layerClusterSimClusterAssociationProducer as _layerClusterSimClusterAssociationProducer, layerClusterBoundaryTrackSimClusterAssociationProducer as _layerClusterBoundaryTrackSimClusterAssociationProducer, layerClusterCaloParticleSimClusterAssociationProducer as _layerClusterCaloParticleSimClusterAssociationProducer from SimCalorimetry.HGCalAssociatorProducers.SimClusterToCaloParticleAssociation_cfi import SimClusterToCaloParticleAssociation from SimCalorimetry.HGCalAssociatorProducers.TSToSimTSAssociation_cfi import allTrackstersToSimTrackstersAssociationsByLCs as _allTrackstersToSimTrackstersAssociationsByLCs -from SimCalorimetry.HGCalAssociatorProducers.hitToSimClusterCaloParticleAssociator_cfi import hitToSimClusterCaloParticleAssociator as _hitToSimClusterCaloParticleAssociator from Validation.HGCalValidation.HLT_TICLIterLabels_cff import hltTiclIterLabelsPSet as _hltTiclIterLabelsPSet @@ -36,8 +32,9 @@ layer_clusters = cms.InputTag("hltMergeLayerClusters"), tracksterCollections = cms.VInputTag( *[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels], - cms.InputTag("hltTiclSimTracksters"), - cms.InputTag("hltTiclSimTracksters", "fromCPs"), + # cms.InputTag("hltTiclSimTracksters", "fromLegacySimCluster"), + cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), + cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), ) ) @@ -48,18 +45,32 @@ *[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels] ), simTracksterCollections = cms.VInputTag( - cms.InputTag('hltTiclSimTracksters'), - cms.InputTag('hltTiclSimTracksters','fromCPs') + # cms.InputTag("hltTiclSimTracksters", "fromLegacySimCluster"), + cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), + cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), ), ) -from SimCalorimetry.HGCalAssociatorProducers.AllTracksterToSimTracksterAssociatorsByHitsProducer_cfi import AllTracksterToSimTracksterAssociatorsByHitsProducer as _AllTracksterToSimTracksterAssociatorsByHitsProducer - +# from SimCalorimetry.HGCalAssociatorProducers.AllTracksterToSimTracksterAssociatorsByHitsProducer_cfi import AllTracksterToSimTracksterAssociatorsByHitsProducer as _AllTracksterToSimTracksterAssociatorsByHitsProducer +from SimCalorimetry.HGCalAssociatorProducers.hitToSimClusterCaloParticleAssociator_cfi import hitToSimClusterCaloParticleAssociator as _hitToSimClusterCaloParticleAssociator hltHitToSimClusterCaloParticleAssociator = _hitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruthCaloParticle"), # CaloParticle but in SimCluster dataformat + hitMap = 'hltHGCalRecHitMapProducer:hgcalRecHitMap', + hits = 'hltHGCalRecHitMapProducer:RefProdVectorHGCRecHitCollection' +) +# hltHitToLegacySimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( +# simClusters = cms.InputTag("mix", "MergedCaloTruth"), +# hitMap = 'hltHGCalRecHitMapProducer:hgcalRecHitMap', +# hits = 'hltHGCalRecHitMapProducer:RefProdVectorHGCRecHitCollection' +# ) +hltHitToBoundarySimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( + simClusters = cms.InputTag("mix", "MergedCaloTruthBoundaryTrackSimCluster"), hitMap = 'hltHGCalRecHitMapProducer:hgcalRecHitMap', hits = 'hltHGCalRecHitMapProducer:RefProdVectorHGCRecHitCollection' ) + + from SimCalorimetry.HGCalAssociatorProducers.AllHitToTracksterAssociatorsProducer_cfi import AllHitToTracksterAssociatorsProducer as _AllHitToTracksterAssociatorsProducer hltAllHitToTracksterAssociations = _AllHitToTracksterAssociatorsProducer.clone( @@ -68,29 +79,32 @@ layerClusters = cms.InputTag("hltMergeLayerClusters"), tracksterCollections = cms.VInputTag( *[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels], - cms.InputTag("hltTiclSimTracksters"), - cms.InputTag("hltTiclSimTracksters", "fromCPs"), + cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), + cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), ) ) +from SimCalorimetry.HGCalAssociatorProducers.AllTracksterToSimTracksterAssociatorsByHitsProducer_cfi import AllTracksterToSimTracksterAssociatorsByHitsProducer as _AllTracksterToSimTracksterAssociatorsByHitsProducer hltAllTrackstersToSimTrackstersAssociationsByHits = _AllTracksterToSimTracksterAssociatorsByHitsProducer.clone( allHitToTSAccoc = cms.string("hltAllHitToTracksterAssociations"), - hitToCaloParticleMap = cms.InputTag("hltHitToSimClusterCaloParticleAssociator","hitToCaloParticleMap"), - hitToSimClusterMap = cms.InputTag("hltHitToSimClusterCaloParticleAssociator","hitToSimClusterMap"), hits = cms.InputTag("hltHGCalRecHitMapProducer", "RefProdVectorHGCRecHitCollection"), tracksterCollections = cms.VInputTag( *[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels] ), - simTracksterCollections = cms.VInputTag( - 'hltTiclSimTracksters', - 'hltTiclSimTracksters:fromCPs' - ), + simTracksters = cms.VPSet( + cms.PSet( + simTracksterCollection=cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), + hitToSimClusterMap=cms.InputTag("hltHitToBoundarySimClusterAssociator") + ), + cms.PSet( + simTracksterCollection=cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), + hitToSimClusterMap=cms.InputTag("hltHitToSimClusterCaloParticleAssociator") + ), + ) ) -from SimCalorimetry.HGCalAssociatorProducers.hltLCToCPAssociation_cfi import hltHGCalLCToCPAssociatorByEnergyScoreProducer, hltHGCalLayerClusterCaloParticleAssociation -from SimCalorimetry.HGCalAssociatorProducers.hltLCToSCAssociation_cfi import hltHGCalLCToSCAssociatorByEnergyScoreProducer, hltHGCalLayerClusterSimClusterAssociation +from SimCalorimetry.HGCalAssociatorProducers.hltLCToSCAssociation_cfi import hltHGCalLCToSCAssociatorByEnergyScoreProducer, hltHGCalLayerClusterSimClusterAssociation, hltHGCalLayerClusterCaloParticleAssociation hltHgcalAssociatorsTask = cms.Task(hltHGCalRecHitMapProducer, - hltHGCalLCToCPAssociatorByEnergyScoreProducer, hltHGCalLCToSCAssociatorByEnergyScoreProducer, SimClusterToCaloParticleAssociation, hltHGCalLayerClusterCaloParticleAssociation, @@ -98,12 +112,11 @@ hltAllLayerClusterToTracksterAssociations, hltAllTrackstersToSimTrackstersAssociationsByLCs, hltAllHitToTracksterAssociations, - hltHitToSimClusterCaloParticleAssociator, + hltHitToBoundarySimClusterAssociator, hltHitToSimClusterCaloParticleAssociator, hltAllTrackstersToSimTrackstersAssociationsByHits ) hltHgcalPrevalidation = cms.Sequence( - hltHGCalLCToCPAssociatorByEnergyScoreProducer * hltHGCalLCToSCAssociatorByEnergyScoreProducer * hltHGCalLayerClusterCaloParticleAssociation * hltHGCalLayerClusterSimClusterAssociation diff --git a/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h b/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h index 8b2e7f403978a..0525d8a6dec61 100644 --- a/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h +++ b/Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h @@ -201,8 +201,6 @@ class BarrelVHistoProducerAlgo { typedef dqm::legacy::MonitorElement MonitorElement; using TracksterToTracksterMap = ticl::AssociationMap, std::vector>; - using SimClusterToCaloParticleMap = - ticl::AssociationMap, std::vector>; enum validationType { byHits_CP = 0, byLCs, byLCs_CP, byHits }; BarrelVHistoProducerAlgo(const edm::ParameterSet& pset); @@ -227,18 +225,19 @@ class BarrelVHistoProducerAlgo { void bookTracksterSTSHistos(DQMStore::IBooker& ibook, Histograms& histograms, const validationType valType); - void layerClusters_to_CaloParticles(const Histograms& histograms, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> caloParticleHandle, - std::vector const& cP, - std::vector const& cPIndices, - std::vector const& cPSelectedIndices, - std::unordered_map const&, - unsigned int layers, - const ticl::RecoToSimCollectionT& recSimColl, - const ticl::SimToRecoCollectionT& simRecColl, - edm::MultiSpan const& barrelHits) const; + void layerClusters_to_CaloParticles( + const Histograms& histograms, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> caloParticleHandle, + std::vector const& cP, + std::vector const& cPIndices, + std::vector const& cPSelectedIndices, + std::unordered_map const&, + unsigned int layers, + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& barrelHits) const; void layerClusters_to_SimClusters( const Histograms& histograms, const int count, @@ -259,7 +258,7 @@ class BarrelVHistoProducerAlgo { const TracksterToTracksterMap& trackstersToSimTrackstersMap, const TracksterToTracksterMap& simTrackstersToTrackstersMap, const validationType valType, - const SimClusterToCaloParticleMap& scToCpMap, + const SimClusterRefVector& scToCpMap, const std::vector& cPIndices, const std::vector& cPSelectedIndices, const edm::ProductID& cPHandle_id) const; @@ -272,19 +271,20 @@ class BarrelVHistoProducerAlgo { unsigned int layers, std::unordered_map const&, edm::MultiSpan const& barrelHits) const; - void fill_generic_cluster_histos(const Histograms& histograms, - const int count, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> caloParticleHandle, - std::vector const& cP, - std::vector const& cPIndices, - std::vector const& cPSelectedIndices, - std::unordered_map const&, - unsigned int layers, - const ticl::RecoToSimCollectionT& recSimColl, - const ticl::SimToRecoCollectionT& simRecColl, - edm::MultiSpan const& barrelHits) const; + void fill_generic_cluster_histos( + const Histograms& histograms, + const int count, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> caloParticleHandle, + std::vector const& cP, + std::vector const& cPIndices, + std::vector const& cPSelectedIndices, + std::unordered_map const&, + unsigned int layers, + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& barrelHits) const; void fill_simCluster_histos(const Histograms& histograms, std::vector const& simClusters, unsigned int layers) const; @@ -310,7 +310,6 @@ class BarrelVHistoProducerAlgo { const reco::CaloClusterCollection& layerClusters, const ticl::TracksterCollection& simTSs, const ticl::TracksterCollection& simTSs_fromCP, - const std::map>& cpToSc_SimTrackstersMap, std::vector const& sC, const edm::ProductID& cPHandle_id, std::vector const& cP, @@ -328,7 +327,7 @@ class BarrelVHistoProducerAlgo { const edm::Handle& simTrackstersToTrackstersByHitsMapH, const edm::Handle& trackstersToSimTrackstersFromCPsByHitsMapH, const edm::Handle& simTrackstersFromCPsToTrackstersByHitsMapH, - const SimClusterToCaloParticleMap& scToCpMap) const; + const SimClusterRefVector& scToCpMap) const; double distance2(const double x1, const double y1, const double x2, const double y2) const; double distance(const double x1, const double y1, const double x2, const double y2) const; diff --git a/Validation/HGCalValidation/interface/BarrelValidator.h b/Validation/HGCalValidation/interface/BarrelValidator.h index eeb025ee764ee..77138a696184f 100644 --- a/Validation/HGCalValidation/interface/BarrelValidator.h +++ b/Validation/HGCalValidation/interface/BarrelValidator.h @@ -99,8 +99,8 @@ class BarrelValidator : public DQMGlobalEDAnalyzer { edm::EDGetTokenT> simVertices_; std::vector>> clustersMaskTokens_; edm::EDGetTokenT> barrelHitMap_; - std::vector>> associatorMapRtS; - std::vector>> associatorMapStR; + std::vector>> associatorMapRtS; + std::vector>> associatorMapStR; std::vector>> associatorMapSimtR; std::vector>> @@ -109,7 +109,7 @@ class BarrelValidator : public DQMGlobalEDAnalyzer { edm::EDGetTokenT> hitsToken_; std::vector> tracksterToTracksterAssociatorsTokens_; std::vector> tracksterToTracksterByHitsAssociatorsTokens_; - edm::EDGetTokenT scToCpMapToken_; + edm::EDGetTokenT scToCpMapToken_; edm::InputTag cpTag_; private: diff --git a/Validation/HGCalValidation/interface/HGCalValidator.h b/Validation/HGCalValidation/interface/HGCalValidator.h index 2f072477bc744..f8c4e3dd82cc8 100644 --- a/Validation/HGCalValidation/interface/HGCalValidator.h +++ b/Validation/HGCalValidation/interface/HGCalValidator.h @@ -14,8 +14,6 @@ #include "FWCore/ParameterSet/interface/FileInPath.h" #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h" -#include "DataFormats/ParticleFlowReco/interface/PFCluster.h" -#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" #include "DataFormats/HGCalReco/interface/Trackster.h" #include "DataFormats/HGCRecHit/interface/HGCRecHitCollections.h" #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" @@ -27,10 +25,7 @@ #include "Validation/HGCalValidation/interface/TICLCandidateValidator.h" #include "Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h" #include "Validation/HGCalValidation/interface/CaloParticleSelector.h" -#include "RecoLocalCalo/HGCalRecProducers/interface/HGCalClusteringAlgoBase.h" -#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociator.h" -#include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociator.h" #include "SimDataFormats/Associations/interface/TICLAssociationMap.h" #include "CommonTools/Utils/interface/StringCutObjectSelector.h" @@ -50,8 +45,6 @@ class HGCalValidator : public DQMGlobalEDAnalyzer { using Histograms = HGCalValidatorHistograms; using TracksterToTracksterMap = ticl::AssociationMap, std::vector>; - using SimClusterToCaloParticleMap = - ticl::AssociationMap, std::vector>; /// Constructor HGCalValidator(const edm::ParameterSet& pset); @@ -109,8 +102,10 @@ class HGCalValidator : public DQMGlobalEDAnalyzer { edm::EDGetTokenT> simVertices_; std::vector>> clustersMaskTokens_; edm::EDGetTokenT> hitMap_; - edm::EDGetTokenT> associatorMapRtS; - edm::EDGetTokenT> associatorMapStR; + /// Maps CaloParticle (as SimCluster dataformat) to layer cluster + edm::EDGetTokenT> associatorMapRtS; + edm::EDGetTokenT> associatorMapStR; + /// Maps SimCluster to layer cluster edm::EDGetTokenT> associatorMapSimtR; edm::EDGetTokenT> associatorMapRtSim; std::unique_ptr histoProducerAlgo_; @@ -118,7 +113,7 @@ class HGCalValidator : public DQMGlobalEDAnalyzer { std::unique_ptr candidateVal_; std::vector> tracksterToTracksterAssociatorsTokens_; std::vector> tracksterToTracksterByHitsAssociatorsTokens_; - edm::EDGetTokenT scToCpMapToken_; + edm::EDGetTokenT scToCpMapToken_; const StringCutObjectSelector cutTk_; private: diff --git a/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h b/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h index 7530f2fbe2e47..4e9eae4ad3df6 100644 --- a/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h +++ b/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h @@ -27,7 +27,6 @@ #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h" #include "SimDataFormats/Vertex/interface/SimVertex.h" #include "RecoLocalCalo/HGCalRecProducers/interface/HGCalClusteringAlgoBase.h" -#include "SimDataFormats/Associations/interface/LayerClusterToCaloParticleAssociatorBaseImpl.h" #include "SimDataFormats/Associations/interface/LayerClusterToSimClusterAssociatorBaseImpl.h" #include "DQMServices/Core/interface/DQMStore.h" @@ -232,8 +231,6 @@ class HGVHistoProducerAlgo { typedef dqm::legacy::MonitorElement MonitorElement; using TracksterToTracksterMap = ticl::AssociationMap, std::vector>; - using SimClusterToCaloParticleMap = - ticl::AssociationMap, std::vector>; enum validationType { byHits_CP = 0, byLCs, byLCs_CP, byHits }; HGVHistoProducerAlgo(const edm::ParameterSet& pset); @@ -271,18 +268,19 @@ class HGVHistoProducerAlgo { void bookTracksterSTSHistos(DQMStore::IBooker& ibook, Histograms& histograms, const validationType valType); - void layerClusters_to_CaloParticles(const Histograms& histograms, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> caloParticleHandle, - std::vector const& cP, - std::vector const& cPIndices, - std::vector const& cPSelectedIndices, - std::unordered_map const&, - unsigned int layers, - const ticl::RecoToSimCollectionT& recSimColl, - const ticl::SimToRecoCollectionT& simRecColl, - edm::MultiSpan const& hits) const; + void layerClusters_to_CaloParticles( + const Histograms& histograms, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> caloParticleHandle, + std::vector const& cP, + std::vector const& cPIndices, + std::vector const& cPSelectedIndices, + std::unordered_map const&, + unsigned int layers, + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& hits) const; void layerClusters_to_SimClusters( const Histograms& histograms, const int count, @@ -303,7 +301,7 @@ class HGVHistoProducerAlgo { const TracksterToTracksterMap& trackstersToSimTrackstersMap, const TracksterToTracksterMap& simTrackstersToTrackstersMap, const validationType valType, - const SimClusterToCaloParticleMap& scToCpMap, + const SimClusterRefVector& scToCpMap, const std::vector& cPIndices, const std::vector& cPSelectedIndices, const edm::ProductID& cPHandle_id) const; @@ -316,21 +314,23 @@ class HGVHistoProducerAlgo { unsigned int layers, std::unordered_map const&, edm::MultiSpan const& hits) const; - void fill_generic_cluster_histos(const Histograms& histograms, - const int count, - edm::Handle clusterHandle, - const reco::CaloClusterCollection& clusters, - edm::Handle> caloParticleHandle, - std::vector const& cP, - std::vector const& cPIndices, - std::vector const& cPSelectedIndices, - std::unordered_map const& hitMap, - std::map cummatbudg, - unsigned int layers, - std::vector thicknesses, - const ticl::RecoToSimCollectionT& recSimColl, - const ticl::SimToRecoCollectionT& simRecColl, - edm::MultiSpan const& hits) const; + void fill_generic_cluster_histos( + const Histograms& histograms, + const int count, + edm::Handle clusterHandle, + const reco::CaloClusterCollection& clusters, + edm::Handle> caloParticleHandle, + std::vector const& cP, + std::vector const& cPIndices, + std::vector const& cPSelectedIndices, + std::unordered_map const& hitMap, + std::map cummatbudg, + unsigned int layers, + std::vector thicknesses, + // reco-sim collection to CaloParticles (as SimCluster dataformat) + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, + edm::MultiSpan const& hits) const; void fill_simCluster_histos(const Histograms& histograms, std::vector const& simClusters, unsigned int layers, @@ -356,7 +356,6 @@ class HGVHistoProducerAlgo { const reco::CaloClusterCollection& layerClusters, const ticl::TracksterCollection& simTSs, const ticl::TracksterCollection& simTSs_fromCP, - const std::map>& cpToSc_SimTrackstersMap, std::vector const& sC, const edm::ProductID& cPHandle_id, std::vector const& cP, @@ -374,7 +373,7 @@ class HGVHistoProducerAlgo { const edm::Handle& simTrackstersToTrackstersByHitsMapH, const edm::Handle& trackstersToSimTrackstersFromCPsByHitsMapH, const edm::Handle& simTrackstersFromCPsToTrackstersByHitsMapH, - const SimClusterToCaloParticleMap& scToCpMap) const; + const SimClusterRefVector& scToCpMap) const; double distance2(const double x1, const double y1, const double x2, const double y2) const; double distance(const double x1, const double y1, const double x2, const double y2) const; diff --git a/Validation/HGCalValidation/plugins/BarrelValidator.cc b/Validation/HGCalValidation/plugins/BarrelValidator.cc index 2dcd44385a600..5fc0d9e85ab66 100644 --- a/Validation/HGCalValidation/plugins/BarrelValidator.cc +++ b/Validation/HGCalValidation/plugins/BarrelValidator.cc @@ -93,8 +93,7 @@ BarrelValidator::BarrelValidator(const edm::ParameterSet& pset) label_TSbyLCsCP_(pset.getParameter("label_TSbyLCsCP")), label_TSbyLCs_(pset.getParameter("label_TSbyLCs")), hitsToken_(consumes>(pset.getParameter("hits"))), - scToCpMapToken_( - consumes(pset.getParameter("simClustersToCaloParticlesMap"))), + scToCpMapToken_(consumes(pset.getParameter("simClustersToCaloParticlesMap"))), cpTag_(pset.getParameter("cpTag_")) { cpToken_ = consumes>(cpTag_); @@ -120,10 +119,10 @@ BarrelValidator::BarrelValidator(const edm::ParameterSet& pset) layerClusters_ = consumes(lclTag_); for (const auto& itag : associator_) { - associatorMapRtS.push_back(consumes>(itag)); + associatorMapRtS.push_back(consumes>(itag)); } for (const auto& itag : associator_) { - associatorMapStR.push_back(consumes>(itag)); + associatorMapStR.push_back(consumes>(itag)); } for (const auto& tag : allTracksterTracksterAssociatorsLabels_) { @@ -341,10 +340,10 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, tools_->setGeometry(*geom); histoProducerAlgo_->setRecHitTools(tools_); - std::vector> recSimColl; - std::vector> simRecColl; + std::vector> recSimColl; + std::vector> simRecColl; for (unsigned int i = 0; i < associatorMapRtS.size(); ++i) { - edm::Handle> simToRecoCollectionH; + edm::Handle> simToRecoCollectionH; event.getByToken(associatorMapStR[i], simToRecoCollectionH); if (!simToRecoCollectionH.isValid()) { edm::LogWarning("BarrelValidator") << "simToRecoCollectionH with InputTag " << associator_[i] << " is not valid."; @@ -352,7 +351,7 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, } simRecColl.push_back(*simToRecoCollectionH); - edm::Handle> recoToSimCollectionH; + edm::Handle> recoToSimCollectionH; event.getByToken(associatorMapRtS[i], recoToSimCollectionH); if (!recoToSimCollectionH.isValid()) { edm::LogWarning("BarrelValidator") << "recoToSimCollectionH with InputTag " << associator_[i] << " is not valid."; @@ -427,9 +426,9 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, } const reco::CaloClusterCollection& clusters = *clusterHandle; - edm::Handle scToCpMapHandle; + edm::Handle scToCpMapHandle; event.getByToken(scToCpMapToken_, scToCpMapHandle); - const SimClusterToCaloParticleMap& scToCpMap = *scToCpMapHandle; + const SimClusterRefVector& scToCpMap = *scToCpMapHandle; auto nSimClusters = simClusters.size(); std::vector sCIndices; @@ -547,9 +546,9 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, } ticl::TracksterCollection const& simTrackstersFromCPs = *simTracksterFromCPHandle; - edm::Handle>> simTrackstersMapHandle; - event.getByToken(simTrackstersMap_, simTrackstersMapHandle); - const std::map>& cpToSc_SimTrackstersMap = *simTrackstersMapHandle; + // edm::Handle>> simTrackstersMapHandle; + // event.getByToken(simTrackstersMap_, simTrackstersMapHandle); + // const std::map>& cpToSc_SimTrackstersMap = *simTrackstersMapHandle; std::vector> tracksterToTracksterMapsHandles; for (const auto& token : tracksterToTracksterAssociatorsTokens_) { @@ -604,7 +603,6 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, clusters, simTracksters, simTrackstersFromCPs, - cpToSc_SimTrackstersMap, simClusters, caloParticleHandle.id(), caloParticles, @@ -745,8 +743,8 @@ void BarrelValidator::fillDescriptions(edm::ConfigurationDescriptions& descripti { edm::InputTag("ticlTrackstersCLUE3DBarrel"), }); - desc.add("label_simTS", edm::InputTag("ticlSimTrackstersBarrel")); - desc.add("label_simTSFromCP", edm::InputTag("ticlSimTrackstersBarrel", "fromCPs")); + desc.add("label_simTS", edm::InputTag("ticlSimTrackstersBarrel", "fromBoundarySimCluster")); + desc.add("label_simTSFromCP", edm::InputTag("ticlSimTrackstersBarrel", "fromCaloParticle")); desc.addUntracked>("associator", {edm::InputTag("barrelLayerClusterCaloParticleAssociation")}); desc.addUntracked>("associatorSim", @@ -767,36 +765,38 @@ void BarrelValidator::fillDescriptions(edm::ConfigurationDescriptions& descripti desc.add("label_TSbyLCs", "TSbyLCs"); desc.add("label_TSbyLCsCP", "TSbyLCs_CP"); desc.add("simClustersToCaloParticlesMap", - edm::InputTag("SimClusterToCaloParticleAssociation", "simClusterToCaloParticleMap")); + edm::InputTag("mix", "MergedCaloTruthBoundaryTrackSimCluster")); desc.add("cpTag_", edm::InputTag("mix", "MergedCaloTruth")); desc.add("sclTag", edm::InputTag("mix", "MergedCaloTruth")); - desc.add>("allTracksterTracksterAssociatorsLabels", - { - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", - "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrel"), - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", - "ticlSimTrackstersBarrelToticlTrackstersCLUE3DBarrel"), - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", - "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrelfromCPs"), - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", - "ticlSimTrackstersBarrelfromCPsToticlTrackstersCLUE3DBarrel"), - }); - - desc.add>("allTracksterTracksterByHitsAssociatorsLabels", - { - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", - "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrel"), - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", - "ticlSimTrackstersBarrelToticlTrackstersCLUE3DBarrel"), - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", - "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrelfromCPs"), - edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", - "ticlSimTrackstersBarrelfromCPsToticlTrackstersCLUE3DBarrel"), - }); + desc.add>( + "allTracksterTracksterAssociatorsLabels", + { + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", + "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrelfromBoundarySimCluster"), + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersBarrelfromBoundarySimClusterToticlTrackstersCLUE3DBarrel"), + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", + "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrelfromCaloParticle"), + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersBarrelfromCaloParticleToticlTrackstersCLUE3DBarrel"), + }); + + desc.add>( + "allTracksterTracksterByHitsAssociatorsLabels", + { + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", + "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrelfromBoundarySimCluster"), + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", + "ticlSimTrackstersBarrelfromBoundarySimClusterToticlTrackstersCLUE3DBarrel"), + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", + "ticlTrackstersCLUE3DBarrelToticlSimTrackstersBarrelfromCaloParticle"), + edm::InputTag("allBarrelTrackstersToSimTrackstersAssociationsByHits", + "ticlSimTrackstersBarrelfromCaloParticleToticlTrackstersCLUE3DBarrel"), + }); desc.add("label_cp_effic", edm::InputTag("mix", "MergedCaloTruth")); desc.add("label_cp_fake", edm::InputTag("mix", "MergedCaloTruth")); - desc.add("label_scl", edm::InputTag("mix", "MergedCaloTruth")); + desc.add("label_scl", edm::InputTag("mix", "MergedCaloTruthBoundaryTrackSimCluster")); desc.add("simTrackstersMap", edm::InputTag("ticlSimTrackstersBarrel")); desc.add("simVertices", edm::InputTag("g4SimHits")); desc.add("totallayers_to_monitor", 6); // ECAL: 1 layer, HCAL Barrel: 4 depths, HCAL Outer Barrel: 1 depth diff --git a/Validation/HGCalValidation/plugins/HGCalValidator.cc b/Validation/HGCalValidation/plugins/HGCalValidator.cc index bef9ab9ead147..5dedcda6bf486 100644 --- a/Validation/HGCalValidation/plugins/HGCalValidator.cc +++ b/Validation/HGCalValidation/plugins/HGCalValidator.cc @@ -45,19 +45,27 @@ namespace { } } if (not trackstersToSimTrackstersMap.isValid()) { - edm::LogError("HGCalValidator") << "trackstersToSimTrackstersMap is not valid"; + LogDebug("HGCalValidator") << "trackstersToSimTrackstersMap is not valid (for reco trackster collection " + << tracksterHandle.provenance()->moduleLabel() << "_" + << tracksterHandle.provenance()->productInstanceName() << ")"; return false; } if (not simTrackstersToTrackstersMap.isValid()) { - edm::LogError("HGCalValidator") << "simTrackstersToTrackstersMap is not valid"; + LogDebug("HGCalValidator") << "simTrackstersToTrackstersMap is not valid (for reco trackster collection " + << tracksterHandle.provenance()->moduleLabel() << "_" + << tracksterHandle.provenance()->productInstanceName() << ")"; return false; } if (not trackstersToSimTrackstersFromCPsMap.isValid()) { - edm::LogError("HGCalValidator") << "trackstersToSimTrackstersFromCPsMap is not valid"; + LogDebug("HGCalValidator") << "trackstersToSimTrackstersFromCPsMap is not valid (for reco trackster collection " + << tracksterHandle.provenance()->moduleLabel() << "_" + << tracksterHandle.provenance()->productInstanceName() << ")"; return false; } if (not simTrackstersFromCPsToTrackstersMap.isValid()) { - edm::LogError("HGCalValidator") << "simTrackstersFromCPsToTrackstersMap is not valid"; + LogDebug("HGCalValidator") << "simTrackstersFromCPsToTrackstersMap is not valid (for reco trackster collection " + << tracksterHandle.provenance()->moduleLabel() << "_" + << tracksterHandle.provenance()->productInstanceName() << ")"; return false; } return true; @@ -97,8 +105,7 @@ HGCalValidator::HGCalValidator(const edm::ParameterSet& pset) label_candidates_(pset.getParameter("ticlCandidates")), cummatbudinxo_(pset.getParameter("cummatbudinxo")), hitsToken_(consumes>(pset.getParameter("hits"))), - scToCpMapToken_( - consumes(pset.getParameter("simClustersToCaloParticlesMap"))), + scToCpMapToken_(consumes(pset.getParameter("simClustersToCaloParticlesMap"))), cutTk_(pset.getParameter("cutTk")) { //In this way we can easily generalize to associations between other objects also. const edm::InputTag& label_cp_effic_tag = pset.getParameter("label_cp_effic"); @@ -116,7 +123,7 @@ HGCalValidator::HGCalValidator(const edm::ParameterSet& pset) associatorMapSimtR = consumes>(associatorSim_); associatorMapRtSim = consumes>(associatorSim_); - simTrackstersMap_ = consumes>>(pset.getParameter("simTrackstersMap")); + // simTrackstersMap_ = consumes>>(pset.getParameter("simTrackstersMap")); hitMap_ = consumes>(pset.getParameter("hitMap")); @@ -160,8 +167,9 @@ HGCalValidator::HGCalValidator(const edm::ParameterSet& pset) simTracksters_ = consumes(label_simTS); simTracksters_fromCPs_ = consumes(label_simTSFromCP); - associatorMapRtS = consumes>(associator_); - associatorMapStR = consumes>(associator_); + // Associators + associatorMapRtS = consumes>(associator_); + associatorMapStR = consumes>(associator_); cpSelector = CaloParticleSelector(pset.getParameter("ptMinCP"), pset.getParameter("ptMaxCP"), @@ -393,20 +401,14 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, } ticl::TracksterCollection const& simTrackstersFromCPs = *simTracksterFromCPHandle; - edm::Handle>> simTrackstersMapHandle; - event.getByToken(simTrackstersMap_, simTrackstersMapHandle); - const std::map>& cpToSc_SimTrackstersMap = *simTrackstersMapHandle; - edm::ESHandle geom = setup.getHandle(caloGeomToken_); tools_->setGeometry(*geom); histoProducerAlgo_->setRecHitTools(tools_); - edm::Handle> simtorecoCollectionH; - event.getByToken(associatorMapStR, simtorecoCollectionH); - const auto& simRecColl = *simtorecoCollectionH; - edm::Handle> recotosimCollectionH; - event.getByToken(associatorMapRtS, recotosimCollectionH); - const auto& recSimColl = *recotosimCollectionH; + const ticl::SimToRecoCollectionWithSimClustersT& simRecColl_CP = + event.get(associatorMapStR); + const ticl::RecoToSimCollectionWithSimClustersT& recSimColl_CP = + event.get(associatorMapRtS); edm::Handle> hitMapHandle; event.getByToken(hitMap_, hitMapHandle); @@ -479,9 +481,7 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, tracksterToTracksterByHitsMapsHandles.push_back(tracksterToTracksterByHitsMapHandle); } - edm::Handle scToCpMapHandle; - event.getByToken(scToCpMapToken_, scToCpMapHandle); - const SimClusterToCaloParticleMap& scToCpMap = *scToCpMapHandle; + const SimClusterRefVector& scToCpMap = event.get(scToCpMapToken_); auto nSimClusters = simClusters.size(); std::vector sCIndices; @@ -510,7 +510,8 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, const auto& inputClusterMaskHandle = event.getHandle(clustersMaskTokens_[ws]); if (!inputClusterMaskHandle.isValid()) { - edm::LogError("ClusterMaskError") << "Failed to retrieve clusters mask for ws index: " << ws; + edm::LogError("ClusterMaskError") + << "Failed to retrieve clusters mask for ws index: " << ws << ", " << label_clustersmask[ws].label(); continue; // Or handle the error appropriately } @@ -521,7 +522,7 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, auto simRecColl = *simtorecoCollectionH; edm::Handle> recotosimCollectionH; event.getByToken(associatorMapRtSim, recotosimCollectionH); - auto recSimColl = *recotosimCollectionH; + auto recSimColl = *recotosimCollectionH; // Warning : variable shadowing here histoProducerAlgo_->fill_simClusterAssociation_histos(histograms.histoProducerAlgo, ws, @@ -560,8 +561,8 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, cumulative_material_budget, totallayers_to_monitor_, thicknesses_to_monitor_, - recSimColl, - simRecColl, + recSimColl_CP, + simRecColl_CP, rechitSpan); for (unsigned int layerclusterIndex = 0; layerclusterIndex < clusters.size(); layerclusterIndex++) { @@ -616,7 +617,6 @@ void HGCalValidator::dqmAnalyze(const edm::Event& event, clusters, simTracksters, simTrackstersFromCPs, - cpToSc_SimTrackstersMap, simClusters, caloParticleHandle.id(), caloParticles, @@ -791,13 +791,15 @@ void HGCalValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptio { edm::InputTag("ticlTrackstersCLUE3DHigh"), edm::InputTag("ticlTrackstersMerge"), - edm::InputTag("ticlSimTracksters", "fromCPs"), - edm::InputTag("ticlSimTracksters"), + edm::InputTag("ticlSimTracksters", "fromCaloParticle"), + edm::InputTag("ticlSimTracksters", "fromBoundarySimCluster"), }); - desc.add("label_simTS", edm::InputTag("ticlSimTracksters")); - desc.add("label_simTSFromCP", edm::InputTag("ticlSimTracksters", "fromCPs")); - desc.addUntracked("associator", edm::InputTag("layerClusterCaloParticleAssociationProducer")); - desc.addUntracked("associatorSim", edm::InputTag("layerClusterSimClusterAssociationProducer")); + desc.add("label_simTS", edm::InputTag("ticlSimTracksters", "fromBoundarySimCluster")); + desc.add("label_simTSFromCP", edm::InputTag("ticlSimTracksters", "fromCaloParticle")); + desc.addUntracked("associator", + edm::InputTag("layerClusterCaloParticleSimClusterAssociationProducer")); + desc.addUntracked("associatorSim", + edm::InputTag("layerClusterBoundaryTrackSimClusterAssociationProducer")); desc.addUntracked("SaveGeneralInfo", true); desc.addUntracked("doCaloParticlePlots", true); desc.addUntracked("doCaloParticleSelection", true); @@ -813,73 +815,90 @@ void HGCalValidator::fillDescriptions(edm::ConfigurationDescriptions& descriptio desc.add("label_TSbyHits", "TSbyHits"); desc.add("label_TSbyLCs", "TSbyLCs"); desc.add("label_TSbyLCsCP", "TSbyLCs_CP"); - desc.add("simClustersToCaloParticlesMap", - edm::InputTag("SimClusterToCaloParticleAssociation", "simClusterToCaloParticleMap")); + desc.add( + "simClustersToCaloParticlesMap", + edm::InputTag( + "mix", + "MergedCaloTruthBoundaryTrackSimCluster")); // CaloTruthAccumulator produces a RefVector SimCluster -> CaloParticle (here we take the legacy SimCluster) desc.add>( "allTracksterTracksterAssociatorsLabels", { - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlTrackstersCLUE3DHighToticlSimTracksters"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersToticlTrackstersCLUE3DHigh"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", - "ticlTrackstersCLUE3DHighToticlSimTrackstersfromCPs"), + "ticlTrackstersCLUE3DHighToticlSimTrackstersfromBoundarySimCluster"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersfromBoundarySimClusterToticlTrackstersCLUE3DHigh"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlTrackstersCLUE3DHighToticlSimTrackstersfromCaloParticle"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersfromBoundarySimClusterfromCaloParticleToticlTrackstersCLUE3DHigh"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlTracksterLinksToticlSimTrackstersfromBoundarySimCluster"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersfromBoundarySimClusterToticlTracksterLinks"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlTracksterLinksToticlSimTrackstersfromCaloParticle"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersfromBoundarySimClusterfromCaloParticleToticlTracksterLinks"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", - "ticlSimTrackstersfromCPsToticlTrackstersCLUE3DHigh"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlTracksterLinksToticlSimTracksters"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersToticlTracksterLinks"), + "ticlCandidateToticlSimTrackstersfromBoundarySimCluster"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", - "ticlTracksterLinksToticlSimTrackstersfromCPs"), + "ticlSimTrackstersfromBoundarySimClusterToticlCandidate"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", - "ticlSimTrackstersfromCPsToticlTracksterLinks"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlCandidateToticlSimTracksters"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersToticlCandidate"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlCandidateToticlSimTrackstersfromCPs"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersfromCPsToticlCandidate"), + "ticlCandidateToticlSimTrackstersfromCaloParticle"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersfromfromCaloParticleToticlCandidate"), }); desc.add>( "allTracksterTracksterByHitsAssociatorsLabels", { edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", - "ticlTrackstersCLUE3DHighToticlSimTracksters"), + "ticlTrackstersCLUE3DHighToticlSimTrackstersfromBoundarySimCluster"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", + "ticlSimTrackstersfromBoundarySimClusterToticlTrackstersCLUE3DHigh"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", + "ticlTrackstersCLUE3DHighToticlSimTrackstersfromCaloParticle"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", + "ticlSimTrackstersfromBoundarySimClusterfromCaloParticleToticlTrackstersCLUE3DHigh"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", + "ticlTracksterLinksToticlSimTrackstersfromBoundarySimCluster"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", - "ticlSimTrackstersToticlTrackstersCLUE3DHigh"), + "ticlSimTrackstersfromBoundarySimClusterToticlTracksterLinks"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", - "ticlTrackstersCLUE3DHighToticlSimTrackstersfromCPs"), + "ticlTracksterLinksToticlSimTrackstersfromCaloParticle"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", - "ticlSimTrackstersfromCPsToticlTrackstersCLUE3DHigh"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlTracksterLinksToticlSimTracksters"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlSimTrackstersToticlTracksterLinks"), + "ticlSimTrackstersfromBoundarySimClusterfromCaloParticleToticlTracksterLinks"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", - "ticlTracksterLinksToticlSimTrackstersfromCPs"), + "ticlCandidateToticlSimTrackstersfromBoundarySimCluster"), edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", - "ticlSimTrackstersfromCPsToticlTracksterLinks"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlCandidateToticlSimTracksters"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlSimTrackstersToticlCandidate"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlCandidateToticlSimTrackstersfromCPs"), - edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", "ticlSimTrackstersfromCPsToticlCandidate"), + "ticlSimTrackstersfromBoundarySimClusterToticlCandidate"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", + "ticlCandidateToticlSimTrackstersfromCaloParticle"), + edm::InputTag("allTrackstersToSimTrackstersAssociationsByHits", + "ticlSimTrackstersfromBoundarySimClusterfromCaloParticleToticlCandidate"), }); desc.addUntracked("doCandidatesPlots", true); desc.add("ticlCandidates", "ticlCandidates"); desc.add("ticlTrackstersMerge", edm::InputTag("ticlCandidate")); - desc.add("simTiclCandidates", edm::InputTag("ticlSimTracksters")); + desc.add("simTiclCandidates", edm::InputTag("ticlSimTICLCandidatesFromBoundary")); desc.add("recoTracks", edm::InputTag("generalTracks")); - desc.add( - "mergeRecoToSimAssociator", - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlCandidateToticlSimTrackstersfromCPs")); - desc.add( - "mergeSimToRecoAssociator", - edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", "ticlSimTrackstersfromCPsToticlCandidate")); + desc.add("mergeRecoToSimAssociator", + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlCandidateToticlSimTrackstersfromCaloParticle")); + desc.add("mergeSimToRecoAssociator", + edm::InputTag("allTrackstersToSimTrackstersAssociationsByLCs", + "ticlSimTrackstersfromCaloParticleToticlCandidate")); desc.add("cummatbudinxo", edm::FileInPath("Validation/HGCalValidation/data/D41.cumulative.xo")); desc.add("label_cp_effic", edm::InputTag("mix", "MergedCaloTruth")); desc.add("label_cp_fake", edm::InputTag("mix", "MergedCaloTruth")); - desc.add("label_scl", edm::InputTag("mix", "MergedCaloTruth")); + desc.add("label_scl", edm::InputTag("mix", "MergedCaloTruthBoundaryTrackSimCluster")); desc.add("simVertices", edm::InputTag("g4SimHits")); desc.add("simTrackstersMap", edm::InputTag("ticlSimTracksters")); desc.add("hitMap", edm::InputTag("recHitMapProducer", "hgcalRecHitMap")); desc.add>("LayerClustersInputMask", { edm::InputTag("ticlTrackstersCLUE3DHigh"), - edm::InputTag("ticlSimTracksters", "fromCPs"), - edm::InputTag("ticlSimTracksters"), + edm::InputTag("ticlSimTracksters", "fromCaloParticle"), + edm::InputTag("ticlSimTracksters", "fromBoundarySimCluster"), }); desc.add("totallayers_to_monitor", 52); desc.add>("thicknesses_to_monitor", diff --git a/Validation/HGCalValidation/python/HGCalValidator_cff.py b/Validation/HGCalValidation/python/HGCalValidator_cff.py index e8f891f748a5d..b186fbc9d705e 100644 --- a/Validation/HGCalValidation/python/HGCalValidator_cff.py +++ b/Validation/HGCalValidation/python/HGCalValidator_cff.py @@ -6,18 +6,18 @@ # Default configuration is now TICLv5 hgcalValidator = _hgcalValidator.clone( - label_tst = cms.VInputTag(*[cms.InputTag(label) for label in ticlIterLabelsPSet.labels] + [cms.InputTag("ticlSimTracksters", "fromCPs"), cms.InputTag("ticlSimTracksters")]), + label_tst = cms.VInputTag(*[cms.InputTag(label) for label in ticlIterLabelsPSet.labels] + [cms.InputTag('ticlSimTracksters', 'fromCaloParticle'), cms.InputTag("ticlSimTracksters", "fromLegacySimCluster"), cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), cms.InputTag("ticlSimTracksters", "fromMergedSimCluster")]), allTracksterTracksterAssociatorsLabels = cms.VInputTag( *[cms.InputTag('allTrackstersToSimTrackstersAssociationsByLCs:'+associator) for associator in associatorsInstances] ), allTracksterTracksterByHitsAssociatorsLabels = cms.VInputTag( *[cms.InputTag('allTrackstersToSimTrackstersAssociationsByHits:'+associator) for associator in associatorsInstances] ), # v5 defaults LayerClustersInputMask = cms.VInputTag( cms.InputTag("ticlTrackstersCLUE3DHigh"), - cms.InputTag("ticlSimTracksters", "fromCPs"), - cms.InputTag("ticlSimTracksters") + cms.InputTag("ticlSimTracksters", "fromCaloParticle"), + cms.InputTag("ticlSimTracksters", "fromBoundarySimCluster"), ), ticlTrackstersMerge = cms.InputTag("ticlCandidate"), - mergeSimToRecoAssociator = cms.InputTag("allTrackstersToSimTrackstersAssociationsByLCs:ticlSimTrackstersfromCPsToticlCandidate"), - mergeRecoToSimAssociator = cms.InputTag("allTrackstersToSimTrackstersAssociationsByLCs:ticlCandidateToticlSimTrackstersfromCPs"), + mergeSimToRecoAssociator = cms.InputTag("allTrackstersToSimTrackstersAssociationsByLCs:ticlSimTrackstersfromCaloParticleToticlCandidate"), + mergeRecoToSimAssociator = cms.InputTag("allTrackstersToSimTrackstersAssociationsByLCs:ticlCandidateToticlSimTrackstersfromCaloParticle"), ) from Configuration.ProcessModifiers.premix_stage2_cff import premix_stage2 @@ -25,6 +25,7 @@ label_cp_fake = "mixData:MergedCaloTruth", label_cp_effic = "mixData:MergedCaloTruth", label_scl = "mixData:MergedCaloTruth", + simClustersToCaloParticlesMap = cms.InputTag("mixData", hgcalValidator.simClustersToCaloParticlesMap.productInstanceLabel) ) from Configuration.Eras.Modifier_phase2_hgcalV10_cff import phase2_hgcalV10 diff --git a/Validation/HGCalValidation/python/HLTBarrelValidator_cff.py b/Validation/HGCalValidation/python/HLTBarrelValidator_cff.py index 3889cebb91b9f..e1e3bf23d1710 100644 --- a/Validation/HGCalValidation/python/HLTBarrelValidator_cff.py +++ b/Validation/HGCalValidation/python/HLTBarrelValidator_cff.py @@ -1,8 +1,7 @@ import FWCore.ParameterSet.Config as cms from Validation.HGCalValidation.barrelValidator_cfi import barrelValidator as _barrelValidator -from SimCalorimetry.HGCalAssociatorProducers.hltLCToCPAssociation_cfi import hltBarrelLayerClusterCaloParticleAssociation -from SimCalorimetry.HGCalAssociatorProducers.hltLCToSCAssociation_cfi import hltBarrelLayerClusterSimClusterAssociation +from SimCalorimetry.HGCalAssociatorProducers.hltLCToSCAssociation_cfi import hltBarrelLayerClusterSimClusterAssociation, hltBarrelLayerClusterSimClusterAssociation hltBarrelValidator = _barrelValidator.clone( lclTag = 'hltMergeLayerClusters', diff --git a/Validation/HGCalValidation/python/HLTHGCalValidator_cff.py b/Validation/HGCalValidation/python/HLTHGCalValidator_cff.py index a6d96e460e0fe..4e13cecf9220a 100644 --- a/Validation/HGCalValidation/python/HLTHGCalValidator_cff.py +++ b/Validation/HGCalValidation/python/HLTHGCalValidator_cff.py @@ -5,14 +5,14 @@ hltAssociatorInstances = [] for labelts in _hltTiclIterLabelsPSet.labels: - for labelsts in ['hltTiclSimTracksters', 'hltTiclSimTrackstersfromCPs']: + for labelsts in ["hltTiclSimTrackstersfromBoundarySimCluster", 'hltTiclSimTrackstersfromCaloParticle']: hltAssociatorInstances.append(labelts+'To'+labelsts) hltAssociatorInstances.append(labelsts+'To'+labelts) # Default is TICLv5 hltHgcalValidator = _hgcalValidator.clone( - LayerClustersInputMask = cms.VInputTag("hltTiclTrackstersCLUE3DHigh", "hltTiclSimTracksters:fromCPs", "hltTiclSimTracksters"), - label_tst = cms.VInputTag(*[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels] + [cms.InputTag("hltTiclSimTracksters", "fromCPs"), cms.InputTag("hltTiclSimTracksters")]), + LayerClustersInputMask = cms.VInputTag("hltTiclTrackstersCLUE3DHigh", "hltTiclSimTracksters:fromCaloParticle", "hltTiclSimTracksters:fromBoundarySimCluster"), # "hltTiclSimTracksters:fromLegacySimCluster", + label_tst = cms.VInputTag(*[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels] + [cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster")]), # cms.InputTag("hltTiclSimTracksters", "fromLegacySimCluster"), allTracksterTracksterAssociatorsLabels = cms.VInputTag( *[cms.InputTag('hltAllTrackstersToSimTrackstersAssociationsByLCs:'+associator) for associator in hltAssociatorInstances] ), allTracksterTracksterByHitsAssociatorsLabels = cms.VInputTag( *[cms.InputTag('hltAllTrackstersToSimTrackstersAssociationsByHits:'+associator) for associator in hltAssociatorInstances] ), associator = cms.untracked.InputTag("hltHGCalLayerClusterCaloParticleAssociation"), @@ -20,17 +20,16 @@ dirName = cms.string('HLT/HGCAL/HGCalValidator/'), hits = cms.InputTag("hltHGCalRecHitMapProducer", "RefProdVectorHGCRecHitCollection"), hitMap = cms.InputTag("hltHGCalRecHitMapProducer","hgcalRecHitMap"), - simTrackstersMap = cms.InputTag("hltTiclSimTracksters"), + simTrackstersMap = cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), label_layerClustersPlots = cms.string("hltHgcalMergeLayerClusters"), label_lcl = cms.InputTag("hltMergeLayerClusters"), - label_simTS = cms.InputTag("hltTiclSimTracksters"), - label_simTSFromCP = cms.InputTag("hltTiclSimTracksters","fromCPs"), + label_simTS = cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), + label_simTSFromCP = cms.InputTag("hltTiclSimTracksters","fromCaloParticle"), recoTracks = cms.InputTag("hltGeneralTracks"), - simClustersToCaloParticlesMap = cms.InputTag("SimClusterToCaloParticleAssociation","simClusterToCaloParticleMap"), - simTiclCandidates = cms.InputTag("hltTiclSimTracksters"), + simTiclCandidates = cms.InputTag("hltTiclSimTICLCandidatesFromBoundary"), ticlCandidates = cms.string('hltTiclCandidate'), ticlTrackstersMerge = cms.InputTag("hltTiclCandidate"), - mergeRecoToSimAssociator = cms.InputTag("hltAllTrackstersToSimTrackstersAssociationsByLCs","hltTiclCandidateTohltTiclSimTrackstersfromCPs"), - mergeSimToRecoAssociator = cms.InputTag("hltAllTrackstersToSimTrackstersAssociationsByLCs","hltTiclSimTrackstersfromCPsTohltTiclCandidate"), + mergeRecoToSimAssociator = cms.InputTag("hltAllTrackstersToSimTrackstersAssociationsByLCs","hltTiclCandidateTohltTiclSimTrackstersfromCaloParticle"), + mergeSimToRecoAssociator = cms.InputTag("hltAllTrackstersToSimTrackstersAssociationsByLCs","hltTiclSimTrackstersfromCaloParticleTohltTiclCandidate"), ) diff --git a/Validation/HGCalValidation/python/ticlSuperclusterValidation_cff.py b/Validation/HGCalValidation/python/ticlSuperclusterValidation_cff.py index 18cf213d2001a..5609fc75abf77 100644 --- a/Validation/HGCalValidation/python/ticlSuperclusterValidation_cff.py +++ b/Validation/HGCalValidation/python/ticlSuperclusterValidation_cff.py @@ -9,7 +9,7 @@ sourceTracksterIteration = "ticlTrackstersCLUE3DHigh" # trackster collection used as input to superclustering (CLUE3D tracksters) superclusterTracksterIteration = "ticlTracksterLinksSuperclusteringDNN" # trackster collection output by superclustering (superclusters in trackster dataformat) -simTrackstersCollection = "ticlSimTrackstersfromCPs" # simtrackster collection used for genmatching (CaloParticle) +simTrackstersCollection = "ticlSimTrackstersfromCaloParticle" # simtrackster collection used for genmatching (CaloParticle) sim2recoscore = 0.3 # cut on sim2reco score to consider a supercluster genmatched diff --git a/Validation/HGCalValidation/scripts/makeHGCalValidationPlots.py b/Validation/HGCalValidation/scripts/makeHGCalValidationPlots.py index 02f29ec0d8bc6..48ad03fd26b84 100755 --- a/Validation/HGCalValidation/scripts/makeHGCalValidationPlots.py +++ b/Validation/HGCalValidation/scripts/makeHGCalValidationPlots.py @@ -8,7 +8,7 @@ from Validation.HGCalValidation.HGCalValidator_cff import hgcalValidator import Validation.RecoTrack.plotting.plotting as plotting -simClustersIters = [hgcalValidator.label_SimClustersLevel.value(), "ticlSimTracksters"] +simClustersIters = [hgcalValidator.label_SimClustersLevel.value(), "ticlSimTracksters_fromBoundarySimCluster"] hitCalLabel = 'hitCalibration' hitValLabel = 'hitValidation' diff --git a/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc b/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc index 920bf23d99d42..b9b27e28f9039 100644 --- a/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc +++ b/Validation/HGCalValidation/src/BarrelVHistoProducerAlgo.cc @@ -2,6 +2,7 @@ #include #include +#include "DataFormats/Common/interface/Ref.h" #include "Validation/HGCalValidation/interface/BarrelVHistoProducerAlgo.h" #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" @@ -1324,8 +1325,8 @@ void BarrelVHistoProducerAlgo::layerClusters_to_CaloParticles( std::vector const& cPSelectedIndices, std::unordered_map const& barrelHitMap, unsigned int layers, - const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, - const ticl::SimToRecoCollectionT& cPOnLayerMap, + const ticl::RecoToSimCollectionWithSimClustersT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& cPOnLayerMap, edm::MultiSpan const& barrelHits) const { const auto nLayerClusters = clusters.size(); @@ -1505,8 +1506,8 @@ void BarrelVHistoProducerAlgo::layerClusters_to_CaloParticles( // gen-level, namely efficiency and duplicate. In this loop should restrict // only to the selected caloParaticles. for (const auto& cpId : cPSelectedIndices) { - const edm::Ref cpRef(caloParticleHandle, cpId); - const auto& lcsIt = cPOnLayerMap.find(cpRef); + // We assume cPOnLayerMap refers to a SimCluster collection in 1-1 mapping with caloParticles + const auto& lcsIt = cPOnLayerMap.find(edm::Ref(cPOnLayerMap.refProd().key, cpId)); std::map cPEnergyOnLayer; for (unsigned int layerId = 0; layerId < layers; ++layerId) @@ -1787,8 +1788,8 @@ void BarrelVHistoProducerAlgo::fill_generic_cluster_histos( std::vector const& cPSelectedIndices, std::unordered_map const& barrelHitMap, unsigned int layers, - const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, - const ticl::SimToRecoCollectionT& cPOnLayerMap, + const ticl::RecoToSimCollectionWithSimClustersT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& cPOnLayerMap, edm::MultiSpan const& barrelHits) const { //To keep track of total num of layer clusters per layer std::vector tnlcpl(layers, 0); @@ -1836,7 +1837,7 @@ void BarrelVHistoProducerAlgo::tracksters_to_SimTracksters_fp( const TracksterToTracksterMap& trackstersToSimTrackstersMap, const TracksterToTracksterMap& simTrackstersToTrackstersMap, const validationType valType, - const SimClusterToCaloParticleMap& scToCpMap, + const SimClusterRefVector& scToCpMap, const std::vector& cPIndices, const std::vector& cPSelectedIndices, const edm::ProductID& cPHandle_id) const { @@ -1844,16 +1845,23 @@ void BarrelVHistoProducerAlgo::tracksters_to_SimTracksters_fp( const auto nSimTracksters = simTrackstersToTrackstersMap.getMap().size(); std::vector tracksters_FakeMerge(nTracksters, 0); std::vector tracksters_PurityDuplicate(nSimTracksters, 0); - auto getCPId = [](const ticl::Trackster& simTS, - const edm::ProductID& cPHandle_id, - const SimClusterToCaloParticleMap& scToCpMap) { - const auto productID = simTS.seedID(); - if (productID == cPHandle_id) { - return simTS.seedIndex(); - } else { - return int(scToCpMap.at(simTS.seedIndex()).index()); - } - }; + auto getCPId = + [](const ticl::Trackster& simTS, const edm::ProductID& cPHandle_id, const SimClusterRefVector& scToCpMap) { + /* 2 cases: + - the simTS is built from "CaloParticle" SimCluster collection, in which case simTS.seedID points to the "CaloParticle" SimCluster which is identically keyed to the CaloParticle collection + thus we can juste use as index into CaloParticle collection simTS.seedIndex() + - the simTs is built from "legacy" (or "boundary") SimCluster collection. Then: + first map from SimTs to SimCluster (imTS.seedIndex()), then map from SimCluster to "CaloParticle" SimCluster (which is same index as CaloParticle) + There is no check that the collections actually match (would need matching of ProductID between "CaloParticle" SimCluster collection & CaloParticle collection, until the usage of CaloParticle is fully replaced by SimCluster in HGCalValidation) + */ + if (simTS.ticlIteration() == ticl::Trackster::SIM_CP) + return simTS.seedIndex(); + else if (simTS.ticlIteration() == ticl::Trackster::SIM) + return int(scToCpMap.at(simTS.seedIndex()).index()); + else + throw cms::Exception("WrongMapping") + << "A SimTrackster object has no valid Trackster iterationIndex (need SIM or SIM_CP)"; + }; auto ScoreCutSTStoTSPurDup = ScoreCutSTStoTSPurDup_[0]; auto ScoreCutTStoSTSFakeMerge = ScoreCutTStoSTSFakeMerge_[0]; @@ -2002,7 +2010,6 @@ void BarrelVHistoProducerAlgo::fill_trackster_histos( const reco::CaloClusterCollection& layerClusters, const ticl::TracksterCollection& simTSs, const ticl::TracksterCollection& simTSs_fromCP, - const std::map>& cpToSc_SimTrackstersMap, std::vector const& sC, const edm::ProductID& cPHandle_id, std::vector const& cP, @@ -2020,7 +2027,7 @@ void BarrelVHistoProducerAlgo::fill_trackster_histos( const edm::Handle& simTrackstersToTrackstersByHitsMapH, const edm::Handle& trackstersToSimTrackstersFromCPsByHitsMapH, const edm::Handle& simTrackstersFromCPsToTrackstersByHitsMapH, - const SimClusterToCaloParticleMap& scToCpMap) const { + const SimClusterRefVector& scToCpMap) const { //Each event to be treated as two events: if (tracksters.empty()) return; diff --git a/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc b/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc index fd05c9106c0e3..4cf135b593ef8 100644 --- a/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc +++ b/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc @@ -1760,8 +1760,8 @@ void HGVHistoProducerAlgo::layerClusters_to_CaloParticles( std::vector const& cPSelectedIndices, std::unordered_map const& hitMap, unsigned int layers, - const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, - const ticl::SimToRecoCollectionT& cPOnLayerMap, + const ticl::RecoToSimCollectionWithSimClustersT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& cPOnLayerMap, edm::MultiSpan const& hits) const { const auto nLayerClusters = clusters.size(); @@ -1939,8 +1939,8 @@ void HGVHistoProducerAlgo::layerClusters_to_CaloParticles( // gen-level, namely efficiency and duplicate. In this loop should restrict // only to the selected caloParaticles. for (const auto& cpId : cPSelectedIndices) { - const edm::Ref cpRef(caloParticleHandle, cpId); - const auto& lcsIt = cPOnLayerMap.find(cpRef); + // We assume cPOnLayerMap refers to a SimCluster collection in 1-1 mapping with caloParticles + const auto& lcsIt = cPOnLayerMap.find(edm::Ref(cPOnLayerMap.refProd().key, cpId)); std::map cPEnergyOnLayer; for (unsigned int layerId = 0; layerId < layers * 2; ++layerId) @@ -2221,8 +2221,8 @@ void HGVHistoProducerAlgo::fill_generic_cluster_histos( std::map cummatbudg, unsigned int layers, std::vector thicknesses, - const ticl::RecoToSimCollectionT& cpsInLayerClusterMap, - const ticl::SimToRecoCollectionT& cPOnLayerMap, + const ticl::RecoToSimCollectionWithSimClustersT& cpsInLayerClusterMap, + const ticl::SimToRecoCollectionWithSimClustersT& cPOnLayerMap, edm::MultiSpan const& hits) const { //Each event to be treated as two events: an event in +ve endcap, //plus another event in -ve endcap. In this spirit there will be @@ -2535,7 +2535,7 @@ void HGVHistoProducerAlgo::tracksters_to_SimTracksters_fp(const Histograms& hist const TracksterToTracksterMap& trackstersToSimTrackstersMap, const TracksterToTracksterMap& simTrackstersToTrackstersMap, const validationType valType, - const SimClusterToCaloParticleMap& scToCpMap, + const SimClusterRefVector& scToCpMap, const std::vector& cPIndices, const std::vector& cPSelectedIndices, const edm::ProductID& cPHandle_id) const { @@ -2543,15 +2543,21 @@ void HGVHistoProducerAlgo::tracksters_to_SimTracksters_fp(const Histograms& hist const auto nSimTracksters = simTrackstersToTrackstersMap.getMap().size(); std::vector tracksters_FakeMerge(nTracksters, 0); std::vector tracksters_PurityDuplicate(nSimTracksters, 0); - auto getCPId = [](const ticl::Trackster& simTS, - const edm::ProductID& cPHandle_id, - const SimClusterToCaloParticleMap& scToCpMap) { - const auto productID = simTS.seedID(); - if (productID == cPHandle_id) { + auto getCPId = [&scToCpMap](const ticl::Trackster& simTS) { + /* 2 cases: + - the simTS is built from "CaloParticle" SimCluster collection, in which case simTS.seedID points to the "CaloParticle" SimCluster which is identically keyed to the CaloParticle collection + thus we can juste use as index into CaloParticle collection simTS.seedIndex() + - the simTs is built from "legacy" (or "boundary") SimCluster collection. Then: + first map from SimTs to SimCluster (imTS.seedIndex()), then map from SimCluster to "CaloParticle" SimCluster (which is same index as CaloParticle) + There is no check that the collections actually match (would need matching of ProductID between "CaloParticle" SimCluster collection & CaloParticle collection, until the usage of CaloParticle is fully replaced by SimCluster in HGCalValidation) + */ + if (simTS.ticlIteration() == ticl::Trackster::SIM_CP) return simTS.seedIndex(); - } else { + else if (simTS.ticlIteration() == ticl::Trackster::SIM) return int(scToCpMap.at(simTS.seedIndex()).index()); - } + else + throw cms::Exception("WrongMapping") + << "A SimTrackster object has no valid Trackster iterationIndex (need SIM or SIM_CP)"; }; auto ScoreCutSTStoTSPurDup = ScoreCutSTStoTSPurDup_[0]; @@ -2614,7 +2620,7 @@ void HGVHistoProducerAlgo::tracksters_to_SimTracksters_fp(const Histograms& hist // only to the selected caloParaticles. for (unsigned int simTracksterIndex = 0; simTracksterIndex < nSimTracksters; ++simTracksterIndex) { const auto& simTrackster = *(simTrackstersToTrackstersMap.getRefFirst(simTracksterIndex)); - const auto cpId = getCPId(simTrackster, cPHandle_id, scToCpMap); + const auto cpId = getCPId(simTrackster); if (std::find(cPSelectedIndices.begin(), cPSelectedIndices.end(), cpId) == cPSelectedIndices.end()) continue; const auto sts_eta = simTrackster.barycenter().eta(); @@ -2701,7 +2707,6 @@ void HGVHistoProducerAlgo::fill_trackster_histos( const reco::CaloClusterCollection& layerClusters, const ticl::TracksterCollection& simTSs, const ticl::TracksterCollection& simTSs_fromCP, - const std::map>& cpToSc_SimTrackstersMap, std::vector const& sC, const edm::ProductID& cPHandle_id, std::vector const& cP, @@ -2719,7 +2724,7 @@ void HGVHistoProducerAlgo::fill_trackster_histos( const edm::Handle& simTrackstersToTrackstersByHitsMapH, const edm::Handle& trackstersToSimTrackstersFromCPsByHitsMapH, const edm::Handle& simTrackstersFromCPsToTrackstersByHitsMapH, - const SimClusterToCaloParticleMap& scToCpMap) const { + const SimClusterRefVector& scToCpMap) const { //Each event to be treated as two events: //an event in +ve endcap, plus another event in -ve endcap. diff --git a/Validation/HGCalValidation/src/TICLCandidateValidator.cc b/Validation/HGCalValidation/src/TICLCandidateValidator.cc index 890e776ef209a..f4e65077e4f6e 100644 --- a/Validation/HGCalValidation/src/TICLCandidateValidator.cc +++ b/Validation/HGCalValidation/src/TICLCandidateValidator.cc @@ -431,7 +431,9 @@ void TICLCandidateValidator::fillCandidateHistos(const edm::Event& event, edm::Handle mergeTsSimToReco_h; event.getByToken(associatorMapStRToken_, mergeTsSimToReco_h); + /// Map : SimTrackster collection in 1-1 correspondance to simTICLCandidate => TICLCandidates tracksters auto const& mergeTsSimToRecoMap = *mergeTsSimToReco_h; + assert(mergeTsSimToRecoMap.getCollectionIDs().second.id() == Tracksters_h.id()); // candidates plots for (const auto& cand : TICLCandidates) { @@ -445,7 +447,7 @@ void TICLCandidateValidator::fillCandidateHistos(const edm::Event& event, histograms.h_candidate_partType->Fill(std::max_element(arr.begin(), arr.end()) - arr.begin()); } - std::vector chargedCandidates; + std::vector chargedCandidates; // indices into SimTICLCandidate collection std::vector neutralCandidates; chargedCandidates.reserve(simTICLCandidates.size()); neutralCandidates.reserve(simTICLCandidates.size()); @@ -508,14 +510,16 @@ void TICLCandidateValidator::fillCandidateHistos(const edm::Event& event, int32_t cand_idx = -1; float shared_energy = 0.; + // take the SimTrackster used to build SimTICLCandidate ("base" ie CaloParticle one) and find simToReco-associated reco "ticlCandidate" tracksters (assume 1-1 mapping SimTICLCandidate-SimTrackster) + assert(i < (int)mergeTsSimToRecoMap.size()); const auto& ts_vec = mergeTsSimToRecoMap[i]; if (!ts_vec.empty()) { auto min_elem = std::min_element(ts_vec.begin(), ts_vec.end(), [](auto const& ts1_id_pair, auto const& ts2_id_pair) { return ts1_id_pair.score() < ts2_id_pair.score(); - }); + }); // take the best-associated trackster shared_energy = min_elem->sharedEnergy(); - cand_idx = min_elem->index(); + cand_idx = min_elem->index(); // index of reco TICLCandidate trackster best-associated to simTICLCandidate } // no reco associated to sim if (cand_idx == -1) { @@ -591,6 +595,7 @@ void TICLCandidateValidator::fillCandidateHistos(const edm::Event& event, int32_t cand_idx = -1; float shared_energy = 0.; + assert(i < (int)mergeTsSimToRecoMap.size()); const auto& ts_vec = mergeTsSimToRecoMap[i]; if (!ts_vec.empty()) { auto min_elem = From 36ac725ecde76cde6cdacc82cf962f0a6cba9af3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Cuisset?= Date: Wed, 10 Jun 2026 09:37:29 +0000 Subject: [PATCH 2/3] Remove commented code, and use const references --- .../Configuration/python/hltHGCalSimValid_cff.py | 11 ----------- .../HGCalValidation/interface/HGVHistoProducerAlgo.h | 4 ++-- Validation/HGCalValidation/plugins/BarrelValidator.cc | 4 ---- .../HGCalValidation/src/HGVHistoProducerAlgo.cc | 11 ++++++----- .../HGCalValidation/src/TICLCandidateValidator.cc | 4 +++- 5 files changed, 11 insertions(+), 23 deletions(-) diff --git a/Validation/Configuration/python/hltHGCalSimValid_cff.py b/Validation/Configuration/python/hltHGCalSimValid_cff.py index 9e2b66366ee0b..e171cfdc113b8 100644 --- a/Validation/Configuration/python/hltHGCalSimValid_cff.py +++ b/Validation/Configuration/python/hltHGCalSimValid_cff.py @@ -1,14 +1,10 @@ import FWCore.ParameterSet.Config as cms -from SimCalorimetry.HGCalAssociatorProducers.LCToSCAssociation_cff import scAssocByEnergyScoreProducer as _scAssocByEnergyScoreProducer, layerClusterSimClusterAssociationProducer as _layerClusterSimClusterAssociationProducer, layerClusterBoundaryTrackSimClusterAssociationProducer as _layerClusterBoundaryTrackSimClusterAssociationProducer, layerClusterCaloParticleSimClusterAssociationProducer as _layerClusterCaloParticleSimClusterAssociationProducer - from SimCalorimetry.HGCalAssociatorProducers.SimClusterToCaloParticleAssociation_cfi import SimClusterToCaloParticleAssociation from SimCalorimetry.HGCalAssociatorProducers.TSToSimTSAssociation_cfi import allTrackstersToSimTrackstersAssociationsByLCs as _allTrackstersToSimTrackstersAssociationsByLCs from Validation.HGCalValidation.HLT_TICLIterLabels_cff import hltTiclIterLabelsPSet as _hltTiclIterLabelsPSet -from RecoLocalCalo.HGCalRecProducers.recHitMapProducer_cff import recHitMapProducer as _recHitMapProducer - from Validation.Configuration.hltBarrelSimValid_cff import hltBarrelRecHitMapProducer as _hltBarrelRecHitMapProducer from Validation.Configuration.hltBarrelSimValid_cff import barrel_hits hgcal_hits = ["hltHGCalRecHit:HGCEERecHits", "hltHGCalRecHit:HGCHEFRecHits", "hltHGCalRecHit:HGCHEBRecHits"] @@ -32,7 +28,6 @@ layer_clusters = cms.InputTag("hltMergeLayerClusters"), tracksterCollections = cms.VInputTag( *[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels], - # cms.InputTag("hltTiclSimTracksters", "fromLegacySimCluster"), cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), ) @@ -45,7 +40,6 @@ *[cms.InputTag(label) for label in _hltTiclIterLabelsPSet.labels] ), simTracksterCollections = cms.VInputTag( - # cms.InputTag("hltTiclSimTracksters", "fromLegacySimCluster"), cms.InputTag("hltTiclSimTracksters", "fromBoundarySimCluster"), cms.InputTag("hltTiclSimTracksters", "fromCaloParticle"), ), @@ -58,11 +52,6 @@ hitMap = 'hltHGCalRecHitMapProducer:hgcalRecHitMap', hits = 'hltHGCalRecHitMapProducer:RefProdVectorHGCRecHitCollection' ) -# hltHitToLegacySimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( -# simClusters = cms.InputTag("mix", "MergedCaloTruth"), -# hitMap = 'hltHGCalRecHitMapProducer:hgcalRecHitMap', -# hits = 'hltHGCalRecHitMapProducer:RefProdVectorHGCRecHitCollection' -# ) hltHitToBoundarySimClusterAssociator = _hitToSimClusterCaloParticleAssociator.clone( simClusters = cms.InputTag("mix", "MergedCaloTruthBoundaryTrackSimCluster"), hitMap = 'hltHGCalRecHitMapProducer:hgcalRecHitMap', diff --git a/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h b/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h index 4e9eae4ad3df6..8b973ce8fb5dc 100644 --- a/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h +++ b/Validation/HGCalValidation/interface/HGVHistoProducerAlgo.h @@ -324,9 +324,9 @@ class HGVHistoProducerAlgo { std::vector const& cPIndices, std::vector const& cPSelectedIndices, std::unordered_map const& hitMap, - std::map cummatbudg, + std::map const& cummatbudg, unsigned int layers, - std::vector thicknesses, + std::vector const& thicknesses, // reco-sim collection to CaloParticles (as SimCluster dataformat) const ticl::RecoToSimCollectionWithSimClustersT& recSimColl, const ticl::SimToRecoCollectionWithSimClustersT& simRecColl, diff --git a/Validation/HGCalValidation/plugins/BarrelValidator.cc b/Validation/HGCalValidation/plugins/BarrelValidator.cc index 5fc0d9e85ab66..98934816b541e 100644 --- a/Validation/HGCalValidation/plugins/BarrelValidator.cc +++ b/Validation/HGCalValidation/plugins/BarrelValidator.cc @@ -546,10 +546,6 @@ void BarrelValidator::dqmAnalyze(const edm::Event& event, } ticl::TracksterCollection const& simTrackstersFromCPs = *simTracksterFromCPHandle; - // edm::Handle>> simTrackstersMapHandle; - // event.getByToken(simTrackstersMap_, simTrackstersMapHandle); - // const std::map>& cpToSc_SimTrackstersMap = *simTrackstersMapHandle; - std::vector> tracksterToTracksterMapsHandles; for (const auto& token : tracksterToTracksterAssociatorsTokens_) { edm::Handle tracksterToTracksterMapHandle; diff --git a/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc b/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc index 4cf135b593ef8..2752505235ef2 100644 --- a/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc +++ b/Validation/HGCalValidation/src/HGVHistoProducerAlgo.cc @@ -2218,9 +2218,9 @@ void HGVHistoProducerAlgo::fill_generic_cluster_histos( std::vector const& cPIndices, std::vector const& cPSelectedIndices, std::unordered_map const& hitMap, - std::map cummatbudg, + std::map const& cummatbudg, unsigned int layers, - std::vector thicknesses, + std::vector const& thicknesses, const ticl::RecoToSimCollectionWithSimClustersT& cpsInLayerClusterMap, const ticl::SimToRecoCollectionWithSimClustersT& cPOnLayerMap, edm::MultiSpan const& hits) const { @@ -2239,7 +2239,7 @@ void HGVHistoProducerAlgo::fill_generic_cluster_histos( std::map tnlcpthminus; tnlcpthminus.clear(); //At the beginning of the event all layers should be initialized to zero total clusters per thickness - for (std::vector::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) { + for (std::vector::const_iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) { tnlcpthplus.insert(std::pair(std::to_string(*it), 0)); tnlcpthminus.insert(std::pair(std::to_string(*it), 0)); } @@ -2465,7 +2465,8 @@ void HGVHistoProducerAlgo::fill_generic_cluster_histos( //Energy clustered per layer tecpl[layerid] = tecpl[layerid] + lc_en; - ldbar[layerid] = ldbar[layerid] + lc_en * cummatbudg[(double)lay]; + ldbar[layerid] = + ldbar[layerid] + lc_en * (cummatbudg.find((double)lay) != cummatbudg.end() ? cummatbudg.at((double)lay) : 0.); } //end of loop through clusters of the event @@ -2507,7 +2508,7 @@ void HGVHistoProducerAlgo::fill_generic_cluster_histos( } //end of loop over layers //Per thickness - for (std::vector::iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) { + for (std::vector::const_iterator it = thicknesses.begin(); it != thicknesses.end(); ++it) { if (histograms.h_clusternum_perthick.count(*it)) { histograms.h_clusternum_perthick.at(*it)->Fill(tnlcpthplus[std::to_string(*it)]); histograms.h_clusternum_perthick.at(*it)->Fill(tnlcpthminus[std::to_string(*it)]); diff --git a/Validation/HGCalValidation/src/TICLCandidateValidator.cc b/Validation/HGCalValidation/src/TICLCandidateValidator.cc index f4e65077e4f6e..d13888a6ad097 100644 --- a/Validation/HGCalValidation/src/TICLCandidateValidator.cc +++ b/Validation/HGCalValidation/src/TICLCandidateValidator.cc @@ -511,7 +511,9 @@ void TICLCandidateValidator::fillCandidateHistos(const edm::Event& event, int32_t cand_idx = -1; float shared_energy = 0.; // take the SimTrackster used to build SimTICLCandidate ("base" ie CaloParticle one) and find simToReco-associated reco "ticlCandidate" tracksters (assume 1-1 mapping SimTICLCandidate-SimTrackster) - assert(i < (int)mergeTsSimToRecoMap.size()); + if (i >= (int)mergeTsSimToRecoMap.size()) + throw cms::Exception("LogicError") << "Mismatch between SimTICLCandidate index and SimTrackster index. Most " + "likely mismatched collections were given as inputs."; const auto& ts_vec = mergeTsSimToRecoMap[i]; if (!ts_vec.empty()) { auto min_elem = From 2396c371f468b8a62e51b426347459091750b9ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Cuisset?= Date: Wed, 10 Jun 2026 09:41:34 +0000 Subject: [PATCH 3/3] Config cleanup --- Validation/Configuration/python/hltHGCalSimValid_cff.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/Validation/Configuration/python/hltHGCalSimValid_cff.py b/Validation/Configuration/python/hltHGCalSimValid_cff.py index e171cfdc113b8..4c7cdf02db9ba 100644 --- a/Validation/Configuration/python/hltHGCalSimValid_cff.py +++ b/Validation/Configuration/python/hltHGCalSimValid_cff.py @@ -23,7 +23,6 @@ ) from SimCalorimetry.HGCalAssociatorProducers.AllLayerClusterToTracksterAssociatorsProducer_cfi import AllLayerClusterToTracksterAssociatorsProducer as _AllLayerClusterToTracksterAssociatorsProducer - hltAllLayerClusterToTracksterAssociations = _AllLayerClusterToTracksterAssociatorsProducer.clone( layer_clusters = cms.InputTag("hltMergeLayerClusters"), tracksterCollections = cms.VInputTag( @@ -45,7 +44,6 @@ ), ) -# from SimCalorimetry.HGCalAssociatorProducers.AllTracksterToSimTracksterAssociatorsByHitsProducer_cfi import AllTracksterToSimTracksterAssociatorsByHitsProducer as _AllTracksterToSimTracksterAssociatorsByHitsProducer from SimCalorimetry.HGCalAssociatorProducers.hitToSimClusterCaloParticleAssociator_cfi import hitToSimClusterCaloParticleAssociator as _hitToSimClusterCaloParticleAssociator hltHitToSimClusterCaloParticleAssociator = _hitToSimClusterCaloParticleAssociator.clone( simClusters = cms.InputTag("mix", "MergedCaloTruthCaloParticle"), # CaloParticle but in SimCluster dataformat @@ -61,7 +59,6 @@ from SimCalorimetry.HGCalAssociatorProducers.AllHitToTracksterAssociatorsProducer_cfi import AllHitToTracksterAssociatorsProducer as _AllHitToTracksterAssociatorsProducer - hltAllHitToTracksterAssociations = _AllHitToTracksterAssociatorsProducer.clone( hitMapTag = cms.InputTag("hltHGCalRecHitMapProducer","hgcalRecHitMap"), hits = cms.InputTag("hltHGCalRecHitMapProducer", "RefProdVectorHGCRecHitCollection"),