Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-04-30 22:24:45 

0001 #include <string>
0002 
0003 #include "FWCore/Framework/interface/Frameworkfwd.h"
0004 #include "FWCore/Framework/interface/Event.h"
0005 #include "FWCore/Framework/interface/MakerMacros.h"
0006 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0007 #include "DataFormats/Common/interface/ValueMap.h"
0008 
0009 #include "DQMServices/Core/interface/DQMEDAnalyzer.h"
0010 #include "DQMServices/Core/interface/DQMStore.h"
0011 
0012 #include "DataFormats/Common/interface/ValidHandle.h"
0013 #include "DataFormats/Math/interface/deltaR.h"
0014 #include "DataFormats/Math/interface/GeantUnits.h"
0015 #include "DataFormats/Math/interface/angle_units.h"
0016 #include "DataFormats/ForwardDetId/interface/ETLDetId.h"
0017 #include "DataFormats/ForwardDetId/interface/BTLDetId.h"
0018 
0019 #include "DataFormats/Common/interface/Ptr.h"
0020 #include "DataFormats/Common/interface/PtrVector.h"
0021 #include "DataFormats/Common/interface/RefProd.h"
0022 #include "DataFormats/Common/interface/Ref.h"
0023 #include "DataFormats/Common/interface/RefVector.h"
0024 
0025 #include "DataFormats/TrackReco/interface/Track.h"
0026 #include "DataFormats/TrackReco/interface/TrackFwd.h"
0027 
0028 #include "Geometry/Records/interface/MTDDigiGeometryRecord.h"
0029 #include "Geometry/Records/interface/MTDTopologyRcd.h"
0030 #include "Geometry/MTDGeometryBuilder/interface/MTDTopology.h"
0031 #include "Geometry/MTDCommonData/interface/MTDTopologyMode.h"
0032 #include "Geometry/MTDGeometryBuilder/interface/MTDGeometry.h"
0033 #include "Geometry/MTDGeometryBuilder/interface/ProxyMTDTopology.h"
0034 #include "Geometry/MTDGeometryBuilder/interface/RectangularMTDTopology.h"
0035 
0036 #include "RecoMTD/DetLayers/interface/MTDDetLayerGeometry.h"
0037 #include "RecoMTD/Records/interface/MTDRecoGeometryRecord.h"
0038 #include "MagneticField/Engine/interface/MagneticField.h"
0039 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
0040 #include "RecoMTD/DetLayers/interface/MTDDetLayerGeometry.h"
0041 #include "RecoMTD/DetLayers/interface/MTDTrayBarrelLayer.h"
0042 #include "RecoMTD/DetLayers/interface/MTDDetTray.h"
0043 #include "RecoMTD/DetLayers/interface/MTDSectorForwardDoubleLayer.h"
0044 #include "RecoMTD/DetLayers/interface/MTDDetSector.h"
0045 #include "RecoMTD/Records/interface/MTDRecoGeometryRecord.h"
0046 #include "Geometry/MTDGeometryBuilder/interface/MTDGeomUtil.h"
0047 
0048 #include "TrackPropagation/SteppingHelixPropagator/interface/SteppingHelixPropagator.h"
0049 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
0050 #include "TrackingTools/PatternTools/interface/Trajectory.h"
0051 #include "TrackingTools/TransientTrack/interface/TransientTrack.h"
0052 #include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h"
0053 #include "TrackingTools/Records/interface/TransientTrackRecord.h"
0054 #include "TrackingTools/KalmanUpdators/interface/Chi2MeasurementEstimator.h"
0055 #include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementError.h"
0056 #include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"
0057 #include "DataFormats/FTLRecHit/interface/FTLRecHitCollections.h"
0058 #include "DataFormats/FTLRecHit/interface/FTLClusterCollections.h"
0059 #include "DataFormats/TrackerRecHit2D/interface/MTDTrackingRecHit.h"
0060 
0061 #include "DataFormats/Common/interface/OneToMany.h"
0062 #include "DataFormats/Common/interface/AssociationMap.h"
0063 
0064 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
0065 #include "SimDataFormats/Associations/interface/TrackToTrackingParticleAssociator.h"
0066 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
0067 #include "SimDataFormats/CrossingFrame/interface/MixCollection.h"
0068 #include "SimDataFormats/TrackingHit/interface/PSimHit.h"
0069 #include "SimDataFormats/Associations/interface/MtdSimLayerClusterToTPAssociatorBaseImpl.h"
0070 #include "SimDataFormats/CaloAnalysis/interface/MtdSimLayerCluster.h"
0071 #include "SimDataFormats/Associations/interface/MtdRecoClusterToSimLayerClusterAssociationMap.h"
0072 #include "SimDataFormats/Associations/interface/MtdSimLayerClusterToRecoClusterAssociationMap.h"
0073 
0074 #include "CLHEP/Units/PhysicalConstants.h"
0075 #include "MTDHit.h"
0076 
0077 class MtdTracksValidation : public DQMEDAnalyzer {
0078 public:
0079   explicit MtdTracksValidation(const edm::ParameterSet&);
0080   ~MtdTracksValidation() override;
0081 
0082   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0083 
0084 private:
0085   void bookHistograms(DQMStore::IBooker&, edm::Run const&, edm::EventSetup const&) override;
0086 
0087   void analyze(const edm::Event&, const edm::EventSetup&) override;
0088 
0089   const std::pair<bool, bool> checkAcceptance(
0090       const reco::Track&, const edm::Event&, const edm::EventSetup&, size_t&, float&, float&, float&, float&);
0091 
0092   const bool trkTPSelLV(const TrackingParticle&);
0093   const bool trkTPSelAll(const TrackingParticle&);
0094   const bool trkRecSel(const reco::TrackBase&);
0095   const bool trkRecSelLowPt(const reco::TrackBase&);
0096   const edm::Ref<std::vector<TrackingParticle>>* getMatchedTP(const reco::TrackBaseRef&);
0097 
0098   const unsigned long int uniqueId(const uint32_t x, const EncodedEventId& y) {
0099     const uint64_t a = static_cast<uint64_t>(x);
0100     const uint64_t b = static_cast<uint64_t>(y.rawId());
0101 
0102     if (x < y.rawId())
0103       return (b << 32) | a;
0104     else
0105       return (a << 32) | b;
0106   }
0107 
0108   bool isETL(const double eta) const { return (std::abs(eta) > trackMinEtlEta_) && (std::abs(eta) < trackMaxEtlEta_); }
0109 
0110   void fillTrackClusterMatchingHistograms(MonitorElement* me1,
0111                                           MonitorElement* me2,
0112                                           MonitorElement* me3,
0113                                           MonitorElement* me4,
0114                                           MonitorElement* me5,
0115                                           float var1,
0116                                           float var2,
0117                                           float var3,
0118                                           float var4,
0119                                           float var5,
0120                                           bool flag);
0121 
0122   // ------------ member data ------------
0123 
0124   const std::string folder_;
0125   const bool optionalPlots_;
0126   const float trackMaxPt_;
0127   const float trackMaxBtlEta_;
0128   const float trackMinEtlEta_;
0129   const float trackMaxEtlEta_;
0130 
0131   static constexpr double simUnit_ = 1e9;                // sim time in s while reco time in ns
0132   static constexpr double etacutGEN_ = 4.;               // |eta| < 4;
0133   static constexpr double etacutREC_ = 3.;               // |eta| < 3;
0134   static constexpr double pTcutBTL_ = 0.7;               // PT > 0.7 GeV
0135   static constexpr double pTcutETL_ = 0.2;               // PT > 0.2 GeV
0136   static constexpr double depositBTLthreshold_ = 1;      // threshold for energy deposit in BTL cell [MeV]
0137   static constexpr double depositETLthreshold_ = 0.001;  // threshold for energy deposit in ETL cell [MeV]
0138   static constexpr double rBTL_ = 110.0;
0139   static constexpr double zETL_ = 290.0;
0140   static constexpr double etaMatchCut_ = 0.05;
0141   static constexpr double cluDRradius_ = 0.05;  // to cluster rechits around extrapolated track
0142 
0143   const reco::RecoToSimCollection* r2s_;
0144 
0145   edm::EDGetTokenT<reco::TrackCollection> GenRecTrackToken_;
0146   edm::EDGetTokenT<reco::TrackCollection> RecTrackToken_;
0147 
0148   edm::EDGetTokenT<TrackingParticleCollection> trackingParticleCollectionToken_;
0149   edm::EDGetTokenT<reco::SimToRecoCollection> simToRecoAssociationToken_;
0150   edm::EDGetTokenT<reco::RecoToSimCollection> recoToSimAssociationToken_;
0151   edm::EDGetTokenT<reco::TPToSimCollectionMtd> tp2SimAssociationMapToken_;
0152   edm::EDGetTokenT<reco::SimToTPCollectionMtd> Sim2tpAssociationMapToken_;
0153   edm::EDGetTokenT<MtdRecoClusterToSimLayerClusterAssociationMap> r2sAssociationMapToken_;
0154 
0155   edm::EDGetTokenT<FTLRecHitCollection> btlRecHitsToken_;
0156   edm::EDGetTokenT<FTLRecHitCollection> etlRecHitsToken_;
0157   edm::EDGetTokenT<FTLClusterCollection> btlRecCluToken_;
0158   edm::EDGetTokenT<FTLClusterCollection> etlRecCluToken_;
0159 
0160   edm::EDGetTokenT<edm::ValueMap<int>> trackAssocToken_;
0161   edm::EDGetTokenT<edm::ValueMap<float>> pathLengthToken_;
0162 
0163   edm::EDGetTokenT<edm::ValueMap<float>> btlMatchTimeChi2Token_;
0164   edm::EDGetTokenT<edm::ValueMap<float>> etlMatchTimeChi2Token_;
0165   edm::EDGetTokenT<edm::ValueMap<float>> btlMatchChi2Token_;
0166 
0167   edm::EDGetTokenT<edm::ValueMap<float>> tmtdToken_;
0168   edm::EDGetTokenT<edm::ValueMap<float>> SigmatmtdToken_;
0169   edm::EDGetTokenT<edm::ValueMap<float>> t0SrcToken_;
0170   edm::EDGetTokenT<edm::ValueMap<float>> Sigmat0SrcToken_;
0171   edm::EDGetTokenT<edm::ValueMap<float>> t0PidToken_;
0172   edm::EDGetTokenT<edm::ValueMap<float>> Sigmat0PidToken_;
0173   edm::EDGetTokenT<edm::ValueMap<float>> t0SafePidToken_;
0174   edm::EDGetTokenT<edm::ValueMap<float>> Sigmat0SafePidToken_;
0175   edm::EDGetTokenT<edm::ValueMap<float>> SigmaTofPiToken_;
0176   edm::EDGetTokenT<edm::ValueMap<float>> SigmaTofKToken_;
0177   edm::EDGetTokenT<edm::ValueMap<float>> SigmaTofPToken_;
0178   edm::EDGetTokenT<edm::ValueMap<float>> trackMVAQualToken_;
0179   edm::EDGetTokenT<edm::ValueMap<float>> outermostHitPositionToken_;
0180 
0181   edm::ESGetToken<MTDGeometry, MTDDigiGeometryRecord> mtdgeoToken_;
0182   edm::ESGetToken<MTDTopology, MTDTopologyRcd> mtdtopoToken_;
0183   edm::ESGetToken<MTDDetLayerGeometry, MTDRecoGeometryRecord> mtdlayerToken_;
0184   edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> magfieldToken_;
0185   edm::ESGetToken<TransientTrackBuilder, TransientTrackRecord> builderToken_;
0186 
0187   MonitorElement* meBTLTrackRPTime_;
0188   MonitorElement* meBTLTrackEtaTot_;
0189   MonitorElement* meBTLTrackPhiTot_;
0190   MonitorElement* meBTLTrackPtTot_;
0191   MonitorElement* meBTLTrackEtaMtd_;
0192   MonitorElement* meBTLTrackPhiMtd_;
0193   MonitorElement* meBTLTrackPtMtd_;
0194   MonitorElement* meBTLTrackPtRes_;
0195 
0196   MonitorElement* meETLTrackRPTime_;
0197   MonitorElement* meETLTrackEtaTot_;
0198   MonitorElement* meETLTrackPhiTot_;
0199   MonitorElement* meETLTrackPtTot_;
0200   MonitorElement* meETLTrackEtaMtd_;
0201   MonitorElement* meETLTrackPhiMtd_;
0202   MonitorElement* meETLTrackPtMtd_;
0203   MonitorElement* meETLTrackEta2Mtd_;
0204   MonitorElement* meETLTrackPhi2Mtd_;
0205   MonitorElement* meETLTrackPt2Mtd_;
0206   MonitorElement* meETLTrackPtRes_;
0207 
0208   MonitorElement* meETLTrackEtaTotLowPt_[2];
0209   MonitorElement* meETLTrackEtaMtdLowPt_[2];
0210   MonitorElement* meETLTrackEta2MtdLowPt_[2];
0211 
0212   MonitorElement* meBTLTrackMatchedTPEtaTot_;
0213   MonitorElement* meBTLTrackMatchedTPPtTot_;
0214   MonitorElement* meBTLTrackMatchedTPEtaMtd_;
0215   MonitorElement* meBTLTrackMatchedTPPtMtd_;
0216   MonitorElement* meETLTrackMatchedTPEtaTot_;
0217   MonitorElement* meETLTrackMatchedTPPtTot_;
0218   MonitorElement* meETLTrackMatchedTPEtaMtd_;
0219   MonitorElement* meETLTrackMatchedTPPtMtd_;
0220   MonitorElement* meETLTrackMatchedTPEta2Mtd_;
0221   MonitorElement* meETLTrackMatchedTPPt2Mtd_;
0222   MonitorElement* meETLTrackMatchedTPEtaMtdCorrect_;
0223   MonitorElement* meETLTrackMatchedTPPtMtdCorrect_;
0224 
0225   MonitorElement* meTracktmtd_;
0226   MonitorElement* meTrackt0Src_;
0227   MonitorElement* meTrackSigmat0Src_;
0228   MonitorElement* meTrackt0Pid_;
0229   MonitorElement* meTrackSigmat0Pid_;
0230   MonitorElement* meTrackt0SafePid_;
0231   MonitorElement* meTrackSigmat0SafePid_;
0232   MonitorElement* meTrackNumHits_;
0233   MonitorElement* meTrackNumHitsNT_;
0234   MonitorElement* meTrackMVAQual_;
0235   MonitorElement* meTrackPathLengthvsEta_;
0236   MonitorElement* meTrackOutermostHitR_;
0237   MonitorElement* meTrackOutermostHitZ_;
0238 
0239   MonitorElement* meTrackSigmaTof_[3];
0240   MonitorElement* meTrackSigmaTofvsP_[3];
0241 
0242   MonitorElement* meBTLTrackMatchedTPPtResMtd_;
0243   MonitorElement* meETLTrackMatchedTPPtResMtd_;
0244   MonitorElement* meETLTrackMatchedTP2PtResMtd_;
0245   MonitorElement* meBTLTrackMatchedTPPtRatioGen_;
0246   MonitorElement* meETLTrackMatchedTPPtRatioGen_;
0247   MonitorElement* meETLTrackMatchedTP2PtRatioGen_;
0248   MonitorElement* meBTLTrackMatchedTPPtRatioMtd_;
0249   MonitorElement* meETLTrackMatchedTPPtRatioMtd_;
0250   MonitorElement* meETLTrackMatchedTP2PtRatioMtd_;
0251   MonitorElement* meBTLTrackMatchedTPPtResvsPtMtd_;
0252   MonitorElement* meETLTrackMatchedTPPtResvsPtMtd_;
0253   MonitorElement* meETLTrackMatchedTP2PtResvsPtMtd_;
0254   MonitorElement* meBTLTrackMatchedTPDPtvsPtGen_;
0255   MonitorElement* meETLTrackMatchedTPDPtvsPtGen_;
0256   MonitorElement* meETLTrackMatchedTP2DPtvsPtGen_;
0257   MonitorElement* meBTLTrackMatchedTPDPtvsPtMtd_;
0258   MonitorElement* meETLTrackMatchedTPDPtvsPtMtd_;
0259   MonitorElement* meETLTrackMatchedTP2DPtvsPtMtd_;
0260 
0261   MonitorElement* meTrackResTot_;
0262   MonitorElement* meTrackPullTot_;
0263   MonitorElement* meTrackResTotvsMVAQual_;
0264   MonitorElement* meTrackPullTotvsMVAQual_;
0265 
0266   MonitorElement* meTrackMatchedTPPtTotLV_;
0267   MonitorElement* meTrackMatchedTPEtaTotLV_;
0268   MonitorElement* meExtraPtMtd_;
0269   MonitorElement* meExtraPtEtl2Mtd_;
0270   MonitorElement* meExtraEtaMtd_;
0271   MonitorElement* meExtraEtaEtl2Mtd_;
0272   MonitorElement* meExtraPhiAtBTL_;
0273   MonitorElement* meExtraPhiAtBTLmatched_;
0274   MonitorElement* meExtraBTLeneInCone_;
0275   MonitorElement* meExtraMTDfailExtenderEta_;
0276   MonitorElement* meExtraMTDfailExtenderPt_;
0277 
0278   // ====== Trak-cluster matching based on MC truth
0279   // - BTL TPmtd Direct, TPmtd Other, TPnomtd
0280   MonitorElement* meBTLTrackMatchedTPmtdDirectEta_;
0281   MonitorElement* meBTLTrackMatchedTPmtdDirectPt_;
0282 
0283   MonitorElement* meBTLTrackMatchedTPmtdOtherEta_;
0284   MonitorElement* meBTLTrackMatchedTPmtdOtherPt_;
0285 
0286   MonitorElement* meBTLTrackMatchedTPnomtdEta_;
0287   MonitorElement* meBTLTrackMatchedTPnomtdPt_;
0288   // - BTL TPmtd Direct hits: correct, wrong, missing association in MTD
0289   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocEta_;
0290   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocPt_;
0291   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocMVAQual_;
0292   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTimeRes_;
0293   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTimePull_;
0294   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTrackOutermostHitR_;
0295   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTrackChi2_;
0296   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2_;
0297   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2vsMVAQual_;
0298   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocSpaceChi2_;
0299   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTrackNdf_;
0300   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocSimClusSize_;
0301   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocRecoClusSize_;
0302   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLengthvsEta_;
0303   MonitorElement* meBTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLength_;
0304 
0305   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocEta_;
0306   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocPt_;
0307   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual_;
0308   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes_;
0309   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimePull_;
0310   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2_;
0311   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual_;
0312   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi2_;
0313   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT_;
0314   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ_;
0315   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi_;
0316   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff_;
0317   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR_;
0318   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi2_;
0319   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf_;
0320   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocSimClusSize_;
0321   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocRecoClusSize_;
0322   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR_;
0323   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta_;
0324   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength_;
0325 
0326   // wrong association with reco from same TP direct hit
0327   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocEta1_;
0328   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocPt1_;
0329   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual1_;
0330   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes1_;
0331   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimePull1_;
0332   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT1_;
0333   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ1_;
0334   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi1_;
0335   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff1_;
0336   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR1_;
0337   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi21_;
0338   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi21_;
0339   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual1_;
0340   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi21_;
0341   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf1_;
0342   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR1_;
0343   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta1_;
0344   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength1_;
0345 
0346   // wrong association with reco from same TP other hit
0347   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocEta2_;
0348   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocPt2_;
0349   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual2_;
0350   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes2_;
0351   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimePull2_;
0352   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT2_;
0353   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ2_;
0354   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi2_;
0355   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff2_;
0356   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR2_;
0357   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi22_;
0358   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi22_;
0359   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual2_;
0360   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi22_;
0361   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf2_;
0362   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR2_;
0363   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta2_;
0364   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength2_;
0365 
0366   // wrong association to reco from another TP
0367   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocEta3_;
0368   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocPt3_;
0369   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual3_;
0370   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes3_;
0371   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimePull3_;
0372   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT3_;
0373   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ3_;
0374   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi3_;
0375   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff3_;
0376   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR3_;
0377   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi23_;
0378   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi23_;
0379   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual3_;
0380   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi23_;
0381   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf3_;
0382   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR3_;
0383   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta3_;
0384   MonitorElement* meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength3_;
0385 
0386   MonitorElement* meBTLTrackMatchedTPmtdDirectNoAssocEta_;
0387   MonitorElement* meBTLTrackMatchedTPmtdDirectNoAssocPt_;
0388   MonitorElement* meBTLTrackMatchedTPmtdDirectNoAssocTrackOutermostHitR_;
0389   MonitorElement* meBTLTrackMatchedTPmtdDirectNoAssocTrackChi2_;
0390   MonitorElement* meBTLTrackMatchedTPmtdDirectNoAssocTrackNdf_;
0391   MonitorElement* meBTLTrackMatchedTPmtdDirectNoAssocSimClusSize_;
0392   MonitorElement* meBTLTrackMatchedTPmtdDirectNoAssocRecoClusSize_;
0393 
0394   // - BTL TPmtd "other" hits: correct, wrong, missing association in MTD
0395   MonitorElement* meBTLTrackMatchedTPmtdOtherCorrectAssocEta_;
0396   MonitorElement* meBTLTrackMatchedTPmtdOtherCorrectAssocPt_;
0397   MonitorElement* meBTLTrackMatchedTPmtdOtherCorrectAssocMVAQual_;
0398   MonitorElement* meBTLTrackMatchedTPmtdOtherCorrectAssocTimeRes_;
0399   MonitorElement* meBTLTrackMatchedTPmtdOtherCorrectAssocTimePull_;
0400 
0401   MonitorElement* meBTLTrackMatchedTPmtdOtherWrongAssocEta_;
0402   MonitorElement* meBTLTrackMatchedTPmtdOtherWrongAssocPt_;
0403   MonitorElement* meBTLTrackMatchedTPmtdOtherWrongAssocMVAQual_;
0404   MonitorElement* meBTLTrackMatchedTPmtdOtherWrongAssocTimeRes_;
0405   MonitorElement* meBTLTrackMatchedTPmtdOtherWrongAssocTimePull_;
0406 
0407   MonitorElement* meBTLTrackMatchedTPmtdOtherNoAssocEta_;
0408   MonitorElement* meBTLTrackMatchedTPmtdOtherNoAssocPt_;
0409 
0410   // - BTL TPnomtd but a reco cluster is associated
0411   MonitorElement* meBTLTrackMatchedTPnomtdAssocEta_;
0412   MonitorElement* meBTLTrackMatchedTPnomtdAssocPt_;
0413   MonitorElement* meBTLTrackMatchedTPnomtdAssocMVAQual_;
0414   MonitorElement* meBTLTrackMatchedTPnomtdAssocTimeRes_;
0415   MonitorElement* meBTLTrackMatchedTPnomtdAssocTimePull_;
0416   MonitorElement* meBTLTrackMatchedTPnomtdAssocTrackChi2_;
0417   MonitorElement* meBTLTrackMatchedTPnomtdAssocTrackNdf_;
0418   MonitorElement* meBTLTrackMatchedTPnomtdAssocTrackOutermostHitR_;
0419   MonitorElement* meBTLTrackMatchedTPnomtdAssocTrackIdOff_;
0420   MonitorElement* meBTLTrackMatchedTPnomtdAssocSimClusSize_;
0421   MonitorElement* meBTLTrackMatchedTPnomtdAssocRecoClusSize_;
0422   MonitorElement* meBTLTrackMatchedTPnomtdAssocTrackID_;
0423 
0424   // - ETL: one, two o no sim hits
0425   MonitorElement* meETLTrackMatchedTPmtd1Eta_;  // -- sim hit in >=1 etl disk
0426   MonitorElement* meETLTrackMatchedTPmtd1Pt_;
0427   MonitorElement* meETLTrackMatchedTPmtd2Eta_;  // -- sim hits in 2 etl disks
0428   MonitorElement* meETLTrackMatchedTPmtd2Pt_;
0429   MonitorElement* meETLTrackMatchedTPnomtdEta_;  // -- no sim hits in etl
0430   MonitorElement* meETLTrackMatchedTPnomtdPt_;
0431 
0432   // - ETL >=1 sim hit: each correct, at least one wrong, each sim hit missing reco association
0433   MonitorElement* meETLTrackMatchedTPmtd1CorrectAssocEta_;
0434   MonitorElement* meETLTrackMatchedTPmtd1CorrectAssocPt_;
0435   MonitorElement* meETLTrackMatchedTPmtd1CorrectAssocMVAQual_;
0436   MonitorElement* meETLTrackMatchedTPmtd1CorrectAssocTimeRes_;
0437   MonitorElement* meETLTrackMatchedTPmtd1CorrectAssocTimePull_;
0438   MonitorElement* meETLTrackMatchedTPmtd1CorrectAssocTimeChi2_;
0439   MonitorElement* meETLTrackMatchedTPmtd1CorrectAssocTimeChi2vsMVAQual_;
0440 
0441   MonitorElement* meETLTrackMatchedTPmtd1WrongAssocEta_;
0442   MonitorElement* meETLTrackMatchedTPmtd1WrongAssocPt_;
0443   MonitorElement* meETLTrackMatchedTPmtd1WrongAssocMVAQual_;
0444   MonitorElement* meETLTrackMatchedTPmtd1WrongAssocTimeRes_;
0445   MonitorElement* meETLTrackMatchedTPmtd1WrongAssocTimePull_;
0446   MonitorElement* meETLTrackMatchedTPmtd1WrongAssocTimeChi2_;
0447   MonitorElement* meETLTrackMatchedTPmtd1WrongAssocTimeChi2vsMVAQual_;
0448 
0449   MonitorElement* meETLTrackMatchedTPmtd1NoAssocEta_;
0450   MonitorElement* meETLTrackMatchedTPmtd1NoAssocPt_;
0451   MonitorElement* meETLTrackMatchedTPmtd1NoAssocMVAQual_;
0452   MonitorElement* meETLTrackMatchedTPmtd1NoAssocTimeRes_;
0453   MonitorElement* meETLTrackMatchedTPmtd1NoAssocTimePull_;
0454 
0455   // - ETL - 2 sim hits: both correct, at least one wrong or one missing, both missing reco association
0456   MonitorElement* meETLTrackMatchedTPmtd2CorrectAssocEta_;
0457   MonitorElement* meETLTrackMatchedTPmtd2CorrectAssocPt_;
0458   MonitorElement* meETLTrackMatchedTPmtd2CorrectAssocMVAQual_;
0459   MonitorElement* meETLTrackMatchedTPmtd2CorrectAssocTimeRes_;
0460   MonitorElement* meETLTrackMatchedTPmtd2CorrectAssocTimePull_;
0461   MonitorElement* meETLTrackMatchedTPmtd2CorrectAssocTimeChi2_;
0462   MonitorElement* meETLTrackMatchedTPmtd2CorrectAssocTimeChi2vsMVAQual_;
0463 
0464   MonitorElement* meETLTrackMatchedTPmtd2WrongAssocEta_;
0465   MonitorElement* meETLTrackMatchedTPmtd2WrongAssocPt_;
0466   MonitorElement* meETLTrackMatchedTPmtd2WrongAssocMVAQual_;
0467   MonitorElement* meETLTrackMatchedTPmtd2WrongAssocTimeRes_;
0468   MonitorElement* meETLTrackMatchedTPmtd2WrongAssocTimePull_;
0469   MonitorElement* meETLTrackMatchedTPmtd2WrongAssocTimeChi2_;
0470   MonitorElement* meETLTrackMatchedTPmtd2WrongAssocTimeChi2vsMVAQual_;
0471 
0472   MonitorElement* meETLTrackMatchedTPmtd2NoAssocEta_;
0473   MonitorElement* meETLTrackMatchedTPmtd2NoAssocPt_;
0474   MonitorElement* meETLTrackMatchedTPmtd2NoAssocMVAQual_;
0475   MonitorElement* meETLTrackMatchedTPmtd2NoAssocTimeRes_;
0476   MonitorElement* meETLTrackMatchedTPmtd2NoAssocTimePull_;
0477 
0478   // - ETL - no sim hits, but reco hit associated to the track
0479   MonitorElement* meETLTrackMatchedTPnomtdAssocEta_;
0480   MonitorElement* meETLTrackMatchedTPnomtdAssocPt_;
0481   MonitorElement* meETLTrackMatchedTPnomtdAssocMVAQual_;
0482   MonitorElement* meETLTrackMatchedTPnomtdAssocTimeRes_;
0483   MonitorElement* meETLTrackMatchedTPnomtdAssocTimePull_;
0484 };
0485 
0486 // ------------ constructor and destructor --------------
0487 MtdTracksValidation::MtdTracksValidation(const edm::ParameterSet& iConfig)
0488     : folder_(iConfig.getParameter<std::string>("folder")),
0489       optionalPlots_(iConfig.getParameter<bool>("optionalPlots")),
0490       trackMaxPt_(iConfig.getParameter<double>("trackMaximumPt")),
0491       trackMaxBtlEta_(iConfig.getParameter<double>("trackMaximumBtlEta")),
0492       trackMinEtlEta_(iConfig.getParameter<double>("trackMinimumEtlEta")),
0493       trackMaxEtlEta_(iConfig.getParameter<double>("trackMaximumEtlEta")) {
0494   GenRecTrackToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("inputTagG"));
0495   RecTrackToken_ = consumes<reco::TrackCollection>(iConfig.getParameter<edm::InputTag>("inputTagT"));
0496 
0497   trackingParticleCollectionToken_ =
0498       consumes<TrackingParticleCollection>(iConfig.getParameter<edm::InputTag>("SimTag"));
0499   simToRecoAssociationToken_ =
0500       consumes<reco::SimToRecoCollection>(iConfig.getParameter<edm::InputTag>("TPtoRecoTrackAssoc"));
0501   recoToSimAssociationToken_ =
0502       consumes<reco::RecoToSimCollection>(iConfig.getParameter<edm::InputTag>("TPtoRecoTrackAssoc"));
0503   tp2SimAssociationMapToken_ =
0504       consumes<reco::TPToSimCollectionMtd>(iConfig.getParameter<edm::InputTag>("tp2SimAssociationMapTag"));
0505   Sim2tpAssociationMapToken_ =
0506       consumes<reco::SimToTPCollectionMtd>(iConfig.getParameter<edm::InputTag>("Sim2tpAssociationMapTag"));
0507   r2sAssociationMapToken_ = consumes<MtdRecoClusterToSimLayerClusterAssociationMap>(
0508       iConfig.getParameter<edm::InputTag>("r2sAssociationMapTag"));
0509   btlRecHitsToken_ = consumes<FTLRecHitCollection>(iConfig.getParameter<edm::InputTag>("btlRecHits"));
0510   etlRecHitsToken_ = consumes<FTLRecHitCollection>(iConfig.getParameter<edm::InputTag>("etlRecHits"));
0511   btlRecCluToken_ = consumes<FTLClusterCollection>(iConfig.getParameter<edm::InputTag>("recCluTagBTL"));
0512   etlRecCluToken_ = consumes<FTLClusterCollection>(iConfig.getParameter<edm::InputTag>("recCluTagETL"));
0513   trackAssocToken_ = consumes<edm::ValueMap<int>>(iConfig.getParameter<edm::InputTag>("trackAssocSrc"));
0514   pathLengthToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("pathLengthSrc"));
0515   btlMatchTimeChi2Token_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("btlMatchTimeChi2"));
0516   etlMatchTimeChi2Token_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("etlMatchTimeChi2"));
0517   btlMatchChi2Token_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("btlMatchChi2"));
0518   tmtdToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("tmtd"));
0519   SigmatmtdToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("sigmatmtd"));
0520   t0SrcToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("t0Src"));
0521   Sigmat0SrcToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("sigmat0Src"));
0522   t0PidToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("t0PID"));
0523   Sigmat0PidToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("sigmat0PID"));
0524   t0SafePidToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("t0SafePID"));
0525   Sigmat0SafePidToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("sigmat0SafePID"));
0526   SigmaTofPiToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("sigmaTofPi"));
0527   SigmaTofKToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("sigmaTofK"));
0528   SigmaTofPToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("sigmaTofP"));
0529   trackMVAQualToken_ = consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("trackMVAQual"));
0530   outermostHitPositionToken_ =
0531       consumes<edm::ValueMap<float>>(iConfig.getParameter<edm::InputTag>("outermostHitPositionSrc"));
0532   mtdgeoToken_ = esConsumes<MTDGeometry, MTDDigiGeometryRecord>();
0533   mtdtopoToken_ = esConsumes<MTDTopology, MTDTopologyRcd>();
0534   mtdlayerToken_ = esConsumes<MTDDetLayerGeometry, MTDRecoGeometryRecord>();
0535   magfieldToken_ = esConsumes<MagneticField, IdealMagneticFieldRecord>();
0536   builderToken_ = esConsumes<TransientTrackBuilder, TransientTrackRecord>(edm::ESInputTag("", "TransientTrackBuilder"));
0537 }
0538 
0539 MtdTracksValidation::~MtdTracksValidation() {}
0540 
0541 // ------------ method called for each event  ------------
0542 void MtdTracksValidation::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
0543   using namespace edm;
0544   using namespace geant_units::operators;
0545   using namespace std;
0546 
0547   auto GenRecTrackHandle = makeValid(iEvent.getHandle(GenRecTrackToken_));
0548 
0549   auto btlRecCluHandle = makeValid(iEvent.getHandle(btlRecCluToken_));
0550   auto etlRecCluHandle = makeValid(iEvent.getHandle(etlRecCluToken_));
0551 
0552   std::unordered_map<uint32_t, MTDHit> m_btlHits;
0553   std::unordered_map<uint32_t, MTDHit> m_etlHits;
0554   std::unordered_map<uint32_t, std::set<unsigned long int>> m_btlTrkPerCell;
0555   std::unordered_map<uint32_t, std::set<unsigned long int>> m_etlTrkPerCell;
0556   const auto& tp2SimAssociationMap = iEvent.get(tp2SimAssociationMapToken_);
0557   const auto& Sim2tpAssociationMap = iEvent.get(Sim2tpAssociationMapToken_);
0558   const auto& r2sAssociationMap = iEvent.get(r2sAssociationMapToken_);
0559 
0560   const auto& tMtd = iEvent.get(tmtdToken_);
0561   const auto& SigmatMtd = iEvent.get(SigmatmtdToken_);
0562   const auto& t0Src = iEvent.get(t0SrcToken_);
0563   const auto& Sigmat0Src = iEvent.get(Sigmat0SrcToken_);
0564   const auto& t0Pid = iEvent.get(t0PidToken_);
0565   const auto& Sigmat0Pid = iEvent.get(Sigmat0PidToken_);
0566   const auto& t0Safe = iEvent.get(t0SafePidToken_);
0567   const auto& Sigmat0Safe = iEvent.get(Sigmat0SafePidToken_);
0568   const auto& SigmaTofPi = iEvent.get(SigmaTofPiToken_);
0569   const auto& SigmaTofK = iEvent.get(SigmaTofKToken_);
0570   const auto& SigmaTofP = iEvent.get(SigmaTofPToken_);
0571   const auto& mtdQualMVA = iEvent.get(trackMVAQualToken_);
0572   const auto& trackAssoc = iEvent.get(trackAssocToken_);
0573   const auto& pathLength = iEvent.get(pathLengthToken_);
0574   const auto& btlMatchTimeChi2 = iEvent.get(btlMatchTimeChi2Token_);
0575   const auto& etlMatchTimeChi2 = iEvent.get(etlMatchTimeChi2Token_);
0576   const auto& btlMatchChi2 = iEvent.get(btlMatchChi2Token_);
0577   const auto& outermostHitPosition = iEvent.get(outermostHitPositionToken_);
0578 
0579   auto recoToSimH = makeValid(iEvent.getHandle(recoToSimAssociationToken_));
0580   r2s_ = recoToSimH.product();
0581   auto geometryHandle = iSetup.getTransientHandle(mtdgeoToken_);
0582   const MTDGeometry* geom = geometryHandle.product();
0583   auto topologyHandle = iSetup.getTransientHandle(mtdtopoToken_);
0584   const MTDTopology* topology = topologyHandle.product();
0585 
0586   mtd::MTDGeomUtil geomUtil;
0587   geomUtil.setGeometry(geom);
0588   geomUtil.setTopology(topology);
0589 
0590   unsigned int index = 0;
0591 
0592   // --- Loop over all RECO tracks ---
0593   for (const auto& trackGen : *GenRecTrackHandle) {
0594     const reco::TrackRef trackref(iEvent.getHandle(GenRecTrackToken_), index);
0595     index++;
0596 
0597     if (trackAssoc[trackref] == -1) {
0598       LogWarning("mtdTracks") << "Extended track not associated";
0599       continue;
0600     }
0601 
0602     const reco::TrackRef mtdTrackref = reco::TrackRef(iEvent.getHandle(RecTrackToken_), trackAssoc[trackref]);
0603     const reco::Track& track = *mtdTrackref;
0604 
0605     bool isBTL = false;
0606     bool isETL = false;
0607     bool ETLdisc1 = false;
0608     bool ETLdisc2 = false;
0609     bool twoETLdiscs = false;
0610     bool noCrack = std::abs(trackGen.eta()) < trackMaxBtlEta_ || std::abs(trackGen.eta()) > trackMinEtlEta_;
0611 
0612     if (trkRecSel(trackGen)) {
0613       meTracktmtd_->Fill(tMtd[trackref]);
0614       if (std::round(SigmatMtd[trackref] - Sigmat0Pid[trackref]) != 0) {
0615         LogWarning("mtdTracks")
0616             << "TimeError associated to refitted track is different from TimeError stored in tofPID "
0617                "sigmat0 ValueMap: this should not happen";
0618       }
0619 
0620       meTrackt0Src_->Fill(t0Src[trackref]);
0621       meTrackSigmat0Src_->Fill(Sigmat0Src[trackref]);
0622 
0623       meTrackt0Pid_->Fill(t0Pid[trackref]);
0624       meTrackSigmat0Pid_->Fill(Sigmat0Pid[trackref]);
0625       meTrackt0SafePid_->Fill(t0Safe[trackref]);
0626       meTrackSigmat0SafePid_->Fill(std::log10(std::max(Sigmat0Safe[trackref], 0.001f)));
0627       meTrackMVAQual_->Fill(mtdQualMVA[trackref]);
0628 
0629       meTrackSigmaTof_[0]->Fill(SigmaTofPi[trackref] * 1e3);  //save as ps
0630       meTrackSigmaTof_[1]->Fill(SigmaTofK[trackref] * 1e3);
0631       meTrackSigmaTof_[2]->Fill(SigmaTofP[trackref] * 1e3);
0632       meTrackSigmaTofvsP_[0]->Fill(trackGen.p(), SigmaTofPi[trackref] * 1e3);
0633       meTrackSigmaTofvsP_[1]->Fill(trackGen.p(), SigmaTofK[trackref] * 1e3);
0634       meTrackSigmaTofvsP_[2]->Fill(trackGen.p(), SigmaTofP[trackref] * 1e3);
0635 
0636       meTrackPathLengthvsEta_->Fill(std::abs(trackGen.eta()), pathLength[trackref]);
0637       bool MTDEtlZnegD1 = false;
0638       bool MTDEtlZnegD2 = false;
0639       bool MTDEtlZposD1 = false;
0640       bool MTDEtlZposD2 = false;
0641       std::vector<edm::Ref<edmNew::DetSetVector<FTLCluster>, FTLCluster>> recoClustersRefs;
0642 
0643       if (std::abs(trackGen.eta()) < trackMaxBtlEta_) {
0644         // --- all BTL tracks (with and without hit in MTD) ---
0645         meBTLTrackEtaTot_->Fill(std::abs(trackGen.eta()));
0646         meBTLTrackPhiTot_->Fill(trackGen.phi());
0647         meBTLTrackPtTot_->Fill(trackGen.pt());
0648 
0649         bool MTDBtl = false;
0650         int numMTDBtlvalidhits = 0;
0651         for (const auto hit : track.recHits()) {
0652           if (hit->isValid() == false)
0653             continue;
0654           MTDDetId Hit = hit->geographicalId();
0655           if ((Hit.det() == 6) && (Hit.subdetId() == 1) && (Hit.mtdSubDetector() == 1)) {
0656             MTDBtl = true;
0657             numMTDBtlvalidhits++;
0658             const auto* mtdhit = static_cast<const MTDTrackingRecHit*>(hit);
0659             const auto& hitCluster = mtdhit->mtdCluster();
0660             if (hitCluster.size() != 0) {
0661               auto recoClusterRef = edmNew::makeRefTo(btlRecCluHandle, &hitCluster);
0662               recoClustersRefs.push_back(recoClusterRef);
0663             }
0664           }
0665         }
0666         meTrackNumHits_->Fill(numMTDBtlvalidhits);
0667         // --- keeping only tracks with last hit in MTD ---
0668         if (MTDBtl == true) {
0669           isBTL = true;
0670           meBTLTrackEtaMtd_->Fill(std::abs(trackGen.eta()));
0671           meBTLTrackPhiMtd_->Fill(trackGen.phi());
0672           meBTLTrackPtMtd_->Fill(trackGen.pt());
0673           meBTLTrackRPTime_->Fill(track.t0());
0674           meBTLTrackPtRes_->Fill((trackGen.pt() - track.pt()) / trackGen.pt());
0675         }
0676         if (isBTL && Sigmat0Safe[trackref] < 0.) {
0677           meTrackNumHitsNT_->Fill(numMTDBtlvalidhits);
0678         }
0679       }  //loop over (geometrical) BTL tracks
0680 
0681       else {
0682         // --- all ETL tracks (with and without hit in MTD) ---
0683         meETLTrackEtaTot_->Fill(std::abs(trackGen.eta()));
0684         meETLTrackPhiTot_->Fill(trackGen.phi());
0685         meETLTrackPtTot_->Fill(trackGen.pt());
0686 
0687         int numMTDEtlvalidhits = 0;
0688         for (const auto hit : track.recHits()) {
0689           if (hit->isValid() == false)
0690             continue;
0691           MTDDetId Hit = hit->geographicalId();
0692           if ((Hit.det() == 6) && (Hit.subdetId() == 1) && (Hit.mtdSubDetector() == 2)) {
0693             isETL = true;
0694             ETLDetId ETLHit = hit->geographicalId();
0695 
0696             const auto* mtdhit = static_cast<const MTDTrackingRecHit*>(hit);
0697             const auto& hitCluster = mtdhit->mtdCluster();
0698             if (hitCluster.size() != 0) {
0699               auto recoClusterRef = edmNew::makeRefTo(etlRecCluHandle, &hitCluster);
0700               recoClustersRefs.push_back(recoClusterRef);
0701             }
0702 
0703             if ((ETLHit.zside() == -1) && (ETLHit.nDisc() == 1)) {
0704               MTDEtlZnegD1 = true;
0705               meETLTrackRPTime_->Fill(track.t0());
0706               meETLTrackPtRes_->Fill((trackGen.pt() - track.pt()) / trackGen.pt());
0707               numMTDEtlvalidhits++;
0708             }
0709             if ((ETLHit.zside() == -1) && (ETLHit.nDisc() == 2)) {
0710               MTDEtlZnegD2 = true;
0711               meETLTrackRPTime_->Fill(track.t0());
0712               meETLTrackPtRes_->Fill((trackGen.pt() - track.pt()) / trackGen.pt());
0713               numMTDEtlvalidhits++;
0714             }
0715             if ((ETLHit.zside() == 1) && (ETLHit.nDisc() == 1)) {
0716               MTDEtlZposD1 = true;
0717               meETLTrackRPTime_->Fill(track.t0());
0718               meETLTrackPtRes_->Fill((trackGen.pt() - track.pt()) / trackGen.pt());
0719               numMTDEtlvalidhits++;
0720             }
0721             if ((ETLHit.zside() == 1) && (ETLHit.nDisc() == 2)) {
0722               MTDEtlZposD2 = true;
0723               meETLTrackRPTime_->Fill(track.t0());
0724               meETLTrackPtRes_->Fill((trackGen.pt() - track.pt()) / trackGen.pt());
0725               numMTDEtlvalidhits++;
0726             }
0727           }
0728         }
0729         meTrackNumHits_->Fill(-numMTDEtlvalidhits);
0730         if (isETL && Sigmat0Safe[trackref] < 0.) {
0731           meTrackNumHitsNT_->Fill(-numMTDEtlvalidhits);
0732         }
0733 
0734         // --- keeping only tracks with last hit in MTD ---
0735         ETLdisc1 = (MTDEtlZnegD1 || MTDEtlZposD1);
0736         ETLdisc2 = (MTDEtlZnegD2 || MTDEtlZposD2);
0737         twoETLdiscs =
0738             ((MTDEtlZnegD1 == true) && (MTDEtlZnegD2 == true)) || ((MTDEtlZposD1 == true) && (MTDEtlZposD2 == true));
0739         if (ETLdisc1 || ETLdisc2) {
0740           meETLTrackEtaMtd_->Fill(std::abs(trackGen.eta()));
0741           meETLTrackPhiMtd_->Fill(trackGen.phi());
0742           meETLTrackPtMtd_->Fill(trackGen.pt());
0743           if (twoETLdiscs) {
0744             meETLTrackEta2Mtd_->Fill(std::abs(trackGen.eta()));
0745             meETLTrackPhi2Mtd_->Fill(trackGen.phi());
0746             meETLTrackPt2Mtd_->Fill(trackGen.pt());
0747           }
0748         }
0749       }
0750 
0751       if (isBTL)
0752         meTrackOutermostHitR_->Fill(outermostHitPosition[trackref]);
0753       if (isETL)
0754         meTrackOutermostHitZ_->Fill(std::abs(outermostHitPosition[trackref]));
0755 
0756       LogDebug("MtdTracksValidation") << "Track p/pt = " << trackGen.p() << " " << trackGen.pt() << " eta "
0757                                       << trackGen.eta() << " BTL " << isBTL << " ETL " << isETL << " 2disks "
0758                                       << twoETLdiscs;
0759 
0760       // == TrackingParticle based matching
0761       const reco::TrackBaseRef trkrefb(trackref);
0762       auto tp_info = getMatchedTP(trkrefb);
0763       if (tp_info != nullptr && trkTPSelAll(**tp_info)) {
0764         // -- pT resolution plots
0765         if (optionalPlots_) {
0766           if (trackGen.pt() < trackMaxPt_) {
0767             if (isBTL) {
0768               meBTLTrackMatchedTPPtResMtd_->Fill(std::abs(track.pt() - (*tp_info)->pt()) /
0769                                                  std::abs(trackGen.pt() - (*tp_info)->pt()));
0770               meBTLTrackMatchedTPPtRatioGen_->Fill(trackGen.pt() / (*tp_info)->pt());
0771               meBTLTrackMatchedTPPtRatioMtd_->Fill(track.pt() / (*tp_info)->pt());
0772               meBTLTrackMatchedTPPtResvsPtMtd_->Fill(
0773                   (*tp_info)->pt(),
0774                   std::abs(track.pt() - (*tp_info)->pt()) / std::abs(trackGen.pt() - (*tp_info)->pt()));
0775               meBTLTrackMatchedTPDPtvsPtGen_->Fill((*tp_info)->pt(),
0776                                                    (trackGen.pt() - (*tp_info)->pt()) / (*tp_info)->pt());
0777               meBTLTrackMatchedTPDPtvsPtMtd_->Fill((*tp_info)->pt(),
0778                                                    (track.pt() - (*tp_info)->pt()) / (*tp_info)->pt());
0779             }
0780             if (isETL && !twoETLdiscs && (std::abs(trackGen.eta()) > trackMinEtlEta_) &&
0781                 (std::abs(trackGen.eta()) < trackMaxEtlEta_)) {
0782               meETLTrackMatchedTPPtResMtd_->Fill(std::abs(track.pt() - (*tp_info)->pt()) /
0783                                                  std::abs(trackGen.pt() - (*tp_info)->pt()));
0784               meETLTrackMatchedTPPtRatioGen_->Fill(trackGen.pt() / (*tp_info)->pt());
0785               meETLTrackMatchedTPPtRatioMtd_->Fill(track.pt() / (*tp_info)->pt());
0786               meETLTrackMatchedTPPtResvsPtMtd_->Fill(
0787                   (*tp_info)->pt(),
0788                   std::abs(track.pt() - (*tp_info)->pt()) / std::abs(trackGen.pt() - (*tp_info)->pt()));
0789               meETLTrackMatchedTPDPtvsPtGen_->Fill((*tp_info)->pt(),
0790                                                    (trackGen.pt() - (*tp_info)->pt()) / ((*tp_info)->pt()));
0791               meETLTrackMatchedTPDPtvsPtMtd_->Fill((*tp_info)->pt(),
0792                                                    (track.pt() - (*tp_info)->pt()) / ((*tp_info)->pt()));
0793             }
0794             if (isETL && twoETLdiscs) {
0795               meETLTrackMatchedTP2PtResMtd_->Fill(std::abs(track.pt() - (*tp_info)->pt()) /
0796                                                   std::abs(trackGen.pt() - (*tp_info)->pt()));
0797               meETLTrackMatchedTP2PtRatioGen_->Fill(trackGen.pt() / (*tp_info)->pt());
0798               meETLTrackMatchedTP2PtRatioMtd_->Fill(track.pt() / (*tp_info)->pt());
0799               meETLTrackMatchedTP2PtResvsPtMtd_->Fill(
0800                   (*tp_info)->pt(),
0801                   std::abs(track.pt() - (*tp_info)->pt()) / std::abs(trackGen.pt() - (*tp_info)->pt()));
0802               meETLTrackMatchedTP2DPtvsPtGen_->Fill((*tp_info)->pt(),
0803                                                     (trackGen.pt() - (*tp_info)->pt()) / ((*tp_info)->pt()));
0804               meETLTrackMatchedTP2DPtvsPtMtd_->Fill((*tp_info)->pt(),
0805                                                     (track.pt() - (*tp_info)->pt()) / ((*tp_info)->pt()));
0806             }
0807           }
0808         }
0809 
0810         // -- Track matched to TP: all and with last hit in MTD
0811         if (std::abs(trackGen.eta()) < trackMaxBtlEta_) {
0812           meBTLTrackMatchedTPEtaTot_->Fill(std::abs(trackGen.eta()));
0813           meBTLTrackMatchedTPPtTot_->Fill(trackGen.pt());
0814           if (isBTL) {
0815             meBTLTrackMatchedTPEtaMtd_->Fill(std::abs(trackGen.eta()));
0816             meBTLTrackMatchedTPPtMtd_->Fill(trackGen.pt());
0817           }
0818         } else {
0819           meETLTrackMatchedTPEtaTot_->Fill(std::abs(trackGen.eta()));
0820           meETLTrackMatchedTPPtTot_->Fill(trackGen.pt());
0821           if (isETL) {
0822             meETLTrackMatchedTPEtaMtd_->Fill(std::abs(trackGen.eta()));
0823             meETLTrackMatchedTPPtMtd_->Fill(trackGen.pt());
0824             if (twoETLdiscs) {
0825               meETLTrackMatchedTPEta2Mtd_->Fill(std::abs(trackGen.eta()));
0826               meETLTrackMatchedTPPt2Mtd_->Fill(trackGen.pt());
0827             }
0828           }
0829         }
0830 
0831         if (noCrack) {
0832           if (trkTPSelLV(**tp_info)) {
0833             meTrackMatchedTPEtaTotLV_->Fill(std::abs(trackGen.eta()));
0834             meTrackMatchedTPPtTotLV_->Fill(trackGen.pt());
0835           }
0836         }
0837 
0838         bool hasTime = false;
0839         double tsim = (*tp_info)->parentVertex()->position().t() * simUnit_;
0840         double dT(-9999.);
0841         double pullT(-9999.);
0842         if (Sigmat0Safe[trackref] != -1.) {
0843           dT = t0Safe[trackref] - tsim;
0844           pullT = dT / Sigmat0Safe[trackref];
0845           hasTime = true;
0846         }
0847 
0848         // ==  MC truth matching
0849         double simClusterRef_RecoMatch_trackIdOff(-9999.);
0850         double simClusterRef_RecoMatch_DeltaZ(-9999.);
0851         double simClusterRef_RecoMatch_DeltaPhi(-9999.);
0852         double simClusterRef_RecoMatch_DeltaT(-9999.);
0853         int simClusSize(-9999);
0854         int recoClusSize(-9999);
0855 
0856         bool isTPmtdDirectBTL = false, isTPmtdOtherBTL = false, isTPmtdDirectCorrectBTL = false,
0857              isTPmtdOtherCorrectBTL = false, isTPmtdETLD1 = false, isTPmtdETLD2 = false, isTPmtdCorrectETLD1 = false,
0858              isTPmtdCorrectETLD2 = false, isFromSameTP = false;
0859 
0860         auto simClustersRefsIt = tp2SimAssociationMap.find(*tp_info);
0861         const bool withMTD = (simClustersRefsIt != tp2SimAssociationMap.end());
0862 
0863         // If there is a mtdSimLayerCluster from the tracking particle
0864         if (withMTD) {
0865           // -- Get the refs to MtdSimLayerClusters associated to the TP
0866           std::vector<edm::Ref<MtdSimLayerClusterCollection>> simClustersRefs;
0867           for (const auto& ref : simClustersRefsIt->val) {
0868             simClustersRefs.push_back(ref);
0869             MTDDetId mtddetid = ref->detIds_and_rows().front().first;
0870             if (mtddetid.mtdSubDetector() == 2) {
0871               ETLDetId detid(mtddetid.rawId());
0872               if (detid.nDisc() == 1)
0873                 isTPmtdETLD1 = true;
0874               if (detid.nDisc() == 2)
0875                 isTPmtdETLD2 = true;
0876             }
0877           }
0878           // === BTL
0879           // -- Sort BTL sim clusters by time
0880           std::vector<edm::Ref<MtdSimLayerClusterCollection>>::iterator directSimClusIt;
0881           if (std::abs(trackGen.eta()) < trackMaxBtlEta_ && !simClustersRefs.empty()) {
0882             std::sort(simClustersRefs.begin(), simClustersRefs.end(), [](const auto& a, const auto& b) {
0883               return a->simLCTime() < b->simLCTime();
0884             });
0885             // Find the first direct hit in time
0886             directSimClusIt = std::find_if(simClustersRefs.begin(), simClustersRefs.end(), [](const auto& simCluster) {
0887               MTDDetId mtddetid = simCluster->detIds_and_rows().front().first;
0888               return (mtddetid.mtdSubDetector() == 1 && simCluster->trackIdOffset() == 0);
0889             });
0890             // Check if TP has direct or other sim cluster for BTL
0891             for (const auto& simClusterRef : simClustersRefs) {
0892               if (directSimClusIt != simClustersRefs.end() && simClusterRef == *directSimClusIt) {
0893                 isTPmtdDirectBTL = true;
0894               } else if (simClusterRef->trackIdOffset() != 0) {
0895                 isTPmtdOtherBTL = true;
0896               }
0897             }
0898           }
0899 
0900           // ==  Check if the track-cluster association is correct: Track->RecoClus->SimClus == Track->TP->SimClus
0901           recoClusSize = recoClustersRefs.size();
0902           for (const auto& recClusterRef : recoClustersRefs) {
0903             if (recClusterRef.isNonnull()) {
0904               auto itp = r2sAssociationMap.equal_range(recClusterRef);
0905               simClusSize = 0;
0906               if (itp.first != itp.second) {
0907                 auto& simClustersRefs_RecoMatch = (*itp.first).second;
0908 
0909                 BTLDetId RecoDetId((*recClusterRef).id());
0910                 simClusSize = simClustersRefs_RecoMatch.size();
0911 
0912                 for (const auto& simClusterRef_RecoMatch : simClustersRefs_RecoMatch) {
0913                   // Check if simClusterRef_RecoMatch  exists in SimClusters
0914                   auto simClusterIt =
0915                       std::find(simClustersRefs.begin(), simClustersRefs.end(), simClusterRef_RecoMatch);
0916                   if (optionalPlots_ && isTPmtdDirectBTL) {
0917                     // simCluster matched to TP
0918                     // NB we are taking the position and id of the first hit in the cluster.
0919                     auto directSimClus = *directSimClusIt;
0920                     MTDDetId mtddetid = directSimClus->detIds_and_rows().front().first;
0921                     BTLDetId detid(mtddetid.rawId());
0922                     LocalPoint simClusLocalPos = directSimClus->hits_and_positions().front().second;
0923                     GlobalPoint simClusGlobalPos = geomUtil.globalPosition(detid, simClusLocalPos);
0924 
0925                     // simClusterRef_RecoMatch infos
0926                     MTDDetId mtddetidRecoMatch = simClusterRef_RecoMatch->detIds_and_rows().front().first;
0927                     BTLDetId detidRecoMatch(mtddetidRecoMatch.rawId());
0928                     LocalPoint simClusRecoMatchLocalPos = simClusterRef_RecoMatch->hits_and_positions().front().second;
0929                     GlobalPoint simClusRecoMatchGlobalPos =
0930                         geomUtil.globalPosition(detidRecoMatch, simClusRecoMatchLocalPos);
0931 
0932                     simClusterRef_RecoMatch_trackIdOff = simClusterRef_RecoMatch->trackIdOffset();
0933                     simClusterRef_RecoMatch_DeltaZ = simClusRecoMatchGlobalPos.z() - simClusGlobalPos.z();
0934                     simClusterRef_RecoMatch_DeltaPhi = simClusRecoMatchGlobalPos.phi() - simClusGlobalPos.phi();
0935                     simClusterRef_RecoMatch_DeltaT = simClusterRef_RecoMatch->simLCTime() - directSimClus->simLCTime();
0936                   }
0937 
0938                   // SimCluster found in SimClusters
0939                   if (simClusterIt != simClustersRefs.end()) {
0940                     isFromSameTP = true;
0941                     if (isBTL) {
0942                       if (directSimClusIt != simClustersRefs.end() && simClusterRef_RecoMatch == *directSimClusIt) {
0943                         isTPmtdDirectCorrectBTL = true;
0944                       } else if (simClusterRef_RecoMatch->trackIdOffset() != 0) {
0945                         isTPmtdOtherCorrectBTL = true;
0946                       }
0947                     }
0948                     if (isETL) {
0949                       MTDDetId mtddetid = (*simClusterIt)->detIds_and_rows().front().first;
0950                       ETLDetId detid(mtddetid.rawId());
0951                       if (detid.nDisc() == 1)
0952                         isTPmtdCorrectETLD1 = true;
0953                       if (detid.nDisc() == 2)
0954                         isTPmtdCorrectETLD2 = true;
0955                     }
0956                   }
0957                 }
0958               }
0959             }
0960           }  /// end loop over reco clusters associated to this track.
0961 
0962           // == BTL
0963           if (std::abs(trackGen.eta()) < trackMaxBtlEta_) {
0964             // -- Track matched to TP with sim hit in MTD
0965             if (isTPmtdDirectBTL) {
0966               meBTLTrackMatchedTPmtdDirectEta_->Fill(std::abs(trackGen.eta()));
0967               meBTLTrackMatchedTPmtdDirectPt_->Fill(trackGen.pt());
0968             } else if (isTPmtdOtherBTL) {
0969               meBTLTrackMatchedTPmtdOtherEta_->Fill(std::abs(trackGen.eta()));
0970               meBTLTrackMatchedTPmtdOtherPt_->Fill(trackGen.pt());
0971             }
0972             //-- Track matched to TP with sim hit in MTD, with associated reco cluster
0973             if (isBTL) {
0974               if (isTPmtdDirectBTL) {
0975                 // -- Track matched to TP with sim hit (direct), correctly associated reco cluster
0976                 if (isTPmtdDirectCorrectBTL) {
0977                   if (optionalPlots_) {
0978                     meBTLTrackMatchedTPmtdDirectCorrectAssocSimClusSize_->Fill(simClusSize);
0979                     meBTLTrackMatchedTPmtdDirectCorrectAssocRecoClusSize_->Fill(recoClusSize);
0980                     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackOutermostHitR_->Fill(outermostHitPosition[trackref]);
0981                     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackNdf_->Fill(trackGen.ndof());
0982                     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackChi2_->Fill(trackGen.chi2());
0983                     meBTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2_->Fill(btlMatchTimeChi2[trackref]);
0984                     meBTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2vsMVAQual_->Fill(btlMatchTimeChi2[trackref],
0985                                                                                      mtdQualMVA[trackref]);
0986                     meBTLTrackMatchedTPmtdDirectCorrectAssocSpaceChi2_->Fill(btlMatchChi2[trackref]);
0987                     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLengthvsEta_->Fill(std::abs(trackGen.eta()),
0988                                                                                         pathLength[trackref]);
0989                     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLength_->Fill(pathLength[trackref]);
0990                   }
0991                   fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPmtdDirectCorrectAssocEta_,
0992                                                      meBTLTrackMatchedTPmtdDirectCorrectAssocPt_,
0993                                                      meBTLTrackMatchedTPmtdDirectCorrectAssocMVAQual_,
0994                                                      meBTLTrackMatchedTPmtdDirectCorrectAssocTimeRes_,
0995                                                      meBTLTrackMatchedTPmtdDirectCorrectAssocTimePull_,
0996                                                      std::abs(trackGen.eta()),
0997                                                      trackGen.pt(),
0998                                                      mtdQualMVA[trackref],
0999                                                      dT,
1000                                                      pullT,
1001                                                      hasTime);
1002                 }
1003                 // -- Track matched to TP with sim hit (direct), incorrectly associated reco cluster
1004                 else {
1005                   if (optionalPlots_) {
1006                     meBTLTrackMatchedTPmtdDirectWrongAssocSimClusSize_->Fill(simClusSize);
1007                     meBTLTrackMatchedTPmtdDirectWrongAssocRecoClusSize_->Fill(recoClusSize);
1008                     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT_->Fill(simClusterRef_RecoMatch_DeltaT);
1009                     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi_->Fill(simClusterRef_RecoMatch_DeltaPhi);
1010                     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ_->Fill(simClusterRef_RecoMatch_DeltaZ);
1011                     meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff_->Fill(simClusterRef_RecoMatch_trackIdOff);
1012                     meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR_->Fill(outermostHitPosition[trackref]);
1013                     meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf_->Fill(trackGen.ndof());
1014                     meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi2_->Fill(trackGen.chi2());
1015                     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR_->Fill(outermostHitPosition[trackref],
1016                                                                             simClusterRef_RecoMatch_DeltaZ);
1017                     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2_->Fill(btlMatchTimeChi2[trackref]);
1018                     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual_->Fill(btlMatchTimeChi2[trackref],
1019                                                                                    mtdQualMVA[trackref]);
1020                     meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi2_->Fill(btlMatchChi2[trackref]);
1021                     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta_->Fill(std::abs(trackGen.eta()),
1022                                                                                       pathLength[trackref]);
1023                     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength_->Fill(pathLength[trackref]);
1024 
1025                     if (simClusterRef_RecoMatch_trackIdOff == 0 && isFromSameTP) {
1026                       fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPmtdDirectWrongAssocEta1_,
1027                                                          meBTLTrackMatchedTPmtdDirectWrongAssocPt1_,
1028                                                          meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual1_,
1029                                                          meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes1_,
1030                                                          meBTLTrackMatchedTPmtdDirectWrongAssocTimePull1_,
1031                                                          std::abs(trackGen.eta()),
1032                                                          trackGen.pt(),
1033                                                          mtdQualMVA[trackref],
1034                                                          dT,
1035                                                          pullT,
1036                                                          hasTime);
1037 
1038                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT1_->Fill(simClusterRef_RecoMatch_DeltaT);
1039                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi1_->Fill(simClusterRef_RecoMatch_DeltaPhi);
1040                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ1_->Fill(simClusterRef_RecoMatch_DeltaZ);
1041                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff1_->Fill(simClusterRef_RecoMatch_trackIdOff);
1042                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR1_->Fill(outermostHitPosition[trackref]);
1043                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf1_->Fill(trackGen.ndof());
1044                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi21_->Fill(trackGen.chi2());
1045                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR1_->Fill(outermostHitPosition[trackref],
1046                                                                                simClusterRef_RecoMatch_DeltaZ);
1047                       meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi21_->Fill(btlMatchTimeChi2[trackref]);
1048                       meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual1_->Fill(btlMatchTimeChi2[trackref],
1049                                                                                       mtdQualMVA[trackref]);
1050                       meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi21_->Fill(btlMatchChi2[trackref]);
1051                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta1_->Fill(std::abs(trackGen.eta()),
1052                                                                                          pathLength[trackref]);
1053                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength1_->Fill(pathLength[trackref]);
1054 
1055                     } else if (simClusterRef_RecoMatch_trackIdOff > 0 && isFromSameTP) {
1056                       fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPmtdDirectWrongAssocEta2_,
1057                                                          meBTLTrackMatchedTPmtdDirectWrongAssocPt2_,
1058                                                          meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual2_,
1059                                                          meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes2_,
1060                                                          meBTLTrackMatchedTPmtdDirectWrongAssocTimePull2_,
1061                                                          std::abs(trackGen.eta()),
1062                                                          trackGen.pt(),
1063                                                          mtdQualMVA[trackref],
1064                                                          dT,
1065                                                          pullT,
1066                                                          hasTime);
1067 
1068                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT2_->Fill(simClusterRef_RecoMatch_DeltaT);
1069                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi2_->Fill(simClusterRef_RecoMatch_DeltaPhi);
1070                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ2_->Fill(simClusterRef_RecoMatch_DeltaZ);
1071                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff2_->Fill(simClusterRef_RecoMatch_trackIdOff);
1072                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR2_->Fill(outermostHitPosition[trackref]);
1073                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf2_->Fill(trackGen.ndof());
1074                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi22_->Fill(trackGen.chi2());
1075                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR2_->Fill(outermostHitPosition[trackref],
1076                                                                                simClusterRef_RecoMatch_DeltaZ);
1077                       meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi22_->Fill(btlMatchTimeChi2[trackref]);
1078                       meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual2_->Fill(btlMatchTimeChi2[trackref],
1079                                                                                       mtdQualMVA[trackref]);
1080                       meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi22_->Fill(btlMatchChi2[trackref]);
1081                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta2_->Fill(std::abs(trackGen.eta()),
1082                                                                                          pathLength[trackref]);
1083                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength2_->Fill(pathLength[trackref]);
1084 
1085                     } else if (!isFromSameTP) {
1086                       fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPmtdDirectWrongAssocEta3_,
1087                                                          meBTLTrackMatchedTPmtdDirectWrongAssocPt3_,
1088                                                          meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual3_,
1089                                                          meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes3_,
1090                                                          meBTLTrackMatchedTPmtdDirectWrongAssocTimePull3_,
1091                                                          std::abs(trackGen.eta()),
1092                                                          trackGen.pt(),
1093                                                          mtdQualMVA[trackref],
1094                                                          dT,
1095                                                          pullT,
1096                                                          hasTime);
1097 
1098                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT3_->Fill(simClusterRef_RecoMatch_DeltaT);
1099                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi3_->Fill(simClusterRef_RecoMatch_DeltaPhi);
1100                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ3_->Fill(simClusterRef_RecoMatch_DeltaZ);
1101                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff3_->Fill(simClusterRef_RecoMatch_trackIdOff);
1102                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR3_->Fill(outermostHitPosition[trackref]);
1103                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf3_->Fill(trackGen.ndof());
1104                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi23_->Fill(trackGen.chi2());
1105                       meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR3_->Fill(outermostHitPosition[trackref],
1106                                                                                simClusterRef_RecoMatch_DeltaZ);
1107                       meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi23_->Fill(btlMatchTimeChi2[trackref]);
1108                       meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual3_->Fill(btlMatchTimeChi2[trackref],
1109                                                                                       mtdQualMVA[trackref]);
1110                       meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi23_->Fill(btlMatchChi2[trackref]);
1111                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta3_->Fill(std::abs(trackGen.eta()),
1112                                                                                          pathLength[trackref]);
1113                       meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength3_->Fill(pathLength[trackref]);
1114                     }
1115                   }
1116                   fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPmtdDirectWrongAssocEta_,
1117                                                      meBTLTrackMatchedTPmtdDirectWrongAssocPt_,
1118                                                      meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual_,
1119                                                      meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes_,
1120                                                      meBTLTrackMatchedTPmtdDirectWrongAssocTimePull_,
1121                                                      std::abs(trackGen.eta()),
1122                                                      trackGen.pt(),
1123                                                      mtdQualMVA[trackref],
1124                                                      dT,
1125                                                      pullT,
1126                                                      hasTime);
1127                 }
1128               }
1129 
1130               // -- Track matched to TP with sim hit (other), correctly associated reco cluster
1131               else if (isTPmtdOtherBTL) {
1132                 if (isTPmtdOtherCorrectBTL) {
1133                   fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPmtdOtherCorrectAssocEta_,
1134                                                      meBTLTrackMatchedTPmtdOtherCorrectAssocPt_,
1135                                                      meBTLTrackMatchedTPmtdOtherCorrectAssocMVAQual_,
1136                                                      meBTLTrackMatchedTPmtdOtherCorrectAssocTimeRes_,
1137                                                      meBTLTrackMatchedTPmtdOtherCorrectAssocTimePull_,
1138                                                      std::abs(trackGen.eta()),
1139                                                      trackGen.pt(),
1140                                                      mtdQualMVA[trackref],
1141                                                      dT,
1142                                                      pullT,
1143                                                      hasTime);
1144                 }
1145                 // -- Track matched to TP with sim hit (other), incorrectly associated reco cluster
1146                 else {
1147                   fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPmtdOtherWrongAssocEta_,
1148                                                      meBTLTrackMatchedTPmtdOtherWrongAssocPt_,
1149                                                      meBTLTrackMatchedTPmtdOtherWrongAssocMVAQual_,
1150                                                      meBTLTrackMatchedTPmtdOtherWrongAssocTimeRes_,
1151                                                      meBTLTrackMatchedTPmtdOtherWrongAssocTimePull_,
1152                                                      std::abs(trackGen.eta()),
1153                                                      trackGen.pt(),
1154                                                      mtdQualMVA[trackref],
1155                                                      dT,
1156                                                      pullT,
1157                                                      hasTime);
1158                 }
1159               }
1160             }
1161             // -- Track matched to TP with sim hit in MTD, missing associated reco cluster
1162             else {
1163               if (isTPmtdDirectBTL) {
1164                 if (optionalPlots_) {
1165                   meBTLTrackMatchedTPmtdDirectNoAssocSimClusSize_->Fill(simClusSize);
1166                   meBTLTrackMatchedTPmtdDirectNoAssocRecoClusSize_->Fill(recoClusSize);
1167                   meBTLTrackMatchedTPmtdDirectNoAssocTrackOutermostHitR_->Fill(outermostHitPosition[trackref]);
1168                   meBTLTrackMatchedTPmtdDirectNoAssocTrackNdf_->Fill(trackGen.ndof());
1169                   meBTLTrackMatchedTPmtdDirectNoAssocTrackChi2_->Fill(trackGen.chi2());
1170                 }
1171 
1172                 meBTLTrackMatchedTPmtdDirectNoAssocEta_->Fill(std::abs(trackGen.eta()));
1173                 meBTLTrackMatchedTPmtdDirectNoAssocPt_->Fill(trackGen.pt());
1174               } else if (isTPmtdOtherBTL) {
1175                 meBTLTrackMatchedTPmtdOtherNoAssocEta_->Fill(std::abs(trackGen.eta()));
1176                 meBTLTrackMatchedTPmtdOtherNoAssocPt_->Fill(trackGen.pt());
1177               }
1178             }
1179           }  // == end BTL
1180           // == ETL
1181           else {
1182             // -- Track matched to TP with reco hits (one or two) correctly matched
1183             if ((ETLdisc1 && isTPmtdCorrectETLD1) || (ETLdisc2 && isTPmtdCorrectETLD2)) {
1184               meETLTrackMatchedTPEtaMtdCorrect_->Fill(std::abs(trackGen.eta()));
1185               meETLTrackMatchedTPPtMtdCorrect_->Fill(trackGen.pt());
1186             }
1187             // -- Track matched to TP with sim hit in one etl layer
1188             if (isTPmtdETLD1 || isTPmtdETLD2) {  // at least one hit (D1 or D2 or both)
1189               meETLTrackMatchedTPmtd1Eta_->Fill(std::abs(trackGen.eta()));
1190               meETLTrackMatchedTPmtd1Pt_->Fill(trackGen.pt());
1191             }
1192             // -- Track matched to TP with sim hits in both etl layers (D1 and D2)
1193             if (isTPmtdETLD1 && isTPmtdETLD2) {
1194               meETLTrackMatchedTPmtd2Eta_->Fill(std::abs(trackGen.eta()));
1195               meETLTrackMatchedTPmtd2Pt_->Fill(trackGen.pt());
1196             }
1197             if (isETL) {
1198               // -- Track matched to TP with sim hit in >=1 etl layer
1199               if (isTPmtdETLD1 || isTPmtdETLD2) {
1200                 // - each hit is correctly associated to the track
1201                 if ((isTPmtdETLD1 && !isTPmtdETLD2 && ETLdisc1 && isTPmtdCorrectETLD1) ||
1202                     (isTPmtdETLD2 && !isTPmtdETLD1 && ETLdisc2 && isTPmtdCorrectETLD2) ||
1203                     (isTPmtdETLD1 && isTPmtdETLD2 && ETLdisc1 && ETLdisc2 && isTPmtdCorrectETLD1 &&
1204                      isTPmtdCorrectETLD2)) {
1205                   if (optionalPlots_) {
1206                     meETLTrackMatchedTPmtd1CorrectAssocTimeChi2_->Fill(etlMatchTimeChi2[trackref]);
1207                     meETLTrackMatchedTPmtd1CorrectAssocTimeChi2vsMVAQual_->Fill(etlMatchTimeChi2[trackref],
1208                                                                                 mtdQualMVA[trackref]);
1209                   }
1210                   fillTrackClusterMatchingHistograms(meETLTrackMatchedTPmtd1CorrectAssocEta_,
1211                                                      meETLTrackMatchedTPmtd1CorrectAssocPt_,
1212                                                      meETLTrackMatchedTPmtd1CorrectAssocMVAQual_,
1213                                                      meETLTrackMatchedTPmtd1CorrectAssocTimeRes_,
1214                                                      meETLTrackMatchedTPmtd1CorrectAssocTimePull_,
1215                                                      std::abs(trackGen.eta()),
1216                                                      trackGen.pt(),
1217                                                      mtdQualMVA[trackref],
1218                                                      dT,
1219                                                      pullT,
1220                                                      hasTime);
1221                 }
1222                 // - at least one reco hit is incorrectly associated or, if two sim hits, one reco hit is missing
1223                 else if ((isTPmtdETLD1 && !isTPmtdCorrectETLD1) || (isTPmtdETLD2 && !isTPmtdCorrectETLD2)) {
1224                   if (optionalPlots_) {
1225                     meETLTrackMatchedTPmtd1WrongAssocTimeChi2_->Fill(etlMatchTimeChi2[trackref]);
1226                     meETLTrackMatchedTPmtd1WrongAssocTimeChi2vsMVAQual_->Fill(etlMatchTimeChi2[trackref],
1227                                                                               mtdQualMVA[trackref]);
1228                   }
1229 
1230                   fillTrackClusterMatchingHistograms(meETLTrackMatchedTPmtd1WrongAssocEta_,
1231                                                      meETLTrackMatchedTPmtd1WrongAssocPt_,
1232                                                      meETLTrackMatchedTPmtd1WrongAssocMVAQual_,
1233                                                      meETLTrackMatchedTPmtd1WrongAssocTimeRes_,
1234                                                      meETLTrackMatchedTPmtd1WrongAssocTimePull_,
1235                                                      std::abs(trackGen.eta()),
1236                                                      trackGen.pt(),
1237                                                      mtdQualMVA[trackref],
1238                                                      dT,
1239                                                      pullT,
1240                                                      hasTime);
1241                 }
1242               }
1243               // -- Track matched to TP with sim hits in both etl layers (D1 and D2)
1244               if (isTPmtdETLD1 && isTPmtdETLD2) {
1245                 // - each hit correctly associated to the track
1246                 if (ETLdisc1 && ETLdisc2 && isTPmtdCorrectETLD1 && isTPmtdCorrectETLD2) {
1247                   if (optionalPlots_) {
1248                     meETLTrackMatchedTPmtd2CorrectAssocTimeChi2_->Fill(etlMatchTimeChi2[trackref]);
1249                     meETLTrackMatchedTPmtd2CorrectAssocTimeChi2vsMVAQual_->Fill(etlMatchTimeChi2[trackref],
1250                                                                                 mtdQualMVA[trackref]);
1251                   }
1252                   fillTrackClusterMatchingHistograms(meETLTrackMatchedTPmtd2CorrectAssocEta_,
1253                                                      meETLTrackMatchedTPmtd2CorrectAssocPt_,
1254                                                      meETLTrackMatchedTPmtd2CorrectAssocMVAQual_,
1255                                                      meETLTrackMatchedTPmtd2CorrectAssocTimeRes_,
1256                                                      meETLTrackMatchedTPmtd2CorrectAssocTimePull_,
1257                                                      std::abs(trackGen.eta()),
1258                                                      trackGen.pt(),
1259                                                      mtdQualMVA[trackref],
1260                                                      dT,
1261                                                      pullT,
1262                                                      hasTime);
1263                 }
1264                 // - at least one reco hit incorrectly associated or one hit missing
1265                 else if ((ETLdisc1 || ETLdisc2) && (!isTPmtdCorrectETLD1 || !isTPmtdCorrectETLD2)) {
1266                   if (optionalPlots_) {
1267                     meETLTrackMatchedTPmtd2WrongAssocTimeChi2_->Fill(etlMatchTimeChi2[trackref]);
1268                     meETLTrackMatchedTPmtd2WrongAssocTimeChi2vsMVAQual_->Fill(etlMatchTimeChi2[trackref],
1269                                                                               mtdQualMVA[trackref]);
1270                   }
1271                   fillTrackClusterMatchingHistograms(meETLTrackMatchedTPmtd2WrongAssocEta_,
1272                                                      meETLTrackMatchedTPmtd2WrongAssocPt_,
1273                                                      meETLTrackMatchedTPmtd2WrongAssocMVAQual_,
1274                                                      meETLTrackMatchedTPmtd2WrongAssocTimeRes_,
1275                                                      meETLTrackMatchedTPmtd2WrongAssocTimePull_,
1276                                                      std::abs(trackGen.eta()),
1277                                                      trackGen.pt(),
1278                                                      mtdQualMVA[trackref],
1279                                                      dT,
1280                                                      pullT,
1281                                                      hasTime);
1282                 }
1283               }
1284             }
1285             // -- Missing association with reco hits in MTD
1286             else {
1287               // -- Track matched to TP with sim hit in >=1 etl layers, no reco hits associated to the track
1288               if (isTPmtdETLD1 || isTPmtdETLD2) {
1289                 meETLTrackMatchedTPmtd1NoAssocEta_->Fill(std::abs(trackGen.eta()));
1290                 meETLTrackMatchedTPmtd1NoAssocPt_->Fill(trackGen.pt());
1291               }
1292               // -- Track matched to TP with sim hit in 2 etl layers, no reco hits associated to the track
1293               if (isTPmtdETLD1 && isTPmtdETLD2) {
1294                 meETLTrackMatchedTPmtd2NoAssocEta_->Fill(std::abs(trackGen.eta()));
1295                 meETLTrackMatchedTPmtd2NoAssocPt_->Fill(trackGen.pt());
1296               }
1297             }
1298           }  // == end ETL
1299         }  // --- end "withMTD"
1300 
1301         // - Track matched to TP without sim hit in MTD, but with reco cluster associated
1302         // - BTL
1303         if (std::abs(trackGen.eta()) < trackMaxBtlEta_) {
1304           if (!isTPmtdDirectBTL && !isTPmtdOtherBTL) {
1305             meBTLTrackMatchedTPnomtdEta_->Fill(std::abs(trackGen.eta()));
1306             meBTLTrackMatchedTPnomtdPt_->Fill(trackGen.pt());
1307             if (isBTL) {
1308               if (optionalPlots_) {
1309                 for (const auto& recClusterRef : recoClustersRefs) {  // having a look at these recos
1310                   if (recClusterRef.isNonnull()) {
1311                     auto itp = r2sAssociationMap.equal_range(recClusterRef);
1312                     if (itp.first != itp.second) {
1313                       auto& simClustersRefs_RecoMatch = (*itp.first).second;
1314                       simClusSize = simClustersRefs_RecoMatch.size();
1315                       for (const auto& sc : simClustersRefs_RecoMatch) {
1316                         auto mytps = Sim2tpAssociationMap.find(sc);
1317                         if (mytps != Sim2tpAssociationMap.end()) {
1318                           for (const auto& mytp : mytps->val) {
1319                             if (((**tp_info).eventId().rawId() - (*mytp).eventId().rawId()) == 0)
1320                               meBTLTrackMatchedTPnomtdAssocTrackID_->Fill(0);
1321                             else
1322                               meBTLTrackMatchedTPnomtdAssocTrackID_->Fill(1);
1323                           }
1324                         }
1325                         meBTLTrackMatchedTPnomtdAssocTrackIdOff_->Fill(sc->trackIdOffset());
1326                       }
1327                     }
1328                   }
1329                 }
1330 
1331                 meBTLTrackMatchedTPnomtdAssocSimClusSize_->Fill(simClusSize);
1332                 meBTLTrackMatchedTPnomtdAssocRecoClusSize_->Fill(recoClusSize);
1333                 meBTLTrackMatchedTPnomtdAssocTrackChi2_->Fill(trackGen.chi2());
1334                 meBTLTrackMatchedTPnomtdAssocTrackNdf_->Fill(trackGen.ndof());
1335                 meBTLTrackMatchedTPnomtdAssocTrackOutermostHitR_->Fill(outermostHitPosition[trackref]);
1336               }
1337               fillTrackClusterMatchingHistograms(meBTLTrackMatchedTPnomtdAssocEta_,
1338                                                  meBTLTrackMatchedTPnomtdAssocPt_,
1339                                                  meBTLTrackMatchedTPnomtdAssocMVAQual_,
1340                                                  meBTLTrackMatchedTPnomtdAssocTimeRes_,
1341                                                  meBTLTrackMatchedTPnomtdAssocTimePull_,
1342                                                  std::abs(trackGen.eta()),
1343                                                  trackGen.pt(),
1344                                                  mtdQualMVA[trackref],
1345                                                  dT,
1346                                                  pullT,
1347                                                  hasTime);
1348             }
1349           }
1350         }
1351         // - ETL
1352         else if (!isTPmtdETLD1 && !isTPmtdETLD2) {
1353           meETLTrackMatchedTPnomtdEta_->Fill(std::abs(trackGen.eta()));
1354           meETLTrackMatchedTPnomtdPt_->Fill(trackGen.pt());
1355           if (isETL) {
1356             fillTrackClusterMatchingHistograms(meETLTrackMatchedTPnomtdAssocEta_,
1357                                                meETLTrackMatchedTPnomtdAssocPt_,
1358                                                meETLTrackMatchedTPnomtdAssocMVAQual_,
1359                                                meETLTrackMatchedTPnomtdAssocTimeRes_,
1360                                                meETLTrackMatchedTPnomtdAssocTimePull_,
1361                                                std::abs(trackGen.eta()),
1362                                                trackGen.pt(),
1363                                                mtdQualMVA[trackref],
1364                                                dT,
1365                                                pullT,
1366                                                hasTime);
1367           }
1368         }
1369 
1370         // == Time pull and detailed extrapolation check only on tracks associated to TP from signal event
1371         if (!trkTPSelLV(**tp_info)) {
1372           continue;
1373         }
1374         size_t nlayers(0);
1375         float extrho(0.);
1376         float exteta(0.);
1377         float extphi(0.);
1378         float selvar(0.);
1379         auto accept = checkAcceptance(trackGen, iEvent, iSetup, nlayers, extrho, exteta, extphi, selvar);
1380         if (accept.first && std::abs(exteta) < trackMaxBtlEta_) {
1381           meExtraPhiAtBTL_->Fill(angle_units::operators::convertRadToDeg(extphi));
1382           meExtraBTLeneInCone_->Fill(selvar);
1383         }
1384         if (accept.second) {
1385           if (std::abs(exteta) < trackMaxBtlEta_) {
1386             meExtraPhiAtBTLmatched_->Fill(angle_units::operators::convertRadToDeg(extphi));
1387           }
1388           if (noCrack) {
1389             meExtraPtMtd_->Fill(trackGen.pt());
1390             if (nlayers == 2) {
1391               meExtraPtEtl2Mtd_->Fill(trackGen.pt());
1392             }
1393           }
1394           meExtraEtaMtd_->Fill(std::abs(trackGen.eta()));
1395           if (nlayers == 2) {
1396             meExtraEtaEtl2Mtd_->Fill(std::abs(trackGen.eta()));
1397           }
1398           if (accept.first && accept.second && !(isBTL || isETL)) {
1399             edm::LogInfo("MtdTracksValidation")
1400                 << "MtdTracksValidation: extender fail in " << iEvent.id().run() << " " << iEvent.id().event()
1401                 << " pt= " << trackGen.pt() << " eta= " << trackGen.eta();
1402             meExtraMTDfailExtenderEta_->Fill(std::abs(trackGen.eta()));
1403             if (noCrack) {
1404               meExtraMTDfailExtenderPt_->Fill(trackGen.pt());
1405             }
1406           }
1407         }  // detailed extrapolation check
1408 
1409         // time res and time pull
1410         if (Sigmat0Safe[trackref] != -1.) {
1411           if (isBTL || isETL) {
1412             meTrackResTot_->Fill(dT);
1413             meTrackPullTot_->Fill(pullT);
1414             meTrackResTotvsMVAQual_->Fill(mtdQualMVA[trackref], dT);
1415             meTrackPullTotvsMVAQual_->Fill(mtdQualMVA[trackref], pullT);
1416           }
1417         }  // time res and time pull
1418       }  // TP matching
1419     }  // trkRecSel
1420 
1421     // ETL tracks with low pt (0.2 < Pt [GeV] < 0.7)
1422     if (trkRecSelLowPt(trackGen)) {
1423       if ((std::abs(trackGen.eta()) > trackMinEtlEta_) && (std::abs(trackGen.eta()) < trackMaxEtlEta_)) {
1424         if (trackGen.pt() < 0.45) {
1425           meETLTrackEtaTotLowPt_[0]->Fill(std::abs(trackGen.eta()));
1426         } else {
1427           meETLTrackEtaTotLowPt_[1]->Fill(std::abs(trackGen.eta()));
1428         }
1429       }
1430       bool MTDEtlZnegD1 = false;
1431       bool MTDEtlZnegD2 = false;
1432       bool MTDEtlZposD1 = false;
1433       bool MTDEtlZposD2 = false;
1434       for (const auto hit : track.recHits()) {
1435         if (hit->isValid() == false)
1436           continue;
1437         MTDDetId Hit = hit->geographicalId();
1438         if ((Hit.det() == 6) && (Hit.subdetId() == 1) && (Hit.mtdSubDetector() == 2)) {
1439           isETL = true;
1440           ETLDetId ETLHit = hit->geographicalId();
1441           if ((ETLHit.zside() == -1) && (ETLHit.nDisc() == 1)) {
1442             MTDEtlZnegD1 = true;
1443           }
1444           if ((ETLHit.zside() == -1) && (ETLHit.nDisc() == 2)) {
1445             MTDEtlZnegD2 = true;
1446           }
1447           if ((ETLHit.zside() == 1) && (ETLHit.nDisc() == 1)) {
1448             MTDEtlZposD1 = true;
1449           }
1450           if ((ETLHit.zside() == 1) && (ETLHit.nDisc() == 2)) {
1451             MTDEtlZposD2 = true;
1452           }
1453         }
1454       }
1455       if ((trackGen.eta() < -trackMinEtlEta_) && (trackGen.eta() > -trackMaxEtlEta_)) {
1456         twoETLdiscs = (MTDEtlZnegD1 == true) && (MTDEtlZnegD2 == true);
1457       }
1458       if ((trackGen.eta() > trackMinEtlEta_) && (trackGen.eta() < trackMaxEtlEta_)) {
1459         twoETLdiscs = (MTDEtlZposD1 == true) && (MTDEtlZposD2 == true);
1460       }
1461       if (isETL && (std::abs(trackGen.eta()) > trackMinEtlEta_) && (std::abs(trackGen.eta()) < trackMaxEtlEta_)) {
1462         if (trackGen.pt() < 0.45) {
1463           meETLTrackEtaMtdLowPt_[0]->Fill(std::abs(trackGen.eta()));
1464         } else {
1465           meETLTrackEtaMtdLowPt_[1]->Fill(std::abs(trackGen.eta()));
1466         }
1467       }
1468       if (isETL && twoETLdiscs) {
1469         if (trackGen.pt() < 0.45) {
1470           meETLTrackEta2MtdLowPt_[0]->Fill(std::abs(trackGen.eta()));
1471         } else {
1472           meETLTrackEta2MtdLowPt_[1]->Fill(std::abs(trackGen.eta()));
1473         }
1474       }
1475     }  // trkRecSelLowPt
1476 
1477   }  // RECO tracks loop
1478 }
1479 
1480 const std::pair<bool, bool> MtdTracksValidation::checkAcceptance(const reco::Track& track,
1481                                                                  const edm::Event& iEvent,
1482                                                                  edm::EventSetup const& iSetup,
1483                                                                  size_t& nlayers,
1484                                                                  float& extrho,
1485                                                                  float& exteta,
1486                                                                  float& extphi,
1487                                                                  float& selvar) {
1488   bool isMatched(false);
1489   nlayers = 0;
1490   extrho = 0.;
1491   exteta = -999.;
1492   extphi = -999.;
1493   selvar = 0.;
1494 
1495   auto geometryHandle = iSetup.getTransientHandle(mtdgeoToken_);
1496   const MTDGeometry* geom = geometryHandle.product();
1497   auto topologyHandle = iSetup.getTransientHandle(mtdtopoToken_);
1498   const MTDTopology* topology = topologyHandle.product();
1499 
1500   auto layerHandle = iSetup.getTransientHandle(mtdlayerToken_);
1501   const MTDDetLayerGeometry* layerGeo = layerHandle.product();
1502 
1503   auto magfieldHandle = iSetup.getTransientHandle(magfieldToken_);
1504   const MagneticField* mfield = magfieldHandle.product();
1505 
1506   auto ttrackBuilder = iSetup.getTransientHandle(builderToken_);
1507 
1508   auto tTrack = ttrackBuilder->build(track);
1509   TrajectoryStateOnSurface tsos = tTrack.outermostMeasurementState();
1510   float theMaxChi2 = 500.;
1511   float theNSigma = 10.;
1512   std::unique_ptr<MeasurementEstimator> theEstimator =
1513       std::make_unique<Chi2MeasurementEstimator>(theMaxChi2, theNSigma);
1514   SteppingHelixPropagator prop(mfield, anyDirection);
1515 
1516   auto btlRecHitsHandle = makeValid(iEvent.getHandle(btlRecHitsToken_));
1517   auto etlRecHitsHandle = makeValid(iEvent.getHandle(etlRecHitsToken_));
1518 
1519   edm::LogVerbatim("MtdTracksValidation")
1520       << "MtdTracksValidation: extrapolating track, pt= " << track.pt() << " eta= " << track.eta();
1521 
1522   //try BTL
1523   bool inBTL = false;
1524   float eneSum(0.);
1525   const std::vector<const DetLayer*>& layersBTL = layerGeo->allBTLLayers();
1526   for (const DetLayer* ilay : layersBTL) {
1527     std::pair<bool, TrajectoryStateOnSurface> comp = ilay->compatible(tsos, prop, *theEstimator);
1528     if (!comp.first)
1529       continue;
1530     if (!inBTL) {
1531       inBTL = true;
1532       extrho = comp.second.globalPosition().perp();
1533       exteta = comp.second.globalPosition().eta();
1534       extphi = comp.second.globalPosition().phi();
1535       edm::LogVerbatim("MtdTracksValidation") << "MtdTracksValidation: extrapolation at BTL surface, rho= " << extrho
1536                                               << " eta= " << exteta << " phi= " << extphi;
1537     }
1538     std::vector<DetLayer::DetWithState> compDets = ilay->compatibleDets(tsos, prop, *theEstimator);
1539     for (const auto& detWithState : compDets) {
1540       const auto& det = detWithState.first;
1541 
1542       // loop on compatible rechits and check energy in a fixed size cone around the extrapolation point
1543 
1544       edm::LogVerbatim("MtdTracksValidation")
1545           << "MtdTracksValidation: DetId= " << det->geographicalId().rawId()
1546           << " gp= " << detWithState.second.globalPosition().x() << " " << detWithState.second.globalPosition().y()
1547           << " " << detWithState.second.globalPosition().z() << " rho= " << detWithState.second.globalPosition().perp()
1548           << " eta= " << detWithState.second.globalPosition().eta()
1549           << " phi= " << detWithState.second.globalPosition().phi();
1550 
1551       for (const auto& recHit : *btlRecHitsHandle) {
1552         BTLDetId detId = recHit.id();
1553         DetId geoId = detId.geographicalId(MTDTopologyMode::crysLayoutFromTopoMode(topology->getMTDTopologyMode()));
1554         const MTDGeomDet* thedet = geom->idToDet(geoId);
1555         if (thedet == nullptr)
1556           throw cms::Exception("MtdTracksValidation") << "GeographicalID: " << std::hex << geoId.rawId() << " ("
1557                                                       << detId.rawId() << ") is invalid!" << std::dec << std::endl;
1558         if (geoId == det->geographicalId()) {
1559           const ProxyMTDTopology& topoproxy = static_cast<const ProxyMTDTopology&>(thedet->topology());
1560           const RectangularMTDTopology& topo = static_cast<const RectangularMTDTopology&>(topoproxy.specificTopology());
1561 
1562           Local3DPoint local_point(0., 0., 0.);
1563           local_point = topo.pixelToModuleLocalPoint(local_point, detId.row(topo.nrows()), detId.column(topo.nrows()));
1564           const auto& global_point = thedet->toGlobal(local_point);
1565           edm::LogVerbatim("MtdTracksValidation")
1566               << "MtdTracksValidation: Hit id= " << detId.rawId() << " ene= " << recHit.energy()
1567               << " dr= " << reco::deltaR(global_point, detWithState.second.globalPosition());
1568           if (reco::deltaR(global_point, detWithState.second.globalPosition()) < cluDRradius_) {
1569             eneSum += recHit.energy();
1570             //extrho = detWithState.second.globalPosition().perp();
1571             //exteta = detWithState.second.globalPosition().eta();
1572             //extphi = detWithState.second.globalPosition().phi();
1573           }
1574         }
1575       }
1576     }
1577     if (eneSum > depositBTLthreshold_) {
1578       nlayers++;
1579       selvar = eneSum;
1580       isMatched = true;
1581       edm::LogVerbatim("MtdTracksValidation")
1582           << "MtdTracksValidation: BTL matched, energy= " << eneSum << " #layers= " << nlayers;
1583     }
1584   }
1585   if (inBTL) {
1586     return std::make_pair(inBTL, isMatched);
1587   }
1588 
1589   //try ETL
1590   bool inETL = false;
1591   const std::vector<const DetLayer*>& layersETL = layerGeo->allETLLayers();
1592   for (const DetLayer* ilay : layersETL) {
1593     size_t hcount(0);
1594     const BoundDisk& disk = static_cast<const MTDSectorForwardDoubleLayer*>(ilay)->specificSurface();
1595     const double diskZ = disk.position().z();
1596     if (tsos.globalPosition().z() * diskZ < 0)
1597       continue;  // only propagate to the disk that's on the same side
1598     std::pair<bool, TrajectoryStateOnSurface> comp = ilay->compatible(tsos, prop, *theEstimator);
1599     if (!comp.first)
1600       continue;
1601     if (!inETL) {
1602       inETL = true;
1603       extrho = comp.second.globalPosition().perp();
1604       exteta = comp.second.globalPosition().eta();
1605       extphi = comp.second.globalPosition().phi();
1606     }
1607     edm::LogVerbatim("MtdTracksValidation") << "MtdTracksValidation: extrapolation at ETL surface, rho= " << extrho
1608                                             << " eta= " << exteta << " phi= " << extphi;
1609     std::vector<DetLayer::DetWithState> compDets = ilay->compatibleDets(tsos, prop, *theEstimator);
1610     for (const auto& detWithState : compDets) {
1611       const auto& det = detWithState.first;
1612 
1613       // loop on compatible rechits and check hits in a fixed size cone around the extrapolation point
1614 
1615       edm::LogVerbatim("MtdTracksValidation")
1616           << "MtdTracksValidation: DetId= " << det->geographicalId().rawId()
1617           << " gp= " << detWithState.second.globalPosition().x() << " " << detWithState.second.globalPosition().y()
1618           << " " << detWithState.second.globalPosition().z() << " rho= " << detWithState.second.globalPosition().perp()
1619           << " eta= " << detWithState.second.globalPosition().eta()
1620           << " phi= " << detWithState.second.globalPosition().phi();
1621 
1622       for (const auto& recHit : *etlRecHitsHandle) {
1623         ETLDetId detId = recHit.id();
1624         DetId geoId = detId.geographicalId();
1625         const MTDGeomDet* thedet = geom->idToDet(geoId);
1626         if (thedet == nullptr)
1627           throw cms::Exception("MtdTracksValidation") << "GeographicalID: " << std::hex << geoId.rawId() << " ("
1628                                                       << detId.rawId() << ") is invalid!" << std::dec << std::endl;
1629         if (geoId == det->geographicalId()) {
1630           const ProxyMTDTopology& topoproxy = static_cast<const ProxyMTDTopology&>(thedet->topology());
1631           const RectangularMTDTopology& topo = static_cast<const RectangularMTDTopology&>(topoproxy.specificTopology());
1632 
1633           Local3DPoint local_point(topo.localX(recHit.row()), topo.localY(recHit.column()), 0.);
1634           const auto& global_point = thedet->toGlobal(local_point);
1635           edm::LogVerbatim("MtdTracksValidation")
1636               << "MtdTracksValidation: Hit id= " << detId.rawId() << " time= " << recHit.time()
1637               << " dr= " << reco::deltaR(global_point, detWithState.second.globalPosition());
1638           if (reco::deltaR(global_point, detWithState.second.globalPosition()) < cluDRradius_) {
1639             hcount++;
1640             if (hcount == 1) {
1641               //extrho = detWithState.second.globalPosition().perp();
1642               //exteta = detWithState.second.globalPosition().eta();
1643               //extphi = detWithState.second.globalPosition().phi();
1644             }
1645           }
1646         }
1647       }
1648     }
1649     if (hcount > 0) {
1650       nlayers++;
1651       selvar = (float)hcount;
1652       isMatched = true;
1653       edm::LogVerbatim("MtdTracksValidation")
1654           << "MtdTracksValidation: ETL matched, counts= " << hcount << " #layers= " << nlayers;
1655     }
1656   }
1657 
1658   if (!inBTL && !inETL) {
1659     edm::LogVerbatim("MtdTracksValidation")
1660         << "MtdTracksValidation: track not extrapolating to MTD: pt= " << track.pt() << " eta= " << track.eta()
1661         << " phi= " << track.phi() << " vz= " << track.vz()
1662         << " vxy= " << std::sqrt(track.vx() * track.vx() + track.vy() * track.vy());
1663   }
1664   return std::make_pair(inETL, isMatched);
1665 }
1666 
1667 // ------------ method for histogram booking ------------
1668 void MtdTracksValidation::bookHistograms(DQMStore::IBooker& ibook, edm::Run const& run, edm::EventSetup const& iSetup) {
1669   ibook.setCurrentFolder(folder_);
1670 
1671   // histogram booking
1672   meBTLTrackRPTime_ = ibook.book1D("TrackBTLRPTime", "Track t0 with respect to R.P.;t0 [ns]", 100, -1, 3);
1673   meBTLTrackEtaTot_ = ibook.book1D("TrackBTLEtaTot", "Eta of tracks (Tot);#eta_{RECO}", 30, 0., 1.5);
1674   meBTLTrackPhiTot_ = ibook.book1D("TrackBTLPhiTot", "Phi of tracks (Tot);#phi_{RECO} [rad]", 100, -3.2, 3.2);
1675   meBTLTrackPtTot_ = ibook.book1D("TrackBTLPtTot", "Pt of tracks (Tot);pt_{RECO} [GeV]", 50, 0, 10);
1676   meBTLTrackEtaMtd_ = ibook.book1D("TrackBTLEtaMtd", "Eta of tracks (Mtd);#eta_{RECO}", 30, 0., 1.5);
1677   meBTLTrackPhiMtd_ = ibook.book1D("TrackBTLPhiMtd", "Phi of tracks (Mtd);#phi_{RECO} [rad]", 100, -3.2, 3.2);
1678   meBTLTrackPtMtd_ = ibook.book1D("TrackBTLPtMtd", "Pt of tracks (Mtd);pt_{RECO} [GeV]", 50, 0, 10);
1679   meBTLTrackPtRes_ =
1680       ibook.book1D("TrackBTLPtRes", "Track pT resolution  ;pT_{Gentrack}-pT_{MTDtrack}/pT_{Gentrack} ", 100, -0.1, 0.1);
1681   meETLTrackRPTime_ = ibook.book1D("TrackETLRPTime", "Track t0 with respect to R.P.;t0 [ns]", 100, -1, 3);
1682   meETLTrackEtaTot_ = ibook.book1D("TrackETLEtaTot", "Eta of tracks (Tot);#eta_{RECO}", 30, 1.5, 3.0);
1683   meETLTrackPhiTot_ = ibook.book1D("TrackETLPhiTot", "Phi of tracks (Tot);#phi_{RECO} [rad]", 100, -3.2, 3.2);
1684   meETLTrackPhiTot_ = ibook.book1D("TrackETLPhiTot", "Phi of tracks (Tot);#phi_{RECO} [rad]", 100, -3.2, 3.2);
1685   meETLTrackPtTot_ = ibook.book1D("TrackETLPtTot", "Pt of tracks (Tot);pt_{RECO} [GeV]", 50, 0, 10);
1686 
1687   meETLTrackEtaTotLowPt_[0] =
1688       ibook.book1D("TrackETLEtaTotLowPt0", "Eta of tracks, 0.2 < pt < 0.45 (Tot);#eta_{RECO}", 30, 1.5, 3.0);
1689   meETLTrackEtaTotLowPt_[1] =
1690       ibook.book1D("TrackETLEtaTotLowPt1", "Eta of tracks, 0.45 < pt < 0.7 (Tot);#eta_{RECO}", 30, 1.5, 3.0);
1691 
1692   meETLTrackEtaMtd_ = ibook.book1D("TrackETLEtaMtd", "Eta of tracks (Mtd);#eta_{RECO}", 30, 1.5, 3.0);
1693   meETLTrackEtaMtdLowPt_[0] =
1694       ibook.book1D("TrackETLEtaMtdLowPt0", "Eta of tracks, 0.2 < pt < 0.45 (Mtd);#eta_{RECO}", 30, 1.5, 3.0);
1695   meETLTrackEtaMtdLowPt_[1] =
1696       ibook.book1D("TrackETLEtaMtdLowPt1", "Eta of tracks, 0.45 < pt < 0.7 (Mtd);#eta_{RECO}", 30, 1.5, 3.0);
1697   meETLTrackEta2MtdLowPt_[0] =
1698       ibook.book1D("TrackETLEta2MtdLowPt0", "Eta of tracks, 0.2 < pt < 0.45 (Mtd 2 hit);#eta_{RECO}", 30, 1.5, 3.0);
1699   meETLTrackEta2MtdLowPt_[1] =
1700       ibook.book1D("TrackETLEta2MtdLowPt1", "Eta of tracks, 0.45 < pt < 0.7 (Mtd 2 hit);#eta_{RECO}", 30, 1.5, 3.0);
1701 
1702   meETLTrackPhiMtd_ = ibook.book1D("TrackETLPhiMtd", "Phi of tracks (Mtd);#phi_{RECO} [rad]", 100, -3.2, 3.2);
1703   meETLTrackPtMtd_ = ibook.book1D("TrackETLPtMtd", "Pt of tracks (Mtd);pt_{RECO} [GeV]", 50, 0, 10);
1704   meETLTrackEta2Mtd_ = ibook.book1D("TrackETLEta2Mtd", "Eta of tracks (Mtd 2 hit);#eta_{RECO}", 30, 1.5, 3.0);
1705   meETLTrackPhi2Mtd_ = ibook.book1D("TrackETLPhi2Mtd", "Phi of tracks (Mtd 2 hit);#phi_{RECO} [rad]", 100, -3.2, 3.2);
1706   meETLTrackPt2Mtd_ = ibook.book1D("TrackETLPt2Mtd", "Pt of tracks (Mtd 2 hit);pt_{RECO} [GeV]", 50, 0, 10);
1707 
1708   meETLTrackPtRes_ =
1709       ibook.book1D("TrackETLPtRes", "Track pT resolution;pT_{Gentrack}-pT_{MTDtrack}/pT_{Gentrack} ", 100, -0.1, 0.1);
1710 
1711   meTracktmtd_ = ibook.book1D("Tracktmtd", "Track time from TrackExtenderWithMTD;tmtd [ns]", 150, 1, 16);
1712   meTrackt0Src_ = ibook.book1D("Trackt0Src", "Track time from TrackExtenderWithMTD;t0Src [ns]", 100, -1.5, 1.5);
1713   meTrackSigmat0Src_ =
1714       ibook.book1D("TrackSigmat0Src", "Time Error from TrackExtenderWithMTD; #sigma_{t0Src} [ns]", 100, 0, 0.1);
1715 
1716   meTrackt0Pid_ = ibook.book1D("Trackt0Pid", "Track t0 as stored in TofPid;t0 [ns]", 100, -1, 1);
1717   meTrackSigmat0Pid_ = ibook.book1D("TrackSigmat0Pid", "Sigmat0 as stored in TofPid; #sigma_{t0} [ns]", 100, 0, 0.1);
1718   meTrackt0SafePid_ = ibook.book1D("Trackt0SafePID", "Track t0 Safe as stored in TofPid;t0 [ns]", 100, -1, 1);
1719   meTrackSigmat0SafePid_ = ibook.book1D(
1720       "TrackSigmat0SafePID", "Log10(Sigmat0 Safe) as stored in TofPid; Log10(#sigma_{t0} [ns])", 80, -3, 1);
1721   meTrackNumHits_ = ibook.book1D("TrackNumHits", "Number of valid MTD hits per track ; Number of hits", 10, -5, 5);
1722   meTrackNumHitsNT_ = ibook.book1D(
1723       "TrackNumHitsNT", "Number of valid MTD hits per track no time associated; Number of hits", 10, -5, 5);
1724   meTrackMVAQual_ = ibook.book1D("TrackMVAQual", "Track MVA Quality as stored in Value Map ; MVAQual", 100, -1, 1);
1725   meTrackPathLengthvsEta_ = ibook.bookProfile(
1726       "TrackPathLengthvsEta", "MTD Track pathlength vs MTD track Eta;|#eta|;Pathlength", 100, 0, 3.2, 100.0, 400.0, "S");
1727 
1728   meTrackOutermostHitR_ = ibook.book1D("TrackOutermostHitR", "Track outermost hit position R; R[cm]", 40, 0, 120.);
1729   meTrackOutermostHitZ_ = ibook.book1D("TrackOutermostHitZ", "Track outermost hit position Z; z[cm]", 100, 0, 300.);
1730 
1731   meTrackSigmaTof_[0] =
1732       ibook.book1D("TrackSigmaTof_Pion", "Sigma(TOF) for pion hypothesis; #sigma_{t0} [ps]", 10, 0, 5);
1733   meTrackSigmaTof_[1] =
1734       ibook.book1D("TrackSigmaTof_Kaon", "Sigma(TOF) for kaon hypothesis; #sigma_{t0} [ps]", 25, 0, 25);
1735   meTrackSigmaTof_[2] =
1736       ibook.book1D("TrackSigmaTof_Proton", "Sigma(TOF) for proton hypothesis; #sigma_{t0} [ps]", 50, 0, 50);
1737 
1738   meTrackSigmaTofvsP_[0] = ibook.bookProfile("TrackSigmaTofvsP_Pion",
1739                                              "Sigma(TOF) for pion hypothesis vs p; p [GeV]; #sigma_{t0} [ps]",
1740                                              20,
1741                                              0,
1742                                              10.,
1743                                              0,
1744                                              50.,
1745                                              "S");
1746   meTrackSigmaTofvsP_[1] = ibook.bookProfile("TrackSigmaTofvsP_Kaon",
1747                                              "Sigma(TOF) for kaon hypothesis vs p; p [GeV]; #sigma_{t0} [ps]",
1748                                              20,
1749                                              0,
1750                                              10.,
1751                                              0,
1752                                              50.,
1753                                              "S");
1754   meTrackSigmaTofvsP_[2] = ibook.bookProfile("TrackSigmaTofvsP_Proton",
1755                                              "Sigma(TOF) for proton hypothesis vs p; p [GeV]; #sigma_{t0} [ps]",
1756                                              20,
1757                                              0,
1758                                              10.,
1759                                              0,
1760                                              50.,
1761                                              "S");
1762 
1763   meExtraPtMtd_ =
1764       ibook.book1D("ExtraPtMtd", "Pt of tracks associated to LV extrapolated to hits; track pt [GeV] ", 110, 0., 11.);
1765   meExtraPtEtl2Mtd_ = ibook.book1D("ExtraPtEtl2Mtd",
1766                                    "Pt of tracks associated to LV extrapolated to hits, 2 ETL layers; track pt [GeV] ",
1767                                    110,
1768                                    0.,
1769                                    11.);
1770   meExtraEtaMtd_ =
1771       ibook.book1D("ExtraEtaMtd", "Eta of tracks associated to LV extrapolated to hits; track eta ", 66, 0., 3.3);
1772   meExtraEtaEtl2Mtd_ = ibook.book1D(
1773       "ExtraEtaEtl2Mtd", "Eta of tracks associated to LV extrapolated to hits, 2 ETL layers; track eta ", 66, 0., 3.3);
1774   meTrackMatchedTPEtaTotLV_ =
1775       ibook.book1D("MatchedTPEtaTotLV", "Eta of tracks associated to LV matched to TP; track eta ", 66, 0., 3.3);
1776   meTrackMatchedTPPtTotLV_ =
1777       ibook.book1D("MatchedTPPtTotLV", "Pt of tracks associated to LV matched to TP; track pt [GeV] ", 110, 0., 11.);
1778 
1779   meBTLTrackMatchedTPEtaTot_ =
1780       ibook.book1D("BTLTrackMatchedTPEtaTot", "Eta of tracks matched to TP; track eta ", 30, 0., 1.5);
1781   meBTLTrackMatchedTPEtaMtd_ =
1782       ibook.book1D("BTLTrackMatchedTPEtaMtd", "Eta of tracks matched to TP with time; track eta ", 30, 0., 1.5);
1783   meBTLTrackMatchedTPPtTot_ =
1784       ibook.book1D("BTLTrackMatchedTPPtTot", "Pt of tracks matched to TP; track pt [GeV] ", 50, 0., 10.);
1785   meBTLTrackMatchedTPPtMtd_ =
1786       ibook.book1D("BTLTrackMatchedTPPtMtd", "Pt of tracks matched to TP with time; track pt [GeV] ", 50, 0., 10.);
1787   meETLTrackMatchedTPEtaTot_ =
1788       ibook.book1D("ETLTrackMatchedTPEtaTot", "Eta of tracks matched to TP; track eta ", 30, 1.5, 3.0);
1789   meETLTrackMatchedTPEtaMtd_ = ibook.book1D(
1790       "ETLTrackMatchedTPEtaMtd", "Eta of tracks matched to TP with time (>=1 ETL hit); track eta ", 30, 1.5, 3.0);
1791   meETLTrackMatchedTPEtaMtdCorrect_ =
1792       ibook.book1D("ETLTrackMatchedTPEtaMtdCorrect",
1793                    "Eta of tracks matched to TP with time (>=1 ETL hit), correct reco match; track eta ",
1794                    30,
1795                    1.5,
1796                    3.0);
1797   meETLTrackMatchedTPEta2Mtd_ = ibook.book1D(
1798       "ETLTrackMatchedTPEta2Mtd", "Eta of tracks matched to TP with time (2 ETL hits); track eta ", 30, 1.5, 3.0);
1799   meETLTrackMatchedTPPtTot_ =
1800       ibook.book1D("ETLTrackMatchedTPPtTot", "Pt of tracks matched to TP; track pt [GeV] ", 50, 0., 10.);
1801   meETLTrackMatchedTPPtMtd_ = ibook.book1D(
1802       "ETLTrackMatchedTPPtMtd", "Pt of tracks matched to TP with time (>=1 ETL hit); track pt [GeV] ", 50, 0., 10.);
1803   meETLTrackMatchedTPPtMtdCorrect_ =
1804       ibook.book1D("ETLTrackMatchedTPPtMtdCorrect",
1805                    "Pt of tracks matched to TP with time (>=1 ETL hit), correct reco match; track pt [GeV] ",
1806                    50,
1807                    0.,
1808                    10.);
1809   meETLTrackMatchedTPPt2Mtd_ = ibook.book1D(
1810       "ETLTrackMatchedTPPt2Mtd", "Pt of tracks matched to TP with time (2 ETL hits); track pt [GeV] ", 50, 0., 10.);
1811 
1812   if (optionalPlots_) {
1813     meBTLTrackMatchedTPPtResMtd_ = ibook.book1D(
1814         "TrackMatchedTPBTLPtResMtd",
1815         "Pt resolution of tracks matched to TP-BTL hit  ;|pT_{MTDtrack}-pT_{truth}|/|pT_{Gentrack}-pT_{truth}| ",
1816         100,
1817         0.,
1818         4.);
1819     meETLTrackMatchedTPPtResMtd_ = ibook.book1D(
1820         "TrackMatchedTPETLPtResMtd",
1821         "Pt resolution of tracks matched to TP-ETL hit  ;|pT_{MTDtrack}-pT_{truth}|/|pT_{Gentrack}-pT_{truth}| ",
1822         100,
1823         0.,
1824         4.);
1825     meETLTrackMatchedTP2PtResMtd_ = ibook.book1D(
1826         "TrackMatchedTPETL2PtResMtd",
1827         "Pt resolution of tracks matched to TP-ETL 2hits  ;|pT_{MTDtrack}-pT_{truth}|/|pT_{Gentrack}-pT_{truth}| ",
1828         100,
1829         0.,
1830         4.);
1831     meBTLTrackMatchedTPPtRatioGen_ = ibook.book1D(
1832         "TrackMatchedTPBTLPtRatioGen", "Pt ratio of Gentracks (BTL)  ;pT_{Gentrack}/pT_{truth} ", 100, 0.9, 1.1);
1833     meETLTrackMatchedTPPtRatioGen_ = ibook.book1D(
1834         "TrackMatchedTPETLPtRatioGen", "Pt ratio of Gentracks (ETL 1hit)  ;pT_{Gentrack}/pT_{truth} ", 100, 0.9, 1.1);
1835     meETLTrackMatchedTP2PtRatioGen_ = ibook.book1D(
1836         "TrackMatchedTPETL2PtRatioGen", "Pt ratio of Gentracks (ETL 2hits)  ;pT_{Gentrack}/pT_{truth} ", 100, 0.9, 1.1);
1837     meBTLTrackMatchedTPPtRatioMtd_ =
1838         ibook.book1D("TrackMatchedTPBTLPtRatioMtd",
1839                      "Pt ratio of tracks matched to TP-BTL hit  ;pT_{MTDtrack}/pT_{truth} ",
1840                      100,
1841                      0.9,
1842                      1.1);
1843     meETLTrackMatchedTPPtRatioMtd_ =
1844         ibook.book1D("TrackMatchedTPETLPtRatioMtd",
1845                      "Pt ratio of tracks matched to TP-ETL hit  ;pT_{MTDtrack}/pT_{truth} ",
1846                      100,
1847                      0.9,
1848                      1.1);
1849     meETLTrackMatchedTP2PtRatioMtd_ =
1850         ibook.book1D("TrackMatchedTPETL2PtRatioMtd",
1851                      "Pt ratio of tracks matched to TP-ETL 2hits  ;pT_{MTDtrack}/pT_{truth} ",
1852                      100,
1853                      0.9,
1854                      1.1);
1855     meBTLTrackMatchedTPPtResvsPtMtd_ =
1856         ibook.bookProfile("TrackMatchedTPBTLPtResvsPtMtd",
1857                           "Pt resolution of tracks matched to TP-BTL hit vs Pt;pT_{truth} "
1858                           "[GeV];|pT_{MTDtrack}-pT_{truth}|/|pT_{Gentrack}-pT_{truth}| ",
1859                           20,
1860                           0.7,
1861                           10.,
1862                           0.,
1863                           4.,
1864                           "s");
1865     meETLTrackMatchedTPPtResvsPtMtd_ =
1866         ibook.bookProfile("TrackMatchedTPETLPtResvsPtMtd",
1867                           "Pt resolution of tracks matched to TP-ETL hit vs Pt;pT_{truth} "
1868                           "[GeV];|pT_{MTDtrack}-pT_{truth}|/|pT_{Gentrack}-pT_{truth}| ",
1869                           20,
1870                           0.7,
1871                           10.,
1872                           0.,
1873                           4.,
1874                           "s");
1875     meETLTrackMatchedTP2PtResvsPtMtd_ =
1876         ibook.bookProfile("TrackMatchedTPETL2PtResvsPtMtd",
1877                           "Pt resolution of tracks matched to TP-ETL 2hits Pt pT;pT_{truth} "
1878                           "[GeV];|pT_{MTDtrack}-pT_{truth}|/|pT_{Gentrack}-pT_{truth}| ",
1879                           20,
1880                           0.7,
1881                           10.,
1882                           0.,
1883                           4.,
1884                           "s");
1885     meBTLTrackMatchedTPDPtvsPtGen_ = ibook.bookProfile(
1886         "TrackMatchedTPBTLDPtvsPtGen",
1887         "Pt relative difference of Gentracks (BTL) vs Pt;pT_{truth} [GeV];pT_{Gentrack}-pT_{truth}/pT_{truth} ",
1888         20,
1889         0.7,
1890         10.,
1891         -0.1,
1892         0.1,
1893         "s");
1894     meETLTrackMatchedTPDPtvsPtGen_ = ibook.bookProfile(
1895         "TrackMatchedTPETLDPtvsPtGen",
1896         "Pt relative difference of Gentracks (ETL 1hit) vs Pt;pT_{truth} [GeV];pT_{Gentrack}-pT_{truth}/pT_{truth} ",
1897         20,
1898         0.7,
1899         10.,
1900         -0.1,
1901         0.1,
1902         "s");
1903     meETLTrackMatchedTP2DPtvsPtGen_ = ibook.bookProfile(
1904         "TrackMatchedTPETL2DPtvsPtGen",
1905         "Pt relative difference  of Gentracks (ETL 2hits) vs Pt;pT_{truth} [GeV];pT_{Gentrack}-pT_{truth}/pT_{truth} ",
1906         20,
1907         0.7,
1908         10.,
1909         -0.1,
1910         0.1,
1911         "s");
1912     meBTLTrackMatchedTPDPtvsPtMtd_ = ibook.bookProfile("TrackMatchedTPBTLDPtvsPtMtd",
1913                                                        "Pt relative difference of tracks matched to TP-BTL hits vs "
1914                                                        "Pt;pT_{truth} [GeV];pT_{MTDtrack}-pT_{truth}/pT_{truth} ",
1915                                                        20,
1916                                                        0.7,
1917                                                        10.,
1918                                                        -0.1,
1919                                                        0.1,
1920                                                        "s");
1921     meETLTrackMatchedTPDPtvsPtMtd_ = ibook.bookProfile("TrackMatchedTPETLDPtvsPtMtd",
1922                                                        "Pt relative difference of tracks matched to TP-ETL hits vs "
1923                                                        "Pt;pT_{truth} [GeV];pT_{MTDtrack}-pT_{truth}/pT_{truth} ",
1924                                                        20,
1925                                                        0.7,
1926                                                        10.,
1927                                                        -0.1,
1928                                                        0.1,
1929                                                        "s");
1930     meETLTrackMatchedTP2DPtvsPtMtd_ = ibook.bookProfile("TrackMatchedTPETL2DPtvsPtMtd",
1931                                                         "Pt relative difference of tracks matched to TP-ETL 2hits vs "
1932                                                         "Pt;pT_{truth} [GeV];pT_{MTDtrack}-pT_{truth}/pT_{truth} ",
1933                                                         20,
1934                                                         0.7,
1935                                                         10.,
1936                                                         -0.1,
1937                                                         0.1,
1938                                                         "s");
1939 
1940     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackNdf_ =
1941         ibook.book1D("BTLTrackMatchedTPmtdDirectCorrectAssocTrackNdf",
1942                      "Ndf of tracks matched to TP with sim hit in MTD (direct), correct track-MTD association; Ndof ",
1943                      80,
1944                      0.,
1945                      220);
1946     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackChi2_ =
1947         ibook.book1D("BTLTrackMatchedTPmtdDirectCorrectAssocTrackChi2",
1948                      "Chi2 of tracks matched to TP with sim hit in MTD (direct), correct track-MTD association; Chi2 ",
1949                      80,
1950                      0.,
1951                      220);
1952     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackOutermostHitR_ =
1953         ibook.book1D("BTLTrackMatchedTPmtdDirectCorrectAssocTrackOutermostHitR",
1954                      "Outermost hit position R of tracks matched to TP with sim hit in MTD (direct), correct track-MTD "
1955                      "association; R [cm] ",
1956                      40,
1957                      0.,
1958                      120);
1959     meBTLTrackMatchedTPmtdDirectCorrectAssocSimClusSize_ =
1960         ibook.book1D("BTLTrackMatchedTPmtdDirectCorrectAssocSimClusSize",
1961                      "Size of the sim clusters associated to the reco cluster associated to the track (direct), "
1962                      "correct track-MTD association; Number of clusters ",
1963                      10,
1964                      -5.,
1965                      5.);
1966     meBTLTrackMatchedTPmtdDirectCorrectAssocRecoClusSize_ = ibook.book1D(
1967         "BTLTrackMatchedTPmtdDirectCorrectAssocRecoClusSize",
1968         "Size of the reco cluster associated to the track (direct), correct track-MTD association; Number of clusters ",
1969         10,
1970         -5.,
1971         5.);
1972     meBTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2_ = ibook.book1D(
1973         "BTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2",
1974         "Time chi2 of tracks matched to TP with sim hit in MTD (direct), correct track-MTD association; Chi2 ",
1975         200,
1976         0.,
1977         100);
1978     meBTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2vsMVAQual_ =
1979         ibook.book2D("BTLTrackMatchedTPmtdDirectCorrectAssocTimeChi2vsMVAQual",
1980                      "Time chi2 vs MVA of tracks matched to TP with sim hit in MTD (direct), correct track-MTD "
1981                      "association; Chi2; MVAQual ",
1982                      200,
1983                      0.,
1984                      100,
1985                      100,
1986                      -1,
1987                      1);
1988 
1989     meBTLTrackMatchedTPmtdDirectCorrectAssocSpaceChi2_ = ibook.book1D(
1990         "BTLTrackMatchedTPmtdDirectCorrectAssocSpaceChi2",
1991         "Space chi2 of tracks matched to TP with sim hit in MTD (direct), correct track-MTD association; Chi2 ",
1992         250,
1993         0.,
1994         250.);
1995     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLengthvsEta_ =
1996         ibook.book2D("BTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLengthvsEta",
1997                      "MTD Track pathlength vs MTD track Eta;|#eta|;Pathlength",
1998                      30,
1999                      0,
2000                      1.5,
2001                      350,
2002                      0.0,
2003                      350.0);
2004     meBTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLength_ = ibook.book1D(
2005         "BTLTrackMatchedTPmtdDirectCorrectAssocTrackPathLength", "MTD Track pathlength ; ;Pathlength", 400, 0, 400);
2006 
2007     meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf1_ =
2008         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackNdf1",
2009                      "Ndf of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Ndof ",
2010                      80,
2011                      0.,
2012                      220);
2013     meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi21_ =
2014         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackChi21",
2015                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2016                      80,
2017                      0.,
2018                      220);
2019     meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR1_ =
2020         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR1",
2021                      "Outermost hit position R of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2022                      "association; R [cm]",
2023                      40,
2024                      0.,
2025                      120);
2026     meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff1_ =
2027         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff1",
2028                      "Track Id offset of reco (wrong) cluster associated to the track (direct)  - wrong track-MTD "
2029                      "association; trackId (wrong)",
2030                      6,
2031                      -1.,
2032                      5.);
2033     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ1_ =
2034         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaZ1",
2035                      "Z of sim matched wrong cluster - Z of true sim cluster (direct) - wrong track-MTD association; "
2036                      "DeltaZ (wrong - true) [cm]",
2037                      1000,
2038                      -50.,
2039                      50.);
2040     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi1_ =
2041         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi1",
2042                      "Phi of sim matched wrong cluster - Z of true sim cluster - wrong track-MTD association; DeltaPhi "
2043                      "(wrong - true) ",
2044                      500,
2045                      -0.1,
2046                      0.1);
2047     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT1_ =
2048         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaT1",
2049                      "Time of sim matched wrong cluster - time of true sim cluster (direct) - wrong track-MTD "
2050                      "association; DeltaT (wrong - true) [ns]",
2051                      480,
2052                      -0.6,
2053                      0.6);
2054     meBTLTrackMatchedTPmtdDirectWrongAssocEta1_ = ibook.book1D(
2055         "BTLTrackMatchedTPmtdDirectWrongAssocEta1",
2056         "Eta of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;#eta_{RECO}",
2057         30,
2058         0.,
2059         1.5);
2060     meBTLTrackMatchedTPmtdDirectWrongAssocPt1_ = ibook.book1D(
2061         "BTLTrackMatchedTPmtdDirectWrongAssocPt1",
2062         "Pt of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;track pt [GeV]",
2063         50,
2064         0.,
2065         10.);
2066     meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual1_ = ibook.book1D(
2067         "BTLTrackMatchedTPmtdDirectWrongAssocMVAQual1",
2068         "MVA of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; MVA score",
2069         100,
2070         -1.,
2071         1.);
2072     meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes1_ =
2073         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimeRes1",
2074                      "Time resolution of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2075                      "association; t_{rec} - t_{sim} [ns] ",
2076                      240,
2077                      -0.3,
2078                      0.3);
2079     meBTLTrackMatchedTPmtdDirectWrongAssocTimePull1_ =
2080         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimePull1",
2081                      "Time pull of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; "
2082                      "(t_{rec}-t_{sim})/#sigma_{t}",
2083                      50,
2084                      -5.,
2085                      5.);
2086     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR1_ = ibook.book2D(
2087         "BTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR1", "; Outer R [cm]; DeltaZ [cm]", 120, 0., 120., 1000, -40., 40);
2088     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta1_ =
2089         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta1",
2090                      "MTD Track pathlength vs MTD track Eta;|#eta|;Pathlength",
2091                      30,
2092                      0,
2093                      1.5,
2094                      350,
2095                      0.0,
2096                      350.0);
2097     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength1_ = ibook.book1D(
2098         "BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength1", "MTD Track pathlength ; ;Pathlength", 400, 0, 400);
2099 
2100     meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf2_ =
2101         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackNdf2",
2102                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Ndof ",
2103                      80,
2104                      0.,
2105                      220);
2106     meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi22_ =
2107         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackChi22",
2108                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2109                      80,
2110                      0.,
2111                      220);
2112     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi21_ = ibook.book1D(
2113         "BTLTrackMatchedTPmtdDirectWrongAssocTimeChi21",
2114         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2115         200,
2116         0.,
2117         100);
2118     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual1_ =
2119         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual1",
2120                      "Time chi2 vs MVA of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD "
2121                      "association; Chi2; MVAQual ",
2122                      200,
2123                      0.,
2124                      100,
2125                      100,
2126                      -1,
2127                      1);
2128     meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi21_ = ibook.book1D(
2129         "BTLTrackMatchedTPmtdDirectWrongAssocSpaceChi21",
2130         "Space chi2 of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD association; Chi2 ",
2131         250,
2132         0.,
2133         250.);
2134     meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR2_ =
2135         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR2",
2136                      "Outermost hit position R of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2137                      "association; R [cm]",
2138                      40,
2139                      0.,
2140                      120);
2141     meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff2_ =
2142         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff2",
2143                      "Track Id offset of reco (wrong) cluster associated to the track (direct)  - wrong track-MTD "
2144                      "association; trackId (wrong)",
2145                      6,
2146                      -1.,
2147                      5.);
2148     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ2_ =
2149         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaZ2",
2150                      "Z of sim matched wrong cluster - Z of true sim cluster (direct) - wrong track-MTD association; "
2151                      "DeltaZ (wrong - true) [cm]",
2152                      1000,
2153                      -50.,
2154                      50.);
2155     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi2_ =
2156         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi2",
2157                      "Phi of sim matched wrong cluster - Z of true sim cluster - wrong track-MTD association; DeltaPhi "
2158                      "(wrong - true) ",
2159                      500,
2160                      -0.1,
2161                      0.1);
2162     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT2_ =
2163         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaT2",
2164                      "Time of sim matched wrong cluster - time of true sim cluster (direct) - wrong track-MTD "
2165                      "association; DeltaT (wrong - true) [ns]",
2166                      480,
2167                      -0.6,
2168                      0.6);
2169     meBTLTrackMatchedTPmtdDirectWrongAssocEta2_ = ibook.book1D(
2170         "BTLTrackMatchedTPmtdDirectWrongAssocEta2",
2171         "Eta of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;#eta_{RECO}",
2172         30,
2173         0.,
2174         1.5);
2175     meBTLTrackMatchedTPmtdDirectWrongAssocPt2_ = ibook.book1D(
2176         "BTLTrackMatchedTPmtdDirectWrongAssocPt2",
2177         "Pt of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;track pt [GeV]",
2178         50,
2179         0.,
2180         10.);
2181     meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual2_ = ibook.book1D(
2182         "BTLTrackMatchedTPmtdDirectWrongAssocMVAQual2",
2183         "MVA of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; MVA score",
2184         100,
2185         -1.,
2186         1.);
2187     meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes2_ =
2188         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimeRes2",
2189                      "Time resolution of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2190                      "association; t_{rec} - t_{sim} [ns] ",
2191                      240,
2192                      -0.3,
2193                      0.3);
2194     meBTLTrackMatchedTPmtdDirectWrongAssocTimePull2_ =
2195         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimePull2",
2196                      "Time pull of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; "
2197                      "(t_{rec}-t_{sim})/#sigma_{t}",
2198                      50,
2199                      -5.,
2200                      5.);
2201     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR2_ = ibook.book2D(
2202         "BTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR2", "; Outer R [cm]; DeltaZ [cm]", 120, 0., 120., 1000, -40., 40);
2203 
2204     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi22_ = ibook.book1D(
2205         "BTLTrackMatchedTPmtdDirectWrongAssocTimeChi22",
2206         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2207         200,
2208         0.,
2209         100);
2210     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual2_ =
2211         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual2",
2212                      "Time chi2 vs MVA of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD "
2213                      "association; Chi2; MVAQual ",
2214                      200,
2215                      0.,
2216                      100,
2217                      100,
2218                      -1,
2219                      1);
2220     meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi22_ = ibook.book1D(
2221         "BTLTrackMatchedTPmtdDirectWrongAssocSpaceChi22",
2222         "Space chi2 of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD association; Chi2 ",
2223         250,
2224         0.,
2225         250.);
2226     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta2_ =
2227         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta2",
2228                      "MTD Track pathlength vs MTD track Eta;|#eta|;Pathlength",
2229                      30,
2230                      0,
2231                      1.5,
2232                      350,
2233                      0.0,
2234                      350.0);
2235     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength2_ = ibook.book1D(
2236         "BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength2", "MTD Track pathlength ; ;Pathlength", 400, 0, 400);
2237 
2238     meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf3_ =
2239         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackNdf3",
2240                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Ndof ",
2241                      80,
2242                      0.,
2243                      220);
2244     meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi23_ =
2245         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackChi23",
2246                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2247                      80,
2248                      0.,
2249                      220);
2250     meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR3_ =
2251         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR3",
2252                      "Outermost hit position R of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2253                      "association; R [cm]",
2254                      40,
2255                      0.,
2256                      120);
2257     meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff3_ =
2258         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff3",
2259                      "Track Id offset of reco (wrong) cluster associated to the track (direct)  - wrong track-MTD "
2260                      "association; trackId (wrong)",
2261                      6,
2262                      -1.,
2263                      5.);
2264     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ3_ =
2265         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaZ3",
2266                      "Z of sim matched wrong cluster - Z of true sim cluster (direct) - wrong track-MTD association; "
2267                      "DeltaZ (wrong - true) [cm]",
2268                      1000,
2269                      -50.,
2270                      50.);
2271     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi3_ =
2272         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi3",
2273                      "Phi of sim matched wrong cluster - Z of true sim cluster - wrong track-MTD association; DeltaPhi "
2274                      "(wrong - true) ",
2275                      500,
2276                      -0.1,
2277                      0.1);
2278     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT3_ =
2279         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaT3",
2280                      "Time of sim matched wrong cluster - time of true sim cluster (direct) - wrong track-MTD "
2281                      "association; DeltaT (wrong - true) [ns]",
2282                      480,
2283                      -0.6,
2284                      0.6);
2285     meBTLTrackMatchedTPmtdDirectWrongAssocEta3_ = ibook.book1D(
2286         "BTLTrackMatchedTPmtdDirectWrongAssocEta3",
2287         "Eta of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;#eta_{RECO}",
2288         30,
2289         0.,
2290         1.5);
2291     meBTLTrackMatchedTPmtdDirectWrongAssocPt3_ = ibook.book1D(
2292         "BTLTrackMatchedTPmtdDirectWrongAssocPt3",
2293         "Pt of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;track pt [GeV]",
2294         50,
2295         0.,
2296         10.);
2297     meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual3_ = ibook.book1D(
2298         "BTLTrackMatchedTPmtdDirectWrongAssocMVAQual3",
2299         "MVA of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; MVA score",
2300         100,
2301         -1.,
2302         1.);
2303     meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes3_ =
2304         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimeRes3",
2305                      "Time resolution of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2306                      "association; t_{rec} - t_{sim} [ns] ",
2307                      240,
2308                      -0.3,
2309                      0.3);
2310     meBTLTrackMatchedTPmtdDirectWrongAssocTimePull3_ =
2311         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimePull3",
2312                      "Time pull of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; "
2313                      "(t_{rec}-t_{sim})/#sigma_{t}",
2314                      50,
2315                      -5.,
2316                      5.);
2317     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR3_ = ibook.book2D(
2318         "BTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR3", "; Outer R [cm]; DeltaZ [cm]", 120, 0., 120., 1000, -40., 40);
2319     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi23_ = ibook.book1D(
2320         "BTLTrackMatchedTPmtdDirectWrongAssocTimeChi23",
2321         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2322         200,
2323         0.,
2324         100);
2325     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual3_ =
2326         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual3",
2327                      "Time chi2 vs MVA of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD "
2328                      "association; Chi2; MVAQual ",
2329                      200,
2330                      0.,
2331                      100,
2332                      100,
2333                      -1,
2334                      1);
2335 
2336     meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi23_ = ibook.book1D(
2337         "BTLTrackMatchedTPmtdDirectWrongAssocSpaceChi23",
2338         "Space chi2 of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD association; Chi2 ",
2339         250,
2340         0.,
2341         250.);
2342     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta3_ =
2343         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta3",
2344                      "MTD Track pathlength vs MTD track Eta;|#eta|;Pathlength",
2345                      30,
2346                      0,
2347                      1.5,
2348                      350,
2349                      0.0,
2350                      350.0);
2351     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength3_ = ibook.book1D(
2352         "BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength3", "MTD Track pathlength ; ;Pathlength", 400, 0, 400);
2353 
2354     meBTLTrackMatchedTPmtdDirectWrongAssocTrackNdf_ =
2355         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackNdf",
2356                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Ndof ",
2357                      80,
2358                      0.,
2359                      220);
2360     meBTLTrackMatchedTPmtdDirectWrongAssocTrackChi2_ =
2361         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackChi2",
2362                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2363                      80,
2364                      0.,
2365                      220);
2366     meBTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR_ =
2367         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackOutermostHitR",
2368                      "Outermost hit position R of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2369                      "association; R [cm]",
2370                      40,
2371                      0.,
2372                      120);
2373     meBTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff_ =
2374         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTrackIdOff",
2375                      "Track Id offset of reco (wrong) cluster associated to the track (direct)  - wrong track-MTD "
2376                      "association; trackId (wrong)",
2377                      6,
2378                      -1.,
2379                      5.);
2380     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZ_ =
2381         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaZ",
2382                      "Z of sim matched wrong cluster - Z of true sim cluster (direct) - wrong track-MTD association; "
2383                      "DeltaZ (wrong - true) [cm]",
2384                      1000,
2385                      -50.,
2386                      50.);
2387     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi_ =
2388         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaPhi",
2389                      "Phi of sim matched wrong cluster - Z of true sim cluster - wrong track-MTD association; DeltaPhi "
2390                      "(wrong - true) ",
2391                      500,
2392                      -0.1,
2393                      0.1);
2394     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaT_ =
2395         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocDeltaT",
2396                      "Time of sim matched wrong cluster - time of true sim cluster (direct) - wrong track-MTD "
2397                      "association; DeltaT (wrong - true) [ns]",
2398                      480,
2399                      -0.6,
2400                      0.6);
2401     meBTLTrackMatchedTPmtdDirectWrongAssocSimClusSize_ =
2402         ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocSimClusSize",
2403                      "Size of the sim clusters associated to the reco cluster associated to the track (direct) - wrong "
2404                      "track-MTD association; Number of clusters ",
2405                      10,
2406                      -5.,
2407                      5.);
2408     meBTLTrackMatchedTPmtdDirectWrongAssocRecoClusSize_ = ibook.book1D(
2409         "BTLTrackMatchedTPmtdDirectWrongAssocRecoClusSize",
2410         "Size of the reco cluster associated to the track (direct) - wrong track-MTD association; Number of clusters ",
2411         10,
2412         -5.,
2413         5.);
2414     meBTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR_ = ibook.book2D(
2415         "BTLTrackMatchedTPmtdDirectWrongAssocDeltaZOutR", "; Outer R [cm]; DeltaZ [cm]", 120, 0., 120., 1000, -40., 40);
2416     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2_ = ibook.book1D(
2417         "BTLTrackMatchedTPmtdDirectWrongAssocTimeChi2",
2418         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2419         200,
2420         0.,
2421         100);
2422     meBTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual_ =
2423         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTimeChi2vsMVAQual",
2424                      "Time chi2 vs MVA of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD "
2425                      "association; Chi2; MVAQual ",
2426                      200,
2427                      0.,
2428                      100,
2429                      100,
2430                      -1,
2431                      1);
2432 
2433     meBTLTrackMatchedTPmtdDirectWrongAssocSpaceChi2_ = ibook.book1D(
2434         "BTLTrackMatchedTPmtdDirectWrongAssocSpaceChi2",
2435         "Space chi2 of tracks matched to TP with sim hit in MTD (direct), wrong track-MTD association; Chi2 ",
2436         250,
2437         0.,
2438         250.);
2439     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta_ =
2440         ibook.book2D("BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLengthvsEta",
2441                      "MTD Track pathlength vs MTD track Eta;|#eta|;Pathlength",
2442                      30,
2443                      0,
2444                      1.5,
2445                      350,
2446                      0.0,
2447                      350.0);
2448     meBTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength_ = ibook.book1D(
2449         "BTLTrackMatchedTPmtdDirectWrongAssocTrackPathLength", "MTD Track pathlength ; ;Pathlength", 400, 0, 400);
2450 
2451     meBTLTrackMatchedTPmtdDirectNoAssocTrackNdf_ =
2452         ibook.book1D("BTLTrackMatchedTPmtdDirectNoAssocTrackNdf",
2453                      "Ndof of tracks matched to TP with sim hit in MTD (direct) - no track-MTD association; Ndof ",
2454                      80,
2455                      0.,
2456                      220);
2457     meBTLTrackMatchedTPmtdDirectNoAssocTrackChi2_ =
2458         ibook.book1D("BTLTrackMatchedTPmtdDirectNoAssocTrackChi2",
2459                      "Chi2 of tracks matched to TP with sim hit in MTD (direct) - no track-MTD association; Chi2 ",
2460                      80,
2461                      0.,
2462                      220);
2463     meBTLTrackMatchedTPmtdDirectNoAssocTrackOutermostHitR_ =
2464         ibook.book1D("BTLTrackMatchedTPmtdDirectNoAssocTrackOutermostHitR",
2465                      "Outermost hit position R of tracks matched to TP with sim hit in MTD (direct) - no track-MTD "
2466                      "association; R [cm]",
2467                      40,
2468                      0.,
2469                      120);
2470     meBTLTrackMatchedTPmtdDirectNoAssocSimClusSize_ =
2471         ibook.book1D("BTLTrackMatchedTPmtdDirectNoAssocSimClusSize",
2472                      "Size of the sim clusters associated to the reco cluster associated to the track (direct) - no "
2473                      "track-MTD association; Number of clusters ",
2474                      10,
2475                      -5.,
2476                      5.);
2477     meBTLTrackMatchedTPmtdDirectNoAssocRecoClusSize_ = ibook.book1D(
2478         "BTLTrackMatchedTPmtdDirectNoAssocRecoClusSize",
2479         "Size of the reco cluster associated to the track (direct) - no track-MTD association; Number of clusters ",
2480         10,
2481         -5.,
2482         5.);
2483 
2484     meBTLTrackMatchedTPnomtdAssocTrackChi2_ = ibook.book1D(
2485         "BTLTrackMatchedTPnomtdAssocTrackChi2", "Chi2 of tracks matched to TP w/o sim hit in MTD; Chi2", 80, 0., 220);
2486     meBTLTrackMatchedTPnomtdAssocTrackOutermostHitR_ =
2487         ibook.book1D("BTLTrackMatchedTPnomtdAssocTrackOutermostHitR",
2488                      "Outermost hit position R of tracks matched to TP w/o sim hit in MTD; R [cm]",
2489                      40,
2490                      0.,
2491                      120.);
2492     meBTLTrackMatchedTPnomtdAssocTrackNdf_ = ibook.book1D(
2493         "BTLTrackMatchedTPnomtdAssocTrackNdf", "Ndf of tracks matched to TP w/o sim hit in MTD; Ndof", 80, 0., 220);
2494     meBTLTrackMatchedTPnomtdAssocTrackIdOff_ =
2495         ibook.book1D("BTLTrackMatchedTPnomtdAssocTrackIdOff",
2496                      "TrackIdOff of simCluster matched to the reco cluster associated to the track,  TP w/o sim hit in "
2497                      "MTD; Track Id Off",
2498                      6,
2499                      -1.,
2500                      5.);
2501     meBTLTrackMatchedTPnomtdAssocSimClusSize_ =
2502         ibook.book1D("BTLTrackMatchedTPnomtdAssocSimClusSize",
2503                      "Size of the sim clusters associated to the reco cluster associated to the track (direct),  TP "
2504                      "w/o sim hit in MTD; Number of clusters ",
2505                      10,
2506                      -5.,
2507                      5.);
2508     meBTLTrackMatchedTPnomtdAssocRecoClusSize_ = ibook.book1D(
2509         "BTLTrackMatchedTPnomtdAssocRecoClusSize",
2510         "Size of the reco cluster associated to the track (direct),  TP w/o sim hit in MTD; Number of clusters ",
2511         10,
2512         -5.,
2513         5.);
2514     meBTLTrackMatchedTPnomtdAssocTrackID_ = ibook.book1D("BTLTrackMatchedTPnomtdAssocTrackID",
2515                                                          "Diff track raw ID, TP w/o sim hit in MTD ; diff track raw Id",
2516                                                          5,
2517                                                          -1.,
2518                                                          4.);
2519 
2520     meETLTrackMatchedTPmtd1CorrectAssocTimeChi2_ = ibook.book1D(
2521         "ETLTrackMatchedTPmtd1CorrectAssocTimeChi2",
2522         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; Chi2 ",
2523         200,
2524         0.,
2525         100);
2526     meETLTrackMatchedTPmtd1CorrectAssocTimeChi2vsMVAQual_ =
2527         ibook.book2D("ETLTrackMatchedTPmtd1CorrectAssocTimeChi2vsMVAQual",
2528                      "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; "
2529                      "Chi2; MVAQual ",
2530                      200,
2531                      0.,
2532                      100,
2533                      100,
2534                      -1,
2535                      1);
2536 
2537     meETLTrackMatchedTPmtd1WrongAssocTimeChi2_ = ibook.book1D(
2538         "ETLTrackMatchedTPmtd1WrongAssocTimeChi2",
2539         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2540         200,
2541         0.,
2542         100);
2543     meETLTrackMatchedTPmtd1WrongAssocTimeChi2vsMVAQual_ = ibook.book2D(
2544         "ETLTrackMatchedTPmtd1WrongAssocTimeChi2vsMVAQual",
2545         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2; MVAQual ",
2546         200,
2547         0.,
2548         100,
2549         100,
2550         -1,
2551         1);
2552 
2553     meETLTrackMatchedTPmtd2CorrectAssocTimeChi2_ = ibook.book1D(
2554         "ETLTrackMatchedTPmtd2CorrectAssocTimeChi2",
2555         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; Chi2 ",
2556         200,
2557         0.,
2558         100);
2559     meETLTrackMatchedTPmtd2CorrectAssocTimeChi2vsMVAQual_ =
2560         ibook.book2D("ETLTrackMatchedTPmtd2CorrectAssocTimeChi2vsMVAQual",
2561                      "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; "
2562                      "Chi2; MVAQual ",
2563                      200,
2564                      0.,
2565                      100,
2566                      100,
2567                      -1,
2568                      1);
2569 
2570     meETLTrackMatchedTPmtd2WrongAssocTimeChi2_ = ibook.book1D(
2571         "ETLTrackMatchedTPmtd2WrongAssocTimeChi2",
2572         "Time chi2 of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; Chi2 ",
2573         200,
2574         0.,
2575         100);
2576     meETLTrackMatchedTPmtd2WrongAssocTimeChi2vsMVAQual_ =
2577         ibook.book2D("ETLTrackMatchedTPmtd2WrongAssocTimeChi2vsMVAQual",
2578                      "Time chi2 vs MVA of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2579                      "association; Chi2; MVAQual ",
2580                      200,
2581                      0.,
2582                      100,
2583                      100,
2584                      -1,
2585                      1);
2586 
2587   }  // end optional plots
2588 
2589   meTrackResTot_ = ibook.book1D(
2590       "TrackRes", "t_{rec} - t_{sim} for LV associated tracks matched to TP; t_{rec} - t_{sim} [ns] ", 120, -0.15, 0.15);
2591   meTrackPullTot_ = ibook.book1D(
2592       "TrackPull", "Pull for LV associated tracks matched to TP; (t_{rec}-t_{sim})/#sigma_{t}", 50, -5., 5.);
2593   meTrackResTotvsMVAQual_ = ibook.bookProfile(
2594       "TrackResvsMVA",
2595       "t_{rec} - t_{sim} for LV associated tracks matched to TP vs MVA Quality; MVAQual; t_{rec} - t_{sim} [ns] ",
2596       100,
2597       -1.,
2598       1.,
2599       -0.15,
2600       0.15,
2601       "s");
2602   meTrackPullTotvsMVAQual_ = ibook.bookProfile(
2603       "TrackPullvsMVA",
2604       "Pull for LV associated tracks matched to TP vs MVA Quality; MVAQual; (t_{rec}-t_{sim})/#sigma_{t}",
2605       100,
2606       -1.,
2607       1.,
2608       -5.,
2609       5.,
2610       "s");
2611 
2612   meExtraPhiAtBTL_ = ibook.book1D(
2613       "ExtraPhiAtBTL", "Phi at BTL surface of extrapolated tracks associated to LV; phi [deg]", 720, -180., 180.);
2614   meExtraPhiAtBTLmatched_ =
2615       ibook.book1D("ExtraPhiAtBTLmatched",
2616                    "Phi at BTL surface of extrapolated tracks associated to LV matched with BTL hits; phi [deg]",
2617                    720,
2618                    -180.,
2619                    180.);
2620   meExtraBTLeneInCone_ =
2621       ibook.book1D("ExtraBTLeneInCone",
2622                    "BTL reconstructed energy in cone arounnd extrapolated track associated to LV; E [MeV]",
2623                    100,
2624                    0.,
2625                    50.);
2626   meExtraMTDfailExtenderEta_ =
2627       ibook.book1D("ExtraMTDfailExtenderEta",
2628                    "Eta of tracks associated to LV extrapolated to MTD with no track extender match to hits; track eta",
2629                    66,
2630                    0.,
2631                    3.3);
2632   meExtraMTDfailExtenderPt_ = ibook.book1D(
2633       "ExtraMTDfailExtenderPt",
2634       "Pt of tracks associated to LV extrapolated to MTD with no track extender match to hits; track pt [GeV] ",
2635       110,
2636       0.,
2637       11.);
2638 
2639   // Book the histograms for track-hit matching based on MC truth
2640   meBTLTrackMatchedTPmtdDirectEta_ =
2641       ibook.book1D("BTLTrackMatchedTPmtdDirectEta",
2642                    "Eta of tracks matched to TP with sim hit in MTD (direct);#eta_{RECO}",
2643                    30,
2644                    0.,
2645                    1.5);
2646   meBTLTrackMatchedTPmtdDirectPt_ =
2647       ibook.book1D("BTLTrackMatchedTPmtdDirectPt",
2648                    "Pt of tracks matched to TP with sim hit in MTD (direct); track pt [GeV]",
2649                    50,
2650                    0.,
2651                    10.);
2652 
2653   meBTLTrackMatchedTPmtdOtherEta_ = ibook.book1D("BTLTrackMatchedTPmtdOtherEta",
2654                                                  "Eta of tracks matched to TP with sim hit in MTD (other);#eta_{RECO}",
2655                                                  30,
2656                                                  0.,
2657                                                  1.5);
2658   meBTLTrackMatchedTPmtdOtherPt_ =
2659       ibook.book1D("BTLTrackMatchedTPmtdOtherPt",
2660                    "Pt of tracks matched to TP with sim hit in MTD (other); track pt [GeV]",
2661                    50,
2662                    0.,
2663                    10.);
2664 
2665   meBTLTrackMatchedTPnomtdEta_ = ibook.book1D(
2666       "BTLTrackMatchedTPnomtdEta", "Eta of tracks matched to TP w/o sim hit in MTD;#eta_{RECO}", 30, 0., 1.5);
2667   meBTLTrackMatchedTPnomtdPt_ = ibook.book1D(
2668       "BTLTrackMatchedTPnomtdPt", "Pt of tracks matched to TP w/o sim hit in MTD; track pt [GeV]", 50, 0., 10.);
2669 
2670   meBTLTrackMatchedTPmtdDirectCorrectAssocEta_ = ibook.book1D(
2671       "BTLTrackMatchedTPmtdDirectCorrectAssocEta",
2672       "Eta of tracks matched to TP with sim hit in MTD (direct), correct track-MTD association;#eta_{RECO}",
2673       30,
2674       0.,
2675       1.5);
2676   meBTLTrackMatchedTPmtdDirectCorrectAssocPt_ = ibook.book1D(
2677       "BTLTrackMatchedTPmtdDirectCorrectAssocPt",
2678       "Pt of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association;track pt [GeV]",
2679       50,
2680       0.,
2681       10.);
2682   meBTLTrackMatchedTPmtdDirectCorrectAssocMVAQual_ = ibook.book1D(
2683       "BTLTrackMatchedTPmtdDirectCorrectAssocMVAQual",
2684       "MVA of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; MVA score",
2685       100,
2686       -1.,
2687       1.);
2688   meBTLTrackMatchedTPmtdDirectCorrectAssocTimeRes_ =
2689       ibook.book1D("BTLTrackMatchedTPmtdDirectCorrectAssocTimeRes",
2690                    "Time resolution of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD "
2691                    "association; t_{rec} - t_{sim} [ns] ",
2692                    120,
2693                    -0.15,
2694                    0.15);
2695   meBTLTrackMatchedTPmtdDirectCorrectAssocTimePull_ =
2696       ibook.book1D("BTLTrackMatchedTPmtdDirectCorrectAssocTimePull",
2697                    "Time pull of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; "
2698                    "(t_{rec}-t_{sim})/#sigma_{t}",
2699                    50,
2700                    -5.,
2701                    5.);
2702 
2703   meBTLTrackMatchedTPmtdDirectWrongAssocEta_ =
2704       ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocEta",
2705                    "Eta of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;#eta_{RECO}",
2706                    30,
2707                    0.,
2708                    1.5);
2709 
2710   meBTLTrackMatchedTPmtdDirectWrongAssocPt_ = ibook.book1D(
2711       "BTLTrackMatchedTPmtdDirectWrongAssocPt",
2712       "Pt of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;track pt [GeV]",
2713       50,
2714       0.,
2715       10.);
2716   meBTLTrackMatchedTPmtdDirectWrongAssocMVAQual_ =
2717       ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocMVAQual",
2718                    "MVA of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; MVA score",
2719                    100,
2720                    -1.,
2721                    1.);
2722   meBTLTrackMatchedTPmtdDirectWrongAssocTimeRes_ =
2723       ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimeRes",
2724                    "Time resolution of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2725                    "association; t_{rec} - t_{sim} [ns] ",
2726                    120,
2727                    -0.15,
2728                    0.15);
2729   meBTLTrackMatchedTPmtdDirectWrongAssocTimePull_ =
2730       ibook.book1D("BTLTrackMatchedTPmtdDirectWrongAssocTimePull",
2731                    "Time pull of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; "
2732                    "(t_{rec}-t_{sim})/#sigma_{t}",
2733                    50,
2734                    -5.,
2735                    5.);
2736 
2737   meBTLTrackMatchedTPmtdDirectNoAssocEta_ =
2738       ibook.book1D("BTLTrackMatchedTPmtdDirectNoAssocEta",
2739                    "Eta of tracks matched to TP with sim hit in MTD (direct) - no track-MTD association;#eta_{RECO}",
2740                    30,
2741                    0.,
2742                    1.5);
2743   meBTLTrackMatchedTPmtdDirectNoAssocPt_ =
2744       ibook.book1D("BTLTrackMatchedTPmtdDirectNoAssocPt",
2745                    "Pt of tracks matched to TP with sim hit in MTD (direct) - no track-MTD association;track pt [GeV]",
2746                    50,
2747                    0.,
2748                    10.);
2749 
2750   meBTLTrackMatchedTPmtdOtherCorrectAssocEta_ = ibook.book1D(
2751       "BTLTrackMatchedTPmtdOtherCorrectAssocEta",
2752       "Eta of tracks matched to TP with sim hit in MTD (direct), correct track-MTD association;#eta_{RECO}",
2753       30,
2754       0.,
2755       1.5);
2756   meBTLTrackMatchedTPmtdOtherCorrectAssocPt_ = ibook.book1D(
2757       "BTLTrackMatchedTPmtdOtherCorrectAssocPt",
2758       "Pt of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association;track pt [GeV]",
2759       50,
2760       0.,
2761       10.);
2762   meBTLTrackMatchedTPmtdOtherCorrectAssocMVAQual_ = ibook.book1D(
2763       "BTLTrackMatchedTPmtdOtherCorrectAssocMVAQual",
2764       "MVA of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; MVA score",
2765       100,
2766       -1.,
2767       1.);
2768   meBTLTrackMatchedTPmtdOtherCorrectAssocTimeRes_ =
2769       ibook.book1D("BTLTrackMatchedTPmtdOtherCorrectAssocTimeRes",
2770                    "Time resolution of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD "
2771                    "association; t_{rec} - t_{sim} [ns] ",
2772                    120,
2773                    -0.15,
2774                    0.15);
2775   meBTLTrackMatchedTPmtdOtherCorrectAssocTimePull_ =
2776       ibook.book1D("BTLTrackMatchedTPmtdOtherCorrectAssocTimePull",
2777                    "Time pull of tracks matched to TP with sim hit in MTD (direct) - correct track-MTD association; "
2778                    "(t_{rec}-t_{sim})/#sigma_{t}",
2779                    50,
2780                    -5.,
2781                    5.);
2782 
2783   meBTLTrackMatchedTPmtdOtherWrongAssocEta_ =
2784       ibook.book1D("BTLTrackMatchedTPmtdOtherWrongAssocEta",
2785                    "Eta of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;#eta_{RECO}",
2786                    30,
2787                    0.,
2788                    1.5);
2789   meBTLTrackMatchedTPmtdOtherWrongAssocPt_ = ibook.book1D(
2790       "BTLTrackMatchedTPmtdOtherWrongAssocPt",
2791       "Pt of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association;track pt [GeV]",
2792       50,
2793       0.,
2794       10.);
2795   meBTLTrackMatchedTPmtdOtherWrongAssocMVAQual_ =
2796       ibook.book1D("BTLTrackMatchedTPmtdOtherWrongAssocMVAQual",
2797                    "MVA of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; MVA score",
2798                    100,
2799                    -1.,
2800                    1.);
2801   meBTLTrackMatchedTPmtdOtherWrongAssocTimeRes_ =
2802       ibook.book1D("BTLTrackMatchedTPmtdOtherWrongAssocTimeRes",
2803                    "Time resolution of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD "
2804                    "association; t_{rec} - t_{sim} [ns] ",
2805                    120,
2806                    -0.15,
2807                    0.15);
2808   meBTLTrackMatchedTPmtdOtherWrongAssocTimePull_ =
2809       ibook.book1D("BTLTrackMatchedTPmtdOtherWrongAssocTimePull",
2810                    "Time pull of tracks matched to TP with sim hit in MTD (direct) - wrong track-MTD association; "
2811                    "(t_{rec}-t_{sim})/#sigma_{t}",
2812                    50,
2813                    -5.,
2814                    5.);
2815 
2816   meBTLTrackMatchedTPmtdOtherNoAssocEta_ =
2817       ibook.book1D("BTLTrackMatchedTPmtdOtherNoAssocEta",
2818                    "Eta of tracks matched to TP with sim hit in MTD (direct) - no track-MTD association;#eta_{RECO}",
2819                    30,
2820                    0.,
2821                    1.5);
2822   meBTLTrackMatchedTPmtdOtherNoAssocPt_ =
2823       ibook.book1D("BTLTrackMatchedTPmtdOtherNoAssocPt",
2824                    "Pt of tracks matched to TP with sim hit in MTD (direct) - no track-MTD association;track pt [GeV]",
2825                    50,
2826                    0.,
2827                    10.);
2828 
2829   meBTLTrackMatchedTPnomtdAssocEta_ =
2830       ibook.book1D("BTLTrackMatchedTPnomtdAssocEta",
2831                    "Eta of tracks matched to TP w/o sim hit in MTD, with associated reco cluster;#eta_{RECO}",
2832                    30,
2833                    0.,
2834                    1.5);
2835   meBTLTrackMatchedTPnomtdAssocPt_ =
2836       ibook.book1D("BTLTrackMatchedTPnomtdAssocPt",
2837                    "Pt of tracks matched to TP w/o sim hit in MTD, with associated reco cluster;track pt [GeV]",
2838                    50,
2839                    0.,
2840                    10.);
2841   meBTLTrackMatchedTPnomtdAssocMVAQual_ =
2842       ibook.book1D("BTLTrackMatchedTPnomtdAssocMVAQual",
2843                    "MVA of tracks matched to TP w/o sim hit in MTD, with associated reco cluster; MVA score",
2844                    100,
2845                    -1.,
2846                    1.);
2847   meBTLTrackMatchedTPnomtdAssocTimeRes_ = ibook.book1D("BTLTrackMatchedTPnomtdAssocTimeRes",
2848                                                        "Time resolution of tracks matched to TP w/o sim hit in MTD, "
2849                                                        "with associated reco cluster; t_{rec} - t_{sim} [ns] ",
2850                                                        120,
2851                                                        -0.15,
2852                                                        0.15);
2853   meBTLTrackMatchedTPnomtdAssocTimePull_ = ibook.book1D("BTLTrackMatchedTPnomtdAssocTimePull",
2854                                                         "Time pull of tracks matched to TP w/o sim hit in MTD, with "
2855                                                         "associated reco cluster; (t_{rec}-t_{sim})/#sigma_{t}",
2856                                                         50,
2857                                                         -5.,
2858                                                         5.);
2859 
2860   meETLTrackMatchedTPmtd1Eta_ = ibook.book1D("ETLTrackMatchedTPmtd1Eta",
2861                                              "Eta of tracks matched to TP with sim hit in MTD (>= 1 hit);#eta_{RECO}",
2862                                              30,
2863                                              1.5,
2864                                              3.0);
2865   meETLTrackMatchedTPmtd1Pt_ = ibook.book1D("ETLTrackMatchedTPmtd1Pt",
2866                                             "Pt of tracks matched to TP with sim hit in MTD (>= 1 hit); track pt [GeV]",
2867                                             50,
2868                                             0.,
2869                                             10.);
2870 
2871   meETLTrackMatchedTPmtd2Eta_ = ibook.book1D(
2872       "ETLTrackMatchedTPmtd2Eta", "Eta of tracks matched to TP with sim hit in MTD (2 hits);#eta_{RECO}", 30, 1.5, 3.0);
2873   meETLTrackMatchedTPmtd2Pt_ = ibook.book1D(
2874       "ETLTrackMatchedTPmtd2Pt", "Pt of tracks matched to TP with sim hit in MTD (2 hits); track pt [GeV]", 50, 0., 10.);
2875 
2876   meETLTrackMatchedTPnomtdEta_ = ibook.book1D(
2877       "ETLTrackMatchedTPnomtdEta", "Eta of tracks matched to TP w/o sim hit in MTD;#eta_{RECO}", 30, 1.5, 3.0);
2878   meETLTrackMatchedTPnomtdPt_ = ibook.book1D(
2879       "ETLTrackMatchedTPnomtdPt", "Pt of tracks matched to TP w/o sim hit in MTD; track pt [GeV]", 50, 0., 10.);
2880 
2881   meETLTrackMatchedTPmtd1CorrectAssocEta_ = ibook.book1D(
2882       "ETLTrackMatchedTPmtd1CorrectAssocEta",
2883       "Eta of tracks matched to TP with sim hit in MTD (>= 1 hit), correct track-MTD association;#eta_{RECO}",
2884       30,
2885       1.5,
2886       3.0);
2887   meETLTrackMatchedTPmtd1CorrectAssocPt_ = ibook.book1D(
2888       "ETLTrackMatchedTPmtd1CorrectAssocPt",
2889       "Pt of tracks matched to TP with sim hit in MTD (>= 1 hit) - correct track-MTD association;track pt [GeV]",
2890       50,
2891       0.,
2892       10.);
2893   meETLTrackMatchedTPmtd1CorrectAssocMVAQual_ = ibook.book1D(
2894       "ETLTrackMatchedTPmtd1CorrectAssocMVAQual",
2895       "MVA of tracks matched to TP with sim hit in MTD (>= 1 hit) - correct track-MTD association; MVA score",
2896       100,
2897       -1.,
2898       1.);
2899   meETLTrackMatchedTPmtd1CorrectAssocTimeRes_ =
2900       ibook.book1D("ETLTrackMatchedTPmtd1CorrectAssocTimeRes",
2901                    "Time resolution of tracks matched to TP with sim hit in MTD (>= 1 hit) - correct track-MTD "
2902                    "association; t_{rec} - t_{sim} [ns] ",
2903                    120,
2904                    -0.15,
2905                    0.15);
2906   meETLTrackMatchedTPmtd1CorrectAssocTimePull_ =
2907       ibook.book1D("ETLTrackMatchedTPmtd1CorrectAssocTimePull",
2908                    "Time pull of tracks matched to TP with sim hit in MTD (>= 1 hit) - correct track-MTD association; "
2909                    "(t_{rec}-t_{sim})/#sigma_{t}",
2910                    50,
2911                    -5.,
2912                    5.);
2913 
2914   meETLTrackMatchedTPmtd2CorrectAssocEta_ = ibook.book1D(
2915       "ETLTrackMatchedTPmtd2CorrectAssocEta",
2916       "Eta of tracks matched to TP with sim hit in MTD (2 hits), correct track-MTD association;#eta_{RECO}",
2917       30,
2918       1.5,
2919       3.0);
2920   meETLTrackMatchedTPmtd2CorrectAssocPt_ = ibook.book1D(
2921       "ETLTrackMatchedTPmtd2CorrectAssocPt",
2922       "Pt of tracks matched to TP with sim hit in MTD (2 hits) - correct track-MTD association;track pt [GeV]",
2923       50,
2924       0.,
2925       10.);
2926   meETLTrackMatchedTPmtd2CorrectAssocMVAQual_ = ibook.book1D(
2927       "ETLTrackMatchedTPmtd2CorrectAssocMVAQual",
2928       "MVA of tracks matched to TP with sim hit in MTD (2 hits) - correct track-MTD association; MVA score",
2929       100,
2930       -1.,
2931       1.);
2932   meETLTrackMatchedTPmtd2CorrectAssocTimeRes_ =
2933       ibook.book1D("ETLTrackMatchedTPmtd2CorrectAssocTimeRes",
2934                    "Time resolution of tracks matched to TP with sim hit in MTD (2 hits) - correct track-MTD "
2935                    "association; t_{rec} - t_{sim} [ns] ",
2936                    120,
2937                    -0.15,
2938                    0.15);
2939   meETLTrackMatchedTPmtd2CorrectAssocTimePull_ =
2940       ibook.book1D("ETLTrackMatchedTPmtd2CorrectAssocTimePull",
2941                    "Time pull of tracks matched to TP with sim hit in MTD (2 hits) - correct track-MTD association; "
2942                    "(t_{rec}-t_{sim})/#sigma_{t}",
2943                    50,
2944                    -5.,
2945                    5.);
2946 
2947   meETLTrackMatchedTPmtd1WrongAssocEta_ = ibook.book1D(
2948       "ETLTrackMatchedTPmtd1WrongAssocEta",
2949       "Eta of tracks matched to TP with sim hit in MTD (>= 1 hit), wrong track-MTD association;#eta_{RECO}",
2950       30,
2951       1.5,
2952       3.0);
2953   meETLTrackMatchedTPmtd1WrongAssocPt_ = ibook.book1D(
2954       "ETLTrackMatchedTPmtd1WrongAssocPt",
2955       "Pt of tracks matched to TP with sim hit in MTD (>= 1 hit) - wrong track-MTD association;track pt [GeV]",
2956       50,
2957       0.,
2958       10.);
2959   meETLTrackMatchedTPmtd1WrongAssocMVAQual_ = ibook.book1D(
2960       "ETLTrackMatchedTPmtd1WrongAssocMVAQual",
2961       "MVA of tracks matched to TP with sim hit in MTD (>= 1 hit) - wrong track-MTD association; MVA score",
2962       100,
2963       -1.,
2964       1.);
2965   meETLTrackMatchedTPmtd1WrongAssocTimeRes_ =
2966       ibook.book1D("ETLTrackMatchedTPmtd1WrongAssocTimeRes",
2967                    "Time resolution of tracks matched to TP with sim hit in MTD (>= 1 hit) - wrong track-MTD "
2968                    "association; t_{rec} - t_{sim} [ns] ",
2969                    120,
2970                    -0.15,
2971                    0.15);
2972   meETLTrackMatchedTPmtd1WrongAssocTimePull_ =
2973       ibook.book1D("ETLTrackMatchedTPmtd1WrongAssocTimePull",
2974                    "Time pull of tracks matched to TP with sim hit in MTD (>= 1 hit) - wrong track-MTD association; "
2975                    "(t_{rec}-t_{sim})/#sigma_{t}",
2976                    50,
2977                    -5.,
2978                    5.);
2979 
2980   meETLTrackMatchedTPmtd2WrongAssocEta_ =
2981       ibook.book1D("ETLTrackMatchedTPmtd2WrongAssocEta",
2982                    "Eta of tracks matched to TP with sim hit in MTD (2 hits), wrong track-MTD association;#eta_{RECO}",
2983                    30,
2984                    1.5,
2985                    3.0);
2986   meETLTrackMatchedTPmtd2WrongAssocPt_ = ibook.book1D(
2987       "ETLTrackMatchedTPmtd2WrongAssocPt",
2988       "Pt of tracks matched to TP with sim hit in MTD (2 hits) - wrong track-MTD association;track pt [GeV]",
2989       50,
2990       0.,
2991       10.);
2992   meETLTrackMatchedTPmtd2WrongAssocMVAQual_ =
2993       ibook.book1D("ETLTrackMatchedTPmtd2WrongAssocMVAQual",
2994                    "MVA of tracks matched to TP with sim hit in MTD (2 hits) - wrong track-MTD association; MVA score",
2995                    100,
2996                    -1.,
2997                    1.);
2998   meETLTrackMatchedTPmtd2WrongAssocTimeRes_ =
2999       ibook.book1D("ETLTrackMatchedTPmtd2WrongAssocTimeRes",
3000                    "Time resolution of tracks matched to TP with sim hit in MTD (2 hits) - wrong track-MTD "
3001                    "association; t_{rec} - t_{sim} [ns] ",
3002                    120,
3003                    -0.15,
3004                    0.15);
3005   meETLTrackMatchedTPmtd2WrongAssocTimePull_ =
3006       ibook.book1D("ETLTrackMatchedTPmtd2WrongAssocTimePull",
3007                    "Time pull of tracks matched to TP with sim hit in MTD (2 hits) - wrong track-MTD association; "
3008                    "(t_{rec}-t_{sim})/#sigma_{t}",
3009                    50,
3010                    -5.,
3011                    5.);
3012 
3013   meETLTrackMatchedTPmtd1NoAssocEta_ = ibook.book1D(
3014       "ETLTrackMatchedTPmtd1NoAssocEta",
3015       "Eta of tracks matched to TP with sim hit in MTD (>= 1 hit), missing track-MTD association;#eta_{RECO}",
3016       30,
3017       1.5,
3018       3.0);
3019   meETLTrackMatchedTPmtd1NoAssocPt_ = ibook.book1D(
3020       "ETLTrackMatchedTPmtd1NoAssocPt",
3021       "Pt of tracks matched to TP with sim hit in MTD (>= 1 hit) - missing track-MTD association;track pt [GeV]",
3022       50,
3023       0.,
3024       10.);
3025 
3026   meETLTrackMatchedTPmtd2NoAssocEta_ = ibook.book1D(
3027       "ETLTrackMatchedTPmtd2NoAssocEta",
3028       "Eta of tracks matched to TP with sim hit in MTD (2 hits), missing track-MTD association;#eta_{RECO}",
3029       30,
3030       1.5,
3031       3.0);
3032   meETLTrackMatchedTPmtd2NoAssocPt_ = ibook.book1D(
3033       "ETLTrackMatchedTPmtd2NoAssocPt",
3034       "Pt of tracks matched to TP with sim hit in MTD (2 hits) - missing track-MTD association;track pt [GeV]",
3035       50,
3036       0.,
3037       10.);
3038   meETLTrackMatchedTPnomtdAssocEta_ =
3039       ibook.book1D("ETLTrackMatchedTPnomtdAssocEta",
3040                    "Eta of tracks matched to TP w/o sim hit in MTD, with associated reco cluster;#eta_{RECO}",
3041                    30,
3042                    1.5,
3043                    3.0);
3044   meETLTrackMatchedTPnomtdAssocPt_ =
3045       ibook.book1D("ETLTrackMatchedTPnomtdAssocPt",
3046                    "Pt of tracks matched to TP w/o sim hit in MTD, with associated reco cluster;track pt [GeV]",
3047                    50,
3048                    0.,
3049                    10.);
3050   meETLTrackMatchedTPnomtdAssocMVAQual_ =
3051       ibook.book1D("ETLTrackMatchedTPnomtdAssocMVAQual",
3052                    "MVA of tracks matched to TP w/o sim hit in MTD, with associated reco cluster; MVA score",
3053                    100,
3054                    -1.,
3055                    1.);
3056   meETLTrackMatchedTPnomtdAssocTimeRes_ = ibook.book1D("ETLTrackMatchedTPnomtdAssocTimeRes",
3057                                                        "Time resolution of tracks matched to TP w/o sim hit in MTD, "
3058                                                        "with associated reco cluster; t_{rec} - t_{sim} [ns] ",
3059                                                        120,
3060                                                        -0.15,
3061                                                        0.15);
3062   meETLTrackMatchedTPnomtdAssocTimePull_ = ibook.book1D("ETLTrackMatchedTPnomtdAssocTimePull",
3063                                                         "Time pull of tracks matched to TP w/o sim hit in MTD, with "
3064                                                         "associated reco cluster; (t_{rec}-t_{sim})/#sigma_{t}",
3065                                                         50,
3066                                                         -5.,
3067                                                         5.);
3068 }
3069 
3070 // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
3071 
3072 void MtdTracksValidation::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
3073   edm::ParameterSetDescription desc;
3074 
3075   desc.add<std::string>("folder", "MTD/Tracks");
3076   desc.add<bool>("optionalPlots", false);
3077   desc.add<edm::InputTag>("inputTagG", edm::InputTag("generalTracks"));
3078   desc.add<edm::InputTag>("inputTagT", edm::InputTag("trackExtenderWithMTD"));
3079   desc.add<edm::InputTag>("inputTagV", edm::InputTag("offlinePrimaryVertices4D"));
3080   desc.add<edm::InputTag>("inputTagH", edm::InputTag("generatorSmeared"));
3081   desc.add<edm::InputTag>("SimTag", edm::InputTag("mix", "MergedTrackTruth"));
3082   desc.add<edm::InputTag>("TPtoRecoTrackAssoc", edm::InputTag("trackingParticleRecoTrackAsssociation"));
3083   desc.add<edm::InputTag>("tp2SimAssociationMapTag", edm::InputTag("mtdSimLayerClusterToTPAssociation"));
3084   desc.add<edm::InputTag>("Sim2tpAssociationMapTag", edm::InputTag("mtdSimLayerClusterToTPAssociation"));
3085   desc.add<edm::InputTag>("r2sAssociationMapTag", edm::InputTag("mtdRecoClusterToSimLayerClusterAssociation"));
3086   desc.add<edm::InputTag>("btlRecHits", edm::InputTag("mtdRecHits", "FTLBarrel"));
3087   desc.add<edm::InputTag>("etlRecHits", edm::InputTag("mtdRecHits", "FTLEndcap"));
3088   desc.add<edm::InputTag>("recCluTagBTL", edm::InputTag("mtdClusters", "FTLBarrel"));
3089   desc.add<edm::InputTag>("recCluTagETL", edm::InputTag("mtdClusters", "FTLEndcap"));
3090   desc.add<edm::InputTag>("tmtd", edm::InputTag("trackExtenderWithMTD:generalTracktmtd"));
3091   desc.add<edm::InputTag>("sigmatmtd", edm::InputTag("trackExtenderWithMTD:generalTracksigmatmtd"));
3092   desc.add<edm::InputTag>("t0Src", edm::InputTag("trackExtenderWithMTD:generalTrackt0"));
3093   desc.add<edm::InputTag>("sigmat0Src", edm::InputTag("trackExtenderWithMTD:generalTracksigmat0"));
3094   desc.add<edm::InputTag>("trackAssocSrc", edm::InputTag("trackExtenderWithMTD:generalTrackassoc"))
3095       ->setComment("Association between General and MTD Extended tracks");
3096   desc.add<edm::InputTag>("pathLengthSrc", edm::InputTag("trackExtenderWithMTD:generalTrackPathLength"));
3097   desc.add<edm::InputTag>("btlMatchTimeChi2", edm::InputTag("trackExtenderWithMTD:btlMatchTimeChi2"));
3098   desc.add<edm::InputTag>("etlMatchTimeChi2", edm::InputTag("trackExtenderWithMTD:etlMatchTimeChi2"));
3099   desc.add<edm::InputTag>("btlMatchChi2", edm::InputTag("trackExtenderWithMTD:btlMatchChi2"));
3100   desc.add<edm::InputTag>("t0SafePID", edm::InputTag("tofPID:t0safe"));
3101   desc.add<edm::InputTag>("sigmat0SafePID", edm::InputTag("tofPID:sigmat0safe"));
3102   desc.add<edm::InputTag>("sigmat0PID", edm::InputTag("tofPID:sigmat0"));
3103   desc.add<edm::InputTag>("t0PID", edm::InputTag("tofPID:t0"));
3104   desc.add<edm::InputTag>("sigmaTofPi", edm::InputTag("trackExtenderWithMTD:generalTrackSigmaTofPi"));
3105   desc.add<edm::InputTag>("sigmaTofK", edm::InputTag("trackExtenderWithMTD:generalTrackSigmaTofK"));
3106   desc.add<edm::InputTag>("sigmaTofP", edm::InputTag("trackExtenderWithMTD:generalTrackSigmaTofP"));
3107   desc.add<edm::InputTag>("trackMVAQual", edm::InputTag("mtdTrackQualityMVA:mtdQualMVA"));
3108   desc.add<edm::InputTag>("outermostHitPositionSrc",
3109                           edm::InputTag("trackExtenderWithMTD:generalTrackOutermostHitPosition"));
3110   desc.add<double>("trackMaximumPt", 12.);  // [GeV]
3111   desc.add<double>("trackMaximumBtlEta", 1.5);
3112   desc.add<double>("trackMinimumEtlEta", 1.6);
3113   desc.add<double>("trackMaximumEtlEta", 3.);
3114 
3115   descriptions.add("mtdTracksValid", desc);
3116 }
3117 
3118 const bool MtdTracksValidation::trkTPSelLV(const TrackingParticle& tp) {
3119   bool match = (tp.status() != 1) ? false : true;
3120   return match;
3121 }
3122 
3123 const bool MtdTracksValidation::trkTPSelAll(const TrackingParticle& tp) {
3124   bool match = false;
3125 
3126   auto x_pv = tp.parentVertex()->position().x();
3127   auto y_pv = tp.parentVertex()->position().y();
3128   auto z_pv = tp.parentVertex()->position().z();
3129 
3130   auto r_pv = std::sqrt(x_pv * x_pv + y_pv * y_pv);
3131 
3132   match = tp.charge() != 0 && std::abs(tp.eta()) < etacutGEN_ && tp.pt() > pTcutBTL_ && r_pv < rBTL_ &&
3133           std::abs(z_pv) < zETL_;
3134   return match;
3135 }
3136 
3137 const bool MtdTracksValidation::trkRecSel(const reco::TrackBase& trk) {
3138   bool match = false;
3139   match = std::abs(trk.eta()) <= etacutREC_ && trk.pt() > pTcutBTL_;
3140   return match;
3141 }
3142 
3143 const bool MtdTracksValidation::trkRecSelLowPt(const reco::TrackBase& trk) {
3144   bool match = false;
3145   match = std::abs(trk.eta()) <= etacutREC_ && trk.pt() > pTcutETL_ && trk.pt() < pTcutBTL_;
3146   return match;
3147 }
3148 
3149 const edm::Ref<std::vector<TrackingParticle>>* MtdTracksValidation::getMatchedTP(const reco::TrackBaseRef& recoTrack) {
3150   auto found = r2s_->find(recoTrack);
3151 
3152   // reco track not matched to any TP
3153   if (found == r2s_->end())
3154     return nullptr;
3155 
3156   //matched TP equal to any TP associated to in time events
3157   for (const auto& tp : found->val) {
3158     if (tp.first->eventId().bunchCrossing() == 0)
3159       return &tp.first;
3160   }
3161 
3162   // reco track not matched to any TP from vertex
3163   return nullptr;
3164 }
3165 
3166 void MtdTracksValidation::fillTrackClusterMatchingHistograms(MonitorElement* me1,
3167                                                              MonitorElement* me2,
3168                                                              MonitorElement* me3,
3169                                                              MonitorElement* me4,
3170                                                              MonitorElement* me5,
3171                                                              float var1,
3172                                                              float var2,
3173                                                              float var3,
3174                                                              float var4,
3175                                                              float var5,
3176                                                              bool flag) {
3177   me1->Fill(var1);
3178   me2->Fill(var2);
3179   if (flag) {
3180     me3->Fill(var3);
3181     me4->Fill(var4);
3182     me5->Fill(var5);
3183   }
3184 }
3185 
3186 DEFINE_FWK_MODULE(MtdTracksValidation);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!