From dbe659978fe36ccfdd8df0e43cba4c406185b714 Mon Sep 17 00:00:00 2001 From: Martina Date: Thu, 8 Feb 2024 12:10:43 +0100 Subject: [PATCH 1/7] implementation of MTD clusters association maps --- .../interface/MTDGeomUtil.h | 2 + .../MTDGeometryBuilder/src/MTDGeomUtil.cc | 13 + ...coClusterToSimLayerClusterAssociationMap.h | 49 ++ ...tdRecoClusterToSimLayerClusterAssociator.h | 49 ++ ...usterToSimLayerClusterAssociatorBaseImpl.h | 37 + ...mLayerClusterToRecoClusterAssociationMap.h | 48 ++ .../MtdSimLayerClusterToTPAssociator.h | 46 ++ ...MtdSimLayerClusterToTPAssociatorBaseImpl.h | 48 ++ ...oClusterToSimLayerClusterAssociationMap.cc | 5 + ...dRecoClusterToSimLayerClusterAssociator.cc | 5 + ...sterToSimLayerClusterAssociatorBaseImpl.cc | 21 + ...LayerClusterToRecoClusterAssociationMap.cc | 5 + .../src/MtdSimLayerClusterToTPAssociator.cc | 5 + ...tdSimLayerClusterToTPAssociatorBaseImpl.cc | 19 + SimDataFormats/Associations/src/classes.h | 18 + .../Associations/src/classes_def.xml | 37 +- .../CaloAnalysis/interface/MtdSimCluster.h | 25 + .../interface/MtdSimLayerClusterFwd.h | 3 +- .../CaloAnalysis/src/classes_def.xml | 6 +- .../plugins/BuildFile.xml | 13 + ...erToSimLayerClusterAssociatorByHitsImpl.cc | 243 +++++++ ...terToSimLayerClusterAssociatorByHitsImpl.h | 34 + ...SimLayerClusterAssociatorByHitsProducer.cc | 79 +++ ...erToSimLayerClusterAssociatorEDProducer.cc | 85 +++ ...LayerClusterToTPAssociatorByTrackIdImpl.cc | 133 ++++ ...mLayerClusterToTPAssociatorByTrackIdImpl.h | 24 + ...rClusterToTPAssociatorByTrackIdProducer.cc | 56 ++ ...SimLayerClusterToTPAssociatorEDProducer.cc | 78 +++ ...ClusterToSimLayerClusterAssociation_cfi.py | 8 + .../mtdSimLayerClusterToTPAssociation_cfi.py | 7 + .../plugins/MtdTruthAccumulator.cc | 141 ++-- .../Configuration/python/mtdSimValid_cff.py | 13 +- .../plugins/BtlLocalRecoValidation.cc | 660 +++++++++++++++++- .../plugins/EtlLocalRecoValidation.cc | 198 +++++- .../plugins/MtdTracksValidation.cc | 49 +- 35 files changed, 2160 insertions(+), 102 deletions(-) create mode 100644 SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h create mode 100644 SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h create mode 100644 SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.h create mode 100644 SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h create mode 100644 SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h create mode 100644 SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h create mode 100644 SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociationMap.cc create mode 100644 SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociator.cc create mode 100644 SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.cc create mode 100644 SimDataFormats/Associations/src/MtdSimLayerClusterToRecoClusterAssociationMap.cc create mode 100644 SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociator.cc create mode 100644 SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociatorBaseImpl.cc create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/BuildFile.xml create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.h create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer.cc create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorEDProducer.cc create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.cc create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.h create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdProducer.cc create mode 100644 SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorEDProducer.cc create mode 100644 SimFastTiming/MtdAssociatorProducers/python/mtdRecoClusterToSimLayerClusterAssociation_cfi.py create mode 100644 SimFastTiming/MtdAssociatorProducers/python/mtdSimLayerClusterToTPAssociation_cfi.py diff --git a/Geometry/MTDGeometryBuilder/interface/MTDGeomUtil.h b/Geometry/MTDGeometryBuilder/interface/MTDGeomUtil.h index fcd8ef871a5f5..ab1d6cec9a4aa 100644 --- a/Geometry/MTDGeometryBuilder/interface/MTDGeomUtil.h +++ b/Geometry/MTDGeometryBuilder/interface/MTDGeomUtil.h @@ -43,6 +43,8 @@ namespace mtd { std::pair pixelInModule(const DetId& id, const LocalPoint& local_point) const; int crystalInModule(const DetId&) const; + uint32_t sensorModuleId(const DetId& id) const; + // 4-vector helper functions using GlobalPoint float eta(const GlobalPoint& position, const float& vertex_z = 0.) const; float phi(const GlobalPoint& position) const; diff --git a/Geometry/MTDGeometryBuilder/src/MTDGeomUtil.cc b/Geometry/MTDGeometryBuilder/src/MTDGeomUtil.cc index 4887ad4b8cd98..57791c6dd7d6c 100644 --- a/Geometry/MTDGeometryBuilder/src/MTDGeomUtil.cc +++ b/Geometry/MTDGeometryBuilder/src/MTDGeomUtil.cc @@ -159,6 +159,19 @@ int MTDGeomUtil::crystalInModule(const DetId& id) const { return hid.crystal(); } +// returns the sensor module id +uint32_t MTDGeomUtil::sensorModuleId(const DetId& id) const { + if (isBTL(id)) { + BTLDetId detId(id); + DetId geoId = detId.geographicalId(MTDTopologyMode::crysLayoutFromTopoMode(topology_->getMTDTopologyMode())); + return (geoId.rawId()); + } else { + ETLDetId detId(id); + DetId geoId = detId.geographicalId(); + return (geoId.rawId()); + } +} + float MTDGeomUtil::eta(const GlobalPoint& position, const float& vertex_z) const { GlobalPoint corrected_position = GlobalPoint(position.x(), position.y(), position.z() - vertex_z); return corrected_position.eta(); diff --git a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h new file mode 100644 index 0000000000000..da28598576314 --- /dev/null +++ b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h @@ -0,0 +1,49 @@ +#ifndef SimDataFormats_Associations_MtdRecoClusterToSimLayerClusterAssociationMap_h +#define SimDataFormats_Associations_MtdRecoClusterToSimLayerClusterAssociationMap_h + +#include "DataFormats/Provenance/interface/ProductID.h" +#include "DataFormats/Common/interface/HandleBase.h" +#include "DataFormats/FTLRecHit/interface/FTLClusterCollections.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h" + +#include +#include +#include + +/** + * Maps FTLCluserRef to SimLayerClusterRef + * + */ +class MtdRecoClusterToSimLayerClusterAssociationMap { +public: + using key_type = FTLClusterRef; + using mapped_type = MtdSimLayerClusterRef; + // using value_type = std::pair; + using value_type = std::pair>; + using map_type = std::vector; + using const_iterator = typename map_type::const_iterator; + + /// Constructor + MtdRecoClusterToSimLayerClusterAssociationMap(); + /// Destructor + ~MtdRecoClusterToSimLayerClusterAssociationMap(); + + void emplace_back(const FTLClusterRef& recoClus, std::vector& simClusVect) { + map_.emplace_back(recoClus, simClusVect); + } + + bool empty() const { return map_.empty(); } + size_t size() const { return map_.size(); } + + const_iterator begin() const { return map_.begin(); } + const_iterator cbegin() const { return map_.cbegin(); } + const_iterator end() const { return map_.end(); } + const_iterator cend() const { return map_.cend(); } + + const map_type& map() const { return map_; } + +private: + map_type map_; +}; + +#endif diff --git a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h new file mode 100644 index 0000000000000..8ed6cb4bec026 --- /dev/null +++ b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h @@ -0,0 +1,49 @@ +#ifndef SimDataFormats_Associations_MtdRecoClusterToSimLayerClusterAssociator_h +#define SimDataFormats_Associations_MtdRecoClusterToSimLayerClusterAssociator_h +// Original Author: Martina Malberti + +// system include files +#include + +// user include files +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.h" + +// forward declarations + +namespace reco { + + class MtdRecoClusterToSimLayerClusterAssociator { + public: + MtdRecoClusterToSimLayerClusterAssociator(std::unique_ptr); + MtdRecoClusterToSimLayerClusterAssociator() = default; + MtdRecoClusterToSimLayerClusterAssociator(MtdRecoClusterToSimLayerClusterAssociator &&) = default; + MtdRecoClusterToSimLayerClusterAssociator &operator=(MtdRecoClusterToSimLayerClusterAssociator &&) = default; + MtdRecoClusterToSimLayerClusterAssociator(const MtdRecoClusterToSimLayerClusterAssociator &) = + delete; // stop default + + ~MtdRecoClusterToSimLayerClusterAssociator() = default; + const MtdRecoClusterToSimLayerClusterAssociator &operator=(const MtdRecoClusterToSimLayerClusterAssociator &) = + delete; // stop default + + // ---------- const member functions --------------------- + /// Associate RecoCluster to MtdSimLayerCluster + reco::RecoToSimCollectionMtd associateRecoToSim(const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const { + return m_impl->associateRecoToSim(btlRecoClusH, etlRecoClusH, simClusH); + }; + + /// Associate MtdSimLayerCluster to RecoCluster + reco::SimToRecoCollectionMtd associateSimToReco(const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const { + return m_impl->associateSimToReco(btlRecoClusH, etlRecoClusH, simClusH); + }; + + private: + // ---------- member data -------------------------------- + std::unique_ptr m_impl; + }; +} // namespace reco + +#endif diff --git a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.h b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.h new file mode 100644 index 0000000000000..21a599e8828de --- /dev/null +++ b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.h @@ -0,0 +1,37 @@ +#ifndef SimDataFormats_Associations_MtdRecoClusterToSimLayerClusterAssociatorBaseImpl_h +#define SimDataFormats_Associations_MtdRecoClusterToSimLayerClusterAssociatorBaseImpl_h + +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/FTLRecHit/interface/FTLClusterCollections.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerCluster.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h" +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h" +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h" + +namespace reco { + + using RecoToSimCollectionMtd = MtdRecoClusterToSimLayerClusterAssociationMap; + using SimToRecoCollectionMtd = MtdSimLayerClusterToRecoClusterAssociationMap; + + class MtdRecoClusterToSimLayerClusterAssociatorBaseImpl { + public: + /// Constructor + MtdRecoClusterToSimLayerClusterAssociatorBaseImpl(); + /// Destructor + virtual ~MtdRecoClusterToSimLayerClusterAssociatorBaseImpl(); + + /// Associate a MtdRecoCluster to MtdSimLayerClusters + virtual reco::RecoToSimCollectionMtd associateRecoToSim( + const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const; + + /// Associate a MtdSimLayerClusters to MtdRecoClusters + virtual reco::SimToRecoCollectionMtd associateSimToReco( + const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const; + }; +} // namespace reco + +#endif diff --git a/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h b/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h new file mode 100644 index 0000000000000..05253940dcdf8 --- /dev/null +++ b/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h @@ -0,0 +1,48 @@ +#ifndef SimDataFormats_Associations_MtdSimLayerClusterToRecoClusterAssociationMap_h +#define SimDataFormats_Associations_MtdSimLayerClusterToRecoClusterAssociationMap_h + +#include "DataFormats/Provenance/interface/ProductID.h" +#include "DataFormats/Common/interface/HandleBase.h" +#include "DataFormats/FTLRecHit/interface/FTLClusterCollections.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h" + +#include +#include +#include + +/** + * Maps MtdSimLayerCluserRef to FTLClusterRef + * + */ +class MtdSimLayerClusterToRecoClusterAssociationMap { +public: + using key_type = MtdSimLayerClusterRef; + using mapped_type = FTLClusterRef; + using value_type = std::pair>; + using map_type = std::vector; + using const_iterator = typename map_type::const_iterator; + + /// Constructor + MtdSimLayerClusterToRecoClusterAssociationMap(); + /// Destructor + ~MtdSimLayerClusterToRecoClusterAssociationMap(); + + void emplace_back(const MtdSimLayerClusterRef& simClus, std::vector& recoClusVect) { + map_.emplace_back(simClus, recoClusVect); + } + + bool empty() const { return map_.empty(); } + size_t size() const { return map_.size(); } + + const_iterator begin() const { return map_.begin(); } + const_iterator cbegin() const { return map_.cbegin(); } + const_iterator end() const { return map_.end(); } + const_iterator cend() const { return map_.cend(); } + + const map_type& map() const { return map_; } + +private: + map_type map_; +}; + +#endif diff --git a/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h b/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h new file mode 100644 index 0000000000000..3efaf558b232f --- /dev/null +++ b/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h @@ -0,0 +1,46 @@ +#ifndef SimDataFormats_Associations_MtdSimLayerClusterToTPAssociator_h +#define SimDataFormats_Associations_MtdSimLayerClusterToTPAssociator_h +// Author: M. Malberti + +// system include files +#include + +// user include files + +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h" + +// forward declarations + +namespace reco { + class MtdSimLayerClusterToTPAssociator { + public: + MtdSimLayerClusterToTPAssociator(std::unique_ptr); + MtdSimLayerClusterToTPAssociator() = default; + MtdSimLayerClusterToTPAssociator(MtdSimLayerClusterToTPAssociator &&) = default; + MtdSimLayerClusterToTPAssociator &operator=(MtdSimLayerClusterToTPAssociator &&) = default; + MtdSimLayerClusterToTPAssociator(const MtdSimLayerClusterToTPAssociator &) = delete; // stop default + const MtdSimLayerClusterToTPAssociator &operator=(const MtdSimLayerClusterToTPAssociator &) = + delete; // stop default + + ~MtdSimLayerClusterToTPAssociator() = default; + + // ---------- const member functions --------------------- + /// Associate MtdSimLayerCluster to TrackingParticle + reco::SimToTPCollectionMtd associateSimToTP(const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const { + return m_impl->associateSimToTP(simClusH, trackingParticleH); + }; + + /// Associate TrackingParticle to MtdSimLayerCluster + reco::TPToSimCollectionMtd associateTPToSim(const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const { + return m_impl->associateTPToSim(simClusH, trackingParticleH); + }; + + private: + // ---------- member data -------------------------------- + std::unique_ptr m_impl; + }; +} // namespace reco + +#endif diff --git a/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h b/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h new file mode 100644 index 0000000000000..14dcd9d1c0574 --- /dev/null +++ b/SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h @@ -0,0 +1,48 @@ +#ifndef SimDataFormats_Associations_MtdSimLayerClusterToTPAssociatorBaseImpl_h +#define SimDataFormats_Associations_MtdSimLayerClusterToTPAssociatorBaseImpl_h + +/** \class MtdSimLayerClusterToTPAssociatorBaseImpl + * + * Base class for MtdSimLayerClusterToTPAssociator. Methods take as input + * the handles of MtdSimLayerCluster and TrackingParticle collections and return an + * AssociationMap (oneToMany) + * + * \author M. Malberti + */ + +#include "DataFormats/Common/interface/Handle.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerCluster.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h" +#include "DataFormats/Common/interface/OneToManyWithQualityGeneric.h" +#include "DataFormats/Common/interface/OneToMany.h" +#include "DataFormats/Common/interface/AssociationMap.h" + +namespace reco { + + typedef edm::AssociationMap > + SimToTPCollectionMtd; + typedef edm::AssociationMap > + TPToSimCollectionMtd; + + class MtdSimLayerClusterToTPAssociatorBaseImpl { + public: + /// Constructor + MtdSimLayerClusterToTPAssociatorBaseImpl(); + /// Destructor + virtual ~MtdSimLayerClusterToTPAssociatorBaseImpl(); + + /// Associate a MtdSimLayerCluster to TrackingParticle + virtual SimToTPCollectionMtd associateSimToTP( + const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const; + + /// Associate a TrackingParticle to MtdSimLayerCluster + virtual TPToSimCollectionMtd associateTPToSim( + const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const; + }; +} // namespace reco + +#endif diff --git a/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociationMap.cc b/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociationMap.cc new file mode 100644 index 0000000000000..8e57265f4a553 --- /dev/null +++ b/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociationMap.cc @@ -0,0 +1,5 @@ +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h" + +MtdRecoClusterToSimLayerClusterAssociationMap::MtdRecoClusterToSimLayerClusterAssociationMap() {} + +MtdRecoClusterToSimLayerClusterAssociationMap::~MtdRecoClusterToSimLayerClusterAssociationMap() {} diff --git a/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociator.cc b/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociator.cc new file mode 100644 index 0000000000000..ea103a3123a83 --- /dev/null +++ b/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociator.cc @@ -0,0 +1,5 @@ +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h" + +reco::MtdRecoClusterToSimLayerClusterAssociator::MtdRecoClusterToSimLayerClusterAssociator( + std::unique_ptr ptr) + : m_impl(std::move(ptr)) {} diff --git a/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.cc b/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.cc new file mode 100644 index 0000000000000..41aa1db9cd286 --- /dev/null +++ b/SimDataFormats/Associations/src/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.cc @@ -0,0 +1,21 @@ +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociatorBaseImpl.h" + +namespace reco { + MtdRecoClusterToSimLayerClusterAssociatorBaseImpl::MtdRecoClusterToSimLayerClusterAssociatorBaseImpl(){}; + MtdRecoClusterToSimLayerClusterAssociatorBaseImpl::~MtdRecoClusterToSimLayerClusterAssociatorBaseImpl(){}; + + reco::RecoToSimCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorBaseImpl::associateRecoToSim( + const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const { + return reco::RecoToSimCollectionMtd(); + } + + reco::SimToRecoCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorBaseImpl::associateSimToReco( + const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const { + return reco::SimToRecoCollectionMtd(); + } + +} // namespace reco diff --git a/SimDataFormats/Associations/src/MtdSimLayerClusterToRecoClusterAssociationMap.cc b/SimDataFormats/Associations/src/MtdSimLayerClusterToRecoClusterAssociationMap.cc new file mode 100644 index 0000000000000..4e91d1c776772 --- /dev/null +++ b/SimDataFormats/Associations/src/MtdSimLayerClusterToRecoClusterAssociationMap.cc @@ -0,0 +1,5 @@ +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h" + +MtdSimLayerClusterToRecoClusterAssociationMap::MtdSimLayerClusterToRecoClusterAssociationMap() {} + +MtdSimLayerClusterToRecoClusterAssociationMap::~MtdSimLayerClusterToRecoClusterAssociationMap() {} diff --git a/SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociator.cc b/SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociator.cc new file mode 100644 index 0000000000000..07421b9cb95b6 --- /dev/null +++ b/SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociator.cc @@ -0,0 +1,5 @@ +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h" + +reco::MtdSimLayerClusterToTPAssociator::MtdSimLayerClusterToTPAssociator( + std::unique_ptr ptr) + : m_impl(std::move(ptr)) {} diff --git a/SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociatorBaseImpl.cc b/SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociatorBaseImpl.cc new file mode 100644 index 0000000000000..a5e42eb6828e3 --- /dev/null +++ b/SimDataFormats/Associations/src/MtdSimLayerClusterToTPAssociatorBaseImpl.cc @@ -0,0 +1,19 @@ +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h" + +namespace reco { + MtdSimLayerClusterToTPAssociatorBaseImpl::MtdSimLayerClusterToTPAssociatorBaseImpl(){}; + MtdSimLayerClusterToTPAssociatorBaseImpl::~MtdSimLayerClusterToTPAssociatorBaseImpl(){}; + + reco::SimToTPCollectionMtd MtdSimLayerClusterToTPAssociatorBaseImpl::associateSimToTP( + const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const { + return reco::SimToTPCollectionMtd(); + } + + reco::TPToSimCollectionMtd MtdSimLayerClusterToTPAssociatorBaseImpl::associateTPToSim( + const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const { + return reco::TPToSimCollectionMtd(); + } + +} // namespace reco diff --git a/SimDataFormats/Associations/src/classes.h b/SimDataFormats/Associations/src/classes.h index 8fa4f488c47a4..6055ba430db97 100644 --- a/SimDataFormats/Associations/src/classes.h +++ b/SimDataFormats/Associations/src/classes.h @@ -15,6 +15,10 @@ #include "SimDataFormats/Associations/interface/TracksterToSimTracksterHitLCAssociator.h" #include "SimDataFormats/Associations/interface/TTTrackTruthPair.h" #include "SimDataFormats/Associations/interface/LayerClusterToSimTracksterAssociator.h" +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h" +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h" +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h" +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h" namespace SimDataFormats_Associations { struct SimDataFormats_Associations { @@ -39,6 +43,8 @@ namespace SimDataFormats_Associations { edm::Wrapper dummy11; + edm::Wrapper dummy12; + reco::VertexSimToRecoCollection vstrc; reco::VertexSimToRecoCollection::const_iterator vstrci; edm::Wrapper wvstrc; @@ -46,5 +52,17 @@ namespace SimDataFormats_Associations { reco::VertexRecoToSimCollection vrtsc; reco::VertexRecoToSimCollection::const_iterator vrtsci; edm::Wrapper wvrtsci; + + std::pair> dummy13; + edm::Wrapper>> dummy14; + MtdRecoClusterToSimLayerClusterAssociationMap dummy15; + edm::Wrapper dummy16; + + std::pair> dummy17; + edm::Wrapper>> dummy18; + MtdSimLayerClusterToRecoClusterAssociationMap dummy19; + edm::Wrapper dummy20; + + edm::Wrapper dummy21; }; } // namespace SimDataFormats_Associations diff --git a/SimDataFormats/Associations/src/classes_def.xml b/SimDataFormats/Associations/src/classes_def.xml index 7e50c17559255..f8e898180fbec 100644 --- a/SimDataFormats/Associations/src/classes_def.xml +++ b/SimDataFormats/Associations/src/classes_def.xml @@ -1,3 +1,4 @@ + @@ -30,7 +31,6 @@ - @@ -141,4 +141,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/SimDataFormats/CaloAnalysis/interface/MtdSimCluster.h b/SimDataFormats/CaloAnalysis/interface/MtdSimCluster.h index 5293e5018552b..b7db1f4afaf60 100644 --- a/SimDataFormats/CaloAnalysis/interface/MtdSimCluster.h +++ b/SimDataFormats/CaloAnalysis/interface/MtdSimCluster.h @@ -4,6 +4,7 @@ #ifndef SimDataFormats_CaloAnalysis_MtdSimCluster_h #define SimDataFormats_CaloAnalysis_MtdSimCluster_h +#include "DataFormats/GeometryVector/interface/LocalPoint.h" #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h" #include "SimDataFormats/TrackingHit/interface/PSimHit.h" #include @@ -31,6 +32,9 @@ class MtdSimCluster : public SimCluster { fractions_.emplace_back(fraction); } + /** @brief add hit position*/ + void addHitPosition(LocalPoint pos) { positions_.emplace_back(pos); } + /** @brief Returns list of hit IDs and fractions for this SimCluster */ std::vector> hits_and_fractions() const { assert(mtdHits_.size() == fractions_.size()); @@ -70,6 +74,17 @@ class MtdSimCluster : public SimCluster { return result; } + /** @brief Returns list of hit IDs and times for this SimCluster */ + std::vector> hits_and_positions() const { + assert(mtdHits_.size() == times_.size()); + std::vector> result; + result.reserve(mtdHits_.size()); + for (size_t i = 0; i < mtdHits_.size(); ++i) { + result.emplace_back(mtdHits_[i], positions_[i]); + } + return result; + } + /** @brief Returns list of detIds, rows and columns for this SimCluster */ std::vector>> detIds_and_rows() const { std::vector>> result; @@ -85,10 +100,14 @@ class MtdSimCluster : public SimCluster { /** @brief clear the times list */ void clearHitsTime() { std::vector().swap(times_); } + /** @brief clear the positions list */ + void clearHitsPosition() { std::vector().swap(positions_); } + void clear() { clearHitsAndFractions(); clearHitsEnergy(); clearHitsTime(); + clearHitsPosition(); } /** @brief add simhit's energy to cluster */ @@ -97,9 +116,15 @@ class MtdSimCluster : public SimCluster { ++nsimhits_; } + void setTrackIdOffset(unsigned int offset) { idOffset_ = offset; } + + unsigned int trackIdOffset() const { return idOffset_; } + protected: std::vector mtdHits_; std::vector times_; + std::vector positions_; + unsigned int idOffset_{0}; }; #endif diff --git a/SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h b/SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h index 1daa84d157984..48383297435a5 100644 --- a/SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h +++ b/SimDataFormats/CaloAnalysis/interface/MtdSimLayerClusterFwd.h @@ -5,7 +5,8 @@ #include "DataFormats/Common/interface/RefVector.h" #include -class MtdSimLayerCluster; +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerCluster.h" +//class MtdSimLayerCluster; typedef std::vector MtdSimLayerClusterCollection; typedef edm::Ref MtdSimLayerClusterRef; typedef edm::RefVector MtdSimLayerClusterRefVector; diff --git a/SimDataFormats/CaloAnalysis/src/classes_def.xml b/SimDataFormats/CaloAnalysis/src/classes_def.xml index 35ee606d29a93..6614517cd5aff 100644 --- a/SimDataFormats/CaloAnalysis/src/classes_def.xml +++ b/SimDataFormats/CaloAnalysis/src/classes_def.xml @@ -28,7 +28,10 @@ - + + + + @@ -36,6 +39,7 @@ + diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/BuildFile.xml b/SimFastTiming/MtdAssociatorProducers/plugins/BuildFile.xml new file mode 100644 index 0000000000000..66783bfccfcad --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/BuildFile.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc new file mode 100644 index 0000000000000..45ecaec9167c2 --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc @@ -0,0 +1,243 @@ +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Utilities/interface/Exception.h" +#include "MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.h" +#include "DataFormats/ForwardDetId/interface/BTLDetId.h" + +using namespace reco; +using namespace std; + +/* Constructor */ + +MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl::MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl( + edm::EDProductGetter const& productGetter, double energyCut, double timeCut, mtd::MTDGeomUtil& geomTools) + : productGetter_(&productGetter), energyCut_(energyCut), timeCut_(timeCut), geomTools_(geomTools) {} + +// +//---member functions +// + +reco::RecoToSimCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl::associateRecoToSim( + const edm::Handle& btlRecoClusH, + const edm::Handle& etlRecoClusH, + const edm::Handle& simClusH) const { + RecoToSimCollectionMtd outputCollection; + + // -- get the collections + std::array, 2> inputRecoClusH{{btlRecoClusH, etlRecoClusH}}; + + const auto& simClusters = *simClusH.product(); + + // -- create temporary map DetId, SimClusterRef (praticamente ... il DetSetVector dei poveri) + std::map> simClusIdsMap; + for (auto simClusIt = simClusters.begin(); simClusIt != simClusters.end(); simClusIt++) { + const auto& simClus = *simClusIt; + + edm::Ref simClusterRef = + edm::Ref(simClusH, simClusIt - simClusters.begin()); + + std::vector>> detIdsAndRows = simClus.detIds_and_rows(); + std::vector detIds(detIdsAndRows.size()); + std::transform(detIdsAndRows.begin(), + detIdsAndRows.end(), + detIds.begin(), + [](const std::pair>& pair) { return pair.first; }); + + // -- get the sensor module id from the first hit id of the MtdSimCluster + DetId id(detIds[0]); + uint32_t modId = geomTools_.sensorModuleId(id); + simClusIdsMap[modId].push_back(simClusterRef); + + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") << "Sim cluster detId = " << modId << std::endl; + } + + for (auto const& recoClusH : inputRecoClusH) { + // -- loop over detSetVec + for (const auto& detSet : *recoClusH) { + // -- loop over reco clusters + for (const auto& recoClus : detSet) { + MTDDetId clusId = recoClus.id(); + + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") << "Reco cluster : " << clusId; + + std::vector recoClusHitIds; + + // -- loop over hits in the reco cluster and find their unique ids + for (int ihit = 0; ihit < recoClus.size(); ++ihit) { + int hit_row = recoClus.minHitRow() + recoClus.hitOffset()[ihit * 2]; + int hit_col = recoClus.minHitCol() + recoClus.hitOffset()[ihit * 2 + 1]; + + // -- Get an unique id from sensor module detId , row, column + uint64_t uniqueId = static_cast(clusId.rawId()) << 32; + uniqueId |= hit_row << 16; + uniqueId |= hit_col; + recoClusHitIds.push_back(uniqueId); + + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << " ======= cluster raw Id : " << clusId.rawId() << " row : " << hit_row << " column: " << hit_col + << " recHit uniqueId : " << uniqueId; + } + + // -- loop over sim clusters and check if this reco clus shares some hits + std::vector simClusterRefs; + + for (const auto& simClusterRef : simClusIdsMap[clusId.rawId()]) { + const auto& simClus = *simClusterRef; + + // get the hit ids of hits in the SimCluster + std::vector>> detIdsAndRows = simClus.detIds_and_rows(); + std::vector simClusHitIds(detIdsAndRows.size()); + for (unsigned int i = 0; i < detIdsAndRows.size(); i++) { + DetId id(detIdsAndRows[i].first); + uint32_t modId = geomTools_.sensorModuleId(id); + // build the unique id from sensor module detId , row, column + uint64_t uniqueId = static_cast(modId) << 32; + uniqueId |= detIdsAndRows[i].second.first << 16; + uniqueId |= detIdsAndRows[i].second.second; + simClusHitIds.push_back(uniqueId); + } + + // -- Get shared hits + std::vector sharedHitIds; + std::set_intersection(recoClusHitIds.begin(), + recoClusHitIds.end(), + simClusHitIds.begin(), + simClusHitIds.end(), + std::back_inserter(sharedHitIds)); + + if (sharedHitIds.empty()) + continue; + + float dE = recoClus.energy() * 0.001 / simClus.simLCEnergy(); // reco cluster energy is in MeV! + float dtSig = std::abs((recoClus.time() - simClus.simLCTime()) / recoClus.timeError()); + + // -- If the sim and reco clusters have common hits, fill the std:vector of sim clusters refs + if (!sharedHitIds.empty() && dE < energyCut_ && + dtSig < timeCut_) { // at least one hit in common + requirement on energy and time compatibility + + simClusterRefs.push_back(simClusterRef); + + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << "RecoToSim --> Found " << sharedHitIds.size() << " shared hits"; + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << "E_recoClus = " << recoClus.energy() << " E_simClus = " << simClus.simLCEnergy() + << " E_recoClus/E_simClus = " << dE; + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << "(t_recoClus-t_simClus)/sigma_t = " << dtSig; + } + } // -- end loop over sim clus refs + + // -- Now fill the output collection + edm::Ref, FTLCluster> recoClusterRef = edmNew::makeRefTo(recoClusH, &recoClus); + outputCollection.emplace_back(recoClusterRef, simClusterRefs); + + } // -- end loop over reco clus + } // -- end loop over detsetclus + } + + return outputCollection; +} + +reco::SimToRecoCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl::associateSimToReco( + const edm::Handle& btlRecoClusH, + const edm::Handle& etlRecoClusH, + const edm::Handle& simClusH) const { + SimToRecoCollectionMtd outputCollection; + + // -- get the collections + const auto& simClusters = *simClusH.product(); + + std::array, 2> inputH{{btlRecoClusH, etlRecoClusH}}; + + // -- loop over MtdSimLayerClusters + for (auto simClusIt = simClusters.begin(); simClusIt != simClusters.end(); simClusIt++) { + const auto& simClus = *simClusIt; + + // get the hit ids of hits in the SimCluster + std::vector>> detIdsAndRows = simClus.detIds_and_rows(); + std::vector simClusHitIds(detIdsAndRows.size()); + uint32_t modId = 0; + for (unsigned int i = 0; i < detIdsAndRows.size(); i++) { + DetId id(detIdsAndRows[i].first); + modId = geomTools_.sensorModuleId(id); + // build the unique id from sensor module detId , row, column + uint64_t uniqueId = static_cast(modId) << 32; + uniqueId |= detIdsAndRows[i].second.first << 16; + uniqueId |= detIdsAndRows[i].second.second; + simClusHitIds.push_back(uniqueId); + } + + DetId simClusId(modId); + + std::vector recoClusterRefs; + + // -- loop over reco clusters + for (auto const& recoClusH : inputH) { + // -- loop over detSetVec + for (const auto& detSet : *recoClusH) { + if (detSet.id() != simClusId.rawId()) + continue; + + // -- loop over reco clusters + for (const auto& recoClus : detSet) { + MTDDetId clusId = recoClus.id(); + + std::vector recoClusHitIds; + + // -- loop over hits in the reco cluster and find their ids + for (int ihit = 0; ihit < recoClus.size(); ++ihit) { + int hit_row = recoClus.minHitRow() + recoClus.hitOffset()[ihit * 2]; + int hit_col = recoClus.minHitCol() + recoClus.hitOffset()[ihit * 2 + 1]; + + // -- Get an unique id from sensor module detId , row, column + uint64_t uniqueId = static_cast(clusId.rawId()) << 32; + uniqueId |= hit_row << 16; + uniqueId |= hit_col; + recoClusHitIds.push_back(uniqueId); + + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << " ======= cluster raw Id : " << clusId.rawId() << " row : " << hit_row << " column: " << hit_col + << " recHit uniqueId : " << uniqueId; + } + + // -- Get shared hits + std::vector sharedHitIds; + std::set_intersection(simClusHitIds.begin(), + simClusHitIds.end(), + recoClusHitIds.begin(), + recoClusHitIds.end(), + std::back_inserter(sharedHitIds)); + if (sharedHitIds.empty()) + continue; + + float dE = recoClus.energy() * 0.001 / simClus.simLCEnergy(); // reco cluster energy is in MeV + float dtSig = std::abs((recoClus.time() - simClus.simLCTime()) / recoClus.timeError()); + + // -- If the sim and reco clusters have common hits, fill the std:vector of reco clusters refs + if (!sharedHitIds.empty() && dE < energyCut_ && dtSig < timeCut_) { + // Create a persistent edm::Ref to the cluster + edm::Ref, FTLCluster> recoClusterRef = + edmNew::makeRefTo(recoClusH, &recoClus); + recoClusterRefs.push_back(recoClusterRef); + + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << "SimToReco --> Found " << sharedHitIds.size() << " shared hits"; + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << "E_recoClus = " << recoClus.energy() << " E_simClus = " << simClus.simLCEnergy() + << " E_recoClus/E_simClus = " << dE; + LogDebug("MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl") + << "(t_recoClus-t_simClus)/sigma_t = " << dtSig; + } + + } // end loop ove reco clus + } // end loop over detsets + } + + // -- Now fill the output collection + edm::Ref simClusterRef = + edm::Ref(simClusH, simClusIt - simClusters.begin()); + outputCollection.emplace_back(simClusterRef, recoClusterRefs); + + } // -- end loop over sim clusters + + return outputCollection; +} diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.h b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.h new file mode 100644 index 0000000000000..ae7bfcaf3b561 --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.h @@ -0,0 +1,34 @@ +#include +#include + +#include "Geometry/MTDGeometryBuilder/interface/MTDGeomUtil.h" +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h" + +namespace edm { + class EDProductGetter; +} + +class MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl + : public reco::MtdRecoClusterToSimLayerClusterAssociatorBaseImpl { +public: + explicit MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl(edm::EDProductGetter const &, + double, + double, + mtd::MTDGeomUtil &); + + reco::RecoToSimCollectionMtd associateRecoToSim( + const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const override; + + reco::SimToRecoCollectionMtd associateSimToReco( + const edm::Handle &btlRecoClusH, + const edm::Handle &etlRecoClusH, + const edm::Handle &simClusH) const override; + +private: + edm::EDProductGetter const *productGetter_; + const double energyCut_; + const double timeCut_; + mtd::MTDGeomUtil geomTools_; +}; diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer.cc new file mode 100644 index 0000000000000..f602472e7f81f --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer.cc @@ -0,0 +1,79 @@ +// 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/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/EDGetToken.h" + +#include "Geometry/MTDCommonData/interface/MTDTopologyMode.h" +#include "Geometry/Records/interface/MTDDigiGeometryRecord.h" +#include "Geometry/MTDGeometryBuilder/interface/MTDGeometry.h" + +#include "MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.h" + +// +// Class declaration +// + +class MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer : public edm::global::EDProducer<> { +public: + explicit MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer(const edm::ParameterSet &); + ~MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); + +private: + void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; + const double energyCut_; + const double timeCut_; + edm::ESGetToken geomToken_; + edm::ESGetToken topoToken_; +}; + +MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer::MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer( + const edm::ParameterSet &ps) + : energyCut_(ps.getParameter("energyCut")), timeCut_(ps.getParameter("timeCut")) { + geomToken_ = esConsumes(); + topoToken_ = esConsumes(); + + // Register the product + produces(); +} + +MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer::~MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer() {} + +void MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &es) const { + auto geometryHandle = es.getTransientHandle(geomToken_); + const MTDGeometry *geom = geometryHandle.product(); + + auto topologyHandle = es.getTransientHandle(topoToken_); + const MTDTopology *topology = topologyHandle.product(); + + mtd::MTDGeomUtil geomTools_; + geomTools_.setGeometry(geom); + geomTools_.setTopology(topology); + + auto impl = std::make_unique( + iEvent.productGetter(), energyCut_, timeCut_, geomTools_); + auto toPut = std::make_unique(std::move(impl)); + iEvent.put(std::move(toPut)); +} + +void MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer::fillDescriptions(edm::ConfigurationDescriptions &cfg) { + edm::ParameterSetDescription desc; + desc.add("energyCut", 5.); + desc.add("timeCut", 10.); + + cfg.add("mtdRecoClusterToSimLayerClusterAssociatorByHits", desc); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(MtdRecoClusterToSimLayerClusterAssociatorByHitsProducer); diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorEDProducer.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorEDProducer.cc new file mode 100644 index 0000000000000..8f561575e9809 --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorEDProducer.cc @@ -0,0 +1,85 @@ +// 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/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/EDGetToken.h" + +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h" + +// +// class decleration +// + +class MtdRecoClusterToSimLayerClusterAssociatorEDProducer : public edm::global::EDProducer<> { +public: + explicit MtdRecoClusterToSimLayerClusterAssociatorEDProducer(const edm::ParameterSet &); + ~MtdRecoClusterToSimLayerClusterAssociatorEDProducer() override; + +private: + void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; + + edm::EDGetTokenT btlRecoClustersToken_; + edm::EDGetTokenT etlRecoClustersToken_; + edm::EDGetTokenT simClustersToken_; + + edm::EDGetTokenT associatorToken_; +}; + +MtdRecoClusterToSimLayerClusterAssociatorEDProducer::MtdRecoClusterToSimLayerClusterAssociatorEDProducer( + const edm::ParameterSet &pset) { + produces(); + produces(); + + btlRecoClustersToken_ = consumes(pset.getParameter("btlRecoClustersTag")); + etlRecoClustersToken_ = consumes(pset.getParameter("etlRecoClustersTag")); + simClustersToken_ = consumes(pset.getParameter("mtdSimClustersTag")); + associatorToken_ = + consumes(pset.getParameter("associator")); +} + +MtdRecoClusterToSimLayerClusterAssociatorEDProducer::~MtdRecoClusterToSimLayerClusterAssociatorEDProducer() {} + +// +// member functions +// + +// ------------ method called to produce the data ------------ +void MtdRecoClusterToSimLayerClusterAssociatorEDProducer::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &iSetup) const { + using namespace edm; + + edm::Handle theAssociator; + iEvent.getByToken(associatorToken_, theAssociator); + + edm::Handle btlRecoClusters; + iEvent.getByToken(btlRecoClustersToken_, btlRecoClusters); + + edm::Handle etlRecoClusters; + iEvent.getByToken(etlRecoClustersToken_, etlRecoClusters); + + edm::Handle simClusters; + iEvent.getByToken(simClustersToken_, simClusters); + + // associate reco clus to sim layer clus + reco::RecoToSimCollectionMtd recoToSimColl = + theAssociator->associateRecoToSim(btlRecoClusters, etlRecoClusters, simClusters); + reco::SimToRecoCollectionMtd simToRecoColl = + theAssociator->associateSimToReco(btlRecoClusters, etlRecoClusters, simClusters); + + auto r2s = std::make_unique(recoToSimColl); + auto s2r = std::make_unique(simToRecoColl); + + iEvent.put(std::move(r2s)); + iEvent.put(std::move(s2r)); +} + +// define this as a plug-in +DEFINE_FWK_MODULE(MtdRecoClusterToSimLayerClusterAssociatorEDProducer); diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.cc new file mode 100644 index 0000000000000..3d640fb378044 --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.cc @@ -0,0 +1,133 @@ +// +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/Utilities/interface/Exception.h" + +#include "MtdSimLayerClusterToTPAssociatorByTrackIdImpl.h" + +using namespace reco; +using namespace std; + +/* Constructor */ +MtdSimLayerClusterToTPAssociatorByTrackIdImpl::MtdSimLayerClusterToTPAssociatorByTrackIdImpl( + edm::EDProductGetter const& productGetter) + : productGetter_(&productGetter) {} + +// +//---member functions +// + +reco::SimToTPCollectionMtd MtdSimLayerClusterToTPAssociatorByTrackIdImpl::associateSimToTP( + const edm::Handle& simClusH, + const edm::Handle& trackingParticleH) const { + SimToTPCollectionMtd outputCollection(productGetter_); + + // -- get the collections + const auto& simClusters = *simClusH.product(); + const auto& trackingParticles = *trackingParticleH.product(); + + // -- Loop over tracking particles and build a temporary map of trackId, eventId --> tpRef + std::map, TrackingParticleRef> tpIdMap; + for (auto tpIt = trackingParticles.begin(); tpIt != trackingParticles.end(); tpIt++) { + const auto& tp = *tpIt; + unsigned int tpTrackId = tp.g4Tracks()[0].trackId(); + EncodedEventId tpEventId = tp.eventId(); + TrackingParticleRef tpRef = + edm::Ref(trackingParticleH, tpIt - trackingParticles.begin()); + tpIdMap[std::make_pair(tpTrackId, tpEventId.rawId())] = tpRef; + } + + // -- loop over sim clusters and get the trackId, eventId + + LogDebug("MtdSimLayerClusterToTPAssociator") + << " Found " << simClusters.size() << " MtdSimLayerClusters in the event"; + + for (auto simClusIt = simClusters.begin(); simClusIt != simClusters.end(); simClusIt++) { + const auto& simClus = *simClusIt; + size_t simClusIndex = simClusIt - simClusters.begin(); + MtdSimLayerClusterRef simClusterRef = edm::Ref(simClusH, simClusIndex); + unsigned int simClusTrackId = simClus.g4Tracks()[0].trackId(); + EncodedEventId simClusEventId = simClus.eventId(); + + // -- Check the trackId offset of the sim hits and keep only clusters with "direct" hits (offset == 0) + /* + if (simClus.trackIdOffset() != 0 ) continue; + */ + + std::pair uniqueId = std::make_pair(simClusTrackId, simClusEventId.rawId()); + auto it = tpIdMap.find(uniqueId); + + if (it != tpIdMap.end()) { + TrackingParticleRef tpRef = tpIdMap[uniqueId]; + outputCollection.insert(simClusterRef, tpRef); + + LogDebug("MtdSimLayerClusterToTPAssociator::associateSimToTP") + << "MtdSimLayerCluster: index = " << simClusIndex << " simClus TrackId = " << simClusTrackId + << " simClus EventId = " << simClusEventId.rawId() << " simClus Eta = " << simClus.eta() + << " simClus Phi = " << simClus.phi() << " simClus Time = " << simClus.simLCTime() + << " simClus Energy = " << simClus.simLCEnergy() << std::endl; + LogDebug("MtdSimLayerClusterToTPAssociator::associateSimToTP") + << " --> Found associated tracking particle: tp TrackId = " << (*tpRef).g4Tracks()[0].trackId() + << " tp EventId = " << (*tpRef).eventId().rawId() << std::endl; + } + + } // -- end loop over sim clus + + return outputCollection; +} + +reco::TPToSimCollectionMtd MtdSimLayerClusterToTPAssociatorByTrackIdImpl::associateTPToSim( + const edm::Handle& simClusH, + const edm::Handle& trackingParticleH) const { + TPToSimCollectionMtd outputCollection(productGetter_); + + // -- get the collections + const auto& simClusters = *simClusH.product(); + const auto& trackingParticles = *trackingParticleH.product(); + + // -- Loop over MtdSimLayerClusters and build a temporary map of trackId, eventId --> simClusterRef + std::map, std::vector> simClusIdMap; + for (auto simClusIt = simClusters.begin(); simClusIt != simClusters.end(); simClusIt++) { + const auto& simClus = *simClusIt; + unsigned int simClusTrackId = simClus.g4Tracks()[0].trackId(); + EncodedEventId simClusEventId = simClus.eventId(); + MtdSimLayerClusterRef simClusterRef = + edm::Ref(simClusH, simClusIt - simClusters.begin()); + simClusIdMap[std::make_pair(simClusTrackId, simClusEventId.rawId())].push_back(simClusterRef); + } + + // -- Loop over the tracking particles + for (auto tpIt = trackingParticles.begin(); tpIt != trackingParticles.end(); tpIt++) { + const auto& tp = *tpIt; + size_t tpIndex = tpIt - trackingParticles.begin(); + TrackingParticleRef tpRef = edm::Ref(trackingParticleH, tpIndex); + unsigned int tpTrackId = tp.g4Tracks()[0].trackId(); + EncodedEventId tpEventId = tp.eventId(); + + std::pair uniqueId = std::make_pair(tpTrackId, tpEventId.rawId()); + auto it = simClusIdMap.find(uniqueId); + + if (it != simClusIdMap.end()) { + for (unsigned int i = 0; i < simClusIdMap[uniqueId].size(); i++) { + MtdSimLayerClusterRef simClusterRef = simClusIdMap[uniqueId][i]; + // -- Check the trackId offset of the sim hits and keep only clusters with "direct" hits (offset == 0) + /* + if (simClus.trackIdOffset() != 0 ) continue; + */ + + outputCollection.insert(tpRef, simClusterRef); + + LogDebug("MtdSimLayerClusterToTPAssociator") + << "Tracking particle: index = " << tpIndex << " tp TrackId = " << tpTrackId + << " tp EventId = " << tpEventId.rawId(); + LogDebug("MtdSimLayerClusterToTPAssociator") + << " --> Found associated MtdSimLayerCluster: simClus TrackId = " + << (*simClusterRef).g4Tracks()[0].trackId() << " simClus EventId = " << (*simClusterRef).eventId().rawId() + << " simClus Eta = " << (*simClusterRef).eta() << " simClus Phi = " << (*simClusterRef).phi() + << " simClus Time = " << (*simClusterRef).simLCTime() + << " simClus Energy = " << (*simClusterRef).simLCEnergy() << std::endl; + } + } + } + + return outputCollection; +} diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.h b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.h new file mode 100644 index 0000000000000..e0783b4f45adf --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdImpl.h @@ -0,0 +1,24 @@ +#include +#include + +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h" + +namespace edm { + class EDProductGetter; +} + +class MtdSimLayerClusterToTPAssociatorByTrackIdImpl : public reco::MtdSimLayerClusterToTPAssociatorBaseImpl { +public: + explicit MtdSimLayerClusterToTPAssociatorByTrackIdImpl(edm::EDProductGetter const &); + + reco::SimToTPCollectionMtd associateSimToTP( + const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const override; + + reco::TPToSimCollectionMtd associateTPToSim( + const edm::Handle &simClusH, + const edm::Handle &trackingParticleH) const override; + +private: + edm::EDProductGetter const *productGetter_; +}; diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdProducer.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdProducer.cc new file mode 100644 index 0000000000000..2c56bc6f29c26 --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorByTrackIdProducer.cc @@ -0,0 +1,56 @@ +// 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/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/EDGetToken.h" + +#include "MtdSimLayerClusterToTPAssociatorByTrackIdImpl.h" + +// +// Class declaration +// + +class MtdSimLayerClusterToTPAssociatorByTrackIdProducer : public edm::global::EDProducer<> { +public: + explicit MtdSimLayerClusterToTPAssociatorByTrackIdProducer(const edm::ParameterSet &); + ~MtdSimLayerClusterToTPAssociatorByTrackIdProducer() override; + + static void fillDescriptions(edm::ConfigurationDescriptions &descriptions); + +private: + void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; +}; + +MtdSimLayerClusterToTPAssociatorByTrackIdProducer::MtdSimLayerClusterToTPAssociatorByTrackIdProducer( + const edm::ParameterSet &pset) { + // Register the product + produces(); +} + +MtdSimLayerClusterToTPAssociatorByTrackIdProducer::~MtdSimLayerClusterToTPAssociatorByTrackIdProducer() {} + +void MtdSimLayerClusterToTPAssociatorByTrackIdProducer::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &es) const { + auto impl = std::make_unique(iEvent.productGetter()); + auto toPut = std::make_unique(std::move(impl)); + iEvent.put(std::move(toPut)); +} + +void MtdSimLayerClusterToTPAssociatorByTrackIdProducer::fillDescriptions(edm::ConfigurationDescriptions &cfg) { + edm::ParameterSetDescription desc; + + cfg.add("mtdSimLayerClusterToTPAssociatorByTrackId", desc); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(MtdSimLayerClusterToTPAssociatorByTrackIdProducer); diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorEDProducer.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorEDProducer.cc new file mode 100644 index 0000000000000..7d42e13797695 --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdSimLayerClusterToTPAssociatorEDProducer.cc @@ -0,0 +1,78 @@ +// 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/MessageLogger/interface/MessageLogger.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h" + +#include "FWCore/Utilities/interface/EDGetToken.h" + +// +// class decleration +// + +class MtdSimLayerClusterToTPAssociatorEDProducer : public edm::global::EDProducer<> { +public: + explicit MtdSimLayerClusterToTPAssociatorEDProducer(const edm::ParameterSet &); + ~MtdSimLayerClusterToTPAssociatorEDProducer() override; + +private: + void produce(edm::StreamID, edm::Event &, const edm::EventSetup &) const override; + + edm::EDGetTokenT simClustersToken_; + edm::EDGetTokenT tpToken_; + edm::EDGetTokenT associatorToken_; +}; + +MtdSimLayerClusterToTPAssociatorEDProducer::MtdSimLayerClusterToTPAssociatorEDProducer(const edm::ParameterSet &pset) { + produces(); + produces(); + + simClustersToken_ = consumes(pset.getParameter("mtdSimClustersTag")); + tpToken_ = consumes(pset.getParameter("trackingParticlesTag")); + associatorToken_ = consumes(pset.getParameter("associator")); +} + +MtdSimLayerClusterToTPAssociatorEDProducer::~MtdSimLayerClusterToTPAssociatorEDProducer() {} + +// +// member functions +// + +// ------------ method called to produce the data ------------ +void MtdSimLayerClusterToTPAssociatorEDProducer::produce(edm::StreamID, + edm::Event &iEvent, + const edm::EventSetup &iSetup) const { + using namespace edm; + + edm::Handle theAssociator; + iEvent.getByToken(associatorToken_, theAssociator); + + edm::Handle simClusters; + iEvent.getByToken(simClustersToken_, simClusters); + + edm::Handle trackingParticles; + iEvent.getByToken(tpToken_, trackingParticles); + + reco::SimToTPCollectionMtd simToTPColl = theAssociator->associateSimToTP(simClusters, trackingParticles); + reco::TPToSimCollectionMtd tpToSimColl = theAssociator->associateTPToSim(simClusters, trackingParticles); + + auto s2tp = std::make_unique(simToTPColl); + auto tp2s = std::make_unique(tpToSimColl); + + iEvent.put(std::move(s2tp)); + iEvent.put(std::move(tp2s)); +} + +// define this as a plug-in +DEFINE_FWK_MODULE(MtdSimLayerClusterToTPAssociatorEDProducer); diff --git a/SimFastTiming/MtdAssociatorProducers/python/mtdRecoClusterToSimLayerClusterAssociation_cfi.py b/SimFastTiming/MtdAssociatorProducers/python/mtdRecoClusterToSimLayerClusterAssociation_cfi.py new file mode 100644 index 0000000000000..b933cdc037a97 --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/python/mtdRecoClusterToSimLayerClusterAssociation_cfi.py @@ -0,0 +1,8 @@ +import FWCore.ParameterSet.Config as cms + +mtdRecoClusterToSimLayerClusterAssociation = cms.EDProducer("MtdRecoClusterToSimLayerClusterAssociatorEDProducer", + associator = cms.InputTag('mtdRecoClusterToSimLayerClusterAssociatorByHits'), + mtdSimClustersTag = cms.InputTag('mix','MergedMtdTruthLC'), + btlRecoClustersTag = cms.InputTag('mtdClusters', 'FTLBarrel'), + etlRecoClustersTag = cms.InputTag('mtdClusters', 'FTLEndcap'), +) diff --git a/SimFastTiming/MtdAssociatorProducers/python/mtdSimLayerClusterToTPAssociation_cfi.py b/SimFastTiming/MtdAssociatorProducers/python/mtdSimLayerClusterToTPAssociation_cfi.py new file mode 100644 index 0000000000000..66ed9292076ac --- /dev/null +++ b/SimFastTiming/MtdAssociatorProducers/python/mtdSimLayerClusterToTPAssociation_cfi.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + +mtdSimLayerClusterToTPAssociation = cms.EDProducer("MtdSimLayerClusterToTPAssociatorEDProducer", + associator = cms.InputTag('mtdSimLayerClusterToTPAssociatorByTrackId'), + mtdSimClustersTag = cms.InputTag('mix','MergedMtdTruthLC'), + trackingParticlesTag = cms.InputTag('mix', 'MergedTrackTruth') +) diff --git a/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc b/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc index b4bc043629f92..b4513af9e3d70 100644 --- a/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc +++ b/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc @@ -1,7 +1,9 @@ // Author: Aurora Perego, Fabio Cossutti - aurora.perego@cern.ch, fabio.cossutti@ts.infn.it // Date: 05/2023 -#define DEBUG false +//#define DEBUG false +#define DEBUG true +#define PRINT_DEBUG true #if DEBUG #pragma GCC diagnostic pop @@ -83,8 +85,7 @@ class MtdTruthAccumulator : public DigiAccumulatorMixMod { * for bad modules if required */ template void fillSimHits(std::vector> &returnValue, - std::unordered_map> &simTrackDetIdEnergyMap, - std::unordered_map> &simTrackDetIdTimeMap, + std::unordered_map>> &simTrackDetIdMap, const T &event, const edm::EventSetup &setup); @@ -163,18 +164,17 @@ class MtdTruthAccumulator : public DigiAccumulatorMixMod { namespace { class CaloParticle_dfs_visitor : public boost::default_dfs_visitor { public: - CaloParticle_dfs_visitor(MtdTruthAccumulator::OutputCollections &output, - MtdTruthAccumulator::calo_particles &caloParticles, - std::unordered_multimap &simHitBarcodeToIndex, - std::unordered_map> &simTrackDetIdEnergyMap, - std::unordered_map> &simTrackDetIdTimeMap, - std::unordered_map &vertex_time_map, - Selector selector) + CaloParticle_dfs_visitor( + MtdTruthAccumulator::OutputCollections &output, + MtdTruthAccumulator::calo_particles &caloParticles, + std::unordered_multimap &simHitBarcodeToIndex, + std::unordered_map>> &simTrackDetIdMap, + std::unordered_map &vertex_time_map, + Selector selector) : output_(output), caloParticles_(caloParticles), simHitBarcodeToIndex_(simHitBarcodeToIndex), - simTrackDetIdEnergyMap_(simTrackDetIdEnergyMap), - simTrackDetIdTimeMap_(simTrackDetIdTimeMap), + simTrackDetIdMap_(simTrackDetIdMap), vertex_time_map_(vertex_time_map), selector_(selector) {} template @@ -186,23 +186,34 @@ namespace { auto const vertex_property = get(vertex_name, g, u); if (!vertex_property.simTrack) return; - auto trackIdx = vertex_property.simTrack->trackId(); - IfLogDebug(DEBUG, messageCategoryGraph_) - << " Found " << simHitBarcodeToIndex_.count(trackIdx) << " associated simHits" << std::endl; - if (simHitBarcodeToIndex_.count(trackIdx)) { - output_.pSimClusters->emplace_back(*vertex_property.simTrack); - auto &simcluster = output_.pSimClusters->back(); - std::unordered_map acc_energy; - for (auto const &hit_and_energy : simTrackDetIdEnergyMap_[trackIdx]) { - acc_energy[hit_and_energy.first] += hit_and_energy.second; - } - for (auto const &hit_and_energy : acc_energy) { - simcluster.addHitAndFraction(hit_and_energy.first, hit_and_energy.second); - simcluster.addHitEnergy(hit_and_energy.second); - simcluster.addHitTime(simTrackDetIdTimeMap_[simcluster.g4Tracks()[0].trackId()][hit_and_energy.first]); + // -- loop over possible trackIdOffsets to save also sim clusters from non-direct hits + for (unsigned int offset = 0; offset < 4; offset++) { + auto trackIdx = vertex_property.simTrack->trackId(); + trackIdx += offset * (static_cast(PSimHit::k_tidOffset)); + IfLogDebug(DEBUG, messageCategoryGraph_) + << " Found " << simHitBarcodeToIndex_.count(trackIdx) << " associated simHits" << std::endl; + if (simHitBarcodeToIndex_.count(trackIdx)) { + output_.pSimClusters->emplace_back(*vertex_property.simTrack); + auto &simcluster = output_.pSimClusters->back(); + std::unordered_map acc_energy; + for (auto const &hit_and_energy : simTrackDetIdMap_[trackIdx]) { + acc_energy[hit_and_energy.first] += std::get<0>(hit_and_energy.second); + } + for (auto const &hit_and_energy : acc_energy) { + simcluster.addHitAndFraction(hit_and_energy.first, hit_and_energy.second); + simcluster.addHitEnergy(hit_and_energy.second); + simcluster.addHitTime(std::get<1>( + simTrackDetIdMap_[simcluster.g4Tracks()[0].trackId() + + offset * (static_cast(PSimHit::k_tidOffset))][hit_and_energy.first])); + simcluster.addHitPosition(std::get<2>( + simTrackDetIdMap_[simcluster.g4Tracks()[0].trackId() + + offset * (static_cast(PSimHit::k_tidOffset))][hit_and_energy.first])); + simcluster.setTrackIdOffset(offset); + } } } } + template void examine_edge(Edge e, const Graph &g) { auto src = source(e, g); @@ -235,12 +246,11 @@ namespace { MtdTruthAccumulator::OutputCollections &output_; MtdTruthAccumulator::calo_particles &caloParticles_; std::unordered_multimap &simHitBarcodeToIndex_; - std::unordered_map> &simTrackDetIdEnergyMap_; - std::unordered_map> &simTrackDetIdTimeMap_; + std::unordered_map>> &simTrackDetIdMap_; std::unordered_map &vertex_time_map_; Selector selector_; }; -} // namespace +} // Namespace MtdTruthAccumulator::MtdTruthAccumulator(const edm::ParameterSet &config, edm::ProducesCollector producesCollector, @@ -406,6 +416,7 @@ void MtdTruthAccumulator::finalizeEvent(edm::Event &event, edm::EventSetup const auto const &hAndF = sc.hits_and_fractions(); auto const &hAndE = sc.hits_and_energies(); auto const &hAndT = sc.hits_and_times(); + auto const &hAndP = sc.hits_and_positions(); auto const &hAndR = sc.detIds_and_rows(); // create a vector with the indices of the hits in the simCluster std::vector indices(hAndF.size()); @@ -429,12 +440,21 @@ void MtdTruthAccumulator::finalizeEvent(edm::Event &event, edm::EventSetup const tmpLC.addHitAndFraction(hAndF[ind].first, hAndF[ind].second); tmpLC.addHitEnergy(hAndE[ind].second); tmpLC.addHitTime(hAndT[ind].second); + tmpLC.addHitPosition(hAndP[ind].second); }; auto update_clu_info = [&](const int &ind) { double energy = hAndE[ind].second; - auto position = - geomTools_.position((DetId)hAndR[ind].first, (hAndR[ind].second).first, (hAndR[ind].second).second).first; + auto position = hAndP[ind].second; + if (geomTools_.isBTL((DetId)hAndR[ind].first)) { + BTLDetId detId{(DetId)hAndR[ind].first}; + DetId geoId = detId.geographicalId(MTDTopologyMode::crysLayoutFromTopoMode(topology->getMTDTopologyMode())); + const MTDGeomDet *thedet = geom->idToDet(geoId); + const ProxyMTDTopology &topoproxy = static_cast(thedet->topology()); + const RectangularMTDTopology &topo = static_cast(topoproxy.specificTopology()); + position = + topo.pixelToModuleLocalPoint(hAndP[ind].second, (hAndR[ind].second).first, (hAndR[ind].second).second); + } SimLCenergy += energy; SimLCx += position.x() * energy; SimLCy += position.y() * energy; @@ -451,6 +471,7 @@ void MtdTruthAccumulator::finalizeEvent(edm::Event &event, edm::EventSetup const SimLCz = 0.; tmpLC.addCluIndex(SC_index); tmpLC.computeClusterTime(); + tmpLC.setTrackIdOffset(sc.trackIdOffset()); // add trackIdoffset output_.pMtdSimLayerClusters->push_back(tmpLC); LC_indices.push_back(LC_index); LC_index++; @@ -583,9 +604,8 @@ void MtdTruthAccumulator::accumulateEvent(const T &event, event.getByLabel(genParticleLabel_, hGenParticleIndices); std::vector> simHitPointers; - std::unordered_map> simTrackDetIdEnergyMap; - std::unordered_map> simTrackDetIdTimeMap; - fillSimHits(simHitPointers, simTrackDetIdEnergyMap, simTrackDetIdTimeMap, event, setup); + std::unordered_map>> simTrackDetIdMap; + fillSimHits(simHitPointers, simTrackDetIdMap, event, setup); // Clear maps from previous event fill them for this one m_simHitBarcodeToIndex.clear(); @@ -600,7 +620,7 @@ void MtdTruthAccumulator::accumulateEvent(const T &event, DecayChain decay; for (uint32_t i = 0; i < vertices.size(); i++) { - vertex_time_map[i] = vertices[i].position().t() * 1e9 + event.bunchCrossing() * bunchSpacing_; + vertex_time_map[i] = vertices[i].position().t() * 1e9 + event.bunchCrossing() * static_cast(bunchSpacing_); } IfLogDebug(DEBUG, messageCategory_) << " TRACKS" << std::endl; @@ -656,10 +676,8 @@ void MtdTruthAccumulator::accumulateEvent(const T &event, // Perform the actual vertex collapsing, if needed. if (collapsed_vertices[origin_vtx]) origin_vtx = collapsed_vertices[origin_vtx]; - add_edge(origin_vtx, - v.vertexId(), - EdgeProperty(&tracks[trk_idx], simTrackDetIdEnergyMap[v.parentIndex()].size(), 0), - decay); + add_edge( + origin_vtx, v.vertexId(), EdgeProperty(&tracks[trk_idx], simTrackDetIdMap[v.parentIndex()].size(), 0), decay); used_sim_tracks[trk_idx] = v.vertexId(); } } @@ -674,8 +692,7 @@ void MtdTruthAccumulator::accumulateEvent(const T &event, // Perform the actual vertex collapsing, if needed. if (collapsed_vertices[origin_vtx]) origin_vtx = collapsed_vertices[origin_vtx]; - add_edge( - origin_vtx, offset, EdgeProperty(&tracks[i], simTrackDetIdEnergyMap[tracks[i].trackId()].size(), 0), decay); + add_edge(origin_vtx, offset, EdgeProperty(&tracks[i], simTrackDetIdMap[tracks[i].trackId()].size(), 0), decay); // The properties for "fake" vertices associated to stable particles have // to be set inside this loop, since they do not belong to the vertices // collection and would be skipped by that loop (coming next) @@ -697,8 +714,7 @@ void MtdTruthAccumulator::accumulateEvent(const T &event, output_, m_caloParticles, m_simHitBarcodeToIndex, - simTrackDetIdEnergyMap, - simTrackDetIdTimeMap, + simTrackDetIdMap, vertex_time_map, [&](EdgeProperty &edge_property) -> bool { // Apply selection on SimTracks in order to promote them to be @@ -720,11 +736,11 @@ void MtdTruthAccumulator::accumulateEvent(const T &event, } template -void MtdTruthAccumulator::fillSimHits(std::vector> &returnValue, - std::unordered_map> &simTrackDetIdEnergyMap, - std::unordered_map> &simTrackDetIdTimeMap, - const T &event, - const edm::EventSetup &setup) { +void MtdTruthAccumulator::fillSimHits( + std::vector> &returnValue, + std::unordered_map>> &simTrackDetIdMap, + const T &event, + const edm::EventSetup &setup) { using namespace geant_units::operators; using namespace angle_units::operators; for (auto const &collectionTag : collectionTags_) { @@ -755,6 +771,7 @@ void MtdTruthAccumulator::fillSimHits(std::vector pixel = geomTools_.pixelInModule(id, simscaled); // create the unique id @@ -762,14 +779,20 @@ void MtdTruthAccumulator::fillSimHits(std::vector(simTrackDetIdMap[simHit.trackId()][uniqueId]) += simHit.energyLoss(); m_detIdToTotalSimEnergy[uniqueId] += simHit.energyLoss(); // --- Get the time of the first SIM hit in the cell - if (simTrackDetIdTimeMap[simHit.trackId()][uniqueId] == 0. || - simHit.tof() < simTrackDetIdTimeMap[simHit.trackId()][uniqueId]) { - simTrackDetIdTimeMap[simHit.trackId()][uniqueId] = simHit.tof(); + if (std::get<1>(simTrackDetIdMap[simHit.trackId()][uniqueId]) == 0. || + simHit.tof() < std::get<1>(simTrackDetIdMap[simHit.trackId()][uniqueId])) { + std::get<1>(simTrackDetIdMap[simHit.trackId()][uniqueId]) = simHit.tof(); } + float xSim = std::get<2>(simTrackDetIdMap[simHit.trackId()][uniqueId]).x() + simscaled.x() * simHit.energyLoss(); + float ySim = std::get<2>(simTrackDetIdMap[simHit.trackId()][uniqueId]).y() + simscaled.y() * simHit.energyLoss(); + float zSim = std::get<2>(simTrackDetIdMap[simHit.trackId()][uniqueId]).z() + simscaled.z() * simHit.energyLoss(); + LocalPoint posSim(xSim, ySim, zSim); + std::get<2>(simTrackDetIdMap[simHit.trackId()][uniqueId]) = posSim; + #ifdef PRINT_DEBUG IfLogDebug(DEBUG, messageCategory_) << "hitId " << id.rawId() << " from track " << simHit.trackId() << " in layer " << geomTools_.layer(id) @@ -779,7 +802,19 @@ void MtdTruthAccumulator::fillSimHits(std::vector(uIt.second); + float xSim = std::get<2>(uIt.second).x() / accEnergy; + float ySim = std::get<2>(uIt.second).y() / accEnergy; + float zSim = std::get<2>(uIt.second).z() / accEnergy; + LocalPoint posSim(xSim, ySim, zSim); + std::get<2>(uIt.second) = posSim; + } + } } // Register with the framework diff --git a/Validation/Configuration/python/mtdSimValid_cff.py b/Validation/Configuration/python/mtdSimValid_cff.py index 091f50d3f689e..77f8f9fa71ae9 100644 --- a/Validation/Configuration/python/mtdSimValid_cff.py +++ b/Validation/Configuration/python/mtdSimValid_cff.py @@ -1,5 +1,16 @@ import FWCore.ParameterSet.Config as cms +# --- Cluster associations maps producers +from SimFastTiming.MtdAssociatorProducers.mtdRecoClusterToSimLayerClusterAssociatorByHits_cfi import mtdRecoClusterToSimLayerClusterAssociatorByHits +from SimFastTiming.MtdAssociatorProducers.mtdRecoClusterToSimLayerClusterAssociation_cfi import mtdRecoClusterToSimLayerClusterAssociation +from SimFastTiming.MtdAssociatorProducers.mtdSimLayerClusterToTPAssociatorByTrackId_cfi import mtdSimLayerClusterToTPAssociatorByTrackId +from SimFastTiming.MtdAssociatorProducers.mtdSimLayerClusterToTPAssociation_cfi import mtdSimLayerClusterToTPAssociation +mtdAssociationProducers = cms.Sequence( mtdRecoClusterToSimLayerClusterAssociatorByHits + + mtdRecoClusterToSimLayerClusterAssociation + + mtdSimLayerClusterToTPAssociatorByTrackId + + mtdSimLayerClusterToTPAssociation + ) + # MTD validation sequences from Validation.MtdValidation.btlSimHitsValid_cfi import btlSimHitsValid from Validation.MtdValidation.btlDigiHitsValid_cfi import btlDigiHitsValid @@ -13,5 +24,5 @@ mtdSimValid = cms.Sequence(btlSimHitsValid + etlSimHitsValid ) mtdDigiValid = cms.Sequence(btlDigiHitsValid + etlDigiHitsValid) -mtdRecoValid = cms.Sequence(btlLocalRecoValid + etlLocalRecoValid + mtdTracksValid + vertices4DValid + mtdEleIsoValid) +mtdRecoValid = cms.Sequence(mtdAssociationProducers + btlLocalRecoValid + etlLocalRecoValid + mtdTracksValid + vertices4DValid + mtdEleIsoValid) diff --git a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc index 6602303cbebb0..1d04e3e20872d 100644 --- a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc +++ b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc @@ -28,6 +28,8 @@ #include "DataFormats/FTLRecHit/interface/FTLClusterCollections.h" #include "DataFormats/TrackerRecHit2D/interface/MTDTrackingRecHit.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerCluster.h" +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h" #include "SimDataFormats/CrossingFrame/interface/CrossingFrame.h" #include "SimDataFormats/CrossingFrame/interface/MixCollection.h" #include "SimDataFormats/TrackingHit/interface/PSimHit.h" @@ -71,9 +73,10 @@ class BtlLocalRecoValidation : public DQMEDAnalyzer { edm::EDGetTokenT btlRecHitsToken_; edm::EDGetTokenT btlUncalibRecHitsToken_; - edm::EDGetTokenT > btlSimHitsToken_; + edm::EDGetTokenT> btlSimHitsToken_; edm::EDGetTokenT btlRecCluToken_; edm::EDGetTokenT mtdTrackingHitToken_; + edm::EDGetTokenT r2sAssociationMapToken_; const edm::ESGetToken mtdgeoToken_; const edm::ESGetToken mtdtopoToken_; @@ -177,6 +180,83 @@ class BtlLocalRecoValidation : public DQMEDAnalyzer { MonitorElement* meCluXLocalErr_; MonitorElement* meCluYLocalErr_; + // resolution wrt to MtdSimLayerClusters + MonitorElement* meCluTimeRes_simLC_; + MonitorElement* meCluEnergyRes_simLC_; + MonitorElement* meCluTResvsE_simLC_; + MonitorElement* meCluTResvsEta_simLC_; + MonitorElement* meCluTPullvsE_simLC_; + MonitorElement* meCluTPullvsEta_simLC_; + MonitorElement* meCluRhoRes_simLC_; + MonitorElement* meCluPhiRes_simLC_; + MonitorElement* meCluLocalXRes_simLC_; + + MonitorElement* meCluLocalYResZGlobPlus_simLC_; + MonitorElement* meCluLocalYResZGlobMinus_simLC_; + + MonitorElement* meCluZRes_simLC_; + MonitorElement* meCluLocalXPull_simLC_; + + MonitorElement* meCluLocalYPullZGlobPlus_simLC_; + MonitorElement* meCluLocalYPullZGlobMinus_simLC_; + + MonitorElement* meCluSingCrystalLocalYRes_simLC_; + MonitorElement* meCluSingCrystalLocalYResZGlobPlus_simLC_; + MonitorElement* meCluSingCrystalLocalYResZGlobMinus_simLC_; + + MonitorElement* meCluMultiCrystalLocalYRes_simLC_; + MonitorElement* meCluMultiCrystalLocalYResZGlobPlus_simLC_; + MonitorElement* meCluMultiCrystalLocalYResZGlobMinus_simLC_; + + MonitorElement* meCluCentralLocalYRes_simLC_; + MonitorElement* meCluCentralLocalYResZGlobPlus_simLC_; + MonitorElement* meCluCentralLocalYResZGlobMinus_simLC_; + + MonitorElement* meCluForwardLocalYRes_simLC_; + MonitorElement* meCluForwardPlusLocalYRes_simLC_; + MonitorElement* meCluForwardMinusLocalYRes_simLC_; + + MonitorElement* meCluZPull_simLC_; + MonitorElement* meCluYXLocalSim_simLC_; + + MonitorElement* meCluTimeRes_simLC_fromIndirectHits_; + MonitorElement* meCluEnergyRes_simLC_fromIndirectHits_; + MonitorElement* meCluTResvsE_simLC_fromIndirectHits_; + MonitorElement* meCluTResvsEta_simLC_fromIndirectHits_; + MonitorElement* meCluTPullvsE_simLC_fromIndirectHits_; + MonitorElement* meCluTPullvsEta_simLC_fromIndirectHits_; + MonitorElement* meCluRhoRes_simLC_fromIndirectHits_; + MonitorElement* meCluPhiRes_simLC_fromIndirectHits_; + MonitorElement* meCluLocalXRes_simLC_fromIndirectHits_; + + MonitorElement* meCluLocalYResZGlobPlus_simLC_fromIndirectHits_; + MonitorElement* meCluLocalYResZGlobMinus_simLC_fromIndirectHits_; + + MonitorElement* meCluZRes_simLC_fromIndirectHits_; + MonitorElement* meCluLocalXPull_simLC_fromIndirectHits_; + + MonitorElement* meCluLocalYPullZGlobPlus_simLC_fromIndirectHits_; + MonitorElement* meCluLocalYPullZGlobMinus_simLC_fromIndirectHits_; + + MonitorElement* meCluSingCrystalLocalYRes_simLC_fromIndirectHits_; + MonitorElement* meCluSingCrystalLocalYResZGlobPlus_simLC_fromIndirectHits_; + MonitorElement* meCluSingCrystalLocalYResZGlobMinus_simLC_fromIndirectHits_; + + MonitorElement* meCluMultiCrystalLocalYRes_simLC_fromIndirectHits_; + MonitorElement* meCluMultiCrystalLocalYResZGlobPlus_simLC_fromIndirectHits_; + MonitorElement* meCluMultiCrystalLocalYResZGlobMinus_simLC_fromIndirectHits_; + + MonitorElement* meCluCentralLocalYRes_simLC_fromIndirectHits_; + MonitorElement* meCluCentralLocalYResZGlobPlus_simLC_fromIndirectHits_; + MonitorElement* meCluCentralLocalYResZGlobMinus_simLC_fromIndirectHits_; + + MonitorElement* meCluForwardLocalYRes_simLC_fromIndirectHits_; + MonitorElement* meCluForwardPlusLocalYRes_simLC_fromIndirectHits_; + MonitorElement* meCluForwardMinusLocalYRes_simLC_fromIndirectHits_; + + MonitorElement* meCluZPull_simLC_fromIndirectHits_; + MonitorElement* meCluYXLocalSim_simLC_fromIndirectHits_; + MonitorElement* meUnmatchedCluEnergy_; // --- UncalibratedRecHits histograms @@ -221,9 +301,11 @@ BtlLocalRecoValidation::BtlLocalRecoValidation(const edm::ParameterSet& iConfig) btlRecHitsToken_ = consumes(iConfig.getParameter("recHitsTag")); btlUncalibRecHitsToken_ = consumes(iConfig.getParameter("uncalibRecHitsTag")); - btlSimHitsToken_ = consumes >(iConfig.getParameter("simHitsTag")); + btlSimHitsToken_ = consumes>(iConfig.getParameter("simHitsTag")); btlRecCluToken_ = consumes(iConfig.getParameter("recCluTag")); mtdTrackingHitToken_ = consumes(iConfig.getParameter("trkHitTag")); + r2sAssociationMapToken_ = consumes( + iConfig.getParameter("r2sAssociationMapTag")); } BtlLocalRecoValidation::~BtlLocalRecoValidation() {} @@ -246,6 +328,7 @@ void BtlLocalRecoValidation::analyze(const edm::Event& iEvent, const edm::EventS auto btlSimHitsHandle = makeValid(iEvent.getHandle(btlSimHitsToken_)); auto btlRecCluHandle = makeValid(iEvent.getHandle(btlRecCluToken_)); auto mtdTrkHitHandle = makeValid(iEvent.getHandle(mtdTrackingHitToken_)); + const auto& r2sAssociationMap = iEvent.get(r2sAssociationMapToken_); MixCollection btlSimHits(btlSimHitsHandle.product()); #ifdef EDM_ML_DEBUG @@ -575,6 +658,173 @@ void BtlLocalRecoValidation::analyze(const edm::Event& iEvent, const edm::EventS meUnmatchedCluEnergy_->Fill(std::log10(cluster.energy())); } + // --- Fill the cluster resolution histograms using MtdSimLayerClusters as mtd truth + edm::Ref, FTLCluster> clusterRef = edmNew::makeRefTo(btlRecCluHandle, &cluster); + auto it = std::find_if( + r2sAssociationMap.begin(), + r2sAssociationMap.end(), + [&](const std::pair>& p) { return p.first == clusterRef; }); + + if (it != r2sAssociationMap.end()) { + std::vector simClustersRefs = (*it).second; + for (unsigned int i = 0; i < simClustersRefs.size(); i++) { + auto simClusterRef = simClustersRefs[i]; + + float simClusEnergy = convertUnitsTo(0.001_MeV, (*simClusterRef).simLCEnergy()); // GeV --> MeV + float simClusTime = (*simClusterRef).simLCTime(); + LocalPoint simClusLocalPos = (*simClusterRef).simLCPos(); + const auto& simClusGlobalPos = genericDet->toGlobal(simClusLocalPos); + unsigned int idOffset = (*simClusterRef).trackIdOffset(); + + float time_res = cluster.time() - simClusTime; + float energy_res = cluster.energy() - simClusEnergy; + float rho_res = global_point.perp() - simClusGlobalPos.perp(); + float phi_res = global_point.phi() - simClusGlobalPos.phi(); + float z_res = global_point.z() - simClusGlobalPos.z(); + float xlocal_res = local_point.x() - simClusLocalPos.x(); + float ylocal_res = local_point.y() - simClusLocalPos.y(); + + // -- Fill for direct hits + if (idOffset == 0) { + meCluTimeRes_simLC_->Fill(time_res); + meCluEnergyRes_simLC_->Fill(energy_res); + meCluRhoRes_simLC_->Fill(rho_res); + meCluPhiRes_simLC_->Fill(phi_res); + meCluZRes_simLC_->Fill(z_res); + + if (matchClu && comp != nullptr) { + meCluLocalXRes_simLC_->Fill(xlocal_res); + + if (global_point.z() > 0) { + meCluLocalYResZGlobPlus_simLC_->Fill(ylocal_res); + meCluLocalYPullZGlobPlus_simLC_->Fill(ylocal_res / std::sqrt(comp->localPositionError().yy())); + } else { + meCluLocalYResZGlobMinus_simLC_->Fill(ylocal_res); + meCluLocalYPullZGlobMinus_simLC_->Fill(ylocal_res / std::sqrt(comp->localPositionError().yy())); + } + if (optionalPlots_) { + if (cluster.size() == 1) { // single-crystal clusters + meCluSingCrystalLocalYRes_simLC_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluSingCrystalLocalYResZGlobPlus_simLC_->Fill(ylocal_res); + } else { + meCluSingCrystalLocalYResZGlobMinus_simLC_->Fill(ylocal_res); + } + } // end of single-crystal clusters + else { + if (cluster.size() > 1) { // multi-crystal clusters + meCluMultiCrystalLocalYRes_simLC_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluMultiCrystalLocalYResZGlobPlus_simLC_->Fill(ylocal_res); + } else { + meCluMultiCrystalLocalYResZGlobMinus_simLC_->Fill(ylocal_res); + } + } + } // end of multi-crystal clusters + + if (abs(global_point.eta()) < 0.3) { + meCluCentralLocalYRes_simLC_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluCentralLocalYResZGlobPlus_simLC_->Fill(ylocal_res); + } else { + meCluCentralLocalYResZGlobMinus_simLC_->Fill(ylocal_res); + } + } else { + if (abs(global_point.eta()) > 1) { + meCluForwardLocalYRes_simLC_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluForwardPlusLocalYRes_simLC_->Fill(ylocal_res); + } else { + meCluForwardMinusLocalYRes_simLC_->Fill(ylocal_res); + } + } + } + } //end of optional plots + + meCluLocalXPull_simLC_->Fill(xlocal_res / std::sqrt(comp->localPositionError().xx())); + meCluZPull_simLC_->Fill(z_res / std::sqrt(comp->globalPositionError().czz())); + } + + meCluTResvsEta_simLC_->Fill(std::abs(simClusGlobalPos.eta()), time_res); + meCluTResvsE_simLC_->Fill(simClusEnergy, time_res); + + meCluTPullvsEta_simLC_->Fill(std::abs(simClusGlobalPos.eta()), time_res / cluster.timeError()); + meCluTPullvsE_simLC_->Fill(simClusEnergy, time_res / cluster.timeError()); + + } // if idOffset == 0 + else { + meCluTimeRes_simLC_fromIndirectHits_->Fill(time_res); + meCluEnergyRes_simLC_fromIndirectHits_->Fill(energy_res); + meCluRhoRes_simLC_fromIndirectHits_->Fill(rho_res); + meCluPhiRes_simLC_fromIndirectHits_->Fill(phi_res); + meCluZRes_simLC_fromIndirectHits_->Fill(z_res); + + if (matchClu && comp != nullptr) { + meCluLocalXRes_simLC_fromIndirectHits_->Fill(xlocal_res); + + if (global_point.z() > 0) { + meCluLocalYResZGlobPlus_simLC_fromIndirectHits_->Fill(ylocal_res); + meCluLocalYPullZGlobPlus_simLC_fromIndirectHits_->Fill(ylocal_res / + std::sqrt(comp->localPositionError().yy())); + } else { + meCluLocalYResZGlobMinus_simLC_fromIndirectHits_->Fill(ylocal_res); + meCluLocalYPullZGlobMinus_simLC_fromIndirectHits_->Fill(ylocal_res / + std::sqrt(comp->localPositionError().yy())); + } + if (optionalPlots_) { + if (cluster.size() == 1) { // single-crystal clusters + meCluSingCrystalLocalYRes_simLC_fromIndirectHits_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluSingCrystalLocalYResZGlobPlus_simLC_fromIndirectHits_->Fill(ylocal_res); + } else { + meCluSingCrystalLocalYResZGlobMinus_simLC_fromIndirectHits_->Fill(ylocal_res); + } + } // end of single-crystal clusters + else { + if (cluster.size() > 1) { // multi-crystal clusters + meCluMultiCrystalLocalYRes_simLC_fromIndirectHits_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluMultiCrystalLocalYResZGlobPlus_simLC_fromIndirectHits_->Fill(ylocal_res); + } else { + meCluMultiCrystalLocalYResZGlobMinus_simLC_fromIndirectHits_->Fill(ylocal_res); + } + } + } // end of multi-crystal clusters + + if (abs(global_point.eta()) < 0.3) { + meCluCentralLocalYRes_simLC_fromIndirectHits_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluCentralLocalYResZGlobPlus_simLC_fromIndirectHits_->Fill(ylocal_res); + } else { + meCluCentralLocalYResZGlobMinus_simLC_fromIndirectHits_->Fill(ylocal_res); + } + } else { + if (abs(global_point.eta()) > 1) { + meCluForwardLocalYRes_simLC_fromIndirectHits_->Fill(ylocal_res); + if (global_point.z() > 0) { + meCluForwardPlusLocalYRes_simLC_fromIndirectHits_->Fill(ylocal_res); + } else { + meCluForwardMinusLocalYRes_simLC_fromIndirectHits_->Fill(ylocal_res); + } + } + } + } //end of optional plots + + meCluLocalXPull_simLC_fromIndirectHits_->Fill(xlocal_res / std::sqrt(comp->localPositionError().xx())); + meCluZPull_simLC_fromIndirectHits_->Fill(z_res / std::sqrt(comp->globalPositionError().czz())); + } + + meCluTResvsEta_simLC_fromIndirectHits_->Fill(std::abs(simClusGlobalPos.eta()), time_res); + meCluTResvsE_simLC_fromIndirectHits_->Fill(simClusEnergy, time_res); + + meCluTPullvsEta_simLC_fromIndirectHits_->Fill(std::abs(simClusGlobalPos.eta()), + time_res / cluster.timeError()); + meCluTPullvsE_simLC_fromIndirectHits_->Fill(simClusEnergy, time_res / cluster.timeError()); + } + + } // simLayerClusterRefs loop + } + } // cluster loop } // DetSetClu loop @@ -933,6 +1183,411 @@ void BtlLocalRecoValidation::bookHistograms(DQMStore::IBooker& ibook, -2.8, 2.8); } + + // with MtdSimLayerCluster as truth + meCluTimeRes_simLC_ = ibook.book1D("BtlCluTimeRes_simLC", + "BTL cluster time resolution (wrt MtdSimLayerClusters);T_{RECO}-T_{SIM} [ns]", + 100, + -0.5, + 0.5); + meCluEnergyRes_simLC_ = ibook.book1D("BtlCluEnergyRes_simLC", + "BTL cluster energy resolution (wrt MtdSimLayerClusters);E_{RECO}-E_{SIM} [MeV]", + 100, + -0.5, + 0.5); + meCluTResvsE_simLC_ = ibook.bookProfile( + "BtlCluTResvsE_simLC", + "BTL cluster time resolution (wrt MtdSimLayerClusters) vs E;E_{SIM} [MeV];(T_{RECO}-T_{SIM}) [ns]", + 20, + 0., + 20., + -0.5, + 0.5, + "S"); + meCluTResvsEta_simLC_ = ibook.bookProfile( + "BtlCluTResvsEta_simLC", + "BTL cluster time resolution (wrt MtdSimLayerClusters) vs #eta;|#eta_{RECO}|;(T_{RECO}-T_{SIM}) [ns]", + 30, + 0, + 1.55, + -0.5, + 0.5, + "S"); + meCluTPullvsE_simLC_ = ibook.bookProfile( + "BtlCluTPullvsE_simLC", + "BTL cluster time pull (wrt MtdSimLayerClusters) vs E;E_{SIM} [MeV];(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 20, + 0., + 20., + -5., + 5., + "S"); + meCluTPullvsEta_simLC_ = ibook.bookProfile( + "BtlCluTPullvsEta_simLC", + "BTL cluster time pull (wrt MtdSimLayerClusters) vs #eta;|#eta_{RECO}|;(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 30, + 0, + 1.55, + -5., + 5., + "S"); + meCluRhoRes_simLC_ = ibook.book1D("BtlCluRhoRes_simLC", + "BTL cluster #rho resolution (wrt MtdSimLayerClusters);#rho_{RECO}-#rho_{SIM} [cm]", + 100, + -0.5, + 0.5); + meCluPhiRes_simLC_ = + ibook.book1D("BtlCluPhiRes_simLC", + "BTL cluster #phi resolution (wrt MtdSimLayerClusters);#phi_{RECO}-#phi_{SIM} [rad]", + 100, + -0.03, + 0.03); + meCluZRes_simLC_ = ibook.book1D( + "BtlCluZRes_simLC", "BTL cluster Z resolution (wrt MtdSimLayerClusters);Z_{RECO}-Z_{SIM} [cm]", 100, -0.2, 0.2); + meCluLocalXRes_simLC_ = ibook.book1D("BtlCluLocalXRes_simLC", + "BTL cluster local X resolution (wrt MtdSimLayerClusters);X_{RECO}-X_{SIM} [cm]", + 100, + -3.1, + 3.1); + meCluLocalYResZGlobPlus_simLC_ = + ibook.book1D("BtlCluLocalYResZGlobPlus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, glob Z > 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluLocalYResZGlobMinus_simLC_ = + ibook.book1D("BtlCluLocalYResZGlobMinus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, glob Z < 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + if (optionalPlots_) { + meCluSingCrystalLocalYRes_simLC_ = ibook.book1D( + "BtlCluSingCrystalLocalYRes_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, single Crystal clusters);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluSingCrystalLocalYResZGlobPlus_simLC_ = + ibook.book1D("BtlCluSingCrystalLocalYResZGlobPlus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, single Crystal clusters, Z glob > " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluSingCrystalLocalYResZGlobMinus_simLC_ = + ibook.book1D("BtlCluSingCrystalLocalYResZGlobMinus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, single Crystal clusters, Z glob < " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluMultiCrystalLocalYRes_simLC_ = ibook.book1D( + "BtlCluMultiCrystalLocalYRes_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, Multi-Crystal clusters);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluMultiCrystalLocalYResZGlobPlus_simLC_ = + ibook.book1D("BtlCluMultiCrystalLocalYResZGlobPlus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, Multi-Crystal clusters, Z glob > " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluMultiCrystalLocalYResZGlobMinus_simLC_ = + ibook.book1D("BtlCluMultiCrystalLocalYResZGlobMinus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, Multi-Crystal clusters, Z glob < " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluCentralLocalYRes_simLC_ = + ibook.book1D("BtlCluCentralLocalYRes_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, central region);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluCentralLocalYResZGlobPlus_simLC_ = ibook.book1D( + "BtlCluCentralLocalYResZGlobPlus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, central region, Z glob > 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluCentralLocalYResZGlobMinus_simLC_ = ibook.book1D( + "BtlCluCentralLocalYResZGlobMinus_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, central region, Z glob < 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluForwardLocalYRes_simLC_ = + ibook.book1D("BtlCluForwardLocalYRes_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, forward region);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluForwardPlusLocalYRes_simLC_ = ibook.book1D( + "BtlCluForwardPlusLocalYRes_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, forward region, Z glob > 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluForwardMinusLocalYRes_simLC_ = ibook.book1D( + "BtlCluForwardMinusLocalYRes_simLC", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, forward region, Z glob < 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + } + meCluLocalYPullZGlobPlus_simLC_ = ibook.book1D("BtlCluLocalYPullZGlobPlus_simLC", + "BTL cluster local Y pull (glob Z > 0);Y_{RECO}-Y_{SIM}/sigmaY_[RECO]", + 100, + -5., + 5.); + meCluLocalYPullZGlobMinus_simLC_ = + ibook.book1D("BtlCluLocalYPullZGlobMinus", + "BTL cluster local Y pull (wrt MtdSimLayerClusters, glob Z < 0);Y_{RECO}-Y_{SIM}/sigmaY_[RECO]", + 100, + -5., + 5.); + + meCluLocalXPull_simLC_ = + ibook.book1D("BtlCluLocalXPull_simLC", + "BTL cluster local X pull (wrt MtdSimLayerClusters);X_{RECO}-X_{SIM}/sigmaX_[RECO]", + 100, + -5., + 5.); + + meCluZPull_simLC_ = ibook.book1D( + "BtlCluZPull_simLC", "BTL cluster Z pull (wrt MtdSimLayerClusters);Z_{RECO}-Z_{SIM}/sigmaZ_[RECO]", 100, -5., 5.); + if (optionalPlots_) { + meCluYXLocalSim_simLC_ = + ibook.book2D("BtlCluYXLocalSim_simLC", + "BTL cluster local Y vs X (MtdSimLayerClusters);X^{local}_{SIM} [cm];Y^{local}_{SIM} [cm]", + 200, + -9.5, + 9.5, + 200, + -2.8, + 2.8); + } + + /// + + meCluTimeRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluTimeRes_simLC_fromIndirectHits", + "BTL cluster time resolution (wrt MtdSimLayerClusters, non-direct hits);T_{RECO}-T_{SIM} [ns]", + 100, + -0.5, + 0.5); + meCluEnergyRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluEnergyRes_simLC_fromIndirectHits", + "BTL cluster energy resolution (wrt MtdSimLayerClusters, non-direct hits);E_{RECO}-E_{SIM} [MeV]", + 100, + -0.5, + 0.5); + meCluTResvsE_simLC_fromIndirectHits_ = + ibook.bookProfile("BtlCluTResvsE_simLC_fromIndirectHits", + "BTL cluster time resolution (wrt MtdSimLayerClusters, non-direct hits) vs E;E_{SIM} " + "[MeV];(T_{RECO}-T_{SIM}) [ns]", + 20, + 0., + 20., + -0.5, + 0.5, + "S"); + meCluTResvsEta_simLC_fromIndirectHits_ = + ibook.bookProfile("BtlCluTResvsEta_simLC_fromIndirectHits", + "BTL cluster time resolution (wrt MtdSimLayerClusters, non-direct hits) vs " + "#eta;|#eta_{RECO}|;(T_{RECO}-T_{SIM}) [ns]", + 30, + 0, + 1.55, + -0.5, + 0.5, + "S"); + meCluTPullvsE_simLC_fromIndirectHits_ = + ibook.bookProfile("BtlCluTPullvsE_simLC_fromIndirectHits", + "BTL cluster time pull (wrt MtdSimLayerClusters, non-direct hits) vs E;E_{SIM} " + "[MeV];(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 20, + 0., + 20., + -5., + 5., + "S"); + meCluTPullvsEta_simLC_fromIndirectHits_ = + ibook.bookProfile("BtlCluTPullvsEta_simLC_fromIndirectHits", + "BTL cluster time pull (wrt MtdSimLayerClusters, non-direct hits) vs " + "#eta;|#eta_{RECO}|;(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 30, + 0, + 1.55, + -5., + 5., + "S"); + meCluRhoRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluRhoRes_simLC_fromIndirectHits", + "BTL cluster #rho resolution (wrt MtdSimLayerClusters, non-direct hits);#rho_{RECO}-#rho_{SIM} [cm]", + 100, + -0.5, + 0.5); + meCluPhiRes_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluPhiRes_simLC_fromIndirectHits", + "BTL cluster #phi resolution (wrt MtdSimLayerClusters, non-direct hits);#phi_{RECO}-#phi_{SIM} [rad]", + 100, + -0.03, + 0.03); + meCluZRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluZRes_simLC_fromIndirectHits", + "BTL cluster Z resolution (wrt MtdSimLayerClusters, non-direct hits);Z_{RECO}-Z_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluLocalXRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluLocalXRes_simLC_fromIndirectHits", + "BTL cluster local X resolution (wrt MtdSimLayerClusters, non-direct hits);X_{RECO}-X_{SIM} [cm]", + 100, + -3.1, + 3.1); + meCluLocalYResZGlobPlus_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluLocalYResZGlobPlus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, glob Z > 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluLocalYResZGlobMinus_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluLocalYResZGlobMinus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, glob Z < 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + if (optionalPlots_) { + meCluSingCrystalLocalYRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluSingCrystalLocalYRes_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, single Crystal " + "clusters);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluSingCrystalLocalYResZGlobPlus_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluSingCrystalLocalYResZGlobPlus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, single Crystal clusters, Z glob > " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluSingCrystalLocalYResZGlobMinus_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluSingCrystalLocalYResZGlobMinus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, single Crystal clusters, Z glob < " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluMultiCrystalLocalYRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluMultiCrystalLocalYRes_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, Multi-Crystal " + "clusters);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluMultiCrystalLocalYResZGlobPlus_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluMultiCrystalLocalYResZGlobPlus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, Multi-Crystal clusters, Z glob > " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluMultiCrystalLocalYResZGlobMinus_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluMultiCrystalLocalYResZGlobMinus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, Multi-Crystal clusters, Z glob < " + "0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluCentralLocalYRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluCentralLocalYRes_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, central " + "region);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluCentralLocalYResZGlobPlus_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluCentralLocalYResZGlobPlus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, central region, Z glob " + "> 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluCentralLocalYResZGlobMinus_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluCentralLocalYResZGlobMinus_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, central region, Z glob " + "< 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluForwardLocalYRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluForwardLocalYRes_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, forward " + "region);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluForwardPlusLocalYRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluForwardPlusLocalYRes_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, forward region, Z glob " + "> 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + meCluForwardMinusLocalYRes_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluForwardMinusLocalYRes_simLC_fromIndirectHits", + "BTL cluster local Y resolution (wrt MtdSimLayerClusters, non-direct hits, forward region, Z glob " + "< 0);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.2, + 0.2); + } + meCluLocalYPullZGlobPlus_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluLocalYPullZGlobPlus_simLC_fromIndirectHits", + "BTL cluster local Y pull (glob Z > 0);Y_{RECO}-Y_{SIM}/sigmaY_[RECO]", + 100, + -5., + 5.); + meCluLocalYPullZGlobMinus_simLC_fromIndirectHits_ = ibook.book1D( + "BtlCluLocalYPullZGlobMinus", + "BTL cluster local Y pull (wrt MtdSimLayerClusters, non-direct hits, glob Z < 0);Y_{RECO}-Y_{SIM}/sigmaY_[RECO]", + 100, + -5., + 5.); + + meCluLocalXPull_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluLocalXPull_simLC_fromIndirectHits", + "BTL cluster local X pull (wrt MtdSimLayerClusters, non-direct hits);X_{RECO}-X_{SIM}/sigmaX_[RECO]", + 100, + -5., + 5.); + + meCluZPull_simLC_fromIndirectHits_ = + ibook.book1D("BtlCluZPull_simLC_fromIndirectHits", + "BTL cluster Z pull (wrt MtdSimLayerClusters, non-direct hits);Z_{RECO}-Z_{SIM}/sigmaZ_[RECO]", + 100, + -5., + 5.); + if (optionalPlots_) { + meCluYXLocalSim_simLC_fromIndirectHits_ = + ibook.book2D("BtlCluYXLocalSim_simLC_fromIndirectHits", + "BTL cluster local Y vs X (MtdSimLayerClusters);X^{local}_{SIM} [cm];Y^{local}_{SIM} [cm]", + 200, + -9.5, + 9.5, + 200, + -2.8, + 2.8); + } + + /// + meUnmatchedCluEnergy_ = ibook.book1D("BtlUnmatchedCluEnergy", "BTL unmatched cluster log10(energy);log10(E_{RECO} [MeV])", 5, -3, 2); @@ -1013,6 +1668,7 @@ void BtlLocalRecoValidation::fillDescriptions(edm::ConfigurationDescriptions& de desc.add("simHitsTag", edm::InputTag("mix", "g4SimHitsFastTimerHitsBarrel")); desc.add("recCluTag", edm::InputTag("mtdClusters", "FTLBarrel")); desc.add("trkHitTag", edm::InputTag("mtdTrackingRecHits")); + desc.add("r2sAssociationMapTag", edm::InputTag("mtdRecoClusterToSimLayerClusterAssociation")); desc.add("HitMinimumEnergy", 1.); // [MeV] desc.add("optionalPlots", false); desc.add("UncalibRecHitsPlots", false); diff --git a/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc b/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc index f51aa435b272e..12848e9dc340b 100644 --- a/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc +++ b/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc @@ -28,6 +28,8 @@ #include "DataFormats/FTLRecHit/interface/FTLClusterCollections.h" #include "DataFormats/TrackerRecHit2D/interface/MTDTrackingRecHit.h" +#include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerCluster.h" +#include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h" #include "SimDataFormats/CrossingFrame/interface/CrossingFrame.h" #include "SimDataFormats/CrossingFrame/interface/MixCollection.h" #include "SimDataFormats/TrackingHit/interface/PSimHit.h" @@ -68,9 +70,10 @@ class EtlLocalRecoValidation : public DQMEDAnalyzer { edm::EDGetTokenT etlRecHitsToken_; edm::EDGetTokenT etlUncalibRecHitsToken_; - edm::EDGetTokenT > etlSimHitsToken_; + edm::EDGetTokenT> etlSimHitsToken_; edm::EDGetTokenT etlRecCluToken_; edm::EDGetTokenT mtdTrackingHitToken_; + edm::EDGetTokenT r2sAssociationMapToken_; const edm::ESGetToken mtdgeoToken_; const edm::ESGetToken mtdtopoToken_; @@ -128,6 +131,18 @@ class EtlLocalRecoValidation : public DQMEDAnalyzer { MonitorElement* meCluXLocalErr_[2]; MonitorElement* meCluYLocalErr_[2]; + // resolution using MtdSimLayerClusters as truth + MonitorElement* meCluTimeRes_simLC_[2]; + MonitorElement* meCluEnergyRes_simLC_[2]; + MonitorElement* meCluTPullvsE_simLC_[2]; + MonitorElement* meCluTPullvsEta_simLC_[2]; + MonitorElement* meCluXRes_simLC_[2]; + MonitorElement* meCluYRes_simLC_[2]; + MonitorElement* meCluZRes_simLC_[2]; + MonitorElement* meCluXPull_simLC_[2]; + MonitorElement* meCluYPull_simLC_[2]; + MonitorElement* meCluYXLocalSim_simLC_[2]; + MonitorElement* meUnmatchedCluEnergy_[2]; // --- UncalibratedRecHits histograms @@ -163,9 +178,11 @@ EtlLocalRecoValidation::EtlLocalRecoValidation(const edm::ParameterSet& iConfig) if (uncalibRecHitsPlots_) etlUncalibRecHitsToken_ = consumes(iConfig.getParameter("uncalibRecHitsTag")); - etlSimHitsToken_ = consumes >(iConfig.getParameter("simHitsTag")); + etlSimHitsToken_ = consumes>(iConfig.getParameter("simHitsTag")); etlRecCluToken_ = consumes(iConfig.getParameter("recCluTag")); mtdTrackingHitToken_ = consumes(iConfig.getParameter("trkHitTag")); + r2sAssociationMapToken_ = consumes( + iConfig.getParameter("r2sAssociationMapTag")); } EtlLocalRecoValidation::~EtlLocalRecoValidation() {} @@ -185,6 +202,7 @@ void EtlLocalRecoValidation::analyze(const edm::Event& iEvent, const edm::EventS auto etlSimHitsHandle = makeValid(iEvent.getHandle(etlSimHitsToken_)); auto etlRecCluHandle = makeValid(iEvent.getHandle(etlRecCluToken_)); auto mtdTrkHitHandle = makeValid(iEvent.getHandle(mtdTrackingHitToken_)); + const auto& r2sAssociationMap = iEvent.get(r2sAssociationMapToken_); MixCollection etlSimHits(etlSimHitsHandle.product()); #ifdef EDM_ML_DEBUG @@ -490,6 +508,49 @@ void EtlLocalRecoValidation::analyze(const edm::Event& iEvent, const edm::EventS meUnmatchedCluEnergy_[iside]->Fill(std::log10(cluster.energy())); } + // --- Fill the cluster resolution histograms using MtdSimLayerClusters as mtd truth + edm::Ref, FTLCluster> clusterRef = edmNew::makeRefTo(etlRecCluHandle, &cluster); + auto it = std::find_if( + r2sAssociationMap.begin(), + r2sAssociationMap.end(), + [&](const std::pair>& p) { return p.first == clusterRef; }); + + if (it != r2sAssociationMap.end()) { + std::vector simClustersRefs = (*it).second; + for (unsigned int i = 0; i < simClustersRefs.size(); i++) { + auto simClusterRef = simClustersRefs[i]; + + float simClusEnergy = convertUnitsTo(0.001_MeV, (*simClusterRef).simLCEnergy()); // GeV --> MeV + float simClusTime = (*simClusterRef).simLCTime(); + LocalPoint simClusLocalPos = (*simClusterRef).simLCPos(); + const auto& simClusGlobalPos = genericDet->toGlobal(simClusLocalPos); + + float time_res = cluster.time() - simClusTime; + float energy_res = cluster.energy() - simClusEnergy; + float x_res = global_point.x() - simClusGlobalPos.x(); + float y_res = global_point.y() - simClusGlobalPos.y(); + float z_res = global_point.z() - simClusGlobalPos.z(); + + meCluTimeRes_simLC_[iside]->Fill(time_res); + meCluEnergyRes_simLC_[iside]->Fill(energy_res); + meCluXRes_simLC_[iside]->Fill(x_res); + meCluYRes_simLC_[iside]->Fill(y_res); + meCluZRes_simLC_[iside]->Fill(z_res); + + meCluTPullvsEta_simLC_[iside]->Fill(simClusGlobalPos.eta(), time_res / cluster.timeError()); + meCluTPullvsE_simLC_[iside]->Fill(simClusEnergy, time_res / cluster.timeError()); + + if (matchClu && comp != nullptr) { + meCluXPull_simLC_[iside]->Fill(x_res / std::sqrt(comp->globalPositionError().cxx())); + meCluYPull_simLC_[iside]->Fill(y_res / std::sqrt(comp->globalPositionError().cyy())); + } + if (optionalPlots_) { + meCluYXLocalSim_simLC_[iside]->Fill(simClusLocalPos.x(), simClusLocalPos.y()); + } + + } // loop over MtdSimLayerClusters + } + } // cluster loop } // DetSetClu loop @@ -1036,7 +1097,139 @@ void EtlLocalRecoValidation::bookHistograms(DQMStore::IBooker& ibook, 200, -1.1, 1.1); + meCluYXLocalSim_simLC_[0] = + ibook.book2D("EtlCluYXLocalSimZneg_simLC", + "ETL cluster local Y vs X (-Z, MtdSimLayerClusters);X^{local}_{SIM} [cm];Y^{local}_{SIM} [cm]", + 200, + -2.2, + 2.2, + 200, + -1.1, + 1.1); + meCluYXLocalSim_simLC_[1] = + ibook.book2D("EtlCluYXLocalSimZpos_simLC", + "ETL cluster local Y vs X (+Z, MtdSimLayerClusters);X^{local}_{SIM} [cm];Y^{local}_{SIM} [cm]", + 200, + -2.2, + 2.2, + 200, + -1.1, + 1.1); } + + // resolution plots using MtdSimLayerClusters as truth + meCluTimeRes_simLC_[0] = ibook.book1D("EtlCluTimeResZneg_simLC", + "ETL cluster time resolution (MtdSimLayerClusters, -Z);T_{RECO}-T_{SIM} [ns]", + 100, + -0.5, + 0.5); + meCluTimeRes_simLC_[1] = ibook.book1D("EtlCluTimeResZpos_simLC", + "ETL cluster time resolution (MtdSimLayerClusters, +Z);T_{RECO}-T_{SIM} [MeV]", + 100, + -0.5, + 0.5); + meCluEnergyRes_simLC_[0] = ibook.book1D("EtlCluEnergyResZneg_simLC", + "ETL cluster energy resolution (MtdSimLayerClusters, -Z);E_{RECO}-E_{SIM}", + 100, + -0.5, + 0.5); + meCluEnergyRes_simLC_[1] = ibook.book1D("EtlCluEnergyResZpos_simLC", + "ETL cluster energy resolution (MtdSimLayerClusters, +Z);E_{RECO}-E_{SIM}", + 100, + -0.5, + 0.5); + + meCluTPullvsE_simLC_[0] = ibook.bookProfile( + "EtlCluTPullvsEZneg_simLC", + "ETL cluster time pull vs E (MtdSimLayerClusters, -Z);E_{SIM} [MeV];(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 25, + 0., + 0.5, + -5., + 5., + "S"); + meCluTPullvsE_simLC_[1] = ibook.bookProfile( + "EtlCluTPullvsEZpos_simLC", + "ETL cluster time pull vs E (MtdSimLayerClusters, +Z);E_{SIM} [MeV];(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 25, + 0., + 0.5, + -5., + 5., + "S"); + meCluTPullvsEta_simLC_[0] = ibook.bookProfile( + "EtlCluTPullvsEtaZneg_simLC", + "ETL cluster time pull vs #eta (MtdSimLayerClusters, -Z);|#eta_{RECO}|;(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 30, + -3., + -1.65, + -5., + 5., + "S"); + meCluTPullvsEta_simLC_[1] = ibook.bookProfile( + "EtlCluTPullvsEtaZpos_simLC", + "ETL cluster time pull vs #eta (MtdSimLayerClusters, +Z);|#eta_{RECO}|;(T_{RECO}-T_{SIM})/#sigma_{T_{RECO}}", + 30, + 1.65, + 3., + -5., + 5., + "S"); + meCluXRes_simLC_[0] = ibook.book1D("EtlCluXResZneg_simLC", + "ETL cluster X resolution (MtdSimLayerClusters, -Z);X_{RECO}-X_{SIM} [cm]", + 100, + -0.1, + 0.1); + meCluXRes_simLC_[1] = ibook.book1D("EtlCluXResZpos_simLC", + "ETL cluster X resolution (MtdSimLayerClusters, +Z);X_{RECO}-X_{SIM} [cm]", + 100, + -0.1, + 0.1); + meCluYRes_simLC_[0] = ibook.book1D("EtlCluYResZneg_simLC", + "ETL cluster Y resolution (MtdSimLayerClusters, -Z);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.1, + 0.1); + meCluYRes_simLC_[1] = ibook.book1D("EtlCluYResZpos_simLC", + "ETL cluster Y resolution (MtdSimLayerClusters, +Z);Y_{RECO}-Y_{SIM} [cm]", + 100, + -0.1, + 0.1); + meCluZRes_simLC_[0] = ibook.book1D("EtlCluZResZneg_simLC", + "ETL cluster Z resolution (MtdSimLayerClusters, -Z);Z_{RECO}-Z_{SIM} [cm]", + 100, + -0.003, + 0.003); + meCluZRes_simLC_[1] = ibook.book1D("EtlCluZResZpos_simLC", + "ETL cluster Z resolution (MtdSimLayerClusters, +Z);Z_{RECO}-Z_{SIM} [cm]", + 100, + -0.003, + 0.003); + meCluXPull_simLC_[0] = + ibook.book1D("EtlCluXPullZneg_simLC", + "ETL cluster X pull (MtdSimLayerClusters, -Z);X_{RECO}-X_{SIM}/sigmaX_[RECO] [cm]", + 100, + -5., + 5.); + meCluXPull_simLC_[1] = + ibook.book1D("EtlCluXPullZpos_simLC", + "ETL cluster X pull (MtdSimLayerClusters, +Z);X_{RECO}-X_{SIM}/sigmaX_[RECO] [cm]", + 100, + -5., + 5.); + meCluYPull_simLC_[0] = + ibook.book1D("EtlCluYPullZneg_simLC", + "ETL cluster Y pull (MtdSimLayerClusters, -Z);Y_{RECO}-Y_{SIM}/sigmaY_[RECO] [cm]", + 100, + -5., + 5.); + meCluYPull_simLC_[1] = + ibook.book1D("EtlCluYPullZpos_simLC", + "ETL cluster Y pull (MtdSimLayerClusters, +Z);Y_{RECO}-Y_{SIM}/sigmaY_[RECO] [cm]", + 100, + -5., + 5.); + meUnmatchedCluEnergy_[0] = ibook.book1D( "EtlUnmatchedCluEnergyNeg", "ETL unmatched cluster log10(energy) (-Z);log10(E_{RECO} [MeV])", 5, -3, 2); meUnmatchedCluEnergy_[1] = ibook.book1D( @@ -1076,6 +1269,7 @@ void EtlLocalRecoValidation::fillDescriptions(edm::ConfigurationDescriptions& de desc.add("simHitsTag", edm::InputTag("mix", "g4SimHitsFastTimerHitsEndcap")); desc.add("recCluTag", edm::InputTag("mtdClusters", "FTLEndcap")); desc.add("trkHitTag", edm::InputTag("mtdTrackingRecHits")); + desc.add("r2sAssociationMapTag", edm::InputTag("mtdRecoClusterToSimLayerClusterAssociation")); desc.add("hitMinimumEnergy2Dis", 0.001); // [MeV] desc.add("optionalPlots", false); desc.add("UncalibRecHitsPlots", false); diff --git a/Validation/MtdValidation/plugins/MtdTracksValidation.cc b/Validation/MtdValidation/plugins/MtdTracksValidation.cc index fb4ff3d791cec..02ba7693c2aa2 100644 --- a/Validation/MtdValidation/plugins/MtdTracksValidation.cc +++ b/Validation/MtdValidation/plugins/MtdTracksValidation.cc @@ -66,6 +66,7 @@ #include "SimDataFormats/TrackingAnalysis/interface/TrackingVertexContainer.h" #include "SimDataFormats/CrossingFrame/interface/MixCollection.h" #include "SimDataFormats/TrackingHit/interface/PSimHit.h" +#include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h" #include "SimDataFormats/GeneratorProducts/interface/HepMCProduct.h" #include "SimGeneral/HepPDTRecord/interface/ParticleDataTable.h" @@ -138,6 +139,7 @@ class MtdTracksValidation : public DQMEDAnalyzer { edm::EDGetTokenT trackingParticleCollectionToken_; edm::EDGetTokenT simToRecoAssociationToken_; edm::EDGetTokenT recoToSimAssociationToken_; + edm::EDGetTokenT tp2SimAssociationMapToken_; edm::EDGetTokenT> btlSimHitsToken_; edm::EDGetTokenT> etlSimHitsToken_; edm::EDGetTokenT btlRecHitsToken_; @@ -266,6 +268,8 @@ MtdTracksValidation::MtdTracksValidation(const edm::ParameterSet& iConfig) consumes(iConfig.getParameter("TPtoRecoTrackAssoc")); recoToSimAssociationToken_ = consumes(iConfig.getParameter("TPtoRecoTrackAssoc")); + tp2SimAssociationMapToken_ = + consumes(iConfig.getParameter("tp2SimAssociationMapTag")); btlSimHitsToken_ = consumes>(iConfig.getParameter("btlSimHits")); etlSimHitsToken_ = consumes>(iConfig.getParameter("etlSimHits")); btlRecHitsToken_ = consumes(iConfig.getParameter("btlRecHits")); @@ -304,7 +308,7 @@ void MtdTracksValidation::analyze(const edm::Event& iEvent, const edm::EventSetu std::unordered_map m_etlHits; std::unordered_map> m_btlTrkPerCell; std::unordered_map> m_etlTrkPerCell; - std::map> m_tp2detid; + const auto& tp2SimAssociationMap = iEvent.get(tp2SimAssociationMapToken_); const auto& tMtd = iEvent.get(tmtdToken_); const auto& SigmatMtd = iEvent.get(SigmatmtdToken_); @@ -364,44 +368,6 @@ void MtdTracksValidation::analyze(const edm::Event& iEvent, const edm::EventSetu (simHitIt->second).energy += convertUnitsTo(0.001_MeV, simHit.energyLoss()); } - //Fill map of DetId per ref to TP - - auto tpHandle = makeValid(iEvent.getHandle(trackingParticleCollectionToken_)); - TrackingParticleCollection tpColl = *(tpHandle.product()); - size_t tpindex(0); - for (auto tp = tpColl.begin(); tp != tpColl.end(); tp++, ++tpindex) { - TrackingParticleRef tpref(iEvent.getHandle(trackingParticleCollectionToken_), tpindex); - if (tp->eventId().bunchCrossing() == 0 && tp->eventId().event() == 0) { - if (!mvaTPSel(*tp)) - continue; - for (const auto& simTrk : tp->g4Tracks()) { - auto const thisTId = uniqueId(simTrk.trackId(), simTrk.eventId()); - for (auto const& cell : m_btlTrkPerCell) { - if (m_btlHits[cell.first].energy < depositBTLthreshold_) { - continue; - } - for (auto const& simtrack : cell.second) { - if (thisTId == simtrack) { - m_tp2detid[tpref].emplace_back(cell.first); - break; - } - } - } - for (auto const& cell : m_etlTrkPerCell) { - if (m_etlHits[cell.first].energy < depositETLthreshold_) { - continue; - } - for (auto const& simtrack : cell.second) { - if (thisTId == simtrack) { - m_tp2detid[tpref].emplace_back(cell.first); - break; - } - } - } - } - } - } - unsigned int index = 0; // flag to select events with reco vertex close to true simulated primary vertex, or PV fake (particle guns) @@ -612,8 +578,8 @@ void MtdTracksValidation::analyze(const edm::Event& iEvent, const edm::EventSetu (track.pt() - (*tp_info)->pt()) / ((*tp_info)->pt())); } } - const bool withMTD = (m_tp2detid.find(*tp_info) != m_tp2detid.end()); - LogDebug("MtdTracksValidation") << "Matched with selected TP, MTD sim hits association: " << withMTD; + auto simClustersRefs = tp2SimAssociationMap.find(*tp_info); + const bool withMTD = (simClustersRefs != tp2SimAssociationMap.end()); if (noCrack) { meTrackMatchedTPEffPtTot_->Fill(trackGen.pt()); if (withMTD) { @@ -1202,6 +1168,7 @@ void MtdTracksValidation::fillDescriptions(edm::ConfigurationDescriptions& descr desc.add("inputTagH", edm::InputTag("generatorSmeared")); desc.add("SimTag", edm::InputTag("mix", "MergedTrackTruth")); desc.add("TPtoRecoTrackAssoc", edm::InputTag("trackingParticleRecoTrackAsssociation")); + desc.add("tp2SimAssociationMapTag", edm::InputTag("mtdSimLayerClusterToTPAssociation")); desc.add("btlSimHits", edm::InputTag("mix", "g4SimHitsFastTimerHitsBarrel")); desc.add("etlSimHits", edm::InputTag("mix", "g4SimHitsFastTimerHitsEndcap")); desc.add("btlRecHits", edm::InputTag("mtdRecHits", "FTLBarrel")); From 3e2c7e7a76e145c35a36571793c61157979a11f0 Mon Sep 17 00:00:00 2001 From: Martina Date: Thu, 8 Feb 2024 12:35:31 +0100 Subject: [PATCH 2/7] set debug option to false --- SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc b/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc index b4513af9e3d70..2c810aac14e17 100644 --- a/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc +++ b/SimGeneral/CaloAnalysis/plugins/MtdTruthAccumulator.cc @@ -1,8 +1,7 @@ // Author: Aurora Perego, Fabio Cossutti - aurora.perego@cern.ch, fabio.cossutti@ts.infn.it // Date: 05/2023 -//#define DEBUG false -#define DEBUG true +#define DEBUG false #define PRINT_DEBUG true #if DEBUG From 030c808dd7f5a474221a06866de63cf387832ea1 Mon Sep 17 00:00:00 2001 From: Martina Date: Thu, 8 Feb 2024 13:38:29 +0100 Subject: [PATCH 3/7] fix histogram names --- Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc index 1d04e3e20872d..e493e3e4fa525 100644 --- a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc +++ b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc @@ -1345,7 +1345,7 @@ void BtlLocalRecoValidation::bookHistograms(DQMStore::IBooker& ibook, -5., 5.); meCluLocalYPullZGlobMinus_simLC_ = - ibook.book1D("BtlCluLocalYPullZGlobMinus", + ibook.book1D("BtlCluLocalYPullZGlobMinus_simLC", "BTL cluster local Y pull (wrt MtdSimLayerClusters, glob Z < 0);Y_{RECO}-Y_{SIM}/sigmaY_[RECO]", 100, -5., @@ -1555,7 +1555,7 @@ void BtlLocalRecoValidation::bookHistograms(DQMStore::IBooker& ibook, -5., 5.); meCluLocalYPullZGlobMinus_simLC_fromIndirectHits_ = ibook.book1D( - "BtlCluLocalYPullZGlobMinus", + "BtlCluLocalYPullZGlobMinus_simLC_fromIndirectHits", "BTL cluster local Y pull (wrt MtdSimLayerClusters, non-direct hits, glob Z < 0);Y_{RECO}-Y_{SIM}/sigmaY_[RECO]", 100, -5., From 8d0fb224b56a57176ef28d1e5400c41f08a17c6d Mon Sep 17 00:00:00 2001 From: Martina Date: Fri, 9 Feb 2024 11:49:19 +0100 Subject: [PATCH 4/7] added histogram of BTL clus categorization --- Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc index e493e3e4fa525..a2fae0bf1e6a3 100644 --- a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc +++ b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc @@ -181,6 +181,8 @@ class BtlLocalRecoValidation : public DQMEDAnalyzer { MonitorElement* meCluYLocalErr_; // resolution wrt to MtdSimLayerClusters + MonitorElement* meCluTrackIdOffset_; + MonitorElement* meCluTimeRes_simLC_; MonitorElement* meCluEnergyRes_simLC_; MonitorElement* meCluTResvsE_simLC_; @@ -684,6 +686,8 @@ void BtlLocalRecoValidation::analyze(const edm::Event& iEvent, const edm::EventS float xlocal_res = local_point.x() - simClusLocalPos.x(); float ylocal_res = local_point.y() - simClusLocalPos.y(); + meCluTrackIdOffset_->Fill(float(idOffset)); + // -- Fill for direct hits if (idOffset == 0) { meCluTimeRes_simLC_->Fill(time_res); @@ -1185,6 +1189,9 @@ void BtlLocalRecoValidation::bookHistograms(DQMStore::IBooker& ibook, } // with MtdSimLayerCluster as truth + + meCluTrackIdOffset_ = + ibook.book1D("BtlCluTrackIdOffset", "BTL cluster category (trackId offset); trackId offset", 4, 0.0, 4.0); meCluTimeRes_simLC_ = ibook.book1D("BtlCluTimeRes_simLC", "BTL cluster time resolution (wrt MtdSimLayerClusters);T_{RECO}-T_{SIM} [ns]", 100, From 11f4db634e6c6c2c3936947074f3c662a4212881 Mon Sep 17 00:00:00 2001 From: Martina Date: Tue, 13 Feb 2024 14:49:31 +0100 Subject: [PATCH 5/7] update with cluster sorting in mtd assoc maps --- ...coClusterToSimLayerClusterAssociationMap.h | 10 ++- ...mLayerClusterToRecoClusterAssociationMap.h | 25 ++++++++ SimDataFormats/Associations/src/classes.h | 62 +++++++++---------- .../Associations/src/classes_def.xml | 13 ++-- ...erToSimLayerClusterAssociatorByHitsImpl.cc | 4 +- .../plugins/BtlLocalRecoValidation.cc | 11 ++-- .../plugins/EtlLocalRecoValidation.cc | 11 ++-- 7 files changed, 83 insertions(+), 53 deletions(-) diff --git a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h index da28598576314..acd6fc7bc2544 100644 --- a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h +++ b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h @@ -18,10 +18,10 @@ class MtdRecoClusterToSimLayerClusterAssociationMap { public: using key_type = FTLClusterRef; using mapped_type = MtdSimLayerClusterRef; - // using value_type = std::pair; using value_type = std::pair>; using map_type = std::vector; using const_iterator = typename map_type::const_iterator; + using range = std::pair; /// Constructor MtdRecoClusterToSimLayerClusterAssociationMap(); @@ -32,6 +32,8 @@ class MtdRecoClusterToSimLayerClusterAssociationMap { map_.emplace_back(recoClus, simClusVect); } + void sort() { std::sort(map_.begin(), map_.end(), compare); } + bool empty() const { return map_.empty(); } size_t size() const { return map_.size(); } @@ -40,9 +42,15 @@ class MtdRecoClusterToSimLayerClusterAssociationMap { const_iterator end() const { return map_.end(); } const_iterator cend() const { return map_.cend(); } + range equal_range(const FTLClusterRef& key) const { + return std::equal_range(map_.begin(), map_.end(), value_type(key, std::vector()), compare); + } + const map_type& map() const { return map_; } private: + static bool compare(const value_type& i, const value_type& j) { return (i.first < j.first); } + map_type map_; }; diff --git a/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h b/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h index 05253940dcdf8..2142275fb844a 100644 --- a/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h +++ b/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h @@ -21,6 +21,7 @@ class MtdSimLayerClusterToRecoClusterAssociationMap { using value_type = std::pair>; using map_type = std::vector; using const_iterator = typename map_type::const_iterator; + using range = std::pair; /// Constructor MtdSimLayerClusterToRecoClusterAssociationMap(); @@ -31,6 +32,8 @@ class MtdSimLayerClusterToRecoClusterAssociationMap { map_.emplace_back(simClus, recoClusVect); } + void sort() { std::sort(map_.begin(), map_.end(), compare); } + bool empty() const { return map_.empty(); } size_t size() const { return map_.size(); } @@ -39,9 +42,31 @@ class MtdSimLayerClusterToRecoClusterAssociationMap { const_iterator end() const { return map_.end(); } const_iterator cend() const { return map_.cend(); } + range equal_range(const MtdSimLayerClusterRef& key) const { + return std::equal_range(map_.begin(), map_.end(), value_type(key, std::vector()), compare); + } + const map_type& map() const { return map_; } private: + static bool compare(const value_type& i, const value_type& j) { + auto i_hAndE = (i.first)->hits_and_energies(); + std::vector i_ids(i_hAndE.size()); + std::transform(i_hAndE.begin(), i_hAndE.end(), i_ids.begin(), [](const std::pair& pair) { + return pair.first; + }); + + auto j_hAndE = (j.first)->hits_and_energies(); + std::vector j_ids(j_hAndE.size()); + std::transform(j_hAndE.begin(), j_hAndE.end(), j_ids.begin(), [](const std::pair& pair) { + return pair.first; + }); + + uint64_t imin = *(std::min_element(i_ids.begin(), i_ids.end())); + uint64_t jmin = *(std::min_element(j_ids.begin(), j_ids.end())); + return (imin < jmin); + } + map_type map_; }; diff --git a/SimDataFormats/Associations/src/classes.h b/SimDataFormats/Associations/src/classes.h index 6055ba430db97..27e6e663386fd 100644 --- a/SimDataFormats/Associations/src/classes.h +++ b/SimDataFormats/Associations/src/classes.h @@ -20,49 +20,47 @@ #include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociator.h" #include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociator.h" -namespace SimDataFormats_Associations { - struct SimDataFormats_Associations { - // add 'dummy' Wrapper variable for each class type you put into the Event - edm::Wrapper dummy1; - edm::Wrapper dummy2; - edm::Wrapper dummy3; +struct SimDataFormats_Associations { + // add 'dummy' Wrapper variable for each class type you put into the Event + edm::Wrapper dummy1; + edm::Wrapper dummy2; + edm::Wrapper dummy3; - edm::Wrapper dummy4; + edm::Wrapper dummy4; - edm::Wrapper dummy5; + edm::Wrapper dummy5; - edm::Wrapper dummy6; + edm::Wrapper dummy6; - edm::Wrapper dummy7; + edm::Wrapper dummy7; - edm::Wrapper dummy8; + edm::Wrapper dummy8; - edm::Wrapper dummy9; + edm::Wrapper dummy9; - edm::Wrapper dummy10; + edm::Wrapper dummy10; - edm::Wrapper dummy11; + edm::Wrapper dummy11; - edm::Wrapper dummy12; + edm::Wrapper dummy12; - reco::VertexSimToRecoCollection vstrc; - reco::VertexSimToRecoCollection::const_iterator vstrci; - edm::Wrapper wvstrc; + reco::VertexSimToRecoCollection vstrc; + reco::VertexSimToRecoCollection::const_iterator vstrci; + edm::Wrapper wvstrc; - reco::VertexRecoToSimCollection vrtsc; - reco::VertexRecoToSimCollection::const_iterator vrtsci; - edm::Wrapper wvrtsci; + reco::VertexRecoToSimCollection vrtsc; + reco::VertexRecoToSimCollection::const_iterator vrtsci; + edm::Wrapper wvrtsci; - std::pair> dummy13; - edm::Wrapper>> dummy14; - MtdRecoClusterToSimLayerClusterAssociationMap dummy15; - edm::Wrapper dummy16; + std::pair> dummy13; + edm::Wrapper>> dummy14; + MtdRecoClusterToSimLayerClusterAssociationMap dummy15; + edm::Wrapper dummy16; - std::pair> dummy17; - edm::Wrapper>> dummy18; - MtdSimLayerClusterToRecoClusterAssociationMap dummy19; - edm::Wrapper dummy20; + std::pair> dummy17; + edm::Wrapper>> dummy18; + MtdSimLayerClusterToRecoClusterAssociationMap dummy19; + edm::Wrapper dummy20; - edm::Wrapper dummy21; - }; -} // namespace SimDataFormats_Associations + edm::Wrapper dummy21; +}; diff --git a/SimDataFormats/Associations/src/classes_def.xml b/SimDataFormats/Associations/src/classes_def.xml index f8e898180fbec..88a0fcf6b56b7 100644 --- a/SimDataFormats/Associations/src/classes_def.xml +++ b/SimDataFormats/Associations/src/classes_def.xml @@ -144,14 +144,17 @@ - + - + + + - + - - + + + diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc index 45ecaec9167c2..7ceab9e8ebb7f 100644 --- a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc @@ -27,7 +27,7 @@ reco::RecoToSimCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl const auto& simClusters = *simClusH.product(); - // -- create temporary map DetId, SimClusterRef (praticamente ... il DetSetVector dei poveri) + // -- create temporary map DetId, SimClusterRef std::map> simClusIdsMap; for (auto simClusIt = simClusters.begin(); simClusIt != simClusters.end(); simClusIt++) { const auto& simClus = *simClusIt; @@ -134,6 +134,7 @@ reco::RecoToSimCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl } // -- end loop over detsetclus } + outputCollection.sort(); return outputCollection; } @@ -239,5 +240,6 @@ reco::SimToRecoCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl } // -- end loop over sim clusters + outputCollection.sort(); return outputCollection; } diff --git a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc index a2fae0bf1e6a3..70d3b41db03d7 100644 --- a/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc +++ b/Validation/MtdValidation/plugins/BtlLocalRecoValidation.cc @@ -662,13 +662,10 @@ void BtlLocalRecoValidation::analyze(const edm::Event& iEvent, const edm::EventS // --- Fill the cluster resolution histograms using MtdSimLayerClusters as mtd truth edm::Ref, FTLCluster> clusterRef = edmNew::makeRefTo(btlRecCluHandle, &cluster); - auto it = std::find_if( - r2sAssociationMap.begin(), - r2sAssociationMap.end(), - [&](const std::pair>& p) { return p.first == clusterRef; }); - - if (it != r2sAssociationMap.end()) { - std::vector simClustersRefs = (*it).second; + auto itp = r2sAssociationMap.equal_range(clusterRef); + if (itp.first != itp.second) { + std::vector simClustersRefs = + (*itp.first).second; // the range of itp.first, itp.second should be always 1 for (unsigned int i = 0; i < simClustersRefs.size(); i++) { auto simClusterRef = simClustersRefs[i]; diff --git a/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc b/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc index 12848e9dc340b..ac2e7d90fa174 100644 --- a/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc +++ b/Validation/MtdValidation/plugins/EtlLocalRecoValidation.cc @@ -510,13 +510,10 @@ void EtlLocalRecoValidation::analyze(const edm::Event& iEvent, const edm::EventS // --- Fill the cluster resolution histograms using MtdSimLayerClusters as mtd truth edm::Ref, FTLCluster> clusterRef = edmNew::makeRefTo(etlRecCluHandle, &cluster); - auto it = std::find_if( - r2sAssociationMap.begin(), - r2sAssociationMap.end(), - [&](const std::pair>& p) { return p.first == clusterRef; }); - - if (it != r2sAssociationMap.end()) { - std::vector simClustersRefs = (*it).second; + auto itp = r2sAssociationMap.equal_range(clusterRef); + if (itp.first != itp.second) { + std::vector simClustersRefs = + (*itp.first).second; // the range of itp.first, itp.second should be always 1 for (unsigned int i = 0; i < simClustersRefs.size(); i++) { auto simClusterRef = simClustersRefs[i]; From 831672717e4d206aaf4404e4ce9fa1d7acdda654 Mon Sep 17 00:00:00 2001 From: Martina Date: Wed, 14 Feb 2024 12:09:57 +0100 Subject: [PATCH 6/7] removed unnecessary auxiliary vectors + use post_insert --- ...coClusterToSimLayerClusterAssociationMap.h | 2 +- ...mLayerClusterToRecoClusterAssociationMap.h | 29 +++++++++---------- ...erToSimLayerClusterAssociatorByHitsImpl.cc | 4 +-- 3 files changed, 16 insertions(+), 19 deletions(-) diff --git a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h index acd6fc7bc2544..c0f0625efffe3 100644 --- a/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h +++ b/SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h @@ -32,7 +32,7 @@ class MtdRecoClusterToSimLayerClusterAssociationMap { map_.emplace_back(recoClus, simClusVect); } - void sort() { std::sort(map_.begin(), map_.end(), compare); } + void post_insert() { std::sort(map_.begin(), map_.end(), compare); } bool empty() const { return map_.empty(); } size_t size() const { return map_.size(); } diff --git a/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h b/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h index 2142275fb844a..af3bff1bcaab0 100644 --- a/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h +++ b/SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h @@ -32,7 +32,7 @@ class MtdSimLayerClusterToRecoClusterAssociationMap { map_.emplace_back(simClus, recoClusVect); } - void sort() { std::sort(map_.begin(), map_.end(), compare); } + void post_insert() { std::sort(map_.begin(), map_.end(), compare); } bool empty() const { return map_.empty(); } size_t size() const { return map_.size(); } @@ -50,21 +50,18 @@ class MtdSimLayerClusterToRecoClusterAssociationMap { private: static bool compare(const value_type& i, const value_type& j) { - auto i_hAndE = (i.first)->hits_and_energies(); - std::vector i_ids(i_hAndE.size()); - std::transform(i_hAndE.begin(), i_hAndE.end(), i_ids.begin(), [](const std::pair& pair) { - return pair.first; - }); - - auto j_hAndE = (j.first)->hits_and_energies(); - std::vector j_ids(j_hAndE.size()); - std::transform(j_hAndE.begin(), j_hAndE.end(), j_ids.begin(), [](const std::pair& pair) { - return pair.first; - }); - - uint64_t imin = *(std::min_element(i_ids.begin(), i_ids.end())); - uint64_t jmin = *(std::min_element(j_ids.begin(), j_ids.end())); - return (imin < jmin); + const auto& i_hAndE = (i.first)->hits_and_energies(); + const auto& j_hAndE = (j.first)->hits_and_energies(); + + auto imin = std::min_element(i_hAndE.begin(), + i_hAndE.end(), + [](std::pair a, std::pair b) { return a < b; }); + + auto jmin = std::min_element(j_hAndE.begin(), + j_hAndE.end(), + [](std::pair a, std::pair b) { return a < b; }); + + return (*imin < *jmin); } map_type map_; diff --git a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc index 7ceab9e8ebb7f..8cfec466d5499 100644 --- a/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc +++ b/SimFastTiming/MtdAssociatorProducers/plugins/MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl.cc @@ -134,7 +134,7 @@ reco::RecoToSimCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl } // -- end loop over detsetclus } - outputCollection.sort(); + outputCollection.post_insert(); return outputCollection; } @@ -240,6 +240,6 @@ reco::SimToRecoCollectionMtd MtdRecoClusterToSimLayerClusterAssociatorByHitsImpl } // -- end loop over sim clusters - outputCollection.sort(); + outputCollection.post_insert(); return outputCollection; } From 1cebff77b6cb6bf13c4b0316c4d5e2f668180c4b Mon Sep 17 00:00:00 2001 From: Martina Date: Tue, 20 Feb 2024 10:23:25 +0100 Subject: [PATCH 7/7] update checker --- .../ReleaseScripts/scripts/duplicateReflexLibrarySearch.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Utilities/ReleaseScripts/scripts/duplicateReflexLibrarySearch.py b/Utilities/ReleaseScripts/scripts/duplicateReflexLibrarySearch.py index a599bfc932ac3..b90c2a61dda41 100755 --- a/Utilities/ReleaseScripts/scripts/duplicateReflexLibrarySearch.py +++ b/Utilities/ReleaseScripts/scripts/duplicateReflexLibrarySearch.py @@ -32,7 +32,7 @@ equivDict = \ [ {'SelectorUtils': ['VersionedSelector']}, - {'Associations': ['TTTrackTruthPair', 'edm::Wrapper.+edm::AssociationMap.+TrackingParticle']}, + {'Associations': ['TTTrackTruthPair', 'edm::Wrapper.+edm::AssociationMap.+TrackingParticle', 'MtdSimLayerCluster.+TrackingParticle', 'TrackingParticle.+MtdSimLayerCluster']}, {'TrajectoryState' : ['TrajectoryStateOnSurface']}, {'TrackTriggerAssociation' : ['(TTClusterAssociationMap|TTStubAssociationMap|TTTrackAssociationMap|TrackingParticle).*Phase2TrackerDigi', '(TTStub|TTCluster|TTTrack).*Phase2TrackerDigi.*TrackingParticle']},