Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2025-06-03 00:12:12 

0001 
0002 //////////////////////////////////////////////////////////////////////
0003 //                                                                  //
0004 //  Analyzer for making mini-ntuple for L1 track performance plots  //
0005 //                                                                  //
0006 //////////////////////////////////////////////////////////////////////
0007 
0008 ////////////////////
0009 // FRAMEWORK HEADERS
0010 #include "FWCore/PluginManager/interface/ModuleDef.h"
0011 #include "FWCore/Framework/interface/MakerMacros.h"
0012 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0013 #include "FWCore/Framework/interface/Event.h"
0014 #include "FWCore/Framework/interface/EventSetup.h"
0015 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0016 #include "FWCore/Utilities/interface/InputTag.h"
0017 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0018 #include "FWCore/ServiceRegistry/interface/Service.h"
0019 
0020 ///////////////////////
0021 // DATA FORMATS HEADERS
0022 #include "DataFormats/Common/interface/Handle.h"
0023 #include "DataFormats/Common/interface/Ref.h"
0024 
0025 #include "DataFormats/L1TrackTrigger/interface/TTTypes.h"
0026 #include "DataFormats/L1TrackTrigger/interface/TTCluster.h"
0027 #include "DataFormats/L1TrackTrigger/interface/TTStub.h"
0028 #include "DataFormats/L1TrackTrigger/interface/TTTrack.h"
0029 #include "DataFormats/L1TrackTrigger/interface/TTTrack_TrackWord.h"
0030 #include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
0031 #include "SimDataFormats/TrackingAnalysis/interface/TrackingVertex.h"
0032 #include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h"
0033 #include "SimDataFormats/TrackingHit/interface/PSimHit.h"
0034 #include "SimDataFormats/Vertex/interface/SimVertex.h"
0035 #include "SimDataFormats/Associations/interface/TTClusterAssociationMap.h"
0036 #include "SimDataFormats/Associations/interface/TTStubAssociationMap.h"
0037 #include "SimDataFormats/Associations/interface/TTTrackAssociationMap.h"
0038 #include "Geometry/Records/interface/StackedTrackerGeometryRecord.h"
0039 
0040 #include "DataFormats/JetReco/interface/GenJetCollection.h"
0041 #include "DataFormats/JetReco/interface/GenJet.h"
0042 
0043 ////////////////////////////
0044 // DETECTOR GEOMETRY HEADERS
0045 #include "MagneticField/Engine/interface/MagneticField.h"
0046 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
0047 #include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h"
0048 #include "Geometry/Records/interface/TrackerDigiGeometryRecord.h"
0049 #include "Geometry/CommonDetUnit/interface/GeomDetType.h"
0050 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
0051 
0052 #include "Geometry/CommonTopologies/interface/PixelGeomDetUnit.h"
0053 #include "Geometry/CommonTopologies/interface/PixelGeomDetType.h"
0054 #include "Geometry/TrackerGeometryBuilder/interface/PixelTopologyBuilder.h"
0055 #include "Geometry/Records/interface/StackedTrackerGeometryRecord.h"
0056 
0057 ////////////////
0058 // PHYSICS TOOLS
0059 #include "CommonTools/UtilAlgos/interface/TFileService.h"
0060 
0061 //My additions
0062 #include "DataFormats/L1TCorrelator/interface/TkJet.h"
0063 #include "DataFormats/L1TCorrelator/interface/TkJetFwd.h"
0064 #include "DataFormats/L1Trigger/interface/TkJetWord.h"
0065 #include "DataFormats/L1TCorrelator/interface/TkTriplet.h"
0066 #include "DataFormats/L1TCorrelator/interface/TkTripletFwd.h"
0067 #include "DataFormats/Math/interface/LorentzVector.h"
0068 #include "DataFormats/L1TCorrelator/interface/TkEtMiss.h"
0069 #include "DataFormats/L1TCorrelator/interface/TkEtMissFwd.h"
0070 #include "DataFormats/L1TCorrelator/interface/TkHTMiss.h"
0071 #include "DataFormats/L1TCorrelator/interface/TkHTMissFwd.h"
0072 #include "DataFormats/L1Trigger/interface/Vertex.h"
0073 #include "DataFormats/L1Trigger/interface/VertexWord.h"
0074 #include "DataFormats/L1Trigger/interface/EtSum.h"
0075 #include "L1Trigger/L1TTrackMatch/interface/L1TkEtMissEmuAlgo.h"
0076 #include "L1Trigger/L1TTrackMatch/interface/L1TkHTMissEmulatorProducer.h"
0077 #include "DataFormats/L1Trigger/interface/DisplacedVertex.h"
0078 #include "L1Trigger/L1TTrackMatch/plugins/L1TrackUnpacker.h"
0079 
0080 ///////////////
0081 // ROOT HEADERS
0082 #include <TROOT.h>
0083 #include <TCanvas.h>
0084 #include <TTree.h>
0085 #include <TFile.h>
0086 #include <TF1.h>
0087 #include <TH2F.h>
0088 #include <TH1F.h>
0089 #include <TLorentzVector.h>
0090 
0091 //////////////
0092 // STD HEADERS
0093 #include <memory>
0094 #include <string>
0095 #include <iostream>
0096 
0097 #include <ap_int.h>
0098 
0099 //////////////
0100 // NAMESPACES
0101 using namespace std;
0102 using namespace edm;
0103 
0104 //////////////////////////////
0105 //                          //
0106 //     CLASS DEFINITION     //
0107 //                          //
0108 //////////////////////////////
0109 
0110 class L1TrackObjectNtupleMaker : public edm::one::EDAnalyzer<edm::one::SharedResources> {
0111 private:
0112   // ----------constants, enums and typedefs ---------
0113   typedef TTTrack<Ref_Phase2TrackerDigi_> L1Track;
0114   typedef edm::Ptr<L1Track> L1TrackPtr;
0115   typedef std::vector<L1TrackPtr> L1TrackPtrCollection;
0116   typedef std::vector<L1Track> L1TrackCollection;
0117   typedef edm::Ref<L1TrackCollection> L1TrackRef;
0118   typedef edm::RefVector<L1TrackCollection> L1TrackRefCollection;
0119   typedef ap_fixed<TTTrack_TrackWord::TrackBitWidths::kTanlSize, 3, AP_TRN, AP_SAT> glbeta_intern;
0120   typedef ap_int<TTTrack_TrackWord::TrackBitWidths::kPhiSize + 4> glbphi_intern;
0121 
0122 public:
0123   // Constructor/destructor
0124   explicit L1TrackObjectNtupleMaker(const edm::ParameterSet& iConfig);
0125   ~L1TrackObjectNtupleMaker() override;
0126 
0127   template <typename T>
0128   bool isHard(T particle);
0129   double DoublePtFromBits(const L1Track&) const;
0130   double DoubleEtaFromBits(const L1Track&) const;
0131   double DoublePhiFromBits(const L1Track&) const;
0132   int ChargeFromBits(const L1Track&) const;
0133   double convertPtToR(double pt);
0134 
0135   // Mandatory methods
0136   void beginJob() override;
0137   void endJob() override;
0138   void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) override;
0139 
0140   // Other member functions
0141   int getSelectedTrackIndex(const L1TrackRef& trackRef,
0142                             const edm::Handle<L1TrackRefCollection>& selectedTrackRefs) const;
0143   int getSelectedTrackPtrIndex(const L1TrackPtr& trackPtr, const edm::Handle<L1TrackCollection>& trackCollection) const;
0144 
0145 private:
0146   //-----------------------------------------------------------------------------------------------
0147   // Containers of parameters passed by python configuration file
0148   edm::ParameterSet config;
0149 
0150   int MyProcess;       // 11/13/211 for single electrons/muons/pions, 6/15 for pions from ttbar/taus, 1 for inclusive
0151   bool DebugMode;      // lots of debug printout statements
0152   bool SaveAllTracks;  // store in ntuples not only truth-matched tracks but ALL tracks
0153   bool SaveStubs;      // option to save also stubs in the ntuples (makes them large...)
0154   string Displaced;    // "Prompt", "Displaced", "Both"
0155   int TP_minNStub;  // require TPs to have >= minNStub (defining efficiency denominator) (==0 means to only require >= 1 cluster)
0156   int TP_minNStubLayer;  // require TPs to have stubs in >= minNStubLayer layers/disks (defining efficiency denominator)
0157   double TP_minPt;       // save TPs with pt > minPt
0158   double TP_maxEta;      // save TPs with |eta| < maxEta
0159   double TP_maxZ0;       // save TPs with |z0| < maxZ0
0160   int L1Tk_minNStub;     // require L1 tracks to have >= minNStub (this is mostly for tracklet purposes)
0161   bool SaveTrackJets;
0162   bool SaveTrackSums;
0163   bool runDispVert;
0164 
0165   edm::InputTag L1TrackInputTag;                                              // L1 track collection
0166   edm::InputTag MCTruthTrackInputTag;                                         // MC truth collection
0167   edm::InputTag SimVertexInputTag;                                            // MC truth vertex collection
0168   edm::InputTag L1TrackGTTInputTag;                                           // L1 track collection
0169   edm::InputTag L1TrackSelectedInputTag;                                      // L1 track collection
0170   edm::InputTag L1TrackSelectedEmulationInputTag;                             // L1 track collection
0171   edm::InputTag L1TrackSelectedAssociatedInputTag;                            // L1 track collection
0172   edm::InputTag L1TrackSelectedAssociatedEmulationInputTag;                   // L1 track collection
0173   edm::InputTag L1TrackSelectedForJetsInputTag;                               // L1 track collection
0174   edm::InputTag L1TrackSelectedEmulationForJetsInputTag;                      // L1 track collection
0175   edm::InputTag L1TrackSelectedAssociatedForJetsInputTag;                     // L1 track collection
0176   edm::InputTag L1TrackSelectedAssociatedEmulationForJetsInputTag;            // L1 track collection
0177   edm::InputTag L1TrackSelectedForEtMissInputTag;                             // L1 track collection
0178   edm::InputTag L1TrackSelectedEmulationForEtMissInputTag;                    // L1 track collection
0179   edm::InputTag L1TrackSelectedAssociatedForEtMissInputTag;                   // L1 track collection
0180   edm::InputTag L1TrackSelectedAssociatedEmulationForEtMissInputTag;          // L1 track collection
0181   edm::InputTag L1TrackExtendedInputTag;                                      // L1 track collection
0182   edm::InputTag MCTruthTrackExtendedInputTag;                                 // MC truth collection
0183   edm::InputTag L1TrackExtendedGTTInputTag;                                   // L1 track collection
0184   edm::InputTag L1TrackExtendedSelectedInputTag;                              // L1 track collection
0185   edm::InputTag L1TrackExtendedSelectedEmulationInputTag;                     // L1 track collection
0186   edm::InputTag L1TrackExtendedSelectedAssociatedInputTag;                    // L1 track collection
0187   edm::InputTag L1TrackExtendedSelectedAssociatedEmulationInputTag;           // L1 track collection
0188   edm::InputTag L1TrackExtendedSelectedForJetsInputTag;                       // L1 track collection
0189   edm::InputTag L1TrackExtendedSelectedEmulationForJetsInputTag;              // L1 track collection
0190   edm::InputTag L1TrackExtendedSelectedAssociatedForJetsInputTag;             // L1 track collection
0191   edm::InputTag L1TrackExtendedSelectedAssociatedEmulationForJetsInputTag;    // L1 track collection
0192   edm::InputTag L1TrackExtendedSelectedForEtMissInputTag;                     // L1 track collection
0193   edm::InputTag L1TrackExtendedSelectedEmulationForEtMissInputTag;            // L1 track collection
0194   edm::InputTag L1TrackExtendedSelectedAssociatedForEtMissInputTag;           // L1 track collection
0195   edm::InputTag L1TrackExtendedSelectedAssociatedEmulationForEtMissInputTag;  // L1 track collection
0196   edm::InputTag MCTruthClusterInputTag;
0197   edm::InputTag L1StubInputTag;
0198   edm::InputTag MCTruthStubInputTag;
0199   edm::InputTag TrackingParticleInputTag;
0200   edm::InputTag TrackingVertexInputTag;
0201   edm::InputTag GenJetInputTag;
0202   edm::InputTag RecoVertexInputTag;
0203   edm::InputTag RecoVertexEmuInputTag;
0204   edm::InputTag GenParticleInputTag;
0205   edm::InputTag DisplacedVertexInputTag;
0206 
0207   edm::InputTag TrackFastJetsInputTag;
0208   edm::InputTag TrackJetsInputTag;
0209   edm::InputTag TrackJetsEmuInputTag;
0210   edm::InputTag TrackTripletsInputTag;
0211 
0212   edm::InputTag TrackMETInputTag;
0213   edm::InputTag TrackMETEmuInputTag;
0214   edm::InputTag TrackMHTInputTag;
0215   edm::InputTag TrackMHTEmuInputTag;
0216 
0217   edm::InputTag TrackFastJetsExtendedInputTag;
0218   edm::InputTag TrackJetsExtendedInputTag;
0219   edm::InputTag TrackJetsExtendedEmuInputTag;
0220   edm::InputTag TrackMETExtendedInputTag;
0221   //edm::InputTag TrackMETEmuExtendedInputTag;
0222   edm::InputTag TrackMHTExtendedInputTag;
0223   edm::InputTag TrackMHTEmuExtendedInputTag;
0224 
0225   edm::EDGetTokenT<edmNew::DetSetVector<TTCluster<Ref_Phase2TrackerDigi_>>> ttClusterToken_;
0226   edm::EDGetTokenT<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>> ttStubToken_;
0227   edm::EDGetTokenT<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>> ttClusterMCTruthToken_;
0228   edm::EDGetTokenT<TTStubAssociationMap<Ref_Phase2TrackerDigi_>> ttStubMCTruthToken_;
0229 
0230   edm::EDGetTokenT<L1TrackCollection> ttTrackToken_;
0231   edm::EDGetTokenT<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>> ttTrackMCTruthToken_;
0232   edm::EDGetTokenT<L1TrackCollection> ttTrackGTTToken_;
0233   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedToken_;
0234   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedEmulationToken_;
0235   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedAssociatedToken_;
0236   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedAssociatedEmulationToken_;
0237   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedForJetsToken_;
0238   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedEmulationForJetsToken_;
0239   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedAssociatedForJetsToken_;
0240   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedAssociatedEmulationForJetsToken_;
0241   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedForEtMissToken_;
0242   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedEmulationForEtMissToken_;
0243   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedAssociatedForEtMissToken_;
0244   edm::EDGetTokenT<L1TrackRefCollection> ttTrackSelectedAssociatedEmulationForEtMissToken_;
0245   edm::EDGetTokenT<L1TrackCollection> ttTrackExtendedToken_;
0246   edm::EDGetTokenT<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>> ttTrackMCTruthExtendedToken_;
0247   edm::EDGetTokenT<L1TrackCollection> ttTrackExtendedGTTToken_;
0248   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedToken_;
0249   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedEmulationToken_;
0250   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedAssociatedToken_;
0251   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedAssociatedEmulationToken_;
0252   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedForJetsToken_;
0253   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedEmulationForJetsToken_;
0254   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedAssociatedForJetsToken_;
0255   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedAssociatedEmulationForJetsToken_;
0256   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedForEtMissToken_;
0257   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedEmulationForEtMissToken_;
0258   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedAssociatedForEtMissToken_;
0259   edm::EDGetTokenT<L1TrackRefCollection> ttTrackExtendedSelectedAssociatedEmulationForEtMissToken_;
0260 
0261   edm::EDGetTokenT<std::vector<TrackingParticle>> TrackingParticleToken_;
0262   edm::EDGetTokenT<std::vector<TrackingVertex>> TrackingVertexToken_;
0263   edm::EDGetTokenT<std::vector<reco::GenJet>> GenJetToken_;
0264   edm::EDGetTokenT<std::vector<reco::GenParticle>> GenParticleToken_;
0265   edm::EDGetTokenT<std::vector<SimVertex>> SimVertexToken_;
0266   edm::EDGetTokenT<std::vector<l1t::DisplacedTrackVertex>> DispVertToken_;
0267   edm::EDGetTokenT<l1t::VertexCollection> L1VertexToken_;
0268   edm::EDGetTokenT<l1t::VertexWordCollection> L1VertexEmuToken_;
0269 
0270   edm::EDGetTokenT<std::vector<l1t::TkJet>> TrackFastJetsToken_;
0271   edm::EDGetTokenT<std::vector<l1t::TkJet>> TrackFastJetsExtendedToken_;
0272   edm::EDGetTokenT<std::vector<l1t::TkEtMiss>> TrackMETToken_;
0273   edm::EDGetTokenT<std::vector<l1t::TkEtMiss>> TrackMETExtendedToken_;
0274   edm::EDGetTokenT<std::vector<l1t::EtSum>> TrackMETEmuToken_;
0275   //edm::EDGetTokenT<std::vector<l1t::TkEtMiss>> TrackMETEmuExtendedToken_;
0276   edm::EDGetTokenT<l1t::TkHTMissCollection> TrackMHTToken_;
0277   edm::EDGetTokenT<l1t::TkHTMissCollection> TrackMHTExtendedToken_;
0278   edm::EDGetTokenT<std::vector<l1t::EtSum>> TrackMHTEmuToken_;
0279   edm::EDGetTokenT<std::vector<l1t::EtSum>> TrackMHTEmuExtendedToken_;
0280   edm::EDGetTokenT<l1t::TkJetCollection> TrackJetsToken_;
0281   edm::EDGetTokenT<l1t::TkJetCollection> TrackJetsExtendedToken_;
0282   edm::EDGetTokenT<l1t::TkJetWordCollection> TrackJetsEmuToken_;
0283   edm::EDGetTokenT<l1t::TkJetWordCollection> TrackJetsExtendedEmuToken_;
0284   edm::EDGetTokenT<l1t::TkTripletCollection> TrackTripletsToken_;
0285 
0286   edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> tTopoToken_;
0287   edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> tGeomToken_;
0288 
0289   //-----------------------------------------------------------------------------------------------
0290   // tree & branches for mini-ntuple
0291   bool available_;  // ROOT file for histograms is open.
0292   TTree* eventTree;
0293 
0294   // primary vertex
0295   std::vector<float>* m_pv_L1reco;
0296   std::vector<float>* m_pv_L1reco_sum;
0297   std::vector<float>* m_pv_L1reco_emu;
0298   std::vector<float>* m_pv_L1reco_sum_emu;
0299   std::vector<float>* m_pv_MC;
0300   std::vector<int>* m_MC_lep;
0301 
0302   //gen particles
0303   std::vector<float>* m_gen_pt;
0304   std::vector<float>* m_gen_phi;
0305   std::vector<float>* m_gen_pdgid;
0306   std::vector<float>* m_gen_z0;
0307   std::vector<float>* m_gen_mother_pdgid;
0308 
0309   //displaced vertices
0310   std::vector<float>* m_dv_d_T;
0311   std::vector<float>* m_dv_R_T;
0312   std::vector<float>* m_dv_cos_T;
0313   std::vector<float>* m_dv_x;
0314   std::vector<float>* m_dv_y;
0315   std::vector<float>* m_dv_z;
0316   std::vector<int>* m_dv_firstIndexTrk;
0317   std::vector<int>* m_dv_secondIndexTrk;
0318   std::vector<float>* m_dv_del_Z;
0319   std::vector<bool>* m_dv_isReal;
0320   std::vector<float>* m_dv_score;
0321 
0322   // all L1 tracks (prompt)
0323   std::vector<float>* m_trk_pt;
0324   std::vector<float>* m_trk_eta;
0325   std::vector<float>* m_trk_phi;
0326   std::vector<float>* m_trk_phi_local;
0327   std::vector<float>* m_trk_d0;  // (filled if nFitPar==5, else 999)
0328   std::vector<float>* m_trk_rinv;
0329   std::vector<float>* m_trk_z0;
0330   std::vector<float>* m_trk_chi2;
0331   std::vector<float>* m_trk_chi2dof;
0332   std::vector<float>* m_trk_chi2rphi;
0333   std::vector<float>* m_trk_chi2rz;
0334   std::vector<float>* m_trk_bendchi2;
0335   std::vector<float>* m_trk_MVA1;
0336   std::vector<int>* m_trk_nstub;
0337   std::vector<int>* m_trk_lhits;
0338   std::vector<int>* m_trk_dhits;
0339   std::vector<int>* m_trk_seed;
0340   std::vector<int>* m_trk_hitpattern;
0341   std::vector<unsigned int>* m_trk_phiSector;
0342   std::vector<int>* m_trk_genuine;
0343   std::vector<int>* m_trk_loose;
0344   std::vector<int>* m_trk_unknown;
0345   std::vector<int>* m_trk_combinatoric;
0346   std::vector<int>* m_trk_fake;  //0 fake, 1 track from primary interaction, 2 secondary track
0347   std::vector<int>* m_trk_matchtp_pdgid;
0348   std::vector<int>* m_trk_matchtp_mother_pdgid;
0349   std::vector<float>* m_trk_matchtp_pt;
0350   std::vector<float>* m_trk_matchtp_eta;
0351   std::vector<float>* m_trk_matchtp_phi;
0352   std::vector<float>* m_trk_matchtp_z0;
0353   std::vector<float>* m_trk_matchtp_dxy;
0354   std::vector<float>* m_trk_gtt_pt;
0355   std::vector<float>* m_trk_gtt_eta;
0356   std::vector<float>* m_trk_gtt_phi;
0357   std::vector<int>* m_trk_selected_index;
0358   std::vector<int>* m_trk_selected_emulation_index;
0359   std::vector<int>* m_trk_selected_associated_index;
0360   std::vector<int>* m_trk_selected_associated_emulation_index;
0361   std::vector<int>* m_trk_selected_forjets_index;
0362   std::vector<int>* m_trk_selected_emulation_forjets_index;
0363   std::vector<int>* m_trk_selected_associated_forjets_index;
0364   std::vector<int>* m_trk_selected_associated_emulation_forjets_index;
0365   std::vector<int>* m_trk_selected_foretmiss_index;
0366   std::vector<int>* m_trk_selected_emulation_foretmiss_index;
0367   std::vector<int>* m_trk_selected_associated_foretmiss_index;
0368   std::vector<int>* m_trk_selected_associated_emulation_foretmiss_index;
0369 
0370   // all L1 tracks (extended)
0371   std::vector<float>* m_trkExt_pt;
0372   std::vector<float>* m_trkExt_eta;
0373   std::vector<float>* m_trkExt_phi;
0374   std::vector<float>* m_trkExt_phi_local;
0375   std::vector<float>* m_trkExt_d0;  // (filled if nFitPar==5, else 999)
0376   std::vector<float>* m_trkExt_rinv;
0377   std::vector<float>* m_trkExt_z0;
0378   std::vector<float>* m_trkExt_chi2;
0379   std::vector<float>* m_trkExt_chi2dof;
0380   std::vector<float>* m_trkExt_chi2rphi;
0381   std::vector<float>* m_trkExt_chi2rz;
0382   std::vector<float>* m_trkExt_bendchi2;
0383   std::vector<float>* m_trkExt_MVA;
0384   std::vector<int>* m_trkExt_nstub;
0385   std::vector<int>* m_trkExt_lhits;
0386   std::vector<int>* m_trkExt_dhits;
0387   std::vector<int>* m_trkExt_seed;
0388   std::vector<int>* m_trkExt_hitpattern;
0389   std::vector<unsigned int>* m_trkExt_phiSector;
0390   std::vector<int>* m_trkExt_genuine;
0391   std::vector<int>* m_trkExt_loose;
0392   std::vector<int>* m_trkExt_unknown;
0393   std::vector<int>* m_trkExt_combinatoric;
0394   std::vector<int>* m_trkExt_fake;  //0 fake, 1 track from primary interaction, 2 secondary track
0395   std::vector<int>* m_trkExt_matchtp_pdgid;
0396   std::vector<bool>* m_trkExt_matchtp_isHard;
0397   std::vector<float>* m_trkExt_matchtp_pt;
0398   std::vector<float>* m_trkExt_matchtp_eta;
0399   std::vector<float>* m_trkExt_matchtp_phi;
0400   std::vector<float>* m_trkExt_matchtp_z0;
0401   std::vector<float>* m_trkExt_matchtp_dxy;
0402   std::vector<float>* m_trkExt_matchtp_d0;
0403   std::vector<float>* m_trkExt_matchtp_x;
0404   std::vector<float>* m_trkExt_matchtp_y;
0405   std::vector<float>* m_trkExt_matchtp_z;
0406   std::vector<float>* m_trkExt_gtt_pt;
0407   std::vector<float>* m_trkExt_gtt_eta;
0408   std::vector<float>* m_trkExt_gtt_phi;
0409   std::vector<int>* m_trkExt_selected_index;
0410   std::vector<int>* m_trkExt_selected_emulation_index;
0411   std::vector<int>* m_trkExt_selected_associated_index;
0412   std::vector<int>* m_trkExt_selected_associated_emulation_index;
0413   std::vector<int>* m_trkExt_selected_forjets_index;
0414   std::vector<int>* m_trkExt_selected_emulation_forjets_index;
0415   std::vector<int>* m_trkExt_selected_associated_forjets_index;
0416   std::vector<int>* m_trkExt_selected_associated_emulation_forjets_index;
0417   std::vector<int>* m_trkExt_selected_foretmiss_index;
0418   std::vector<int>* m_trkExt_selected_emulation_foretmiss_index;
0419   std::vector<int>* m_trkExt_selected_associated_foretmiss_index;
0420   std::vector<int>* m_trkExt_selected_associated_emulation_foretmiss_index;
0421 
0422   // extended L1 tracks emulation
0423   std::vector<float>* m_trkExtEmu_pt;
0424   std::vector<float>* m_trkExtEmu_eta;
0425   std::vector<float>* m_trkExtEmu_phi;
0426   std::vector<float>* m_trkExtEmu_d0;  // (filled if nFitPar==5, else 999)
0427   std::vector<float>* m_trkExtEmu_rho;
0428   std::vector<float>* m_trkExtEmu_z0;
0429   std::vector<float>* m_trkExtEmu_chi2rphi;
0430   std::vector<float>* m_trkExtEmu_chi2rz;
0431   std::vector<float>* m_trkExtEmu_bendchi2;
0432   std::vector<float>* m_trkExtEmu_MVA;
0433   std::vector<int>* m_trkExtEmu_nstub;
0434 
0435   // all tracking particles
0436   std::vector<float>* m_tp_pt;
0437   std::vector<float>* m_tp_eta;
0438   std::vector<float>* m_tp_phi;
0439   std::vector<float>* m_tp_dxy;
0440   std::vector<float>* m_tp_d0;
0441   std::vector<float>* m_tp_z0;
0442   std::vector<float>* m_tp_x;
0443   std::vector<float>* m_tp_y;
0444   std::vector<float>* m_tp_z;
0445   std::vector<float>* m_tp_d0_prod;
0446   std::vector<float>* m_tp_z0_prod;
0447   std::vector<int>* m_tp_pdgid;
0448   std::vector<bool>* m_tp_isHard;
0449   std::vector<int>* m_tp_nmatch;
0450   std::vector<int>* m_tp_nstub;
0451   std::vector<int>* m_tp_eventid;
0452   std::vector<int>* m_tp_charge;
0453 
0454   // *L1 track* properties if m_tp_nmatch > 0 (prompt)
0455   std::vector<float>* m_matchtrk_pt;
0456   std::vector<float>* m_matchtrk_eta;
0457   std::vector<float>* m_matchtrk_phi;
0458   std::vector<float>* m_matchtrk_d0;  //this variable is only filled if nFitPar==5
0459   std::vector<float>* m_matchtrk_rinv;
0460   std::vector<float>* m_matchtrk_z0;
0461   std::vector<float>* m_matchtrk_chi2;
0462   std::vector<float>* m_matchtrk_chi2dof;
0463   std::vector<float>* m_matchtrk_chi2rphi;
0464   std::vector<float>* m_matchtrk_chi2rz;
0465   std::vector<float>* m_matchtrk_bendchi2;
0466   std::vector<float>* m_matchtrk_MVA1;
0467   std::vector<int>* m_matchtrk_nstub;
0468   std::vector<int>* m_matchtrk_lhits;
0469   std::vector<int>* m_matchtrk_dhits;
0470   std::vector<int>* m_matchtrk_seed;
0471   std::vector<int>* m_matchtrk_hitpattern;
0472 
0473   // *L1 track* properties if m_tp_nmatch > 0 (extended)
0474   std::vector<float>* m_matchtrkExt_pt;
0475   std::vector<float>* m_matchtrkExt_eta;
0476   std::vector<float>* m_matchtrkExt_phi;
0477   std::vector<float>* m_matchtrkExt_d0;  //this variable is only filled if nFitPar==5
0478   std::vector<float>* m_matchtrkExt_rinv;
0479   std::vector<float>* m_matchtrkExt_z0;
0480   std::vector<float>* m_matchtrkExt_chi2;
0481   std::vector<float>* m_matchtrkExt_chi2dof;
0482   std::vector<float>* m_matchtrkExt_chi2rphi;
0483   std::vector<float>* m_matchtrkExt_chi2rz;
0484   std::vector<float>* m_matchtrkExt_bendchi2;
0485   std::vector<float>* m_matchtrkExt_MVA;
0486   std::vector<int>* m_matchtrkExt_nstub;
0487   std::vector<int>* m_matchtrkExt_lhits;
0488   std::vector<int>* m_matchtrkExt_dhits;
0489   std::vector<int>* m_matchtrkExt_seed;
0490   std::vector<int>* m_matchtrkExt_hitpattern;
0491 
0492   // *L1 track* emulation properties if m_tp_nmatch > 0 (extended)
0493   std::vector<float>* m_matchtrkExtEmu_pt;
0494   std::vector<float>* m_matchtrkExtEmu_eta;
0495   std::vector<float>* m_matchtrkExtEmu_phi;
0496   std::vector<float>* m_matchtrkExtEmu_d0;  // (filled if nFitPar==5, else 999)
0497   std::vector<float>* m_matchtrkExtEmu_rho;
0498   std::vector<float>* m_matchtrkExtEmu_z0;
0499   std::vector<float>* m_matchtrkExtEmu_chi2rphi;
0500   std::vector<float>* m_matchtrkExtEmu_chi2rz;
0501   std::vector<float>* m_matchtrkExtEmu_bendchi2;
0502   std::vector<float>* m_matchtrkExtEmu_MVA;
0503   std::vector<int>* m_matchtrkExtEmu_nstub;
0504 
0505   // ALL stubs
0506   std::vector<float>* m_allstub_x;
0507   std::vector<float>* m_allstub_y;
0508   std::vector<float>* m_allstub_z;
0509   std::vector<int>* m_allstub_isBarrel;  // stub is in barrel (1) or in disk (0)
0510   std::vector<int>* m_allstub_layer;
0511   std::vector<int>* m_allstub_isPSmodule;
0512   std::vector<float>* m_allstub_trigDisplace;
0513   std::vector<float>* m_allstub_trigOffset;
0514   std::vector<float>* m_allstub_trigPos;
0515   std::vector<float>* m_allstub_trigBend;
0516 
0517   // stub associated with tracking particle ?
0518   std::vector<int>* m_allstub_matchTP_pdgid;  // -999 if not matched
0519   std::vector<float>* m_allstub_matchTP_pt;   // -999 if not matched
0520   std::vector<float>* m_allstub_matchTP_eta;  // -999 if not matched
0521   std::vector<float>* m_allstub_matchTP_phi;  // -999 if not matched
0522   std::vector<int>* m_allstub_genuine;
0523 
0524   //prompt
0525   float trueMET = 0;
0526   float trueTkMET = 0;
0527   float trkMET = 0;
0528   float trkMETPhi = 0;
0529   float trkMHT = 0;
0530   float trkHT = 0;
0531   float trkMHTEmu = 0;
0532   float trkMHTEmuPhi = 0;
0533   float trkHTEmu = 0;
0534   float trkMETEmu = 0;
0535   float trkMETEmuPhi = 0;
0536 
0537   //displaced
0538   float trkMETExt = 0;
0539   float trkMETPhiExt = 0;
0540   float trkMHTExt = 0;
0541   float trkHTExt = 0;
0542   float trkMHTEmuExt = 0;
0543   float trkMHTEmuPhiExt = 0;
0544   float trkHTEmuExt = 0;
0545 
0546   //fast track jet
0547   std::vector<float>* m_trkfastjet_vz;
0548   std::vector<float>* m_trkfastjet_p;
0549   std::vector<float>* m_trkfastjet_phi;
0550   std::vector<float>* m_trkfastjet_eta;
0551   std::vector<float>* m_trkfastjet_pt;
0552   std::vector<int>* m_trkfastjet_ntracks;
0553   std::vector<float>* m_trkfastjet_tp_sumpt;
0554   std::vector<float>* m_trkfastjet_truetp_sumpt;
0555 
0556   std::vector<float>* m_trkfastjetExt_vz;
0557   std::vector<float>* m_trkfastjetExt_p;
0558   std::vector<float>* m_trkfastjetExt_phi;
0559   std::vector<float>* m_trkfastjetExt_eta;
0560   std::vector<float>* m_trkfastjetExt_pt;
0561   std::vector<int>* m_trkfastjetExt_ntracks;
0562   std::vector<float>* m_trkfastjetExt_tp_sumpt;
0563   std::vector<float>* m_trkfastjetExt_truetp_sumpt;
0564 
0565   std::vector<float>* m_genjet_p;
0566   std::vector<float>* m_genjet_phi;
0567   std::vector<float>* m_genjet_eta;
0568   std::vector<float>* m_genjet_pt;
0569 
0570   std::vector<float>* m_trkjet_vz;
0571   std::vector<float>* m_trkjet_p;
0572   std::vector<float>* m_trkjet_phi;
0573   std::vector<float>* m_trkjet_eta;
0574   std::vector<float>* m_trkjet_pt;
0575   std::vector<int>* m_trkjet_ntracks;
0576   std::vector<int>* m_trkjet_nDisplaced;
0577   std::vector<int>* m_trkjet_nTight;
0578   std::vector<int>* m_trkjet_nTightDisplaced;
0579   std::vector<int>* m_trkjet_ntdtrk;
0580 
0581   std::vector<float>* m_trkjetem_pt;
0582   std::vector<float>* m_trkjetem_phi;
0583   std::vector<float>* m_trkjetem_eta;
0584   std::vector<float>* m_trkjetem_z;
0585   std::vector<int>* m_trkjetem_ntracks;
0586   std::vector<int>* m_trkjetem_nxtracks;
0587 
0588   std::vector<float>* m_triplet_phi;
0589   std::vector<float>* m_triplet_eta;
0590   std::vector<float>* m_triplet_pt;
0591   std::vector<float>* m_triplet_mass;
0592   std::vector<float>* m_triplet_charge;
0593   std::vector<float>* m_triplet_dmassmax;
0594   std::vector<float>* m_triplet_dmassmin;
0595   std::vector<float>* m_triplet_dzmax;
0596   std::vector<float>* m_triplet_dzmin;
0597   std::vector<float>* m_triplet_trk1pt;
0598   std::vector<float>* m_triplet_trk1eta;
0599   std::vector<float>* m_triplet_trk1phi;
0600   std::vector<float>* m_triplet_trk1z;
0601   std::vector<float>* m_triplet_trk1npar;
0602   std::vector<float>* m_triplet_trk1mva;
0603   std::vector<float>* m_triplet_trk2pt;
0604   std::vector<float>* m_triplet_trk2eta;
0605   std::vector<float>* m_triplet_trk2phi;
0606   std::vector<float>* m_triplet_trk2z;
0607   std::vector<float>* m_triplet_trk2npar;
0608   std::vector<float>* m_triplet_trk2mva;
0609   std::vector<float>* m_triplet_trk3pt;
0610   std::vector<float>* m_triplet_trk3eta;
0611   std::vector<float>* m_triplet_trk3phi;
0612   std::vector<float>* m_triplet_trk3z;
0613   std::vector<float>* m_triplet_trk3npar;
0614   std::vector<float>* m_triplet_trk3mva;
0615 
0616   std::vector<float>* m_trkjetExt_vz;
0617   std::vector<float>* m_trkjetExt_p;
0618   std::vector<float>* m_trkjetExt_phi;
0619   std::vector<float>* m_trkjetExt_eta;
0620   std::vector<float>* m_trkjetExt_pt;
0621   std::vector<int>* m_trkjetExt_ntracks;
0622   std::vector<int>* m_trkjetExt_nDisplaced;
0623   std::vector<int>* m_trkjetExt_nTight;
0624   std::vector<int>* m_trkjetExt_nTightDisplaced;
0625   std::vector<int>* m_trkjetExt_ntdtrk;
0626 
0627   std::vector<float>* m_trkjetemExt_pt;
0628   std::vector<float>* m_trkjetemExt_phi;
0629   std::vector<float>* m_trkjetemExt_eta;
0630   std::vector<float>* m_trkjetemExt_z;
0631   std::vector<int>* m_trkjetemExt_ntracks;
0632   std::vector<int>* m_trkjetemExt_nxtracks;
0633 };
0634 
0635 //////////////////////////////////
0636 //                              //
0637 //     CLASS IMPLEMENTATION     //
0638 //                              //
0639 //////////////////////////////////
0640 
0641 //////////////
0642 // CONSTRUCTOR
0643 L1TrackObjectNtupleMaker::L1TrackObjectNtupleMaker(edm::ParameterSet const& iConfig) : config(iConfig) {
0644   MyProcess = iConfig.getParameter<int>("MyProcess");
0645   DebugMode = iConfig.getParameter<bool>("DebugMode");
0646   SaveAllTracks = iConfig.getParameter<bool>("SaveAllTracks");
0647   SaveStubs = iConfig.getParameter<bool>("SaveStubs");
0648   Displaced = iConfig.getParameter<string>("Displaced");
0649   TP_minNStub = iConfig.getParameter<int>("TP_minNStub");
0650   TP_minNStubLayer = iConfig.getParameter<int>("TP_minNStubLayer");
0651   TP_minPt = iConfig.getParameter<double>("TP_minPt");
0652   TP_maxEta = iConfig.getParameter<double>("TP_maxEta");
0653   TP_maxZ0 = iConfig.getParameter<double>("TP_maxZ0");
0654   L1Tk_minNStub = iConfig.getParameter<int>("L1Tk_minNStub");
0655 
0656   SaveTrackJets = iConfig.getParameter<bool>("SaveTrackJets");
0657   SaveTrackSums = iConfig.getParameter<bool>("SaveTrackSums");
0658   runDispVert = iConfig.getParameter<bool>("runDispVert");
0659 
0660   L1StubInputTag = iConfig.getParameter<edm::InputTag>("L1StubInputTag");
0661   MCTruthClusterInputTag = iConfig.getParameter<edm::InputTag>("MCTruthClusterInputTag");
0662   MCTruthStubInputTag = iConfig.getParameter<edm::InputTag>("MCTruthStubInputTag");
0663   TrackingParticleInputTag = iConfig.getParameter<edm::InputTag>("TrackingParticleInputTag");
0664   TrackingVertexInputTag = iConfig.getParameter<edm::InputTag>("TrackingVertexInputTag");
0665   GenJetInputTag = iConfig.getParameter<edm::InputTag>("GenJetInputTag");
0666   RecoVertexInputTag = iConfig.getParameter<InputTag>("RecoVertexInputTag");
0667   RecoVertexEmuInputTag = iConfig.getParameter<InputTag>("RecoVertexEmuInputTag");
0668   GenParticleInputTag = iConfig.getParameter<InputTag>("GenParticleInputTag");
0669   SimVertexInputTag = iConfig.getParameter<InputTag>("SimVertexInputTag");
0670   DisplacedVertexInputTag = iConfig.getParameter<InputTag>("DisplacedVertexInputTag");
0671 
0672   if (Displaced == "Prompt" || Displaced == "Both") {
0673     L1TrackInputTag = iConfig.getParameter<edm::InputTag>("L1TrackInputTag");
0674     MCTruthTrackInputTag = iConfig.getParameter<edm::InputTag>("MCTruthTrackInputTag");
0675     L1TrackGTTInputTag = iConfig.getParameter<edm::InputTag>("L1TrackGTTInputTag");
0676     L1TrackSelectedInputTag = iConfig.getParameter<edm::InputTag>("L1TrackSelectedInputTag");
0677     L1TrackSelectedEmulationInputTag = iConfig.getParameter<edm::InputTag>("L1TrackSelectedEmulationInputTag");
0678     L1TrackSelectedAssociatedInputTag = iConfig.getParameter<edm::InputTag>("L1TrackSelectedAssociatedInputTag");
0679     L1TrackSelectedAssociatedEmulationInputTag =
0680         iConfig.getParameter<edm::InputTag>("L1TrackSelectedAssociatedEmulationInputTag");
0681     L1TrackSelectedForJetsInputTag = iConfig.getParameter<edm::InputTag>("L1TrackSelectedForJetsInputTag");
0682     L1TrackSelectedEmulationForJetsInputTag =
0683         iConfig.getParameter<edm::InputTag>("L1TrackSelectedEmulationForJetsInputTag");
0684     L1TrackSelectedAssociatedForJetsInputTag =
0685         iConfig.getParameter<edm::InputTag>("L1TrackSelectedAssociatedForJetsInputTag");
0686     L1TrackSelectedAssociatedEmulationForJetsInputTag =
0687         iConfig.getParameter<edm::InputTag>("L1TrackSelectedAssociatedEmulationForJetsInputTag");
0688     L1TrackSelectedForEtMissInputTag = iConfig.getParameter<edm::InputTag>("L1TrackSelectedForEtMissInputTag");
0689     L1TrackSelectedEmulationForEtMissInputTag =
0690         iConfig.getParameter<edm::InputTag>("L1TrackSelectedEmulationForEtMissInputTag");
0691     L1TrackSelectedAssociatedForEtMissInputTag =
0692         iConfig.getParameter<edm::InputTag>("L1TrackSelectedAssociatedForEtMissInputTag");
0693     L1TrackSelectedAssociatedEmulationForEtMissInputTag =
0694         iConfig.getParameter<edm::InputTag>("L1TrackSelectedAssociatedEmulationForEtMissInputTag");
0695     TrackFastJetsInputTag = iConfig.getParameter<InputTag>("TrackFastJetsInputTag");
0696     TrackJetsInputTag = iConfig.getParameter<InputTag>("TrackJetsInputTag");
0697     TrackJetsEmuInputTag = iConfig.getParameter<InputTag>("TrackJetsEmuInputTag");
0698     TrackTripletsInputTag = iConfig.getParameter<InputTag>("TrackTripletsInputTag");
0699     TrackMETInputTag = iConfig.getParameter<InputTag>("TrackMETInputTag");
0700     TrackMETEmuInputTag = iConfig.getParameter<InputTag>("TrackMETEmuInputTag");
0701     TrackMHTInputTag = iConfig.getParameter<InputTag>("TrackMHTInputTag");
0702     TrackMHTEmuInputTag = iConfig.getParameter<InputTag>("TrackMHTEmuInputTag");
0703 
0704     ttTrackToken_ = consumes<L1TrackCollection>(L1TrackInputTag);
0705     ttTrackMCTruthToken_ = consumes<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>>(MCTruthTrackInputTag);
0706     ttTrackGTTToken_ = consumes<L1TrackCollection>(L1TrackGTTInputTag);
0707     ttTrackSelectedToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedInputTag);
0708     ttTrackSelectedEmulationToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedEmulationInputTag);
0709     ttTrackSelectedAssociatedToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedAssociatedInputTag);
0710     ttTrackSelectedAssociatedEmulationToken_ =
0711         consumes<L1TrackRefCollection>(L1TrackSelectedAssociatedEmulationInputTag);
0712     ttTrackSelectedForJetsToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedForJetsInputTag);
0713     ttTrackSelectedEmulationForJetsToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedEmulationForJetsInputTag);
0714     ttTrackSelectedAssociatedForJetsToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedAssociatedForJetsInputTag);
0715     ttTrackSelectedAssociatedEmulationForJetsToken_ =
0716         consumes<L1TrackRefCollection>(L1TrackSelectedAssociatedEmulationForJetsInputTag);
0717     ttTrackSelectedForEtMissToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedForEtMissInputTag);
0718     ttTrackSelectedEmulationForEtMissToken_ = consumes<L1TrackRefCollection>(L1TrackSelectedEmulationForEtMissInputTag);
0719     ttTrackSelectedAssociatedForEtMissToken_ =
0720         consumes<L1TrackRefCollection>(L1TrackSelectedAssociatedForEtMissInputTag);
0721     ttTrackSelectedAssociatedEmulationForEtMissToken_ =
0722         consumes<L1TrackRefCollection>(L1TrackSelectedAssociatedEmulationForEtMissInputTag);
0723     TrackFastJetsToken_ = consumes<std::vector<l1t::TkJet>>(TrackFastJetsInputTag);
0724     TrackJetsToken_ = consumes<l1t::TkJetCollection>(TrackJetsInputTag);
0725     TrackJetsEmuToken_ = consumes<l1t::TkJetWordCollection>(TrackJetsEmuInputTag);
0726     TrackTripletsToken_ = consumes<l1t::TkTripletCollection>(TrackTripletsInputTag);
0727     TrackMETToken_ = consumes<std::vector<l1t::TkEtMiss>>(TrackMETInputTag);
0728     TrackMETEmuToken_ = consumes<std::vector<l1t::EtSum>>(TrackMETEmuInputTag);
0729     TrackMHTToken_ = consumes<l1t::TkHTMissCollection>(TrackMHTInputTag);
0730     TrackMHTEmuToken_ = consumes<std::vector<l1t::EtSum>>(TrackMHTEmuInputTag);
0731   }
0732 
0733   if (Displaced == "Displaced" || Displaced == "Both") {
0734     L1TrackExtendedInputTag = iConfig.getParameter<edm::InputTag>("L1TrackExtendedInputTag");
0735     MCTruthTrackExtendedInputTag = iConfig.getParameter<edm::InputTag>("MCTruthTrackExtendedInputTag");
0736     L1TrackExtendedGTTInputTag = iConfig.getParameter<edm::InputTag>("L1TrackExtendedGTTInputTag");
0737     L1TrackExtendedSelectedInputTag = iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedInputTag");
0738     L1TrackExtendedSelectedEmulationInputTag =
0739         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedEmulationInputTag");
0740     L1TrackExtendedSelectedAssociatedInputTag =
0741         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedAssociatedInputTag");
0742     L1TrackExtendedSelectedAssociatedEmulationInputTag =
0743         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedAssociatedEmulationInputTag");
0744     L1TrackExtendedSelectedForJetsInputTag =
0745         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedForJetsInputTag");
0746     L1TrackExtendedSelectedEmulationForJetsInputTag =
0747         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedEmulationForJetsInputTag");
0748     L1TrackExtendedSelectedAssociatedForJetsInputTag =
0749         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedAssociatedForJetsInputTag");
0750     L1TrackExtendedSelectedAssociatedEmulationForJetsInputTag =
0751         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedAssociatedEmulationForJetsInputTag");
0752     L1TrackExtendedSelectedForEtMissInputTag =
0753         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedForEtMissInputTag");
0754     L1TrackExtendedSelectedEmulationForEtMissInputTag =
0755         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedEmulationForEtMissInputTag");
0756     L1TrackExtendedSelectedAssociatedForEtMissInputTag =
0757         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedAssociatedForEtMissInputTag");
0758     L1TrackExtendedSelectedAssociatedEmulationForEtMissInputTag =
0759         iConfig.getParameter<edm::InputTag>("L1TrackExtendedSelectedAssociatedEmulationForEtMissInputTag");
0760     TrackFastJetsExtendedInputTag = iConfig.getParameter<InputTag>("TrackFastJetsExtendedInputTag");
0761     TrackJetsExtendedInputTag = iConfig.getParameter<InputTag>("TrackJetsExtendedInputTag");
0762     TrackJetsExtendedEmuInputTag = iConfig.getParameter<InputTag>("TrackJetsExtendedEmuInputTag");
0763     TrackMETExtendedInputTag = iConfig.getParameter<InputTag>("TrackMETExtendedInputTag");
0764     TrackMHTExtendedInputTag = iConfig.getParameter<InputTag>("TrackMHTExtendedInputTag");
0765     TrackMHTEmuInputTag = iConfig.getParameter<InputTag>("TrackMHTEmuInputTag");
0766     TrackMHTEmuExtendedInputTag = iConfig.getParameter<InputTag>("TrackMHTEmuExtendedInputTag");
0767 
0768     ttTrackExtendedToken_ = consumes<L1TrackCollection>(L1TrackExtendedInputTag);
0769     ttTrackMCTruthExtendedToken_ =
0770         consumes<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>>(MCTruthTrackExtendedInputTag);
0771     ttTrackExtendedGTTToken_ = consumes<L1TrackCollection>(L1TrackExtendedGTTInputTag);
0772     ttTrackExtendedSelectedToken_ = consumes<L1TrackRefCollection>(L1TrackExtendedSelectedInputTag);
0773     ttTrackExtendedSelectedEmulationToken_ = consumes<L1TrackRefCollection>(L1TrackExtendedSelectedEmulationInputTag);
0774     ttTrackExtendedSelectedAssociatedToken_ = consumes<L1TrackRefCollection>(L1TrackExtendedSelectedAssociatedInputTag);
0775     ttTrackExtendedSelectedAssociatedEmulationToken_ =
0776         consumes<L1TrackRefCollection>(L1TrackExtendedSelectedAssociatedEmulationInputTag);
0777     ttTrackExtendedSelectedForJetsToken_ = consumes<L1TrackRefCollection>(L1TrackExtendedSelectedForJetsInputTag);
0778     ttTrackExtendedSelectedEmulationForJetsToken_ =
0779         consumes<L1TrackRefCollection>(L1TrackExtendedSelectedEmulationForJetsInputTag);
0780     ttTrackExtendedSelectedAssociatedForJetsToken_ =
0781         consumes<L1TrackRefCollection>(L1TrackExtendedSelectedAssociatedForJetsInputTag);
0782     ttTrackExtendedSelectedAssociatedEmulationForJetsToken_ =
0783         consumes<L1TrackRefCollection>(L1TrackExtendedSelectedAssociatedEmulationForJetsInputTag);
0784     ttTrackExtendedSelectedForEtMissToken_ = consumes<L1TrackRefCollection>(L1TrackExtendedSelectedForEtMissInputTag);
0785     ttTrackExtendedSelectedEmulationForEtMissToken_ =
0786         consumes<L1TrackRefCollection>(L1TrackExtendedSelectedEmulationForEtMissInputTag);
0787     ttTrackExtendedSelectedAssociatedForEtMissToken_ =
0788         consumes<L1TrackRefCollection>(L1TrackExtendedSelectedAssociatedForEtMissInputTag);
0789     ttTrackExtendedSelectedAssociatedEmulationForEtMissToken_ =
0790         consumes<L1TrackRefCollection>(L1TrackExtendedSelectedAssociatedEmulationForEtMissInputTag);
0791     TrackFastJetsExtendedToken_ = consumes<std::vector<l1t::TkJet>>(TrackFastJetsExtendedInputTag);
0792     TrackJetsExtendedToken_ = consumes<l1t::TkJetCollection>(TrackJetsExtendedInputTag);
0793     TrackJetsExtendedEmuToken_ = consumes<l1t::TkJetWordCollection>(TrackJetsExtendedEmuInputTag);
0794     TrackMETExtendedToken_ = consumes<std::vector<l1t::TkEtMiss>>(TrackMETExtendedInputTag);
0795     TrackMHTExtendedToken_ = consumes<l1t::TkHTMissCollection>(TrackMHTExtendedInputTag);
0796     TrackMHTEmuToken_ = consumes<std::vector<l1t::EtSum>>(TrackMHTEmuInputTag);
0797     TrackMHTEmuExtendedToken_ = consumes<std::vector<l1t::EtSum>>(TrackMHTEmuExtendedInputTag);
0798   }
0799 
0800   ttStubToken_ = consumes<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>>(L1StubInputTag);
0801   ttClusterMCTruthToken_ = consumes<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>>(MCTruthClusterInputTag);
0802   ttStubMCTruthToken_ = consumes<TTStubAssociationMap<Ref_Phase2TrackerDigi_>>(MCTruthStubInputTag);
0803   TrackingParticleToken_ = consumes<std::vector<TrackingParticle>>(TrackingParticleInputTag);
0804   TrackingVertexToken_ = consumes<std::vector<TrackingVertex>>(TrackingVertexInputTag);
0805   GenJetToken_ = consumes<std::vector<reco::GenJet>>(GenJetInputTag);
0806   GenParticleToken_ = consumes<std::vector<reco::GenParticle>>(GenParticleInputTag);
0807   SimVertexToken_ = consumes<std::vector<SimVertex>>(SimVertexInputTag);
0808   if (runDispVert) {
0809     DispVertToken_ = consumes<std::vector<l1t::DisplacedTrackVertex>>(DisplacedVertexInputTag);
0810   }
0811   L1VertexToken_ = consumes<l1t::VertexCollection>(RecoVertexInputTag);
0812   L1VertexEmuToken_ = consumes<l1t::VertexWordCollection>(RecoVertexEmuInputTag);
0813   tTopoToken_ = esConsumes<TrackerTopology, TrackerTopologyRcd>(edm::ESInputTag("", ""));
0814   tGeomToken_ = esConsumes<TrackerGeometry, TrackerDigiGeometryRecord>(edm::ESInputTag("", ""));
0815 
0816   usesResource(TFileService::kSharedResource);
0817 }
0818 
0819 /////////////
0820 // DESTRUCTOR
0821 L1TrackObjectNtupleMaker::~L1TrackObjectNtupleMaker() {}
0822 
0823 //////////
0824 // END JOB
0825 void L1TrackObjectNtupleMaker::endJob() {
0826   // things to be done at the exit of the event Loop
0827   //  edm::LogVerbatim("Tracklet") << "L1TrackObjectNtupleMaker::endJob";
0828   // clean up raw pointers
0829   delete m_trk_pt;
0830   delete m_trk_eta;
0831   delete m_trk_phi;
0832   delete m_trk_phi_local;
0833   delete m_trk_z0;
0834   delete m_trk_d0;
0835   delete m_trk_rinv;
0836   delete m_trk_chi2;
0837   delete m_trk_chi2dof;
0838   delete m_trk_chi2rphi;
0839   delete m_trk_chi2rz;
0840   delete m_trk_bendchi2;
0841   delete m_trk_MVA1;
0842   delete m_trk_nstub;
0843   delete m_trk_lhits;
0844   delete m_trk_dhits;
0845   delete m_trk_seed;
0846   delete m_trk_hitpattern;
0847   delete m_trk_phiSector;
0848   delete m_trk_genuine;
0849   delete m_trk_loose;
0850   delete m_trk_unknown;
0851   delete m_trk_combinatoric;
0852   delete m_trk_fake;
0853   delete m_trk_matchtp_pdgid;
0854   delete m_trk_matchtp_mother_pdgid;
0855   delete m_trk_matchtp_pt;
0856   delete m_trk_matchtp_eta;
0857   delete m_trk_matchtp_phi;
0858   delete m_trk_matchtp_z0;
0859   delete m_trk_matchtp_dxy;
0860   delete m_trk_gtt_pt;
0861   delete m_trk_gtt_eta;
0862   delete m_trk_gtt_phi;
0863   delete m_trk_selected_index;
0864   delete m_trk_selected_emulation_index;
0865   delete m_trk_selected_associated_index;
0866   delete m_trk_selected_associated_emulation_index;
0867   delete m_trk_selected_forjets_index;
0868   delete m_trk_selected_emulation_forjets_index;
0869   delete m_trk_selected_associated_forjets_index;
0870   delete m_trk_selected_associated_emulation_forjets_index;
0871   delete m_trk_selected_foretmiss_index;
0872   delete m_trk_selected_emulation_foretmiss_index;
0873   delete m_trk_selected_associated_foretmiss_index;
0874   delete m_trk_selected_associated_emulation_foretmiss_index;
0875 
0876   delete m_trkExt_pt;
0877   delete m_trkExt_eta;
0878   delete m_trkExt_phi;
0879   delete m_trkExt_phi_local;
0880   delete m_trkExt_z0;
0881   delete m_trkExt_d0;
0882   delete m_trkExt_rinv;
0883   delete m_trkExt_chi2;
0884   delete m_trkExt_chi2dof;
0885   delete m_trkExt_chi2rphi;
0886   delete m_trkExt_chi2rz;
0887   delete m_trkExt_bendchi2;
0888   delete m_trkExt_MVA;
0889   delete m_trkExt_nstub;
0890   delete m_trkExt_lhits;
0891   delete m_trkExt_dhits;
0892   delete m_trkExt_seed;
0893   delete m_trkExt_hitpattern;
0894   delete m_trkExt_phiSector;
0895   delete m_trkExt_genuine;
0896   delete m_trkExt_loose;
0897   delete m_trkExt_unknown;
0898   delete m_trkExt_combinatoric;
0899   delete m_trkExt_fake;
0900   delete m_trkExt_matchtp_pdgid;
0901   delete m_trkExt_matchtp_isHard;
0902   delete m_trkExt_matchtp_pt;
0903   delete m_trkExt_matchtp_eta;
0904   delete m_trkExt_matchtp_phi;
0905   delete m_trkExt_matchtp_z0;
0906   delete m_trkExt_matchtp_dxy;
0907   delete m_trkExt_matchtp_d0;
0908   delete m_trkExt_matchtp_x;
0909   delete m_trkExt_matchtp_y;
0910   delete m_trkExt_matchtp_z;
0911   delete m_trkExt_gtt_pt;
0912   delete m_trkExt_gtt_eta;
0913   delete m_trkExt_gtt_phi;
0914   delete m_trkExt_selected_index;
0915   delete m_trkExt_selected_emulation_index;
0916   delete m_trkExt_selected_associated_index;
0917   delete m_trkExt_selected_associated_emulation_index;
0918   delete m_trkExt_selected_forjets_index;
0919   delete m_trkExt_selected_emulation_forjets_index;
0920   delete m_trkExt_selected_associated_forjets_index;
0921   delete m_trkExt_selected_associated_emulation_forjets_index;
0922   delete m_trkExt_selected_foretmiss_index;
0923   delete m_trkExt_selected_emulation_foretmiss_index;
0924   delete m_trkExt_selected_associated_foretmiss_index;
0925   delete m_trkExt_selected_associated_emulation_foretmiss_index;
0926 
0927   delete m_trkExtEmu_pt;
0928   delete m_trkExtEmu_eta;
0929   delete m_trkExtEmu_phi;
0930   delete m_trkExtEmu_d0;
0931   delete m_trkExtEmu_rho;
0932   delete m_trkExtEmu_z0;
0933   delete m_trkExtEmu_chi2rphi;
0934   delete m_trkExtEmu_chi2rz;
0935   delete m_trkExtEmu_bendchi2;
0936   delete m_trkExtEmu_MVA;
0937   delete m_trkExtEmu_nstub;
0938 
0939   delete m_tp_pt;
0940   delete m_tp_eta;
0941   delete m_tp_phi;
0942   delete m_tp_dxy;
0943   delete m_tp_d0;
0944   delete m_tp_z0;
0945   delete m_tp_x;
0946   delete m_tp_y;
0947   delete m_tp_z;
0948   delete m_tp_d0_prod;
0949   delete m_tp_z0_prod;
0950   delete m_tp_pdgid;
0951   delete m_tp_isHard;
0952   delete m_tp_nmatch;
0953   delete m_tp_nstub;
0954   delete m_tp_eventid;
0955   delete m_tp_charge;
0956 
0957   delete m_gen_pt;
0958   delete m_gen_phi;
0959   delete m_gen_pdgid;
0960   delete m_gen_mother_pdgid;
0961 
0962   delete m_gen_z0;
0963 
0964   delete m_dv_d_T;
0965   delete m_dv_R_T;
0966   delete m_dv_cos_T;
0967   delete m_dv_x;
0968   delete m_dv_y;
0969   delete m_dv_z;
0970   delete m_dv_firstIndexTrk;
0971   delete m_dv_secondIndexTrk;
0972   delete m_dv_del_Z;
0973   delete m_dv_isReal;
0974   delete m_dv_score;
0975 
0976   delete m_matchtrk_pt;
0977   delete m_matchtrk_eta;
0978   delete m_matchtrk_phi;
0979   delete m_matchtrk_z0;
0980   delete m_matchtrk_d0;
0981   delete m_matchtrk_rinv;
0982   delete m_matchtrk_chi2;
0983   delete m_matchtrk_chi2dof;
0984   delete m_matchtrk_chi2rphi;
0985   delete m_matchtrk_chi2rz;
0986   delete m_matchtrk_bendchi2;
0987   delete m_matchtrk_MVA1;
0988   delete m_matchtrk_nstub;
0989   delete m_matchtrk_dhits;
0990   delete m_matchtrk_lhits;
0991   delete m_matchtrk_seed;
0992   delete m_matchtrk_hitpattern;
0993 
0994   delete m_matchtrkExt_pt;
0995   delete m_matchtrkExt_eta;
0996   delete m_matchtrkExt_phi;
0997   delete m_matchtrkExt_z0;
0998   delete m_matchtrkExt_d0;
0999   delete m_matchtrkExt_rinv;
1000   delete m_matchtrkExt_chi2;
1001   delete m_matchtrkExt_chi2dof;
1002   delete m_matchtrkExt_chi2rphi;
1003   delete m_matchtrkExt_chi2rz;
1004   delete m_matchtrkExt_bendchi2;
1005   delete m_matchtrkExt_MVA;
1006   delete m_matchtrkExt_nstub;
1007   delete m_matchtrkExt_dhits;
1008   delete m_matchtrkExt_lhits;
1009   delete m_matchtrkExt_seed;
1010   delete m_matchtrkExt_hitpattern;
1011 
1012   delete m_matchtrkExtEmu_pt;
1013   delete m_matchtrkExtEmu_eta;
1014   delete m_matchtrkExtEmu_phi;
1015   delete m_matchtrkExtEmu_d0;
1016   delete m_matchtrkExtEmu_rho;
1017   delete m_matchtrkExtEmu_z0;
1018   delete m_matchtrkExtEmu_chi2rphi;
1019   delete m_matchtrkExtEmu_chi2rz;
1020   delete m_matchtrkExtEmu_bendchi2;
1021   delete m_matchtrkExtEmu_MVA;
1022   delete m_matchtrkExtEmu_nstub;
1023 
1024   delete m_allstub_x;
1025   delete m_allstub_y;
1026   delete m_allstub_z;
1027   delete m_allstub_isBarrel;
1028   delete m_allstub_layer;
1029   delete m_allstub_isPSmodule;
1030   delete m_allstub_trigDisplace;
1031   delete m_allstub_trigOffset;
1032   delete m_allstub_trigPos;
1033   delete m_allstub_trigBend;
1034   delete m_allstub_matchTP_pdgid;
1035   delete m_allstub_matchTP_pt;
1036   delete m_allstub_matchTP_eta;
1037   delete m_allstub_matchTP_phi;
1038   delete m_allstub_genuine;
1039 
1040   delete m_pv_L1reco;
1041   delete m_pv_L1reco_sum;
1042   delete m_pv_L1reco_emu;
1043   delete m_pv_L1reco_sum_emu;
1044   delete m_pv_MC;
1045   delete m_MC_lep;
1046 
1047   delete m_trkjet_eta;
1048   delete m_trkjet_vz;
1049   delete m_trkjet_phi;
1050   delete m_trkjet_p;
1051   delete m_trkjet_pt;
1052   delete m_trkjet_ntracks;
1053   delete m_trkjet_nDisplaced;
1054   delete m_trkjet_nTight;
1055   delete m_trkjet_nTightDisplaced;
1056   delete m_trkjet_ntdtrk;
1057 
1058   delete m_trkjetem_pt;
1059   delete m_trkjetem_phi;
1060   delete m_trkjetem_eta;
1061   delete m_trkjetem_z;
1062   delete m_trkjetem_ntracks;
1063   delete m_trkjetem_nxtracks;
1064 
1065   delete m_triplet_eta;
1066   delete m_triplet_phi;
1067   delete m_triplet_pt;
1068   delete m_triplet_mass;
1069   delete m_triplet_charge;
1070   delete m_triplet_dmassmax;
1071   delete m_triplet_dmassmin;
1072   delete m_triplet_dzmax;
1073   delete m_triplet_dzmin;
1074   delete m_triplet_trk1pt;
1075   delete m_triplet_trk1eta;
1076   delete m_triplet_trk1phi;
1077   delete m_triplet_trk1z;
1078   delete m_triplet_trk1npar;
1079   delete m_triplet_trk1mva;
1080   delete m_triplet_trk2pt;
1081   delete m_triplet_trk2eta;
1082   delete m_triplet_trk2phi;
1083   delete m_triplet_trk2z;
1084   delete m_triplet_trk2npar;
1085   delete m_triplet_trk2mva;
1086   delete m_triplet_trk3pt;
1087   delete m_triplet_trk3eta;
1088   delete m_triplet_trk3phi;
1089   delete m_triplet_trk3z;
1090   delete m_triplet_trk3npar;
1091   delete m_triplet_trk3mva;
1092 
1093   delete m_trkfastjet_eta;
1094   delete m_trkfastjet_vz;
1095   delete m_trkfastjet_phi;
1096   delete m_trkfastjet_p;
1097   delete m_trkfastjet_pt;
1098   delete m_trkfastjet_ntracks;
1099   delete m_trkfastjet_tp_sumpt;
1100   delete m_trkfastjet_truetp_sumpt;
1101 
1102   delete m_trkjetExt_eta;
1103   delete m_trkjetExt_vz;
1104   delete m_trkjetExt_phi;
1105   delete m_trkjetExt_p;
1106   delete m_trkjetExt_pt;
1107   delete m_trkjetExt_ntracks;
1108   delete m_trkjetExt_nDisplaced;
1109   delete m_trkjetExt_nTight;
1110   delete m_trkjetExt_nTightDisplaced;
1111   delete m_trkjetExt_ntdtrk;
1112 
1113   delete m_trkjetemExt_pt;
1114   delete m_trkjetemExt_phi;
1115   delete m_trkjetemExt_eta;
1116   delete m_trkjetemExt_z;
1117   delete m_trkjetemExt_ntracks;
1118   delete m_trkjetemExt_nxtracks;
1119 
1120   delete m_trkfastjetExt_eta;
1121   delete m_trkfastjetExt_vz;
1122   delete m_trkfastjetExt_phi;
1123   delete m_trkfastjetExt_p;
1124   delete m_trkfastjetExt_pt;
1125   delete m_trkfastjetExt_ntracks;
1126   delete m_trkfastjetExt_tp_sumpt;
1127   delete m_trkfastjetExt_truetp_sumpt;
1128 }
1129 
1130 template <typename T>
1131 bool L1TrackObjectNtupleMaker::isHard(T particle) {
1132   reco::GenParticleRefVector genParts = particle->genParticles();
1133   if (genParts.size() == 0) {
1134     return false;
1135   }
1136   if (genParts[0]->isHardProcess() || genParts[0]->fromHardProcessFinalState()) {
1137     return true;
1138   }
1139   return false;
1140 }
1141 
1142 double L1TrackObjectNtupleMaker::DoublePtFromBits(const L1Track& track) const {
1143   ap_uint<14> ptEmulationBits = track.getTrackWord()(TTTrack_TrackWord::TrackBitLocations::kRinvMSB - 1,
1144                                                      TTTrack_TrackWord::TrackBitLocations::kRinvLSB);
1145   ap_ufixed<14, 9> ptEmulation;
1146   ptEmulation.V = (ptEmulationBits.range());
1147   return ptEmulation.to_double();
1148 }
1149 
1150 double L1TrackObjectNtupleMaker::DoubleEtaFromBits(const L1Track& track) const {
1151   TTTrack_TrackWord::tanl_t etaBits = track.getTanlWord();
1152   l1trackunpacker::glbeta_intern digieta;
1153   digieta.V = etaBits.range();
1154   return (double)digieta;
1155 }
1156 
1157 double L1TrackObjectNtupleMaker::DoublePhiFromBits(const L1Track& track) const {
1158   int Sector = track.phiSector();
1159   double sector_phi_value = 0;
1160   if (Sector < 5) {
1161     sector_phi_value = 2.0 * M_PI * Sector / 9.0;
1162   } else {
1163     sector_phi_value = (-1.0 * M_PI + M_PI / 9.0 + (Sector - 5) * 2.0 * M_PI / 9.0);
1164   }
1165   l1trackunpacker::glbphi_intern trkphiSector = l1trackunpacker::DoubleToBit(
1166       sector_phi_value, TTTrack_TrackWord::TrackBitWidths::kPhiSize + 4, TTTrack_TrackWord::stepPhi0);
1167   l1trackunpacker::glbphi_intern local_phiBits = 0;
1168   local_phiBits.V = track.getPhiWord();
1169   l1trackunpacker::glbphi_intern local_phi = l1trackunpacker::DoubleToBit(
1170       l1trackunpacker::BitToDouble(
1171           local_phiBits, TTTrack_TrackWord::TrackBitWidths::kPhiSize, TTTrack_TrackWord::stepPhi0),
1172       TTTrack_TrackWord::TrackBitWidths::kPhiSize + 4,
1173       TTTrack_TrackWord::stepPhi0);
1174   l1trackunpacker::glbphi_intern digiphi = local_phi + trkphiSector;
1175   return l1trackunpacker::BitToDouble(
1176       digiphi, TTTrack_TrackWord::TrackBitWidths::kPhiSize + 4, TTTrack_TrackWord::stepPhi0);
1177 }
1178 
1179 int L1TrackObjectNtupleMaker::ChargeFromBits(const L1Track& track) const {
1180   ap_uint<1> chargeBit = track.getTrackWord()[TTTrack_TrackWord::TrackBitLocations::kRinvMSB];
1181   return 1 - (2 * chargeBit.to_uint());
1182 }
1183 
1184 double L1TrackObjectNtupleMaker::convertPtToR(double pt) {
1185   return 100.0 * (1.0 / (0.3 * 3.8)) * pt;  //returns R in cm
1186 }
1187 
1188 ////////////
1189 // BEGIN JOB
1190 void L1TrackObjectNtupleMaker::beginJob() {
1191   // things to be done before entering the event Loop
1192   //  edm::LogVerbatim("Tracklet") << "L1TrackObjectNtupleMaker::beginJob";
1193 
1194   //-----------------------------------------------------------------------------------------------
1195   // book histograms / make ntuple
1196   edm::Service<TFileService> fs;
1197   available_ = fs.isAvailable();
1198   if (not available_)
1199     return;  // No ROOT file open.
1200 
1201   // initilize
1202   m_trk_pt = new std::vector<float>;
1203   m_trk_eta = new std::vector<float>;
1204   m_trk_phi = new std::vector<float>;
1205   m_trk_phi_local = new std::vector<float>;
1206   m_trk_z0 = new std::vector<float>;
1207   m_trk_d0 = new std::vector<float>;
1208   m_trk_rinv = new std::vector<float>;
1209   m_trk_chi2 = new std::vector<float>;
1210   m_trk_chi2dof = new std::vector<float>;
1211   m_trk_chi2rphi = new std::vector<float>;
1212   m_trk_chi2rz = new std::vector<float>;
1213   m_trk_bendchi2 = new std::vector<float>;
1214   m_trk_MVA1 = new std::vector<float>;
1215   m_trk_nstub = new std::vector<int>;
1216   m_trk_lhits = new std::vector<int>;
1217   m_trk_dhits = new std::vector<int>;
1218   m_trk_seed = new std::vector<int>;
1219   m_trk_hitpattern = new std::vector<int>;
1220   m_trk_phiSector = new std::vector<unsigned int>;
1221   m_trk_genuine = new std::vector<int>;
1222   m_trk_loose = new std::vector<int>;
1223   m_trk_unknown = new std::vector<int>;
1224   m_trk_combinatoric = new std::vector<int>;
1225   m_trk_fake = new std::vector<int>;
1226   m_trk_matchtp_pdgid = new std::vector<int>;
1227   m_trk_matchtp_mother_pdgid = new std::vector<int>;
1228   m_trk_matchtp_pt = new std::vector<float>;
1229   m_trk_matchtp_eta = new std::vector<float>;
1230   m_trk_matchtp_phi = new std::vector<float>;
1231   m_trk_matchtp_z0 = new std::vector<float>;
1232   m_trk_matchtp_dxy = new std::vector<float>;
1233   m_trk_gtt_pt = new std::vector<float>;
1234   m_trk_gtt_eta = new std::vector<float>;
1235   m_trk_gtt_phi = new std::vector<float>;
1236   m_trk_selected_index = new std::vector<int>;
1237   m_trk_selected_emulation_index = new std::vector<int>;
1238   m_trk_selected_associated_index = new std::vector<int>;
1239   m_trk_selected_associated_emulation_index = new std::vector<int>;
1240   m_trk_selected_forjets_index = new std::vector<int>;
1241   m_trk_selected_emulation_forjets_index = new std::vector<int>;
1242   m_trk_selected_associated_forjets_index = new std::vector<int>;
1243   m_trk_selected_associated_emulation_forjets_index = new std::vector<int>;
1244   m_trk_selected_foretmiss_index = new std::vector<int>;
1245   m_trk_selected_emulation_foretmiss_index = new std::vector<int>;
1246   m_trk_selected_associated_foretmiss_index = new std::vector<int>;
1247   m_trk_selected_associated_emulation_foretmiss_index = new std::vector<int>;
1248 
1249   m_trkExt_pt = new std::vector<float>;
1250   m_trkExt_eta = new std::vector<float>;
1251   m_trkExt_phi = new std::vector<float>;
1252   m_trkExt_phi_local = new std::vector<float>;
1253   m_trkExt_z0 = new std::vector<float>;
1254   m_trkExt_d0 = new std::vector<float>;
1255   m_trkExt_rinv = new std::vector<float>;
1256   m_trkExt_chi2 = new std::vector<float>;
1257   m_trkExt_chi2dof = new std::vector<float>;
1258   m_trkExt_chi2rphi = new std::vector<float>;
1259   m_trkExt_chi2rz = new std::vector<float>;
1260   m_trkExt_bendchi2 = new std::vector<float>;
1261   m_trkExt_MVA = new std::vector<float>;
1262   m_trkExt_nstub = new std::vector<int>;
1263   m_trkExt_lhits = new std::vector<int>;
1264   m_trkExt_dhits = new std::vector<int>;
1265   m_trkExt_seed = new std::vector<int>;
1266   m_trkExt_hitpattern = new std::vector<int>;
1267   m_trkExt_phiSector = new std::vector<unsigned int>;
1268   m_trkExt_genuine = new std::vector<int>;
1269   m_trkExt_loose = new std::vector<int>;
1270   m_trkExt_unknown = new std::vector<int>;
1271   m_trkExt_combinatoric = new std::vector<int>;
1272   m_trkExt_fake = new std::vector<int>;
1273   m_trkExt_matchtp_pdgid = new std::vector<int>;
1274   m_trkExt_matchtp_isHard = new std::vector<bool>;
1275   m_trkExt_matchtp_pt = new std::vector<float>;
1276   m_trkExt_matchtp_eta = new std::vector<float>;
1277   m_trkExt_matchtp_phi = new std::vector<float>;
1278   m_trkExt_matchtp_z0 = new std::vector<float>;
1279   m_trkExt_matchtp_dxy = new std::vector<float>;
1280   m_trkExt_matchtp_d0 = new std::vector<float>;
1281   m_trkExt_matchtp_x = new std::vector<float>;
1282   m_trkExt_matchtp_y = new std::vector<float>;
1283   m_trkExt_matchtp_z = new std::vector<float>;
1284   m_trkExt_gtt_pt = new std::vector<float>;
1285   m_trkExt_gtt_eta = new std::vector<float>;
1286   m_trkExt_gtt_phi = new std::vector<float>;
1287   m_trkExt_selected_index = new std::vector<int>;
1288   m_trkExt_selected_emulation_index = new std::vector<int>;
1289   m_trkExt_selected_associated_index = new std::vector<int>;
1290   m_trkExt_selected_associated_emulation_index = new std::vector<int>;
1291   m_trkExt_selected_forjets_index = new std::vector<int>;
1292   m_trkExt_selected_emulation_forjets_index = new std::vector<int>;
1293   m_trkExt_selected_associated_forjets_index = new std::vector<int>;
1294   m_trkExt_selected_associated_emulation_forjets_index = new std::vector<int>;
1295   m_trkExt_selected_foretmiss_index = new std::vector<int>;
1296   m_trkExt_selected_emulation_foretmiss_index = new std::vector<int>;
1297   m_trkExt_selected_associated_foretmiss_index = new std::vector<int>;
1298   m_trkExt_selected_associated_emulation_foretmiss_index = new std::vector<int>;
1299 
1300   m_trkExtEmu_pt = new std::vector<float>;
1301   m_trkExtEmu_eta = new std::vector<float>;
1302   m_trkExtEmu_phi = new std::vector<float>;
1303   m_trkExtEmu_d0 = new std::vector<float>;
1304   m_trkExtEmu_rho = new std::vector<float>;
1305   m_trkExtEmu_z0 = new std::vector<float>;
1306   m_trkExtEmu_chi2rphi = new std::vector<float>;
1307   m_trkExtEmu_chi2rz = new std::vector<float>;
1308   m_trkExtEmu_bendchi2 = new std::vector<float>;
1309   m_trkExtEmu_MVA = new std::vector<float>;
1310   m_trkExtEmu_nstub = new std::vector<int>;
1311 
1312   m_tp_pt = new std::vector<float>;
1313   m_tp_eta = new std::vector<float>;
1314   m_tp_phi = new std::vector<float>;
1315   m_tp_dxy = new std::vector<float>;
1316   m_tp_d0 = new std::vector<float>;
1317   m_tp_z0 = new std::vector<float>;
1318   m_tp_x = new std::vector<float>;
1319   m_tp_y = new std::vector<float>;
1320   m_tp_z = new std::vector<float>;
1321   m_tp_d0_prod = new std::vector<float>;
1322   m_tp_z0_prod = new std::vector<float>;
1323   m_tp_pdgid = new std::vector<int>;
1324   m_tp_isHard = new std::vector<bool>;
1325   m_tp_nmatch = new std::vector<int>;
1326   m_tp_nstub = new std::vector<int>;
1327   m_tp_eventid = new std::vector<int>;
1328   m_tp_charge = new std::vector<int>;
1329 
1330   m_gen_pt = new std::vector<float>;
1331   m_gen_phi = new std::vector<float>;
1332   m_gen_pdgid = new std::vector<float>;
1333   m_gen_mother_pdgid = new std::vector<float>;
1334 
1335   m_gen_z0 = new std::vector<float>;
1336 
1337   m_dv_d_T = new std::vector<float>;
1338   m_dv_R_T = new std::vector<float>;
1339   m_dv_cos_T = new std::vector<float>;
1340   m_dv_x = new std::vector<float>;
1341   m_dv_y = new std::vector<float>;
1342   m_dv_z = new std::vector<float>;
1343   m_dv_firstIndexTrk = new std::vector<int>;
1344   m_dv_secondIndexTrk = new std::vector<int>;
1345   m_dv_del_Z = new std::vector<float>;
1346   m_dv_isReal = new std::vector<bool>;
1347   m_dv_score = new std::vector<float>;
1348 
1349   m_matchtrk_pt = new std::vector<float>;
1350   m_matchtrk_eta = new std::vector<float>;
1351   m_matchtrk_phi = new std::vector<float>;
1352   m_matchtrk_z0 = new std::vector<float>;
1353   m_matchtrk_d0 = new std::vector<float>;
1354   m_matchtrk_rinv = new std::vector<float>;
1355   m_matchtrk_chi2 = new std::vector<float>;
1356   m_matchtrk_chi2dof = new std::vector<float>;
1357   m_matchtrk_chi2rphi = new std::vector<float>;
1358   m_matchtrk_chi2rz = new std::vector<float>;
1359   m_matchtrk_bendchi2 = new std::vector<float>;
1360   m_matchtrk_MVA1 = new std::vector<float>;
1361   m_matchtrk_nstub = new std::vector<int>;
1362   m_matchtrk_dhits = new std::vector<int>;
1363   m_matchtrk_lhits = new std::vector<int>;
1364   m_matchtrk_seed = new std::vector<int>;
1365   m_matchtrk_hitpattern = new std::vector<int>;
1366 
1367   m_matchtrkExt_pt = new std::vector<float>;
1368   m_matchtrkExt_eta = new std::vector<float>;
1369   m_matchtrkExt_phi = new std::vector<float>;
1370   m_matchtrkExt_z0 = new std::vector<float>;
1371   m_matchtrkExt_d0 = new std::vector<float>;
1372   m_matchtrkExt_rinv = new std::vector<float>;
1373   m_matchtrkExt_chi2 = new std::vector<float>;
1374   m_matchtrkExt_chi2dof = new std::vector<float>;
1375   m_matchtrkExt_chi2rphi = new std::vector<float>;
1376   m_matchtrkExt_chi2rz = new std::vector<float>;
1377   m_matchtrkExt_bendchi2 = new std::vector<float>;
1378   m_matchtrkExt_MVA = new std::vector<float>;
1379   m_matchtrkExt_nstub = new std::vector<int>;
1380   m_matchtrkExt_dhits = new std::vector<int>;
1381   m_matchtrkExt_lhits = new std::vector<int>;
1382   m_matchtrkExt_seed = new std::vector<int>;
1383   m_matchtrkExt_hitpattern = new std::vector<int>;
1384 
1385   m_matchtrkExtEmu_pt = new std::vector<float>;
1386   m_matchtrkExtEmu_eta = new std::vector<float>;
1387   m_matchtrkExtEmu_phi = new std::vector<float>;
1388   m_matchtrkExtEmu_d0 = new std::vector<float>;
1389   m_matchtrkExtEmu_rho = new std::vector<float>;
1390   m_matchtrkExtEmu_z0 = new std::vector<float>;
1391   m_matchtrkExtEmu_chi2rphi = new std::vector<float>;
1392   m_matchtrkExtEmu_chi2rz = new std::vector<float>;
1393   m_matchtrkExtEmu_bendchi2 = new std::vector<float>;
1394   m_matchtrkExtEmu_MVA = new std::vector<float>;
1395   m_matchtrkExtEmu_nstub = new std::vector<int>;
1396 
1397   m_allstub_x = new std::vector<float>;
1398   m_allstub_y = new std::vector<float>;
1399   m_allstub_z = new std::vector<float>;
1400   m_allstub_isBarrel = new std::vector<int>;
1401   m_allstub_layer = new std::vector<int>;
1402   m_allstub_isPSmodule = new std::vector<int>;
1403   m_allstub_trigDisplace = new std::vector<float>;
1404   m_allstub_trigOffset = new std::vector<float>;
1405   m_allstub_trigPos = new std::vector<float>;
1406   m_allstub_trigBend = new std::vector<float>;
1407   m_allstub_matchTP_pdgid = new std::vector<int>;
1408   m_allstub_matchTP_pt = new std::vector<float>;
1409   m_allstub_matchTP_eta = new std::vector<float>;
1410   m_allstub_matchTP_phi = new std::vector<float>;
1411   m_allstub_genuine = new std::vector<int>;
1412 
1413   m_pv_L1reco = new std::vector<float>;
1414   m_pv_L1reco_sum = new std::vector<float>;
1415   m_pv_L1reco_emu = new std::vector<float>;
1416   m_pv_L1reco_sum_emu = new std::vector<float>;
1417   m_pv_MC = new std::vector<float>;
1418   m_MC_lep = new std::vector<int>;
1419 
1420   m_genjet_eta = new std::vector<float>;
1421   m_genjet_phi = new std::vector<float>;
1422   m_genjet_p = new std::vector<float>;
1423   m_genjet_pt = new std::vector<float>;
1424 
1425   m_trkjet_eta = new std::vector<float>;
1426   m_trkjet_vz = new std::vector<float>;
1427   m_trkjet_phi = new std::vector<float>;
1428   m_trkjet_p = new std::vector<float>;
1429   m_trkjet_pt = new std::vector<float>;
1430   m_trkjet_ntracks = new std::vector<int>;
1431   m_trkjet_nDisplaced = new std::vector<int>;
1432   m_trkjet_nTight = new std::vector<int>;
1433   m_trkjet_nTightDisplaced = new std::vector<int>;
1434   m_trkjet_ntdtrk = new std::vector<int>;
1435 
1436   m_triplet_eta = new std::vector<float>;
1437   m_triplet_phi = new std::vector<float>;
1438   m_triplet_pt = new std::vector<float>;
1439   m_triplet_mass = new std::vector<float>;
1440   m_triplet_charge = new std::vector<float>;
1441   m_triplet_dmassmax = new std::vector<float>;
1442   m_triplet_dmassmin = new std::vector<float>;
1443   m_triplet_dzmax = new std::vector<float>;
1444   m_triplet_dzmin = new std::vector<float>;
1445   m_triplet_trk1pt = new std::vector<float>;
1446   m_triplet_trk1eta = new std::vector<float>;
1447   m_triplet_trk1phi = new std::vector<float>;
1448   m_triplet_trk1z = new std::vector<float>;
1449   m_triplet_trk1npar = new std::vector<float>;
1450   m_triplet_trk1mva = new std::vector<float>;
1451   m_triplet_trk2pt = new std::vector<float>;
1452   m_triplet_trk2eta = new std::vector<float>;
1453   m_triplet_trk2phi = new std::vector<float>;
1454   m_triplet_trk2z = new std::vector<float>;
1455   m_triplet_trk2npar = new std::vector<float>;
1456   m_triplet_trk2mva = new std::vector<float>;
1457   m_triplet_trk3pt = new std::vector<float>;
1458   m_triplet_trk3eta = new std::vector<float>;
1459   m_triplet_trk3phi = new std::vector<float>;
1460   m_triplet_trk3z = new std::vector<float>;
1461   m_triplet_trk3npar = new std::vector<float>;
1462   m_triplet_trk3mva = new std::vector<float>;
1463 
1464   m_trkjetem_pt = new std::vector<float>;
1465   m_trkjetem_phi = new std::vector<float>;
1466   m_trkjetem_eta = new std::vector<float>;
1467   m_trkjetem_z = new std::vector<float>;
1468   m_trkjetem_ntracks = new std::vector<int>;
1469   m_trkjetem_nxtracks = new std::vector<int>;
1470 
1471   m_trkfastjet_eta = new std::vector<float>;
1472   m_trkfastjet_vz = new std::vector<float>;
1473   m_trkfastjet_phi = new std::vector<float>;
1474   m_trkfastjet_p = new std::vector<float>;
1475   m_trkfastjet_pt = new std::vector<float>;
1476   m_trkfastjet_ntracks = new std::vector<int>;
1477   m_trkfastjet_tp_sumpt = new std::vector<float>;
1478   m_trkfastjet_truetp_sumpt = new std::vector<float>;
1479 
1480   m_trkjetExt_eta = new std::vector<float>;
1481   m_trkjetExt_vz = new std::vector<float>;
1482   m_trkjetExt_phi = new std::vector<float>;
1483   m_trkjetExt_p = new std::vector<float>;
1484   m_trkjetExt_pt = new std::vector<float>;
1485   m_trkjetExt_ntracks = new std::vector<int>;
1486   m_trkjetExt_nDisplaced = new std::vector<int>;
1487   m_trkjetExt_nTight = new std::vector<int>;
1488   m_trkjetExt_nTightDisplaced = new std::vector<int>;
1489   m_trkjetExt_ntdtrk = new std::vector<int>;
1490 
1491   m_trkjetemExt_pt = new std::vector<float>;
1492   m_trkjetemExt_phi = new std::vector<float>;
1493   m_trkjetemExt_eta = new std::vector<float>;
1494   m_trkjetemExt_z = new std::vector<float>;
1495   m_trkjetemExt_ntracks = new std::vector<int>;
1496   m_trkjetemExt_nxtracks = new std::vector<int>;
1497 
1498   m_trkfastjetExt_eta = new std::vector<float>;
1499   m_trkfastjetExt_vz = new std::vector<float>;
1500   m_trkfastjetExt_phi = new std::vector<float>;
1501   m_trkfastjetExt_p = new std::vector<float>;
1502   m_trkfastjetExt_pt = new std::vector<float>;
1503   m_trkfastjetExt_ntracks = new std::vector<int>;
1504   m_trkfastjetExt_tp_sumpt = new std::vector<float>;
1505   m_trkfastjetExt_truetp_sumpt = new std::vector<float>;
1506 
1507   // ntuple
1508   eventTree = fs->make<TTree>("eventTree", "Event tree");
1509   if (SaveAllTracks && (Displaced == "Prompt" || Displaced == "Both")) {
1510     eventTree->Branch("trk_pt", &m_trk_pt);
1511     eventTree->Branch("trk_eta", &m_trk_eta);
1512     eventTree->Branch("trk_phi", &m_trk_phi);
1513     eventTree->Branch("trk_phi_local", &m_trk_phi_local);
1514     eventTree->Branch("trk_d0", &m_trk_d0);
1515     eventTree->Branch("trk_rinv", &m_trk_rinv);
1516     eventTree->Branch("trk_z0", &m_trk_z0);
1517     eventTree->Branch("trk_chi2", &m_trk_chi2);
1518     eventTree->Branch("trk_chi2dof", &m_trk_chi2dof);
1519     eventTree->Branch("trk_chi2rphi", &m_trk_chi2rphi);
1520     eventTree->Branch("trk_chi2rz", &m_trk_chi2rz);
1521     eventTree->Branch("trk_bendchi2", &m_trk_bendchi2);
1522     eventTree->Branch("trk_MVA1", &m_trk_MVA1);
1523     eventTree->Branch("trk_nstub", &m_trk_nstub);
1524     eventTree->Branch("trk_lhits", &m_trk_lhits);
1525     eventTree->Branch("trk_dhits", &m_trk_dhits);
1526     eventTree->Branch("trk_seed", &m_trk_seed);
1527     eventTree->Branch("trk_hitpattern", &m_trk_hitpattern);
1528     eventTree->Branch("trk_phiSector", &m_trk_phiSector);
1529     eventTree->Branch("trk_genuine", &m_trk_genuine);
1530     eventTree->Branch("trk_loose", &m_trk_loose);
1531     eventTree->Branch("trk_unknown", &m_trk_unknown);
1532     eventTree->Branch("trk_combinatoric", &m_trk_combinatoric);
1533     eventTree->Branch("trk_fake", &m_trk_fake);
1534     eventTree->Branch("trk_matchtp_pdgid", &m_trk_matchtp_pdgid);
1535     eventTree->Branch("trk_matchtp_mother_pdgid", &m_trk_matchtp_mother_pdgid);
1536     eventTree->Branch("trk_matchtp_pt", &m_trk_matchtp_pt);
1537     eventTree->Branch("trk_matchtp_eta", &m_trk_matchtp_eta);
1538     eventTree->Branch("trk_matchtp_phi", &m_trk_matchtp_phi);
1539     eventTree->Branch("trk_matchtp_z0", &m_trk_matchtp_z0);
1540     eventTree->Branch("trk_matchtp_dxy", &m_trk_matchtp_dxy);
1541     eventTree->Branch("trk_gtt_pt", &m_trk_gtt_pt);
1542     eventTree->Branch("trk_gtt_eta", &m_trk_gtt_eta);
1543     eventTree->Branch("trk_gtt_phi", &m_trk_gtt_phi);
1544     eventTree->Branch("trk_gtt_selected_index", &m_trk_selected_index);
1545     eventTree->Branch("trk_gtt_selected_emulation_index", &m_trk_selected_emulation_index);
1546     eventTree->Branch("trk_gtt_selected_associated_index", &m_trk_selected_associated_index);
1547     eventTree->Branch("trk_gtt_selected_associated_emulation_index", &m_trk_selected_associated_emulation_index);
1548     eventTree->Branch("trk_gtt_selected_forjets_index", &m_trk_selected_forjets_index);
1549     eventTree->Branch("trk_gtt_selected_emulation_forjets_index", &m_trk_selected_emulation_forjets_index);
1550     eventTree->Branch("trk_gtt_selected_associated_forjets_index", &m_trk_selected_associated_forjets_index);
1551     eventTree->Branch("trk_gtt_selected_associated_emulation_forjets_index",
1552                       &m_trk_selected_associated_emulation_forjets_index);
1553     eventTree->Branch("trk_gtt_selected_foretmiss_index", &m_trk_selected_foretmiss_index);
1554     eventTree->Branch("trk_gtt_selected_emulation_foretmiss_index", &m_trk_selected_emulation_foretmiss_index);
1555     eventTree->Branch("trk_gtt_selected_associated_foretmiss_index", &m_trk_selected_associated_foretmiss_index);
1556     eventTree->Branch("trk_gtt_selected_associated_emulation_foretmiss_index",
1557                       &m_trk_selected_associated_emulation_foretmiss_index);
1558   }
1559 
1560   if (SaveAllTracks && (Displaced == "Displaced" || Displaced == "Both")) {
1561     eventTree->Branch("trkExt_pt", &m_trkExt_pt);
1562     eventTree->Branch("trkExt_eta", &m_trkExt_eta);
1563     eventTree->Branch("trkExt_phi", &m_trkExt_phi);
1564     eventTree->Branch("trkExt_phi_local", &m_trkExt_phi_local);
1565     eventTree->Branch("trkExt_d0", &m_trkExt_d0);
1566     eventTree->Branch("trkExt_rinv", &m_trkExt_rinv);
1567     eventTree->Branch("trkExt_z0", &m_trkExt_z0);
1568     eventTree->Branch("trkExt_chi2", &m_trkExt_chi2);
1569     eventTree->Branch("trkExt_chi2dof", &m_trkExt_chi2dof);
1570     eventTree->Branch("trkExt_chi2rphi", &m_trkExt_chi2rphi);
1571     eventTree->Branch("trkExt_chi2rz", &m_trkExt_chi2rz);
1572     eventTree->Branch("trkExt_bendchi2", &m_trkExt_bendchi2);
1573     eventTree->Branch("trkExt_MVA", &m_trkExt_MVA);
1574     eventTree->Branch("trkExt_nstub", &m_trkExt_nstub);
1575     eventTree->Branch("trkExt_lhits", &m_trkExt_lhits);
1576     eventTree->Branch("trkExt_dhits", &m_trkExt_dhits);
1577     eventTree->Branch("trkExt_seed", &m_trkExt_seed);
1578     eventTree->Branch("trkExt_hitpattern", &m_trkExt_hitpattern);
1579     eventTree->Branch("trkExt_phiSector", &m_trkExt_phiSector);
1580     eventTree->Branch("trkExt_genuine", &m_trkExt_genuine);
1581     eventTree->Branch("trkExt_loose", &m_trkExt_loose);
1582     eventTree->Branch("trkExt_unknown", &m_trkExt_unknown);
1583     eventTree->Branch("trkExt_combinatoric", &m_trkExt_combinatoric);
1584     eventTree->Branch("trkExt_fake", &m_trkExt_fake);
1585     eventTree->Branch("trkExt_matchtp_pdgid", &m_trkExt_matchtp_pdgid);
1586     eventTree->Branch("trkExt_matchtp_isHard", &m_trkExt_matchtp_isHard);
1587     eventTree->Branch("trkExt_matchtp_pt", &m_trkExt_matchtp_pt);
1588     eventTree->Branch("trkExt_matchtp_eta", &m_trkExt_matchtp_eta);
1589     eventTree->Branch("trkExt_matchtp_phi", &m_trkExt_matchtp_phi);
1590     eventTree->Branch("trkExt_matchtp_z0", &m_trkExt_matchtp_z0);
1591     eventTree->Branch("trkExt_matchtp_dxy", &m_trkExt_matchtp_dxy);
1592     eventTree->Branch("trkExt_matchtp_d0", &m_trkExt_matchtp_d0);
1593     eventTree->Branch("trkExt_matchtp_x", &m_trkExt_matchtp_x);
1594     eventTree->Branch("trkExt_matchtp_y", &m_trkExt_matchtp_y);
1595     eventTree->Branch("trkExt_matchtp_z", &m_trkExt_matchtp_z);
1596     eventTree->Branch("trkExt_gtt_pt", &m_trkExt_gtt_pt);
1597     eventTree->Branch("trkExt_gtt_eta", &m_trkExt_gtt_eta);
1598     eventTree->Branch("trkExt_gtt_phi", &m_trkExt_gtt_phi);
1599     eventTree->Branch("trkExt_gtt_selected_index", &m_trkExt_selected_index);
1600     eventTree->Branch("trkExt_gtt_selected_emulation_index", &m_trkExt_selected_emulation_index);
1601     eventTree->Branch("trkExt_gtt_selected_associated_index", &m_trkExt_selected_associated_index);
1602     eventTree->Branch("trkExt_gtt_selected_associated_emulation_index", &m_trkExt_selected_associated_emulation_index);
1603     eventTree->Branch("trkExt_gtt_selected_forjets_index", &m_trkExt_selected_forjets_index);
1604     eventTree->Branch("trkExt_gtt_selected_emulation_forjets_index", &m_trkExt_selected_emulation_forjets_index);
1605     eventTree->Branch("trkExt_gtt_selected_associated_forjets_index", &m_trkExt_selected_associated_forjets_index);
1606     eventTree->Branch("trkExt_gtt_selected_associated_emulation_forjets_index",
1607                       &m_trkExt_selected_associated_emulation_forjets_index);
1608     eventTree->Branch("trkExt_gtt_selected_foretmiss_index", &m_trkExt_selected_foretmiss_index);
1609     eventTree->Branch("trkExt_gtt_selected_emulation_foretmiss_index", &m_trkExt_selected_emulation_foretmiss_index);
1610     eventTree->Branch("trkExt_gtt_selected_associated_foretmiss_index", &m_trkExt_selected_associated_foretmiss_index);
1611     eventTree->Branch("trkExt_gtt_selected_associated_emulation_foretmiss_index",
1612                       &m_trkExt_selected_associated_emulation_foretmiss_index);
1613 
1614     eventTree->Branch("trkExtEmu_pt", &m_trkExtEmu_pt);
1615     eventTree->Branch("trkExtEmu_eta", &m_trkExtEmu_eta);
1616     eventTree->Branch("trkExtEmu_phi", &m_trkExtEmu_phi);
1617     eventTree->Branch("trkExtEmu_d0", &m_trkExtEmu_d0);
1618     eventTree->Branch("trkExtEmu_rho", &m_trkExtEmu_rho);
1619     eventTree->Branch("trkExtEmu_z0", &m_trkExtEmu_z0);
1620     eventTree->Branch("trkExtEmu_chi2rphi", &m_trkExtEmu_chi2rphi);
1621     eventTree->Branch("trkExtEmu_chi2rz", &m_trkExtEmu_chi2rz);
1622     eventTree->Branch("trkExtEmu_bendchi2", &m_trkExtEmu_bendchi2);
1623     eventTree->Branch("trkExtEmu_MVA", &m_trkExtEmu_MVA);
1624     eventTree->Branch("trkExtEmu_nstub", &m_trkExtEmu_nstub);
1625   }
1626   eventTree->Branch("tp_pt", &m_tp_pt);
1627   eventTree->Branch("tp_eta", &m_tp_eta);
1628   eventTree->Branch("tp_phi", &m_tp_phi);
1629   eventTree->Branch("tp_dxy", &m_tp_dxy);
1630   eventTree->Branch("tp_d0", &m_tp_d0);
1631   eventTree->Branch("tp_z0", &m_tp_z0);
1632   eventTree->Branch("tp_x", &m_tp_x);
1633   eventTree->Branch("tp_y", &m_tp_y);
1634   eventTree->Branch("tp_z", &m_tp_z);
1635   eventTree->Branch("tp_d0_prod", &m_tp_d0_prod);
1636   eventTree->Branch("tp_z0_prod", &m_tp_z0_prod);
1637   eventTree->Branch("tp_pdgid", &m_tp_pdgid);
1638   eventTree->Branch("tp_isHard", &m_tp_isHard);
1639   eventTree->Branch("tp_nmatch", &m_tp_nmatch);
1640   eventTree->Branch("tp_nstub", &m_tp_nstub);
1641   eventTree->Branch("tp_eventid", &m_tp_eventid);
1642   eventTree->Branch("tp_charge", &m_tp_charge);
1643 
1644   if (Displaced == "Prompt" || Displaced == "Both") {
1645     eventTree->Branch("matchtrk_pt", &m_matchtrk_pt);
1646     eventTree->Branch("matchtrk_eta", &m_matchtrk_eta);
1647     eventTree->Branch("matchtrk_phi", &m_matchtrk_phi);
1648     eventTree->Branch("matchtrk_z0", &m_matchtrk_z0);
1649     eventTree->Branch("matchtrk_d0", &m_matchtrk_d0);
1650     eventTree->Branch("matchtrk_rinv", &m_matchtrk_rinv);
1651     eventTree->Branch("matchtrk_chi2", &m_matchtrk_chi2);
1652     eventTree->Branch("matchtrk_chi2dof", &m_matchtrk_chi2dof);
1653     eventTree->Branch("matchtrk_chi2rphi", &m_matchtrk_chi2rphi);
1654     eventTree->Branch("matchtrk_chi2rz", &m_matchtrk_chi2rz);
1655     eventTree->Branch("matchtrk_bendchi2", &m_matchtrk_bendchi2);
1656     eventTree->Branch("matchtrk_MVA1", &m_matchtrk_MVA1);
1657     eventTree->Branch("matchtrk_nstub", &m_matchtrk_nstub);
1658     eventTree->Branch("matchtrk_lhits", &m_matchtrk_lhits);
1659     eventTree->Branch("matchtrk_dhits", &m_matchtrk_dhits);
1660     eventTree->Branch("matchtrk_seed", &m_matchtrk_seed);
1661     eventTree->Branch("matchtrk_hitpattern", &m_matchtrk_hitpattern);
1662   }
1663 
1664   if (Displaced == "Displaced" || Displaced == "Both") {
1665     eventTree->Branch("matchtrkExt_pt", &m_matchtrkExt_pt);
1666     eventTree->Branch("matchtrkExt_eta", &m_matchtrkExt_eta);
1667     eventTree->Branch("matchtrkExt_phi", &m_matchtrkExt_phi);
1668     eventTree->Branch("matchtrkExt_z0", &m_matchtrkExt_z0);
1669     eventTree->Branch("matchtrkExt_d0", &m_matchtrkExt_d0);
1670     eventTree->Branch("matchtrkExt_rinv", &m_matchtrkExt_rinv);
1671     eventTree->Branch("matchtrkExt_chi2", &m_matchtrkExt_chi2);
1672     eventTree->Branch("matchtrkExt_chi2dof", &m_matchtrkExt_chi2dof);
1673     eventTree->Branch("matchtrkExt_chi2rphi", &m_matchtrkExt_chi2rphi);
1674     eventTree->Branch("matchtrkExt_chi2rz", &m_matchtrkExt_chi2rz);
1675     eventTree->Branch("matchtrkExt_bendchi2", &m_matchtrkExt_bendchi2);
1676     eventTree->Branch("matchtrkExt_MVA", &m_matchtrkExt_MVA);
1677     eventTree->Branch("matchtrkExt_nstub", &m_matchtrkExt_nstub);
1678     eventTree->Branch("matchtrkExt_lhits", &m_matchtrkExt_lhits);
1679     eventTree->Branch("matchtrkExt_dhits", &m_matchtrkExt_dhits);
1680     eventTree->Branch("matchtrkExt_seed", &m_matchtrkExt_seed);
1681     eventTree->Branch("matchtrkExt_hitpattern", &m_matchtrkExt_hitpattern);
1682 
1683     eventTree->Branch("matchtrkExtEmu_pt", &m_matchtrkExtEmu_pt);
1684     eventTree->Branch("matchtrkExtEmu_eta", &m_matchtrkExtEmu_eta);
1685     eventTree->Branch("matchtrkExtEmu_phi", &m_matchtrkExtEmu_phi);
1686     eventTree->Branch("matchtrkExtEmu_d0", &m_matchtrkExtEmu_d0);
1687     eventTree->Branch("matchtrkExtEmu_rho", &m_matchtrkExtEmu_rho);
1688     eventTree->Branch("matchtrkExtEmu_z0", &m_matchtrkExtEmu_z0);
1689     eventTree->Branch("matchtrkExtEmu_chi2rphi", &m_matchtrkExtEmu_chi2rphi);
1690     eventTree->Branch("matchtrkExtEmu_chi2rz", &m_matchtrkExtEmu_chi2rz);
1691     eventTree->Branch("matchtrkExtEmu_bendchi2", &m_matchtrkExtEmu_bendchi2);
1692     eventTree->Branch("matchtrkExtEmu_MVA", &m_matchtrkExtEmu_MVA);
1693     eventTree->Branch("matchtrkExtEmu_nstub", &m_matchtrkExtEmu_nstub);
1694   }
1695 
1696   if (SaveStubs) {
1697     eventTree->Branch("allstub_x", &m_allstub_x);
1698     eventTree->Branch("allstub_y", &m_allstub_y);
1699     eventTree->Branch("allstub_z", &m_allstub_z);
1700     eventTree->Branch("allstub_isBarrel", &m_allstub_isBarrel);
1701     eventTree->Branch("allstub_layer", &m_allstub_layer);
1702     eventTree->Branch("allstub_isPSmodule", &m_allstub_isPSmodule);
1703     eventTree->Branch("allstub_trigDisplace", &m_allstub_trigDisplace);
1704     eventTree->Branch("allstub_trigOffset", &m_allstub_trigOffset);
1705     eventTree->Branch("allstub_trigPos", &m_allstub_trigPos);
1706     eventTree->Branch("allstub_trigBend", &m_allstub_trigBend);
1707     eventTree->Branch("allstub_matchTP_pdgid", &m_allstub_matchTP_pdgid);
1708     eventTree->Branch("allstub_matchTP_pt", &m_allstub_matchTP_pt);
1709     eventTree->Branch("allstub_matchTP_eta", &m_allstub_matchTP_eta);
1710     eventTree->Branch("allstub_matchTP_phi", &m_allstub_matchTP_phi);
1711     eventTree->Branch("allstub_genuine", &m_allstub_genuine);
1712   }
1713 
1714   eventTree->Branch("pv_L1reco", &m_pv_L1reco);
1715   eventTree->Branch("pv_L1reco_sum", &m_pv_L1reco_sum);
1716   eventTree->Branch("pv_L1reco_emu", &m_pv_L1reco_emu);
1717   eventTree->Branch("pv_L1reco_sum_emu", &m_pv_L1reco_sum_emu);
1718   eventTree->Branch("MC_lep", &m_MC_lep);
1719   eventTree->Branch("pv_MC", &m_pv_MC);
1720   eventTree->Branch("gen_pt", &m_gen_pt);
1721   eventTree->Branch("gen_phi", &m_gen_phi);
1722   eventTree->Branch("gen_pdgid", &m_gen_pdgid);
1723   eventTree->Branch("gen_mother_pdgid", &m_gen_mother_pdgid);
1724 
1725   eventTree->Branch("gen_z0", &m_gen_z0);
1726   if (runDispVert) {
1727     eventTree->Branch("dv_d_T", &m_dv_d_T);
1728     eventTree->Branch("dv_R_T", &m_dv_R_T);
1729     eventTree->Branch("dv_cos_T", &m_dv_cos_T);
1730     eventTree->Branch("dv_x", &m_dv_x);
1731     eventTree->Branch("dv_y", &m_dv_y);
1732     eventTree->Branch("dv_z", &m_dv_z);
1733     eventTree->Branch("dv_firstIndexTrk", &m_dv_firstIndexTrk);
1734     eventTree->Branch("dv_secondIndexTrk", &m_dv_secondIndexTrk);
1735     eventTree->Branch("dv_del_Z", &m_dv_del_Z);
1736     eventTree->Branch("dv_isReal", &m_dv_isReal);
1737     eventTree->Branch("dv_score", &m_dv_score);
1738   }
1739   if (SaveTrackJets) {
1740     eventTree->Branch("genjet_eta", &m_genjet_eta);
1741     eventTree->Branch("genjet_p", &m_genjet_p);
1742     eventTree->Branch("genjet_pt", &m_genjet_pt);
1743     eventTree->Branch("genjet_phi", &m_genjet_phi);
1744     if (Displaced == "Prompt" || Displaced == "Both") {
1745       eventTree->Branch("trkfastjet_eta", &m_trkfastjet_eta);
1746       eventTree->Branch("trkfastjet_vz", &m_trkfastjet_vz);
1747       eventTree->Branch("trkfastjet_p", &m_trkfastjet_p);
1748       eventTree->Branch("trkfastjet_pt", &m_trkfastjet_pt);
1749       eventTree->Branch("trkfastjet_phi", &m_trkfastjet_phi);
1750       eventTree->Branch("trkfastjet_ntracks", &m_trkfastjet_ntracks);
1751       eventTree->Branch("trkfastjet_truetp_sumpt", m_trkfastjet_truetp_sumpt);
1752 
1753       eventTree->Branch("trkjet_eta", &m_trkjet_eta);
1754       eventTree->Branch("trkjet_vz", &m_trkjet_vz);
1755       eventTree->Branch("trkjet_p", &m_trkjet_p);
1756       eventTree->Branch("trkjet_pt", &m_trkjet_pt);
1757       eventTree->Branch("trkjet_phi", &m_trkjet_phi);
1758       eventTree->Branch("trkjet_ntracks", &m_trkjet_ntracks);
1759       eventTree->Branch("trkjet_nDisplaced", &m_trkjet_nDisplaced);
1760       eventTree->Branch("trkjet_nTight", &m_trkjet_nTight);
1761       eventTree->Branch("trkjet_nTightDisplaced", &m_trkjet_nTightDisplaced);
1762 
1763       eventTree->Branch("trkjetem_eta", &m_trkjetem_eta);
1764       eventTree->Branch("trkjetem_pt", &m_trkjetem_pt);
1765       eventTree->Branch("trkjetem_phi", &m_trkjetem_phi);
1766       eventTree->Branch("trkjetem_z", &m_trkjetem_z);
1767       eventTree->Branch("trkjetem_ntracks", &m_trkjetem_ntracks);
1768       eventTree->Branch("trkjetem_nxtracks", &m_trkjetem_nxtracks);
1769     }
1770     eventTree->Branch("triplet_eta", &m_triplet_eta);
1771     eventTree->Branch("triplet_pt", &m_triplet_pt);
1772     eventTree->Branch("triplet_phi", &m_triplet_phi);
1773     eventTree->Branch("triplet_mass", &m_triplet_mass);
1774     eventTree->Branch("triplet_charge", &m_triplet_charge);
1775     eventTree->Branch("triplet_dmassmax", &m_triplet_dmassmax);
1776     eventTree->Branch("triplet_dmassmin", &m_triplet_dmassmin);
1777     eventTree->Branch("triplet_dzmax", &m_triplet_dzmax);
1778     eventTree->Branch("triplet_dzmin", &m_triplet_dzmin);
1779     eventTree->Branch("triplet_trk1pt", &m_triplet_trk1pt);
1780     eventTree->Branch("triplet_trk1eta", &m_triplet_trk1eta);
1781     eventTree->Branch("triplet_trk1phi", &m_triplet_trk1phi);
1782     eventTree->Branch("triplet_trk1z", &m_triplet_trk1z);
1783     eventTree->Branch("triplet_trk1npar", &m_triplet_trk1npar);
1784     eventTree->Branch("triplet_trk1mva", &m_triplet_trk1mva);
1785     eventTree->Branch("triplet_trk2pt", &m_triplet_trk2pt);
1786     eventTree->Branch("triplet_trk2eta", &m_triplet_trk2eta);
1787     eventTree->Branch("triplet_trk2phi", &m_triplet_trk2phi);
1788     eventTree->Branch("triplet_trk2z", &m_triplet_trk2z);
1789     eventTree->Branch("triplet_trk2npar", &m_triplet_trk2npar);
1790     eventTree->Branch("triplet_trk2mva", &m_triplet_trk2mva);
1791     eventTree->Branch("triplet_trk3pt", &m_triplet_trk3pt);
1792     eventTree->Branch("triplet_trk3eta", &m_triplet_trk3eta);
1793     eventTree->Branch("triplet_trk3phi", &m_triplet_trk3phi);
1794     eventTree->Branch("triplet_trk3z", &m_triplet_trk3z);
1795     eventTree->Branch("triplet_trk3npar", &m_triplet_trk3npar);
1796     eventTree->Branch("triplet_trk3mva", &m_triplet_trk3mva);
1797 
1798     if (Displaced == "Displaced" || Displaced == "Both") {
1799       eventTree->Branch("trkfastjetExt_eta", &m_trkfastjetExt_eta);
1800       eventTree->Branch("trkfastjetExt_vz", &m_trkfastjetExt_vz);
1801       eventTree->Branch("trkfastjetExt_p", &m_trkfastjetExt_p);
1802       eventTree->Branch("trkfastjetExt_pt", &m_trkfastjetExt_pt);
1803       eventTree->Branch("trkfastjetExt_phi", &m_trkfastjetExt_phi);
1804       eventTree->Branch("trkfastjetExt_ntracks", &m_trkfastjetExt_ntracks);
1805       eventTree->Branch("trkfastjetExt_truetp_sumpt", m_trkfastjetExt_truetp_sumpt);
1806 
1807       eventTree->Branch("trkjetExt_eta", &m_trkjetExt_eta);
1808       eventTree->Branch("trkjetExt_vz", &m_trkjetExt_vz);
1809       eventTree->Branch("trkjetExt_p", &m_trkjetExt_p);
1810       eventTree->Branch("trkjetExt_pt", &m_trkjetExt_pt);
1811       eventTree->Branch("trkjetExt_phi", &m_trkjetExt_phi);
1812       eventTree->Branch("trkjetExt_ntracks", &m_trkjetExt_ntracks);
1813       eventTree->Branch("trkjetExt_nDisplaced", &m_trkjetExt_nDisplaced);
1814       eventTree->Branch("trkjetExt_nTight", &m_trkjetExt_nTight);
1815       eventTree->Branch("trkjetExt_nTightDisplaced", &m_trkjetExt_nTightDisplaced);
1816 
1817       eventTree->Branch("trkjetemExt_eta", &m_trkjetemExt_eta);
1818       eventTree->Branch("trkjetemExt_pt", &m_trkjetemExt_pt);
1819       eventTree->Branch("trkjetemExt_phi", &m_trkjetemExt_phi);
1820       eventTree->Branch("trkjetemExt_z", &m_trkjetemExt_z);
1821       eventTree->Branch("trkjetemExt_ntracks", &m_trkjetemExt_ntracks);
1822       eventTree->Branch("trkjetemExt_nxtracks", &m_trkjetemExt_nxtracks);
1823     }
1824   }
1825 
1826   if (SaveTrackSums) {
1827     eventTree->Branch("trueMET", &trueMET, "trueMET/F");
1828     eventTree->Branch("trueTkMET", &trueTkMET, "trueTkMET/F");
1829 
1830     if (Displaced == "Prompt" || Displaced == "Both") {
1831       eventTree->Branch("trkMET", &trkMET, "trkMET/F");
1832       eventTree->Branch("trkMETPhi", &trkMETPhi, "trkMETPhi/F");
1833       eventTree->Branch("trkMETEmu", &trkMETEmu, "trkMETEmu/F");
1834       eventTree->Branch("trkMETEmuPhi", &trkMETEmuPhi, "trkMETEmuPhi/F");
1835       eventTree->Branch("trkMHT", &trkMHT, "trkMHT/F");
1836       eventTree->Branch("trkHT", &trkHT, "trkHT/F");
1837       eventTree->Branch("trkMHTEmu", &trkMHTEmu, "trkMHTEmu/F");
1838       eventTree->Branch("trkMHTEmuPhi", &trkMHTEmuPhi, "trkMHTEmuPhi/F");
1839       eventTree->Branch("trkHTEmu", &trkHTEmu, "trkHTEmu/F");
1840     }
1841     if (Displaced == "Displaced" || Displaced == "Both") {
1842       eventTree->Branch("trkMETExt", &trkMETExt, "trkMETExt/F");
1843       eventTree->Branch("trkMETPhiExt", &trkMETPhiExt, "trkMETPhiExt/F");
1844       eventTree->Branch("trkMHTExt", &trkMHTExt, "trkMHTExt/F");
1845       eventTree->Branch("trkHTExt", &trkHTExt, "trkHTExt/F");
1846       eventTree->Branch("trkMHTEmuExt", &trkMHTEmuExt, "trkMHTEmuExt/F");
1847       eventTree->Branch("trkMHTEmuPhiExt", &trkMHTEmuPhiExt, "trkMHTEmuPhiExt/F");
1848       eventTree->Branch("trkHTEmuExt", &trkHTEmuExt, "trkHTEmuExt/F");
1849     }
1850   }
1851 }
1852 
1853 //////////
1854 // ANALYZE
1855 void L1TrackObjectNtupleMaker::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) {
1856   if (not available_)
1857     return;  // No ROOT file open.
1858 
1859   if (!(MyProcess == 13 || MyProcess == 11 || MyProcess == 211 || MyProcess == 6 || MyProcess == 15 ||
1860         MyProcess == 1)) {
1861     edm::LogVerbatim("Tracklet") << "The specified MyProcess is invalid! Exiting...";
1862     return;
1863   }
1864 
1865   // clear variables
1866   if (SaveAllTracks && (Displaced == "Prompt" || Displaced == "Both")) {
1867     m_trk_pt->clear();
1868     m_trk_eta->clear();
1869     m_trk_phi->clear();
1870     m_trk_phi_local->clear();
1871     m_trk_d0->clear();
1872     m_trk_rinv->clear();
1873     m_trk_z0->clear();
1874     m_trk_chi2->clear();
1875     m_trk_chi2dof->clear();
1876     m_trk_chi2rphi->clear();
1877     m_trk_chi2rz->clear();
1878     m_trk_bendchi2->clear();
1879     m_trk_MVA1->clear();
1880     m_trk_nstub->clear();
1881     m_trk_lhits->clear();
1882     m_trk_dhits->clear();
1883     m_trk_seed->clear();
1884     m_trk_hitpattern->clear();
1885     m_trk_phiSector->clear();
1886     m_trk_genuine->clear();
1887     m_trk_loose->clear();
1888     m_trk_unknown->clear();
1889     m_trk_combinatoric->clear();
1890     m_trk_fake->clear();
1891     m_trk_matchtp_pdgid->clear();
1892     m_trk_matchtp_mother_pdgid->clear();
1893     m_trk_matchtp_pt->clear();
1894     m_trk_matchtp_eta->clear();
1895     m_trk_matchtp_phi->clear();
1896     m_trk_matchtp_z0->clear();
1897     m_trk_matchtp_dxy->clear();
1898     m_trk_gtt_pt->clear();
1899     m_trk_gtt_eta->clear();
1900     m_trk_gtt_phi->clear();
1901     m_trk_selected_index->clear();
1902     m_trk_selected_emulation_index->clear();
1903     m_trk_selected_associated_index->clear();
1904     m_trk_selected_associated_emulation_index->clear();
1905     m_trk_selected_forjets_index->clear();
1906     m_trk_selected_emulation_forjets_index->clear();
1907     m_trk_selected_associated_forjets_index->clear();
1908     m_trk_selected_associated_emulation_forjets_index->clear();
1909     m_trk_selected_foretmiss_index->clear();
1910     m_trk_selected_emulation_foretmiss_index->clear();
1911     m_trk_selected_associated_foretmiss_index->clear();
1912     m_trk_selected_associated_emulation_foretmiss_index->clear();
1913   }
1914   if (SaveAllTracks && (Displaced == "Displaced" || Displaced == "Both")) {
1915     m_trkExt_pt->clear();
1916     m_trkExt_eta->clear();
1917     m_trkExt_phi->clear();
1918     m_trkExt_phi_local->clear();
1919     m_trkExt_d0->clear();
1920     m_trkExt_rinv->clear();
1921     m_trkExt_z0->clear();
1922     m_trkExt_chi2->clear();
1923     m_trkExt_chi2dof->clear();
1924     m_trkExt_chi2rphi->clear();
1925     m_trkExt_chi2rz->clear();
1926     m_trkExt_bendchi2->clear();
1927     m_trkExt_MVA->clear();
1928     m_trkExt_nstub->clear();
1929     m_trkExt_lhits->clear();
1930     m_trkExt_dhits->clear();
1931     m_trkExt_seed->clear();
1932     m_trkExt_hitpattern->clear();
1933     m_trkExt_phiSector->clear();
1934     m_trkExt_genuine->clear();
1935     m_trkExt_loose->clear();
1936     m_trkExt_unknown->clear();
1937     m_trkExt_combinatoric->clear();
1938     m_trkExt_fake->clear();
1939     m_trkExt_matchtp_pdgid->clear();
1940     m_trkExt_matchtp_isHard->clear();
1941     m_trkExt_matchtp_pt->clear();
1942     m_trkExt_matchtp_eta->clear();
1943     m_trkExt_matchtp_phi->clear();
1944     m_trkExt_matchtp_z0->clear();
1945     m_trkExt_matchtp_dxy->clear();
1946     m_trkExt_matchtp_d0->clear();
1947     m_trkExt_matchtp_x->clear();
1948     m_trkExt_matchtp_y->clear();
1949     m_trkExt_matchtp_z->clear();
1950     m_trkExt_gtt_pt->clear();
1951     m_trkExt_gtt_eta->clear();
1952     m_trkExt_gtt_phi->clear();
1953     m_trkExt_selected_index->clear();
1954     m_trkExt_selected_emulation_index->clear();
1955     m_trkExt_selected_associated_index->clear();
1956     m_trkExt_selected_associated_emulation_index->clear();
1957     m_trkExt_selected_forjets_index->clear();
1958     m_trkExt_selected_emulation_forjets_index->clear();
1959     m_trkExt_selected_associated_forjets_index->clear();
1960     m_trkExt_selected_associated_emulation_forjets_index->clear();
1961     m_trkExt_selected_foretmiss_index->clear();
1962     m_trkExt_selected_emulation_foretmiss_index->clear();
1963     m_trkExt_selected_associated_foretmiss_index->clear();
1964     m_trkExt_selected_associated_emulation_foretmiss_index->clear();
1965 
1966     m_trkExtEmu_pt->clear();
1967     m_trkExtEmu_eta->clear();
1968     m_trkExtEmu_phi->clear();
1969     m_trkExtEmu_d0->clear();
1970     m_trkExtEmu_rho->clear();
1971     m_trkExtEmu_z0->clear();
1972     m_trkExtEmu_chi2rphi->clear();
1973     m_trkExtEmu_chi2rz->clear();
1974     m_trkExtEmu_bendchi2->clear();
1975     m_trkExtEmu_MVA->clear();
1976     m_trkExtEmu_nstub->clear();
1977   }
1978   m_tp_pt->clear();
1979   m_tp_eta->clear();
1980   m_tp_phi->clear();
1981   m_tp_dxy->clear();
1982   m_tp_d0->clear();
1983   m_tp_z0->clear();
1984   m_tp_x->clear();
1985   m_tp_y->clear();
1986   m_tp_z->clear();
1987   m_tp_d0_prod->clear();
1988   m_tp_z0_prod->clear();
1989   m_tp_pdgid->clear();
1990   m_tp_isHard->clear();
1991   m_tp_nmatch->clear();
1992   m_tp_nstub->clear();
1993   m_tp_eventid->clear();
1994   m_tp_charge->clear();
1995 
1996   m_gen_pt->clear();
1997   m_gen_phi->clear();
1998   m_gen_pdgid->clear();
1999   m_gen_mother_pdgid->clear();
2000 
2001   m_gen_z0->clear();
2002   if (runDispVert) {
2003     m_dv_d_T->clear();
2004     m_dv_R_T->clear();
2005     m_dv_cos_T->clear();
2006     m_dv_x->clear();
2007     m_dv_y->clear();
2008     m_dv_z->clear();
2009     m_dv_firstIndexTrk->clear();
2010     m_dv_secondIndexTrk->clear();
2011     m_dv_del_Z->clear();
2012     m_dv_isReal->clear();
2013     m_dv_score->clear();
2014   }
2015   if (Displaced == "Prompt" || Displaced == "Both") {
2016     m_matchtrk_pt->clear();
2017     m_matchtrk_eta->clear();
2018     m_matchtrk_phi->clear();
2019     m_matchtrk_z0->clear();
2020     m_matchtrk_d0->clear();
2021     m_matchtrk_rinv->clear();
2022     m_matchtrk_chi2->clear();
2023     m_matchtrk_chi2dof->clear();
2024     m_matchtrk_chi2rphi->clear();
2025     m_matchtrk_chi2rz->clear();
2026     m_matchtrk_bendchi2->clear();
2027     m_matchtrk_MVA1->clear();
2028     m_matchtrk_nstub->clear();
2029     m_matchtrk_lhits->clear();
2030     m_matchtrk_dhits->clear();
2031     m_matchtrk_seed->clear();
2032     m_matchtrk_hitpattern->clear();
2033   }
2034 
2035   if (Displaced == "Displaced" || Displaced == "Both") {
2036     m_matchtrkExt_pt->clear();
2037     m_matchtrkExt_eta->clear();
2038     m_matchtrkExt_phi->clear();
2039     m_matchtrkExt_z0->clear();
2040     m_matchtrkExt_d0->clear();
2041     m_matchtrkExt_rinv->clear();
2042     m_matchtrkExt_chi2->clear();
2043     m_matchtrkExt_chi2dof->clear();
2044     m_matchtrkExt_chi2rphi->clear();
2045     m_matchtrkExt_chi2rz->clear();
2046     m_matchtrkExt_bendchi2->clear();
2047     m_matchtrkExt_MVA->clear();
2048     m_matchtrkExt_nstub->clear();
2049     m_matchtrkExt_lhits->clear();
2050     m_matchtrkExt_dhits->clear();
2051     m_matchtrkExt_seed->clear();
2052     m_matchtrkExt_hitpattern->clear();
2053 
2054     m_matchtrkExtEmu_pt->clear();
2055     m_matchtrkExtEmu_eta->clear();
2056     m_matchtrkExtEmu_phi->clear();
2057     m_matchtrkExtEmu_d0->clear();
2058     m_matchtrkExtEmu_rho->clear();
2059     m_matchtrkExtEmu_z0->clear();
2060     m_matchtrkExtEmu_chi2rphi->clear();
2061     m_matchtrkExtEmu_chi2rz->clear();
2062     m_matchtrkExtEmu_bendchi2->clear();
2063     m_matchtrkExtEmu_MVA->clear();
2064     m_matchtrkExtEmu_nstub->clear();
2065   }
2066 
2067   if (SaveStubs) {
2068     m_allstub_x->clear();
2069     m_allstub_y->clear();
2070     m_allstub_z->clear();
2071     m_allstub_isBarrel->clear();
2072     m_allstub_layer->clear();
2073     m_allstub_isPSmodule->clear();
2074     m_allstub_trigDisplace->clear();
2075     m_allstub_trigOffset->clear();
2076     m_allstub_trigPos->clear();
2077     m_allstub_trigBend->clear();
2078     m_allstub_matchTP_pdgid->clear();
2079     m_allstub_matchTP_pt->clear();
2080     m_allstub_matchTP_eta->clear();
2081     m_allstub_matchTP_phi->clear();
2082     m_allstub_genuine->clear();
2083   }
2084 
2085   if (SaveTrackJets) {
2086     m_genjet_eta->clear();
2087     m_genjet_pt->clear();
2088     m_genjet_phi->clear();
2089     m_genjet_p->clear();
2090     if (Displaced == "Prompt" || Displaced == "Both") {
2091       m_trkjet_eta->clear();
2092       m_trkjet_pt->clear();
2093       m_trkjet_vz->clear();
2094       m_trkjet_phi->clear();
2095       m_trkjet_p->clear();
2096       m_trkjet_ntracks->clear();
2097       m_trkjet_nDisplaced->clear();
2098       m_trkjet_nTight->clear();
2099       m_trkjet_nTightDisplaced->clear();
2100       m_trkjet_ntdtrk->clear();
2101       m_trkfastjet_eta->clear();
2102       m_trkfastjet_pt->clear();
2103       m_trkfastjet_vz->clear();
2104       m_trkfastjet_phi->clear();
2105       m_trkfastjet_p->clear();
2106       m_trkfastjet_ntracks->clear();
2107       m_trkfastjet_truetp_sumpt->clear();
2108       m_trkfastjet_tp_sumpt->clear();
2109       m_trkjetem_eta->clear();
2110       m_trkjetem_pt->clear();
2111       m_trkjetem_phi->clear();
2112       m_trkjetem_z->clear();
2113       m_trkjetem_ntracks->clear();
2114       m_trkjetem_nxtracks->clear();
2115     }
2116     m_triplet_eta->clear();
2117     m_triplet_pt->clear();
2118     m_triplet_phi->clear();
2119     m_triplet_mass->clear();
2120     m_triplet_charge->clear();
2121     m_triplet_dmassmax->clear();
2122     m_triplet_dmassmin->clear();
2123     m_triplet_dzmax->clear();
2124     m_triplet_dzmin->clear();
2125     m_triplet_trk1pt->clear();
2126     m_triplet_trk1eta->clear();
2127     m_triplet_trk1phi->clear();
2128     m_triplet_trk1z->clear();
2129     m_triplet_trk1npar->clear();
2130     m_triplet_trk1mva->clear();
2131     m_triplet_trk2pt->clear();
2132     m_triplet_trk2eta->clear();
2133     m_triplet_trk2phi->clear();
2134     m_triplet_trk2z->clear();
2135     m_triplet_trk2npar->clear();
2136     m_triplet_trk2mva->clear();
2137     m_triplet_trk3pt->clear();
2138     m_triplet_trk3eta->clear();
2139     m_triplet_trk3phi->clear();
2140     m_triplet_trk3z->clear();
2141     m_triplet_trk3npar->clear();
2142     m_triplet_trk3mva->clear();
2143 
2144     if (Displaced == "Displaced" || Displaced == "Both") {
2145       m_trkjetExt_eta->clear();
2146       m_trkjetExt_pt->clear();
2147       m_trkjetExt_vz->clear();
2148       m_trkjetExt_phi->clear();
2149       m_trkjetExt_p->clear();
2150       m_trkjetExt_ntracks->clear();
2151       m_trkjetExt_nDisplaced->clear();
2152       m_trkjetExt_nTight->clear();
2153       m_trkjetExt_nTightDisplaced->clear();
2154       m_trkjetExt_ntdtrk->clear();
2155       m_trkfastjetExt_eta->clear();
2156       m_trkfastjetExt_pt->clear();
2157       m_trkfastjetExt_vz->clear();
2158       m_trkfastjetExt_phi->clear();
2159       m_trkfastjetExt_p->clear();
2160       m_trkfastjetExt_ntracks->clear();
2161       m_trkfastjetExt_truetp_sumpt->clear();
2162       m_trkfastjetExt_tp_sumpt->clear();
2163       m_trkjetemExt_eta->clear();
2164       m_trkjetemExt_pt->clear();
2165       m_trkjetemExt_phi->clear();
2166       m_trkjetemExt_z->clear();
2167       m_trkjetemExt_ntracks->clear();
2168       m_trkjetemExt_nxtracks->clear();
2169     }
2170   }
2171 
2172   m_pv_L1reco->clear();
2173   m_pv_L1reco_sum->clear();
2174   m_pv_L1reco_emu->clear();
2175   m_pv_L1reco_sum_emu->clear();
2176   m_pv_MC->clear();
2177   m_MC_lep->clear();
2178 
2179   // -----------------------------------------------------------------------------------------------
2180   // retrieve various containers
2181   // -----------------------------------------------------------------------------------------------
2182 
2183   // L1 stubs
2184   edm::Handle<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>> TTStubHandle;
2185   if (SaveStubs)
2186     iEvent.getByToken(ttStubToken_, TTStubHandle);
2187 
2188   // MC truth association maps
2189   edm::Handle<TTClusterAssociationMap<Ref_Phase2TrackerDigi_>> MCTruthTTClusterHandle;
2190   iEvent.getByToken(ttClusterMCTruthToken_, MCTruthTTClusterHandle);
2191   edm::Handle<TTStubAssociationMap<Ref_Phase2TrackerDigi_>> MCTruthTTStubHandle;
2192   iEvent.getByToken(ttStubMCTruthToken_, MCTruthTTStubHandle);
2193 
2194   // tracking particles
2195   edm::Handle<std::vector<TrackingParticle>> TrackingParticleHandle;
2196   edm::Handle<std::vector<TrackingVertex>> TrackingVertexHandle;
2197   iEvent.getByToken(TrackingParticleToken_, TrackingParticleHandle);
2198   iEvent.getByToken(TrackingVertexToken_, TrackingVertexHandle);
2199 
2200   // -----------------------------------------------------------------------------------------------
2201   // more for TTStubs
2202   const TrackerTopology& tTopo = iSetup.getData(tTopoToken_);
2203   const TrackerGeometry& tGeom = iSetup.getData(tGeomToken_);
2204 
2205   //Gen particles
2206   edm::Handle<std::vector<reco::GenParticle>> GenParticleHandle;
2207   iEvent.getByToken(GenParticleToken_, GenParticleHandle);
2208   edm::Handle<std::vector<SimVertex>> SimVertexHandle;
2209   iEvent.getByToken(SimVertexToken_, SimVertexHandle);
2210   edm::Handle<std::vector<reco::GenJet>> GenJetHandle;
2211   iEvent.getByToken(GenJetToken_, GenJetHandle);
2212 
2213   //Displaced vertices
2214   edm::Handle<std::vector<l1t::DisplacedTrackVertex>> DispVertHandle;
2215   if (runDispVert) {
2216     iEvent.getByToken(DispVertToken_, DispVertHandle);
2217   }
2218 
2219   //Vertex
2220   edm::Handle<l1t::VertexCollection> L1PrimaryVertexHandle;
2221   iEvent.getByToken(L1VertexToken_, L1PrimaryVertexHandle);
2222   std::vector<l1t::Vertex>::const_iterator vtxIter;
2223 
2224   edm::Handle<l1t::VertexWordCollection> L1PrimaryVertexEmuHandle;
2225   iEvent.getByToken(L1VertexEmuToken_, L1PrimaryVertexEmuHandle);
2226   std::vector<l1t::VertexWord>::const_iterator vtxEmuIter;
2227 
2228   // Track jets
2229   edm::Handle<std::vector<l1t::TkJet>> TrackFastJetsHandle;
2230   edm::Handle<std::vector<l1t::TkJet>> TrackFastJetsExtendedHandle;
2231   edm::Handle<l1t::TkJetCollection> TrackJetsHandle;
2232   edm::Handle<l1t::TkJetCollection> TrackJetsExtendedHandle;
2233   edm::Handle<l1t::TkJetWordCollection> TrackJetsEmuHandle;
2234   edm::Handle<l1t::TkJetWordCollection> TrackJetsExtendedEmuHandle;
2235   std::vector<l1t::TkJet>::const_iterator jetIter;
2236   std::vector<l1t::TkJetWord>::const_iterator jetemIter;
2237   edm::Handle<l1t::TkTripletCollection> TrackTripletsHandle;
2238   std::vector<l1t::TkTriplet>::const_iterator tripletIter;
2239 
2240   // Track Sums
2241   edm::Handle<std::vector<l1t::TkEtMiss>> L1TkMETHandle;
2242   edm::Handle<std::vector<l1t::TkEtMiss>> L1TkMETExtendedHandle;
2243   edm::Handle<std::vector<l1t::EtSum>> L1TkMETEmuHandle;
2244   edm::Handle<std::vector<l1t::TkHTMiss>> L1TkMHTHandle;
2245   edm::Handle<std::vector<l1t::TkHTMiss>> L1TkMHTExtendedHandle;
2246   edm::Handle<std::vector<l1t::EtSum>> L1TkMHTEmuHandle;
2247   edm::Handle<std::vector<l1t::EtSum>> L1TkMHTEmuExtendedHandle;
2248 
2249   // L1 tracks
2250   edm::Handle<L1TrackCollection> TTTrackHandle;
2251   edm::Handle<L1TrackCollection> TTTrackExtendedHandle;
2252   edm::Handle<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>> MCTruthTTTrackHandle;
2253   edm::Handle<TTTrackAssociationMap<Ref_Phase2TrackerDigi_>> MCTruthTTTrackExtendedHandle;
2254   edm::Handle<L1TrackCollection> TTTrackGTTHandle;
2255   edm::Handle<L1TrackCollection> TTTrackExtendedGTTHandle;
2256   edm::Handle<L1TrackRefCollection> TTTrackSelectedHandle;
2257   edm::Handle<L1TrackRefCollection> TTTrackSelectedEmulationHandle;
2258   edm::Handle<L1TrackRefCollection> TTTrackSelectedAssociatedHandle;
2259   edm::Handle<L1TrackRefCollection> TTTrackSelectedAssociatedEmulationHandle;
2260   edm::Handle<L1TrackRefCollection> TTTrackSelectedForJetsHandle;
2261   edm::Handle<L1TrackRefCollection> TTTrackSelectedEmulationForJetsHandle;
2262   edm::Handle<L1TrackRefCollection> TTTrackSelectedAssociatedForJetsHandle;
2263   edm::Handle<L1TrackRefCollection> TTTrackSelectedAssociatedEmulationForJetsHandle;
2264   edm::Handle<L1TrackRefCollection> TTTrackSelectedForEtMissHandle;
2265   edm::Handle<L1TrackRefCollection> TTTrackSelectedEmulationForEtMissHandle;
2266   edm::Handle<L1TrackRefCollection> TTTrackSelectedAssociatedForEtMissHandle;
2267   edm::Handle<L1TrackRefCollection> TTTrackSelectedAssociatedEmulationForEtMissHandle;
2268   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedAssociatedHandle;
2269   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedAssociatedEmulationHandle;
2270   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedHandle;
2271   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedEmulationHandle;
2272   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedAssociatedForJetsHandle;
2273   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedAssociatedEmulationForJetsHandle;
2274   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedForJetsHandle;
2275   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedEmulationForJetsHandle;
2276   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedAssociatedForEtMissHandle;
2277   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedAssociatedEmulationForEtMissHandle;
2278   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedForEtMissHandle;
2279   edm::Handle<L1TrackRefCollection> TTTrackExtendedSelectedEmulationForEtMissHandle;
2280   L1TrackCollection::const_iterator iterL1Track;
2281 
2282   if (Displaced == "Prompt" || Displaced == "Both") {
2283     iEvent.getByToken(TrackFastJetsToken_, TrackFastJetsHandle);
2284     iEvent.getByToken(TrackJetsToken_, TrackJetsHandle);
2285     iEvent.getByToken(TrackJetsEmuToken_, TrackJetsEmuHandle);
2286     iEvent.getByToken(TrackTripletsToken_, TrackTripletsHandle);
2287     iEvent.getByToken(TrackMETToken_, L1TkMETHandle);
2288     iEvent.getByToken(TrackMETEmuToken_, L1TkMETEmuHandle);
2289     iEvent.getByToken(TrackMHTToken_, L1TkMHTHandle);
2290     iEvent.getByToken(TrackMHTEmuToken_, L1TkMHTEmuHandle);
2291     iEvent.getByToken(ttTrackToken_, TTTrackHandle);
2292     iEvent.getByToken(ttTrackMCTruthToken_, MCTruthTTTrackHandle);
2293     iEvent.getByToken(ttTrackGTTToken_, TTTrackGTTHandle);
2294     iEvent.getByToken(ttTrackSelectedToken_, TTTrackSelectedHandle);
2295     iEvent.getByToken(ttTrackSelectedEmulationToken_, TTTrackSelectedEmulationHandle);
2296     iEvent.getByToken(ttTrackSelectedAssociatedToken_, TTTrackSelectedAssociatedHandle);
2297     iEvent.getByToken(ttTrackSelectedAssociatedEmulationToken_, TTTrackSelectedAssociatedEmulationHandle);
2298     iEvent.getByToken(ttTrackSelectedForJetsToken_, TTTrackSelectedForJetsHandle);
2299     iEvent.getByToken(ttTrackSelectedEmulationForJetsToken_, TTTrackSelectedEmulationForJetsHandle);
2300     iEvent.getByToken(ttTrackSelectedAssociatedForJetsToken_, TTTrackSelectedAssociatedForJetsHandle);
2301     iEvent.getByToken(ttTrackSelectedAssociatedEmulationForJetsToken_, TTTrackSelectedAssociatedEmulationForJetsHandle);
2302     iEvent.getByToken(ttTrackSelectedForEtMissToken_, TTTrackSelectedForEtMissHandle);
2303     iEvent.getByToken(ttTrackSelectedEmulationForEtMissToken_, TTTrackSelectedEmulationForEtMissHandle);
2304     iEvent.getByToken(ttTrackSelectedAssociatedForEtMissToken_, TTTrackSelectedAssociatedForEtMissHandle);
2305     iEvent.getByToken(ttTrackSelectedAssociatedEmulationForEtMissToken_,
2306                       TTTrackSelectedAssociatedEmulationForEtMissHandle);
2307   }
2308   if (Displaced == "Displaced" || Displaced == "Both") {
2309     iEvent.getByToken(TrackFastJetsExtendedToken_, TrackFastJetsExtendedHandle);
2310     iEvent.getByToken(TrackJetsExtendedToken_, TrackJetsExtendedHandle);
2311     iEvent.getByToken(TrackJetsExtendedEmuToken_, TrackJetsExtendedEmuHandle);
2312     iEvent.getByToken(TrackMETExtendedToken_, L1TkMETExtendedHandle);
2313     iEvent.getByToken(TrackMHTExtendedToken_, L1TkMHTExtendedHandle);
2314     iEvent.getByToken(TrackMHTEmuExtendedToken_, L1TkMHTEmuExtendedHandle);
2315     iEvent.getByToken(ttTrackExtendedToken_, TTTrackExtendedHandle);
2316     iEvent.getByToken(ttTrackMCTruthExtendedToken_, MCTruthTTTrackExtendedHandle);
2317     iEvent.getByToken(ttTrackExtendedGTTToken_, TTTrackExtendedGTTHandle);
2318     iEvent.getByToken(ttTrackExtendedSelectedToken_, TTTrackExtendedSelectedHandle);
2319     iEvent.getByToken(ttTrackExtendedSelectedEmulationToken_, TTTrackExtendedSelectedEmulationHandle);
2320     iEvent.getByToken(ttTrackExtendedSelectedAssociatedToken_, TTTrackExtendedSelectedAssociatedHandle);
2321     iEvent.getByToken(ttTrackExtendedSelectedAssociatedEmulationToken_,
2322                       TTTrackExtendedSelectedAssociatedEmulationHandle);
2323     iEvent.getByToken(ttTrackExtendedSelectedForJetsToken_, TTTrackExtendedSelectedForJetsHandle);
2324     iEvent.getByToken(ttTrackExtendedSelectedEmulationForJetsToken_, TTTrackExtendedSelectedEmulationForJetsHandle);
2325     iEvent.getByToken(ttTrackExtendedSelectedAssociatedForJetsToken_, TTTrackExtendedSelectedAssociatedForJetsHandle);
2326     iEvent.getByToken(ttTrackExtendedSelectedAssociatedEmulationForJetsToken_,
2327                       TTTrackExtendedSelectedAssociatedEmulationForJetsHandle);
2328     iEvent.getByToken(ttTrackExtendedSelectedForEtMissToken_, TTTrackExtendedSelectedForEtMissHandle);
2329     iEvent.getByToken(ttTrackExtendedSelectedEmulationForEtMissToken_, TTTrackExtendedSelectedEmulationForEtMissHandle);
2330     iEvent.getByToken(ttTrackExtendedSelectedAssociatedForEtMissToken_,
2331                       TTTrackExtendedSelectedAssociatedForEtMissHandle);
2332     iEvent.getByToken(ttTrackExtendedSelectedAssociatedEmulationForEtMissToken_,
2333                       TTTrackExtendedSelectedAssociatedEmulationForEtMissHandle);
2334   }
2335 
2336   //Loop over gen particles
2337   if (GenParticleHandle.isValid()) {
2338     vector<reco::GenParticle>::const_iterator genpartIter;
2339 
2340     float zvtx_gen = -999;
2341     float trueMETx = 0;
2342     float trueMETy = 0;
2343     trueMET = 0;
2344     for (genpartIter = GenParticleHandle->begin(); genpartIter != GenParticleHandle->end(); ++genpartIter) {
2345       int status = genpartIter->status();
2346       if (status != 1)
2347         continue;
2348       zvtx_gen = genpartIter->vz();  //for gen vertex
2349       int id = genpartIter->pdgId();
2350       bool isNeutrino = false;
2351       if ((std::abs(id) == 12 || std::abs(id) == 14 || std::abs(id) == 16))
2352         isNeutrino = true;
2353       if (isNeutrino || id == 1000022) {
2354         trueMETx += genpartIter->pt() * cos(genpartIter->phi());
2355         trueMETy += genpartIter->pt() * sin(genpartIter->phi());
2356       }
2357 
2358       m_gen_pt->push_back(genpartIter->pt());
2359       m_gen_phi->push_back(genpartIter->phi());
2360       m_gen_pdgid->push_back(genpartIter->pdgId());
2361       if (genpartIter->numberOfMothers() > 0) {
2362         m_gen_mother_pdgid->push_back(genpartIter->mother(0)->pdgId());
2363       } else {
2364         m_gen_mother_pdgid->push_back(-999);
2365       }
2366 
2367       m_gen_z0->push_back(zvtx_gen);
2368     }
2369 
2370     trueMET = sqrt(trueMETx * trueMETx + trueMETy * trueMETy);
2371   } else {
2372     edm::LogWarning("DataNotFound") << "\nWarning: GenParticleHandle not found in the event" << std::endl;
2373   }
2374 
2375   // loop over displaced vertices
2376   if (DispVertHandle.isValid()) {
2377     vector<l1t::DisplacedTrackVertex>::const_iterator dispVertIter;
2378     for (dispVertIter = DispVertHandle->begin(); dispVertIter != DispVertHandle->end(); ++dispVertIter) {
2379       m_dv_d_T->push_back(dispVertIter->d_T());
2380       m_dv_R_T->push_back(dispVertIter->R_T());
2381       m_dv_cos_T->push_back(dispVertIter->cos_T());
2382       m_dv_x->push_back(dispVertIter->x());
2383       m_dv_y->push_back(dispVertIter->y());
2384       m_dv_z->push_back(dispVertIter->z());
2385       m_dv_firstIndexTrk->push_back(dispVertIter->firstIndexTrk());
2386       m_dv_secondIndexTrk->push_back(dispVertIter->secondIndexTrk());
2387       m_dv_del_Z->push_back(dispVertIter->del_Z());
2388       m_dv_isReal->push_back(dispVertIter->isReal());
2389       m_dv_score->push_back(dispVertIter->score());
2390     }
2391   }
2392 
2393   if (SimVertexHandle.isValid()) {
2394     if (!SimVertexHandle->empty()) {
2395       const SimVertex simPVh = *(SimVertexHandle->begin());
2396       m_pv_MC->push_back(simPVh.position().z());
2397     } else {
2398       edm::LogWarning("MissingCollectionEntries") << "\nWarning: SimVertex collection is empty!" << std::endl;
2399     }
2400   } else {
2401     edm::LogWarning("DataNotFound") << "\nWarning: SimVertexHandle not found in the event" << std::endl;
2402   }
2403 
2404   // ----------------------------------------------------------------------------------------------
2405   // loop over L1 stubs
2406   // ----------------------------------------------------------------------------------------------
2407   if (SaveStubs) {
2408     for (auto gd = tGeom.dets().begin(); gd != tGeom.dets().end(); gd++) {
2409       DetId detid = (*gd)->geographicalId();
2410       if (detid.subdetId() != StripSubdetector::TOB && detid.subdetId() != StripSubdetector::TID)
2411         continue;
2412       if (!tTopo.isLower(detid))
2413         continue;                             // loop on the stacks: choose the lower arbitrarily
2414       DetId stackDetid = tTopo.stack(detid);  // Stub module detid
2415 
2416       if (TTStubHandle->find(stackDetid) == TTStubHandle->end())
2417         continue;
2418 
2419       // Get the DetSets of the Clusters
2420       edmNew::DetSet<TTStub<Ref_Phase2TrackerDigi_>> stubs = (*TTStubHandle)[stackDetid];
2421       const GeomDetUnit* det0 = tGeom.idToDetUnit(detid);
2422       const auto* theGeomDet = dynamic_cast<const PixelGeomDetUnit*>(det0);
2423       const PixelTopology* topol = dynamic_cast<const PixelTopology*>(&(theGeomDet->specificTopology()));
2424 
2425       // loop over stubs
2426       for (auto stubIter = stubs.begin(); stubIter != stubs.end(); ++stubIter) {
2427         edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>> tempStubPtr =
2428             edmNew::makeRefTo(TTStubHandle, stubIter);
2429 
2430         int isBarrel = 0;
2431         int layer = -999999;
2432         if (detid.subdetId() == StripSubdetector::TOB) {
2433           isBarrel = 1;
2434           layer = static_cast<int>(tTopo.layer(detid));
2435         } else if (detid.subdetId() == StripSubdetector::TID) {
2436           isBarrel = 0;
2437           layer = static_cast<int>(tTopo.layer(detid));
2438         } else {
2439           edm::LogVerbatim("Tracklet") << "WARNING -- neither TOB or TID stub, shouldn't happen...";
2440           layer = -1;
2441         }
2442 
2443         int isPSmodule = 0;
2444         if (topol->nrows() == 960)
2445           isPSmodule = 1;
2446 
2447         MeasurementPoint coords = tempStubPtr->clusterRef(0)->findAverageLocalCoordinatesCentered();
2448         LocalPoint clustlp = topol->localPosition(coords);
2449         GlobalPoint posStub = theGeomDet->surface().toGlobal(clustlp);
2450 
2451         double tmp_stub_x = posStub.x();
2452         double tmp_stub_y = posStub.y();
2453         double tmp_stub_z = posStub.z();
2454 
2455         float trigDisplace = tempStubPtr->rawBend();
2456         float trigOffset = tempStubPtr->bendOffset();
2457         float trigPos = tempStubPtr->innerClusterPosition();
2458         float trigBend = tempStubPtr->bendFE();
2459 
2460         m_allstub_x->push_back(tmp_stub_x);
2461         m_allstub_y->push_back(tmp_stub_y);
2462         m_allstub_z->push_back(tmp_stub_z);
2463         m_allstub_isBarrel->push_back(isBarrel);
2464         m_allstub_layer->push_back(layer);
2465         m_allstub_isPSmodule->push_back(isPSmodule);
2466         m_allstub_trigDisplace->push_back(trigDisplace);
2467         m_allstub_trigOffset->push_back(trigOffset);
2468         m_allstub_trigPos->push_back(trigPos);
2469         m_allstub_trigBend->push_back(trigBend);
2470 
2471         // matched to tracking particle?
2472         edm::Ptr<TrackingParticle> my_tp = MCTruthTTStubHandle->findTrackingParticlePtr(tempStubPtr);
2473 
2474         int myTP_pdgid = -999;
2475         float myTP_pt = -999;
2476         float myTP_eta = -999;
2477         float myTP_phi = -999;
2478 
2479         if (my_tp.isNull() == false) {
2480           int tmp_eventid = my_tp->eventId().event();
2481           if (tmp_eventid > 0)
2482             continue;  // this means stub from pileup track
2483           myTP_pdgid = my_tp->pdgId();
2484           myTP_pt = my_tp->p4().pt();
2485           myTP_eta = my_tp->p4().eta();
2486           myTP_phi = my_tp->p4().phi();
2487         }
2488         int tmp_stub_genuine = 0;
2489         if (MCTruthTTStubHandle->isGenuine(tempStubPtr))
2490           tmp_stub_genuine = 1;
2491 
2492         m_allstub_matchTP_pdgid->push_back(myTP_pdgid);
2493         m_allstub_matchTP_pt->push_back(myTP_pt);
2494         m_allstub_matchTP_eta->push_back(myTP_eta);
2495         m_allstub_matchTP_phi->push_back(myTP_phi);
2496         m_allstub_genuine->push_back(tmp_stub_genuine);
2497       }
2498     }
2499   }
2500 
2501   // ----------------------------------------------------------------------------------------------
2502   // loop over (prompt) L1 tracks
2503   // ----------------------------------------------------------------------------------------------
2504   if (SaveAllTracks && (Displaced == "Prompt" || Displaced == "Both")) {
2505     if (DebugMode) {
2506       edm::LogVerbatim("Tracklet") << "\n Loop over L1 tracks!";
2507       edm::LogVerbatim("Tracklet") << "\n Looking at " << Displaced << " tracks!";
2508     }
2509 
2510     int this_l1track = 0;
2511     for (iterL1Track = TTTrackHandle->begin(); iterL1Track != TTTrackHandle->end(); iterL1Track++) {
2512       L1TrackPtr l1track_ptr(TTTrackHandle, this_l1track);
2513       L1TrackRef l1track_ref(TTTrackGTTHandle, this_l1track);
2514 
2515       float tmp_trk_pt = iterL1Track->momentum().perp();
2516       float tmp_trk_eta = iterL1Track->momentum().eta();
2517       float tmp_trk_phi = iterL1Track->momentum().phi();
2518       float tmp_trk_phi_local = iterL1Track->localPhi();
2519       float tmp_trk_z0 = iterL1Track->z0();            //cm
2520       int tmp_trk_nFitPars = iterL1Track->nFitPars();  //4 or 5
2521 
2522       float tmp_trk_d0 = -999;
2523       float tmp_trk_rinv = iterL1Track->rInv();
2524       if (tmp_trk_nFitPars == 5) {
2525         float tmp_trk_x0 = iterL1Track->POCA().x();
2526         float tmp_trk_y0 = iterL1Track->POCA().y();
2527         tmp_trk_d0 = -tmp_trk_x0 * sin(tmp_trk_phi) + tmp_trk_y0 * cos(tmp_trk_phi);
2528         // tmp_trk_d0 = iterL1Track->d0();
2529       }
2530 
2531       float tmp_trk_chi2 = iterL1Track->chi2();
2532       float tmp_trk_chi2dof = iterL1Track->chi2Red();
2533       float tmp_trk_chi2rphi = iterL1Track->chi2XYRed();
2534       float tmp_trk_chi2rz = iterL1Track->chi2ZRed();
2535       float tmp_trk_bendchi2 = iterL1Track->stubPtConsistency();
2536       float tmp_trk_MVA1 = iterL1Track->trkMVA1();
2537 
2538       std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
2539           stubRefs = iterL1Track->getStubRefs();
2540       int tmp_trk_nstub = (int)stubRefs.size();
2541       int tmp_trk_seed = 0;
2542       tmp_trk_seed = (int)iterL1Track->trackSeedType();
2543       int tmp_trk_hitpattern = 0;
2544       tmp_trk_hitpattern = (int)iterL1Track->hitPattern();
2545       unsigned int tmp_trk_phiSector = iterL1Track->phiSector();
2546 
2547       // ----------------------------------------------------------------------------------------------
2548       // loop over stubs on tracks
2549       int tmp_trk_dhits = 0;
2550       int tmp_trk_lhits = 0;
2551       if (true) {
2552         // loop over stubs
2553         for (int is = 0; is < tmp_trk_nstub; is++) {
2554           //detID of stub
2555           DetId detIdStub = tGeom.idToDet((stubRefs.at(is)->clusterRef(0))->getDetId())->geographicalId();
2556           MeasurementPoint coords = stubRefs.at(is)->clusterRef(0)->findAverageLocalCoordinatesCentered();
2557           const GeomDet* theGeomDet = tGeom.idToDet(detIdStub);
2558           Global3DPoint posStub = theGeomDet->surface().toGlobal(theGeomDet->topology().localPosition(coords));
2559 
2560           double x = posStub.x();
2561           double y = posStub.y();
2562           double z = posStub.z();
2563 
2564           int layer = -999999;
2565           if (detIdStub.subdetId() == StripSubdetector::TOB) {
2566             layer = static_cast<int>(tTopo.layer(detIdStub));
2567             if (DebugMode)
2568               edm::LogVerbatim("Tracklet")
2569                   << "   stub in layer " << layer << " at position x y z = " << x << " " << y << " " << z;
2570             tmp_trk_lhits += pow(10, layer - 1);
2571           } else if (detIdStub.subdetId() == StripSubdetector::TID) {
2572             layer = static_cast<int>(tTopo.layer(detIdStub));
2573             if (DebugMode)
2574               edm::LogVerbatim("Tracklet")
2575                   << "   stub in disk " << layer << " at position x y z = " << x << " " << y << " " << z;
2576             tmp_trk_dhits += pow(10, layer - 1);
2577           }
2578         }  //end loop over stubs
2579       }
2580       // ----------------------------------------------------------------------------------------------
2581 
2582       int tmp_trk_genuine = 0;
2583       int tmp_trk_loose = 0;
2584       int tmp_trk_unknown = 0;
2585       int tmp_trk_combinatoric = 0;
2586       if (MCTruthTTTrackHandle->isLooselyGenuine(l1track_ptr))
2587         tmp_trk_loose = 1;
2588       if (MCTruthTTTrackHandle->isGenuine(l1track_ptr))
2589         tmp_trk_genuine = 1;
2590       if (MCTruthTTTrackHandle->isUnknown(l1track_ptr))
2591         tmp_trk_unknown = 1;
2592       if (MCTruthTTTrackHandle->isCombinatoric(l1track_ptr))
2593         tmp_trk_combinatoric = 1;
2594 
2595       if (DebugMode) {
2596         edm::LogVerbatim("Tracklet") << "L1 track,"
2597                                      << " pt: " << tmp_trk_pt << " eta: " << tmp_trk_eta << " phi: " << tmp_trk_phi
2598                                      << " z0: " << tmp_trk_z0 << " chi2: " << tmp_trk_chi2
2599                                      << " chi2rphi: " << tmp_trk_chi2rphi << " chi2rz: " << tmp_trk_chi2rz
2600                                      << " nstub: " << tmp_trk_nstub;
2601         if (tmp_trk_genuine)
2602           edm::LogVerbatim("Tracklet") << "    (is genuine)";
2603         if (tmp_trk_unknown)
2604           edm::LogVerbatim("Tracklet") << "    (is unknown)";
2605         if (tmp_trk_combinatoric)
2606           edm::LogVerbatim("Tracklet") << "    (is combinatoric)";
2607       }
2608 
2609       m_trk_pt->push_back(tmp_trk_pt);
2610       m_trk_eta->push_back(tmp_trk_eta);
2611       m_trk_phi->push_back(tmp_trk_phi);
2612       m_trk_phi_local->push_back(tmp_trk_phi_local);
2613       m_trk_z0->push_back(tmp_trk_z0);
2614       if (tmp_trk_nFitPars == 5)
2615         m_trk_d0->push_back(tmp_trk_d0);
2616       else
2617         m_trk_d0->push_back(999.);
2618       m_trk_rinv->push_back(tmp_trk_rinv);
2619       m_trk_chi2->push_back(tmp_trk_chi2);
2620       m_trk_chi2dof->push_back(tmp_trk_chi2dof);
2621       m_trk_chi2rphi->push_back(tmp_trk_chi2rphi);
2622       m_trk_chi2rz->push_back(tmp_trk_chi2rz);
2623       m_trk_bendchi2->push_back(tmp_trk_bendchi2);
2624       m_trk_MVA1->push_back(tmp_trk_MVA1);
2625       m_trk_nstub->push_back(tmp_trk_nstub);
2626       m_trk_dhits->push_back(tmp_trk_dhits);
2627       m_trk_lhits->push_back(tmp_trk_lhits);
2628       m_trk_seed->push_back(tmp_trk_seed);
2629       m_trk_hitpattern->push_back(tmp_trk_hitpattern);
2630       m_trk_phiSector->push_back(tmp_trk_phiSector);
2631       m_trk_genuine->push_back(tmp_trk_genuine);
2632       m_trk_loose->push_back(tmp_trk_loose);
2633       m_trk_unknown->push_back(tmp_trk_unknown);
2634       m_trk_combinatoric->push_back(tmp_trk_combinatoric);
2635 
2636       // ----------------------------------------------------------------------------------------------
2637       // for studying the fake rate
2638       // ----------------------------------------------------------------------------------------------
2639       edm::Ptr<TrackingParticle> my_tp = MCTruthTTTrackHandle->findTrackingParticlePtr(l1track_ptr);
2640 
2641       int myFake = 0;
2642       int myTP_pdgid = -999;
2643       int myTP_mother_pdgid = -999;
2644       float myTP_pt = -999;
2645       float myTP_eta = -999;
2646       float myTP_phi = -999;
2647       float myTP_z0 = -999;
2648       float myTP_dxy = -999;
2649 
2650       if (my_tp.isNull())
2651         myFake = 0;
2652       else {
2653         int tmp_eventid = my_tp->eventId().event();
2654         if (tmp_eventid > 0)
2655           myFake = 2;
2656         else
2657           myFake = 1;
2658 
2659         myTP_pdgid = my_tp->pdgId();
2660         if (!my_tp->genParticles().empty()) {
2661           myTP_mother_pdgid = my_tp->genParticles().at(0)->mother(0)->pdgId();
2662         }
2663         myTP_pt = my_tp->p4().pt();
2664         myTP_eta = my_tp->p4().eta();
2665         myTP_phi = my_tp->p4().phi();
2666         myTP_z0 = my_tp->vertex().z();
2667 
2668         float myTP_x0 = my_tp->vertex().x();
2669         float myTP_y0 = my_tp->vertex().y();
2670         myTP_dxy = sqrt(myTP_x0 * myTP_x0 + myTP_y0 * myTP_y0);
2671 
2672         if (DebugMode) {
2673           edm::LogVerbatim("Tracklet") << "TP matched to track has pt = " << my_tp->p4().pt()
2674                                        << " eta = " << my_tp->momentum().eta() << " phi = " << my_tp->momentum().phi()
2675                                        << " z0 = " << my_tp->vertex().z() << " pdgid = " << my_tp->pdgId()
2676                                        << " dxy = " << myTP_dxy;
2677         }
2678       }
2679 
2680       m_trk_fake->push_back(myFake);
2681       m_trk_matchtp_pdgid->push_back(myTP_pdgid);
2682       m_trk_matchtp_mother_pdgid->push_back(myTP_mother_pdgid);
2683       m_trk_matchtp_pt->push_back(myTP_pt);
2684       m_trk_matchtp_eta->push_back(myTP_eta);
2685       m_trk_matchtp_phi->push_back(myTP_phi);
2686       m_trk_matchtp_z0->push_back(myTP_z0);
2687       m_trk_matchtp_dxy->push_back(myTP_dxy);
2688 
2689       // ----------------------------------------------------------------------------------------------
2690       // store the index to the selected track or -1 if not selected
2691       // ----------------------------------------------------------------------------------------------
2692       m_trk_gtt_pt->push_back(l1track_ref->momentum().perp());
2693       m_trk_gtt_eta->push_back(l1track_ref->momentum().eta());
2694       m_trk_gtt_phi->push_back(l1track_ref->momentum().phi());
2695       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedHandle) >= 0)
2696         m_trk_selected_index->push_back(this_l1track);
2697       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedEmulationHandle) >= 0)
2698         m_trk_selected_emulation_index->push_back(this_l1track);
2699       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedAssociatedHandle) >= 0)
2700         m_trk_selected_associated_index->push_back(this_l1track);
2701       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedAssociatedEmulationHandle) >= 0)
2702         m_trk_selected_associated_emulation_index->push_back(this_l1track);
2703       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedForJetsHandle) >= 0)
2704         m_trk_selected_forjets_index->push_back(this_l1track);
2705       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedEmulationForJetsHandle) >= 0)
2706         m_trk_selected_emulation_forjets_index->push_back(this_l1track);
2707       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedAssociatedForJetsHandle) >= 0)
2708         m_trk_selected_associated_forjets_index->push_back(this_l1track);
2709       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedAssociatedEmulationForJetsHandle) >= 0)
2710         m_trk_selected_associated_emulation_forjets_index->push_back(this_l1track);
2711       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedForEtMissHandle) >= 0)
2712         m_trk_selected_foretmiss_index->push_back(this_l1track);
2713       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedEmulationForEtMissHandle) >= 0)
2714         m_trk_selected_emulation_foretmiss_index->push_back(this_l1track);
2715       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedAssociatedForEtMissHandle) >= 0)
2716         m_trk_selected_associated_foretmiss_index->push_back(this_l1track);
2717       if (getSelectedTrackIndex(l1track_ref, TTTrackSelectedAssociatedEmulationForEtMissHandle) >= 0)
2718         m_trk_selected_associated_emulation_foretmiss_index->push_back(this_l1track);
2719 
2720       this_l1track++;
2721     }  //end track loop
2722   }  //end if SaveAllTracks
2723 
2724   // ----------------------------------------------------------------------------------------------
2725   // loop over (extended) L1 tracks
2726   // ----------------------------------------------------------------------------------------------
2727   if (SaveAllTracks && (Displaced == "Displaced" || Displaced == "Both")) {
2728     if (DebugMode) {
2729       edm::LogVerbatim("Tracklet") << "\n Loop over L1 tracks!";
2730       edm::LogVerbatim("Tracklet") << "\n Looking at " << Displaced << " tracks!";
2731     }
2732 
2733     int this_l1track = 0;
2734     for (iterL1Track = TTTrackExtendedHandle->begin(); iterL1Track != TTTrackExtendedHandle->end(); iterL1Track++) {
2735       L1TrackPtr l1track_ptr(TTTrackExtendedHandle, this_l1track);
2736       L1TrackRef l1track_ref(TTTrackExtendedGTTHandle, this_l1track);
2737 
2738       float tmp_trk_pt = iterL1Track->momentum().perp();
2739       float tmp_trk_eta = iterL1Track->momentum().eta();
2740       float tmp_trk_phi = iterL1Track->momentum().phi();
2741       float tmp_trk_phi_local = iterL1Track->localPhi();
2742       float tmp_trk_z0 = iterL1Track->z0();            //cm
2743       int tmp_trk_nFitPars = iterL1Track->nFitPars();  //4 or 5
2744 
2745       float tmp_trk_d0 = -999;
2746       float tmp_trk_rinv = iterL1Track->rInv();
2747       if (tmp_trk_nFitPars == 5) {
2748         float tmp_trk_x0 = iterL1Track->POCA().x();
2749         float tmp_trk_y0 = iterL1Track->POCA().y();
2750         tmp_trk_d0 = -tmp_trk_x0 * sin(tmp_trk_phi) + tmp_trk_y0 * cos(tmp_trk_phi);
2751         // tmp_trk_d0 = iterL1Track->d0();
2752       }
2753 
2754       float tmp_trk_chi2 = iterL1Track->chi2();
2755       float tmp_trk_chi2dof = iterL1Track->chi2Red();
2756       float tmp_trk_chi2rphi = iterL1Track->chi2XYRed();
2757       float tmp_trk_chi2rz = iterL1Track->chi2ZRed();
2758       float tmp_trk_bendchi2 = iterL1Track->stubPtConsistency();
2759       float tmp_trk_MVA1 = iterL1Track->trkMVA1();
2760 
2761       std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
2762           stubRefs = iterL1Track->getStubRefs();
2763       int tmp_trk_nstub = (int)stubRefs.size();
2764       int tmp_trk_seed = 0;
2765       tmp_trk_seed = (int)iterL1Track->trackSeedType();
2766       int tmp_trk_hitpattern = 0;
2767       tmp_trk_hitpattern = (int)iterL1Track->hitPattern();
2768       unsigned int tmp_trk_phiSector = iterL1Track->phiSector();
2769 
2770       float tmp_trkEmu_pt = DoublePtFromBits(*l1track_ref);
2771       float tmp_trkEmu_eta = DoubleEtaFromBits(*l1track_ref);
2772       float tmp_trkEmu_phi = DoublePhiFromBits(*l1track_ref);
2773       float tmp_trkEmu_z0 = l1track_ref->getZ0();
2774       float tmp_trkEmu_d0 = l1track_ref->getD0();
2775       float tmp_trkEmu_rho = ChargeFromBits(*l1track_ref) * convertPtToR(tmp_trkEmu_pt);
2776       float tmp_trkEmu_chi2rphi = l1track_ref->getChi2RPhi();
2777       float tmp_trkEmu_chi2rz = l1track_ref->getChi2RZ();
2778       float tmp_trkEmu_bendchi2 = l1track_ref->getBendChi2();
2779       float tmp_trkEmu_MVA = l1track_ref->getMVAQuality();
2780       int tmp_trkEmu_nstub = l1track_ref->getNStubs();
2781 
2782       // ----------------------------------------------------------------------------------------------
2783       // loop over stubs on tracks
2784       int tmp_trk_dhits = 0;
2785       int tmp_trk_lhits = 0;
2786       if (true) {
2787         // loop over stubs
2788         for (int is = 0; is < tmp_trk_nstub; is++) {
2789           //detID of stub
2790           DetId detIdStub = tGeom.idToDet((stubRefs.at(is)->clusterRef(0))->getDetId())->geographicalId();
2791           MeasurementPoint coords = stubRefs.at(is)->clusterRef(0)->findAverageLocalCoordinatesCentered();
2792           const GeomDet* theGeomDet = tGeom.idToDet(detIdStub);
2793           Global3DPoint posStub = theGeomDet->surface().toGlobal(theGeomDet->topology().localPosition(coords));
2794 
2795           double x = posStub.x();
2796           double y = posStub.y();
2797           double z = posStub.z();
2798 
2799           int layer = -999999;
2800           if (detIdStub.subdetId() == StripSubdetector::TOB) {
2801             layer = static_cast<int>(tTopo.layer(detIdStub));
2802             if (DebugMode)
2803               edm::LogVerbatim("Tracklet")
2804                   << "   stub in layer " << layer << " at position x y z = " << x << " " << y << " " << z;
2805             tmp_trk_lhits += pow(10, layer - 1);
2806           } else if (detIdStub.subdetId() == StripSubdetector::TID) {
2807             layer = static_cast<int>(tTopo.layer(detIdStub));
2808             if (DebugMode)
2809               edm::LogVerbatim("Tracklet")
2810                   << "   stub in disk " << layer << " at position x y z = " << x << " " << y << " " << z;
2811             tmp_trk_dhits += pow(10, layer - 1);
2812           }
2813         }  //end loop over stubs
2814       }
2815       // ----------------------------------------------------------------------------------------------
2816 
2817       int tmp_trk_genuine = 0;
2818       int tmp_trk_loose = 0;
2819       int tmp_trk_unknown = 0;
2820       int tmp_trk_combinatoric = 0;
2821       if (MCTruthTTTrackExtendedHandle->isLooselyGenuine(l1track_ptr))
2822         tmp_trk_loose = 1;
2823       if (MCTruthTTTrackExtendedHandle->isGenuine(l1track_ptr))
2824         tmp_trk_genuine = 1;
2825       if (MCTruthTTTrackExtendedHandle->isUnknown(l1track_ptr))
2826         tmp_trk_unknown = 1;
2827       if (MCTruthTTTrackExtendedHandle->isCombinatoric(l1track_ptr))
2828         tmp_trk_combinatoric = 1;
2829 
2830       if (DebugMode) {
2831         edm::LogVerbatim("Tracklet") << "L1 track,"
2832                                      << " pt: " << tmp_trk_pt << " eta: " << tmp_trk_eta << " phi: " << tmp_trk_phi
2833                                      << " z0: " << tmp_trk_z0 << " chi2: " << tmp_trk_chi2
2834                                      << " chi2rphi: " << tmp_trk_chi2rphi << " chi2rz: " << tmp_trk_chi2rz
2835                                      << " nstub: " << tmp_trk_nstub;
2836         if (tmp_trk_genuine)
2837           edm::LogVerbatim("Tracklet") << "    (is genuine)";
2838         if (tmp_trk_unknown)
2839           edm::LogVerbatim("Tracklet") << "    (is unknown)";
2840         if (tmp_trk_combinatoric)
2841           edm::LogVerbatim("Tracklet") << "    (is combinatoric)";
2842       }
2843 
2844       m_trkExt_pt->push_back(tmp_trk_pt);
2845       m_trkExt_eta->push_back(tmp_trk_eta);
2846       m_trkExt_phi->push_back(tmp_trk_phi);
2847       m_trkExt_phi_local->push_back(tmp_trk_phi_local);
2848       m_trkExt_z0->push_back(tmp_trk_z0);
2849       if (tmp_trk_nFitPars == 5)
2850         m_trkExt_d0->push_back(tmp_trk_d0);
2851       else
2852         m_trkExt_d0->push_back(999.);
2853       m_trkExt_rinv->push_back(tmp_trk_rinv);
2854       m_trkExt_chi2->push_back(tmp_trk_chi2);
2855       m_trkExt_chi2dof->push_back(tmp_trk_chi2dof);
2856       m_trkExt_chi2rphi->push_back(tmp_trk_chi2rphi);
2857       m_trkExt_chi2rz->push_back(tmp_trk_chi2rz);
2858       m_trkExt_bendchi2->push_back(tmp_trk_bendchi2);
2859       m_trkExt_MVA->push_back(tmp_trk_MVA1);
2860       m_trkExt_nstub->push_back(tmp_trk_nstub);
2861       m_trkExt_dhits->push_back(tmp_trk_dhits);
2862       m_trkExt_lhits->push_back(tmp_trk_lhits);
2863       m_trkExt_seed->push_back(tmp_trk_seed);
2864       m_trkExt_hitpattern->push_back(tmp_trk_hitpattern);
2865       m_trkExt_phiSector->push_back(tmp_trk_phiSector);
2866       m_trkExt_genuine->push_back(tmp_trk_genuine);
2867       m_trkExt_loose->push_back(tmp_trk_loose);
2868       m_trkExt_unknown->push_back(tmp_trk_unknown);
2869       m_trkExt_combinatoric->push_back(tmp_trk_combinatoric);
2870 
2871       m_trkExtEmu_pt->push_back(tmp_trkEmu_pt);
2872       m_trkExtEmu_eta->push_back(tmp_trkEmu_eta);
2873       m_trkExtEmu_phi->push_back(tmp_trkEmu_phi);
2874       m_trkExtEmu_d0->push_back(tmp_trkEmu_d0);
2875       m_trkExtEmu_rho->push_back(tmp_trkEmu_rho);
2876       m_trkExtEmu_z0->push_back(tmp_trkEmu_z0);
2877       m_trkExtEmu_chi2rphi->push_back(tmp_trkEmu_chi2rphi);
2878       m_trkExtEmu_chi2rz->push_back(tmp_trkEmu_chi2rz);
2879       m_trkExtEmu_bendchi2->push_back(tmp_trkEmu_bendchi2);
2880       m_trkExtEmu_MVA->push_back(tmp_trkEmu_MVA);
2881       m_trkExtEmu_nstub->push_back(tmp_trkEmu_nstub);
2882       // ----------------------------------------------------------------------------------------------
2883       // for studying the fake rate
2884       // ----------------------------------------------------------------------------------------------
2885       edm::Ptr<TrackingParticle> my_tp = MCTruthTTTrackExtendedHandle->findTrackingParticlePtr(l1track_ptr);
2886 
2887       int myFake = 0;
2888       int myTP_pdgid = -999;
2889       bool myTP_isHard = false;
2890       float myTP_pt = -999;
2891       float myTP_eta = -999;
2892       float myTP_phi = -999;
2893       float myTP_z0 = -999;
2894       float myTP_z = -999;
2895       float myTP_dxy = -999;
2896       float myTP_d0 = -999;
2897       float myTP_x0 = -999;
2898       float myTP_y0 = -999;
2899 
2900       if (my_tp.isNull())
2901         myFake = 0;
2902       else {
2903         int tmp_eventid = my_tp->eventId().event();
2904         if (tmp_eventid > 0)
2905           myFake = 2;
2906         else
2907           myFake = 1;
2908 
2909         myTP_pdgid = my_tp->pdgId();
2910         myTP_isHard = isHard(my_tp);
2911         myTP_pt = my_tp->p4().pt();
2912         myTP_eta = my_tp->p4().eta();
2913         myTP_phi = my_tp->p4().phi();
2914         myTP_z = my_tp->vertex().z();
2915 
2916         myTP_x0 = my_tp->vertex().x();
2917         myTP_y0 = my_tp->vertex().y();
2918 
2919         myTP_dxy = sqrt(myTP_x0 * myTP_x0 + myTP_y0 * myTP_y0);
2920 
2921         // get d0/z0 propagated back to the IP
2922         float tmp_tp_t = tan(2.0 * atan(1.0) - 2.0 * atan(exp(-myTP_eta)));
2923         float delx = -myTP_x0;
2924         float dely = -myTP_y0;
2925         float A = 0.01 * 0.5696;
2926         float Kmagnitude = A / myTP_pt;
2927         float tmp_tp_charge = my_tp->charge();
2928         float K = Kmagnitude * tmp_tp_charge;
2929         float d = 0;
2930         float tmp_tp_x0p = delx - (d + 1. / (2. * K) * sin(myTP_phi));
2931         float tmp_tp_y0p = dely + (d + 1. / (2. * K) * cos(myTP_phi));
2932         float tmp_tp_rp = sqrt(tmp_tp_x0p * tmp_tp_x0p + tmp_tp_y0p * tmp_tp_y0p);
2933         float tmp_tp_d0 = tmp_tp_charge * tmp_tp_rp - (1. / (2. * K));
2934         myTP_d0 = tmp_tp_d0 * (-1);  //fix d0 sign
2935         const double pi = 4.0 * atan(1.0);
2936         float delphi = myTP_phi - atan2(-K * tmp_tp_x0p, K * tmp_tp_y0p);
2937         if (delphi < -pi)
2938           delphi += 2.0 * pi;
2939         if (delphi > pi)
2940           delphi -= 2.0 * pi;
2941 
2942         myTP_z0 = myTP_z + tmp_tp_t * delphi / (2.0 * K);
2943         if (DebugMode) {
2944           edm::LogVerbatim("Tracklet") << "TP matched to track has pt = " << my_tp->p4().pt()
2945                                        << " eta = " << my_tp->momentum().eta() << " phi = " << my_tp->momentum().phi()
2946                                        << " z0 = " << my_tp->vertex().z() << " pdgid = " << my_tp->pdgId()
2947                                        << " dxy = " << myTP_dxy;
2948         }
2949       }
2950 
2951       m_trkExt_fake->push_back(myFake);
2952       m_trkExt_matchtp_pdgid->push_back(myTP_pdgid);
2953       m_trkExt_matchtp_isHard->push_back(myTP_isHard);
2954       m_trkExt_matchtp_pt->push_back(myTP_pt);
2955       m_trkExt_matchtp_eta->push_back(myTP_eta);
2956       m_trkExt_matchtp_phi->push_back(myTP_phi);
2957       m_trkExt_matchtp_z0->push_back(myTP_z0);
2958       m_trkExt_matchtp_dxy->push_back(myTP_dxy);
2959       m_trkExt_matchtp_d0->push_back(myTP_d0);
2960       m_trkExt_matchtp_x->push_back(myTP_x0);
2961       m_trkExt_matchtp_y->push_back(myTP_y0);
2962       m_trkExt_matchtp_z->push_back(myTP_z);
2963 
2964       // ----------------------------------------------------------------------------------------------
2965       // store the index to the selected track or -1 if not selected
2966       // ----------------------------------------------------------------------------------------------
2967       m_trkExt_gtt_pt->push_back(l1track_ref->momentum().perp());
2968       m_trkExt_gtt_eta->push_back(l1track_ref->momentum().eta());
2969       m_trkExt_gtt_phi->push_back(l1track_ref->momentum().phi());
2970       m_trkExt_selected_index->push_back(getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedHandle));
2971       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedEmulationHandle) >= 0)
2972         m_trkExt_selected_emulation_index->push_back(this_l1track);
2973       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedAssociatedHandle) >= 0)
2974         m_trkExt_selected_associated_index->push_back(this_l1track);
2975       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedAssociatedEmulationHandle) >= 0)
2976         m_trkExt_selected_associated_emulation_index->push_back(this_l1track);
2977       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedForJetsHandle) >= 0)
2978         m_trkExt_selected_forjets_index->push_back(this_l1track);
2979       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedEmulationForJetsHandle) >= 0)
2980         m_trkExt_selected_emulation_forjets_index->push_back(this_l1track);
2981       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedAssociatedForJetsHandle) >= 0)
2982         m_trkExt_selected_associated_forjets_index->push_back(this_l1track);
2983       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedAssociatedEmulationForJetsHandle) >= 0)
2984         m_trkExt_selected_associated_emulation_forjets_index->push_back(this_l1track);
2985       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedForEtMissHandle) >= 0)
2986         m_trkExt_selected_foretmiss_index->push_back(this_l1track);
2987       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedEmulationForEtMissHandle) >= 0)
2988         m_trkExt_selected_emulation_foretmiss_index->push_back(this_l1track);
2989       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedAssociatedForEtMissHandle) >= 0)
2990         m_trkExt_selected_associated_foretmiss_index->push_back(this_l1track);
2991       if (getSelectedTrackIndex(l1track_ref, TTTrackExtendedSelectedAssociatedEmulationForEtMissHandle) >= 0)
2992         m_trkExt_selected_associated_emulation_foretmiss_index->push_back(this_l1track);
2993       this_l1track++;
2994     }  //end track loop
2995   }  //end if SaveAllTracks (displaced)
2996 
2997   // ----------------------------------------------------------------------------------------------
2998   // loop over tracking particles
2999   // ----------------------------------------------------------------------------------------------
3000   if (DebugMode)
3001     edm::LogVerbatim("Tracklet") << "\n Loop over tracking particles!";
3002 
3003   trueTkMET = 0;
3004   float trueTkMETx = 0;
3005   float trueTkMETy = 0;
3006 
3007   int this_tp = 0;
3008   std::vector<TrackingParticle>::const_iterator iterTP;
3009   for (iterTP = TrackingParticleHandle->begin(); iterTP != TrackingParticleHandle->end(); ++iterTP) {
3010     edm::Ptr<TrackingParticle> tp_ptr(TrackingParticleHandle, this_tp);
3011     this_tp++;
3012 
3013     int tmp_eventid = iterTP->eventId().event();
3014     if (MyProcess != 1 && tmp_eventid > 0)
3015       continue;  //only care about primary interaction
3016 
3017     float tmp_tp_pt = iterTP->pt();
3018     float tmp_tp_eta = iterTP->eta();
3019     float tmp_tp_phi = iterTP->phi();
3020     float tmp_tp_vz = iterTP->vz();
3021     float tmp_tp_vx = iterTP->vx();
3022     float tmp_tp_vy = iterTP->vy();
3023     int tmp_tp_pdgid = iterTP->pdgId();
3024     float tmp_tp_z0_prod = tmp_tp_vz;
3025     float tmp_tp_d0_prod = tmp_tp_vx * sin(tmp_tp_phi) - tmp_tp_vy * cos(tmp_tp_phi);
3026 
3027     if (MyProcess == 13 && abs(tmp_tp_pdgid) != 13)
3028       continue;
3029     if (MyProcess == 11 && abs(tmp_tp_pdgid) != 11)
3030       continue;
3031     if ((MyProcess == 6 || MyProcess == 15 || MyProcess == 211) && abs(tmp_tp_pdgid) != 211)
3032       continue;
3033 
3034     if (tmp_tp_pt < TP_minPt)
3035       continue;
3036     if (std::abs(tmp_tp_eta) > TP_maxEta)
3037       continue;
3038 
3039     // ----------------------------------------------------------------------------------------------
3040     // get d0/z0 propagated back to the IP
3041     float tmp_tp_t = tan(2.0 * atan(1.0) - 2.0 * atan(exp(-tmp_tp_eta)));
3042     float delx = -tmp_tp_vx;
3043     float dely = -tmp_tp_vy;
3044 
3045     float A = 0.01 * 0.5696;
3046     float Kmagnitude = A / tmp_tp_pt;
3047     float tmp_tp_charge = tp_ptr->charge();
3048     float K = Kmagnitude * tmp_tp_charge;
3049     float d = 0;
3050     float tmp_tp_x0p = delx - (d + 1. / (2. * K) * sin(tmp_tp_phi));
3051     float tmp_tp_y0p = dely + (d + 1. / (2. * K) * cos(tmp_tp_phi));
3052     float tmp_tp_rp = sqrt(tmp_tp_x0p * tmp_tp_x0p + tmp_tp_y0p * tmp_tp_y0p);
3053     float tmp_tp_d0 = tmp_tp_charge * tmp_tp_rp - (1. / (2. * K));
3054     tmp_tp_d0 = tmp_tp_d0 * (-1);  //fix d0 sign
3055     const double pi = 4.0 * atan(1.0);
3056     float delphi = tmp_tp_phi - atan2(-K * tmp_tp_x0p, K * tmp_tp_y0p);
3057     if (delphi < -pi)
3058       delphi += 2.0 * pi;
3059     if (delphi > pi)
3060       delphi -= 2.0 * pi;
3061     float tmp_tp_z0 = tmp_tp_vz + tmp_tp_t * delphi / (2.0 * K);
3062     // ----------------------------------------------------------------------------------------------
3063 
3064     if (std::abs(tmp_tp_z0) > TP_maxZ0)
3065       continue;
3066 
3067     // for pions in ttbar, only consider TPs coming from near the IP!
3068     float dxy = sqrt(tmp_tp_vx * tmp_tp_vx + tmp_tp_vy * tmp_tp_vy);
3069     float tmp_tp_dxy = dxy;
3070     if (MyProcess == 6 && (dxy > 1.0))
3071       continue;
3072 
3073     bool tmp_tp_isHard = isHard(iterTP);
3074 
3075     if (DebugMode && (Displaced == "Prompt" || Displaced == "Both"))
3076       edm::LogVerbatim("Tracklet") << "Tracking particle, pt: " << tmp_tp_pt << " eta: " << tmp_tp_eta
3077                                    << " phi: " << tmp_tp_phi << " z0: " << tmp_tp_z0 << " d0: " << tmp_tp_d0
3078                                    << " z_prod: " << tmp_tp_z0_prod << " d_prod: " << tmp_tp_d0_prod
3079                                    << " pdgid: " << tmp_tp_pdgid << " eventID: " << iterTP->eventId().event()
3080                                    << " ttclusters " << MCTruthTTClusterHandle->findTTClusterRefs(tp_ptr).size()
3081                                    << " ttstubs " << MCTruthTTStubHandle->findTTStubRefs(tp_ptr).size() << " tttracks "
3082                                    << MCTruthTTTrackHandle->findTTTrackPtrs(tp_ptr).size();
3083 
3084     // ----------------------------------------------------------------------------------------------
3085     // only consider TPs associated with >= 1 cluster, or >= X stubs, or have stubs in >= X layers (configurable options)
3086     if (MCTruthTTClusterHandle->findTTClusterRefs(tp_ptr).empty()) {
3087       if (DebugMode)
3088         edm::LogVerbatim("Tracklet") << "No matching TTClusters for TP, continuing...";
3089       continue;
3090     }
3091 
3092     std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
3093         theStubRefs = MCTruthTTStubHandle->findTTStubRefs(tp_ptr);
3094     int nStubTP = (int)theStubRefs.size();
3095 
3096     // how many layers/disks have stubs?
3097     int hasStubInLayer[11] = {0};
3098     for (auto& theStubRef : theStubRefs) {
3099       DetId detid(theStubRef->getDetId());
3100 
3101       int layer = -1;
3102       if (detid.subdetId() == StripSubdetector::TOB) {
3103         layer = static_cast<int>(tTopo.layer(detid)) - 1;  //fill in array as entries 0-5
3104       } else if (detid.subdetId() == StripSubdetector::TID) {
3105         layer = static_cast<int>(tTopo.layer(detid)) + 5;  //fill in array as entries 6-10
3106       }
3107 
3108       //treat genuine stubs separately (==2 is genuine, ==1 is not)
3109       if (MCTruthTTStubHandle->findTrackingParticlePtr(theStubRef).isNull() && hasStubInLayer[layer] < 2)
3110         hasStubInLayer[layer] = 1;
3111       else
3112         hasStubInLayer[layer] = 2;
3113     }
3114 
3115     int nStubLayerTP = 0;
3116     int nStubLayerTP_g = 0;
3117     for (int isum : hasStubInLayer) {
3118       if (isum >= 1)
3119         nStubLayerTP += 1;
3120       if (isum == 2)
3121         nStubLayerTP_g += 1;
3122     }
3123 
3124     if (DebugMode)
3125       edm::LogVerbatim("Tracklet") << "TP is associated with " << nStubTP << " stubs, and has stubs in " << nStubLayerTP
3126                                    << " different layers/disks, and has GENUINE stubs in " << nStubLayerTP_g
3127                                    << " layers ";
3128 
3129     if (TP_minNStub > 0) {
3130       if (DebugMode)
3131         edm::LogVerbatim("Tracklet") << "Only consider TPs with >= " << TP_minNStub << " stubs";
3132       if (nStubTP < TP_minNStub) {
3133         if (DebugMode)
3134           edm::LogVerbatim("Tracklet") << "TP fails minimum nbr stubs requirement! Continuing...";
3135         continue;
3136       }
3137     }
3138     if (TP_minNStubLayer > 0) {
3139       if (DebugMode)
3140         edm::LogVerbatim("Tracklet") << "Only consider TPs with stubs in >= " << TP_minNStubLayer << " layers/disks";
3141       if (nStubLayerTP < TP_minNStubLayer) {
3142         if (DebugMode)
3143           edm::LogVerbatim("Tracklet") << "TP fails stubs in minimum nbr of layers/disks requirement! Continuing...";
3144         continue;
3145       }
3146     }
3147 
3148     if (tmp_eventid == 0) {
3149       trueTkMETx += tmp_tp_pt * cos(tmp_tp_phi);
3150       trueTkMETy += tmp_tp_pt * sin(tmp_tp_phi);
3151     }
3152 
3153     m_tp_pt->push_back(tmp_tp_pt);
3154     m_tp_eta->push_back(tmp_tp_eta);
3155     m_tp_phi->push_back(tmp_tp_phi);
3156     m_tp_dxy->push_back(tmp_tp_dxy);
3157     m_tp_z0->push_back(tmp_tp_z0);
3158     m_tp_d0->push_back(tmp_tp_d0);
3159     m_tp_x->push_back(tmp_tp_vx);
3160     m_tp_y->push_back(tmp_tp_vy);
3161     m_tp_z->push_back(tmp_tp_vz);
3162     m_tp_z0_prod->push_back(tmp_tp_z0_prod);
3163     m_tp_d0_prod->push_back(tmp_tp_d0_prod);
3164     m_tp_pdgid->push_back(tmp_tp_pdgid);
3165     m_tp_isHard->push_back(tmp_tp_isHard);
3166     m_tp_nstub->push_back(nStubTP);
3167     m_tp_eventid->push_back(tmp_eventid);
3168     m_tp_charge->push_back(tmp_tp_charge);
3169 
3170     // ----------------------------------------------------------------------------------------------
3171     // look for L1 tracks (prompt) matched to the tracking particle
3172     if (Displaced == "Prompt" || Displaced == "Both") {
3173       std::vector<edm::Ptr<TTTrack<Ref_Phase2TrackerDigi_>>> matchedTracks =
3174           MCTruthTTTrackHandle->findTTTrackPtrs(tp_ptr);
3175 
3176       int nMatch = 0;
3177       int i_track = -1;
3178       float i_chi2dof = 99999;
3179 
3180       if (!matchedTracks.empty()) {
3181         if (DebugMode && (matchedTracks.size() > 1))
3182           edm::LogVerbatim("Tracklet") << "TrackingParticle has more than one matched L1 track!";
3183 
3184         // ----------------------------------------------------------------------------------------------
3185         // loop over matched L1 tracks
3186         // here, "match" means tracks that can be associated to a TrackingParticle with at least one hit of at least one of its clusters
3187         // https://twiki.cern.ch/twiki/bin/viewauth/CMS/SLHCTrackerTriggerSWTools#MC_truth_for_TTTrack
3188 
3189         for (int it = 0; it < (int)matchedTracks.size(); it++) {
3190           bool tmp_trk_genuine = false;
3191           bool tmp_trk_loosegenuine = false;
3192           if (MCTruthTTTrackHandle->isGenuine(matchedTracks.at(it)))
3193             tmp_trk_genuine = true;
3194           if (MCTruthTTTrackHandle->isLooselyGenuine(matchedTracks.at(it)))
3195             tmp_trk_loosegenuine = true;
3196           if (!tmp_trk_loosegenuine)
3197             continue;
3198 
3199           if (DebugMode) {
3200             if (MCTruthTTTrackHandle->findTrackingParticlePtr(matchedTracks.at(it)).isNull()) {
3201               edm::LogVerbatim("Tracklet") << "track matched to TP is NOT uniquely matched to a TP";
3202             } else {
3203               edm::Ptr<TrackingParticle> my_tp = MCTruthTTTrackHandle->findTrackingParticlePtr(matchedTracks.at(it));
3204               edm::LogVerbatim("Tracklet") << "TP matched to track matched to TP ... tp pt = " << my_tp->p4().pt()
3205                                            << " eta = " << my_tp->momentum().eta()
3206                                            << " phi = " << my_tp->momentum().phi() << " z0 = " << my_tp->vertex().z();
3207             }
3208             edm::LogVerbatim("Tracklet") << "   ... matched L1 track has pt = "
3209                                          << matchedTracks.at(it)->momentum().perp()
3210                                          << " eta = " << matchedTracks.at(it)->momentum().eta()
3211                                          << " phi = " << matchedTracks.at(it)->momentum().phi()
3212                                          << " chi2 = " << matchedTracks.at(it)->chi2()
3213                                          << " consistency = " << matchedTracks.at(it)->stubPtConsistency()
3214                                          << " z0 = " << matchedTracks.at(it)->z0()
3215                                          << " nstub = " << matchedTracks.at(it)->getStubRefs().size();
3216             if (tmp_trk_genuine)
3217               edm::LogVerbatim("Tracklet") << "    (genuine!) ";
3218             if (tmp_trk_loosegenuine)
3219               edm::LogVerbatim("Tracklet") << "    (loose genuine!) ";
3220           }
3221 
3222           std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
3223               stubRefs = matchedTracks.at(it)->getStubRefs();
3224           int tmp_trk_nstub = stubRefs.size();
3225 
3226           if (tmp_trk_nstub < L1Tk_minNStub)
3227             continue;
3228 
3229           float dmatch_pt = 999;
3230           float dmatch_eta = 999;
3231           float dmatch_phi = 999;
3232           int match_id = 999;
3233 
3234           edm::Ptr<TrackingParticle> my_tp = MCTruthTTTrackHandle->findTrackingParticlePtr(matchedTracks.at(it));
3235           dmatch_pt = std::abs(my_tp->p4().pt() - tmp_tp_pt);
3236           dmatch_eta = std::abs(my_tp->p4().eta() - tmp_tp_eta);
3237           dmatch_phi = std::abs(my_tp->p4().phi() - tmp_tp_phi);
3238           match_id = my_tp->pdgId();
3239           float tmp_trk_chi2dof = matchedTracks.at(it)->chi2Red();
3240 
3241           // ensure that track is uniquely matched to the TP we are looking at!
3242           if (dmatch_pt < 0.1 && dmatch_eta < 0.1 && dmatch_phi < 0.1 && tmp_tp_pdgid == match_id && tmp_trk_genuine) {
3243             nMatch++;
3244             if (i_track < 0 || tmp_trk_chi2dof < i_chi2dof) {
3245               i_track = it;
3246               i_chi2dof = tmp_trk_chi2dof;
3247             }
3248           }
3249 
3250         }  // end loop over matched L1 tracks
3251       }  // end has at least 1 matched L1 track
3252       // ----------------------------------------------------------------------------------------------
3253 
3254       float tmp_matchtrk_pt = -999;
3255       float tmp_matchtrk_eta = -999;
3256       float tmp_matchtrk_phi = -999;
3257       float tmp_matchtrk_z0 = -999;
3258       float tmp_matchtrk_d0 = -999;
3259       float tmp_matchtrk_rinv = -999;
3260       float tmp_matchtrk_chi2 = -999;
3261       float tmp_matchtrk_chi2dof = -999;
3262       float tmp_matchtrk_chi2rphi = -999;
3263       float tmp_matchtrk_chi2rz = -999;
3264       float tmp_matchtrk_bendchi2 = -999;
3265       float tmp_matchtrk_MVA1 = -999;
3266       int tmp_matchtrk_nstub = -999;
3267       int tmp_matchtrk_dhits = -999;
3268       int tmp_matchtrk_lhits = -999;
3269       int tmp_matchtrk_seed = -999;
3270       int tmp_matchtrk_hitpattern = -999;
3271       int tmp_matchtrk_nFitPars = -999;
3272 
3273       if (nMatch > 1 && DebugMode)
3274         edm::LogVerbatim("Tracklet") << "WARNING *** 2 or more matches to genuine L1 tracks ***";
3275 
3276       if (nMatch > 0) {
3277         tmp_matchtrk_pt = matchedTracks.at(i_track)->momentum().perp();
3278         tmp_matchtrk_eta = matchedTracks.at(i_track)->momentum().eta();
3279         tmp_matchtrk_phi = matchedTracks.at(i_track)->momentum().phi();
3280         tmp_matchtrk_z0 = matchedTracks.at(i_track)->z0();
3281         tmp_matchtrk_nFitPars = matchedTracks.at(i_track)->nFitPars();
3282 
3283         if (tmp_matchtrk_nFitPars == 5) {
3284           float tmp_matchtrk_x0 = matchedTracks.at(i_track)->POCA().x();
3285           float tmp_matchtrk_y0 = matchedTracks.at(i_track)->POCA().y();
3286           tmp_matchtrk_d0 = -tmp_matchtrk_x0 * sin(tmp_matchtrk_phi) + tmp_matchtrk_y0 * cos(tmp_matchtrk_phi);
3287           // tmp_matchtrk_d0 = matchedTracks.at(i_track)->d0();
3288         }
3289         tmp_matchtrk_rinv = matchedTracks.at(i_track)->rInv();
3290         tmp_matchtrk_chi2 = matchedTracks.at(i_track)->chi2();
3291         tmp_matchtrk_chi2dof = matchedTracks.at(i_track)->chi2Red();
3292         tmp_matchtrk_chi2rphi = matchedTracks.at(i_track)->chi2XYRed();
3293         tmp_matchtrk_chi2rz = matchedTracks.at(i_track)->chi2ZRed();
3294         tmp_matchtrk_bendchi2 = matchedTracks.at(i_track)->stubPtConsistency();
3295         tmp_matchtrk_MVA1 = matchedTracks.at(i_track)->trkMVA1();
3296         tmp_matchtrk_nstub = (int)matchedTracks.at(i_track)->getStubRefs().size();
3297         tmp_matchtrk_seed = (int)matchedTracks.at(i_track)->trackSeedType();
3298         tmp_matchtrk_hitpattern = (int)matchedTracks.at(i_track)->hitPattern();
3299 
3300         // ------------------------------------------------------------------------------------------
3301         tmp_matchtrk_dhits = 0;
3302         tmp_matchtrk_lhits = 0;
3303 
3304         std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
3305             stubRefs = matchedTracks.at(i_track)->getStubRefs();
3306         int tmp_nstub = stubRefs.size();
3307 
3308         for (int is = 0; is < tmp_nstub; is++) {
3309           DetId detIdStub = tGeom.idToDet((stubRefs.at(is)->clusterRef(0))->getDetId())->geographicalId();
3310           int layer = -999999;
3311           if (detIdStub.subdetId() == StripSubdetector::TOB) {
3312             layer = static_cast<int>(tTopo.layer(detIdStub));
3313             tmp_matchtrk_lhits += pow(10, layer - 1);
3314           } else if (detIdStub.subdetId() == StripSubdetector::TID) {
3315             layer = static_cast<int>(tTopo.layer(detIdStub));
3316             tmp_matchtrk_dhits += pow(10, layer - 1);
3317           }
3318         }
3319       }
3320 
3321       m_tp_nmatch->push_back(nMatch);
3322 
3323       m_matchtrk_pt->push_back(tmp_matchtrk_pt);
3324       m_matchtrk_eta->push_back(tmp_matchtrk_eta);
3325       m_matchtrk_phi->push_back(tmp_matchtrk_phi);
3326       m_matchtrk_z0->push_back(tmp_matchtrk_z0);
3327       m_matchtrk_d0->push_back(tmp_matchtrk_d0);
3328       m_matchtrk_rinv->push_back(tmp_matchtrk_rinv);
3329       m_matchtrk_chi2->push_back(tmp_matchtrk_chi2);
3330       m_matchtrk_chi2dof->push_back(tmp_matchtrk_chi2dof);
3331       m_matchtrk_chi2rphi->push_back(tmp_matchtrk_chi2rphi);
3332       m_matchtrk_chi2rz->push_back(tmp_matchtrk_chi2rz);
3333       m_matchtrk_bendchi2->push_back(tmp_matchtrk_bendchi2);
3334       m_matchtrk_MVA1->push_back(tmp_matchtrk_MVA1);
3335       m_matchtrk_nstub->push_back(tmp_matchtrk_nstub);
3336       m_matchtrk_dhits->push_back(tmp_matchtrk_dhits);
3337       m_matchtrk_lhits->push_back(tmp_matchtrk_lhits);
3338       m_matchtrk_seed->push_back(tmp_matchtrk_seed);
3339       m_matchtrk_hitpattern->push_back(tmp_matchtrk_hitpattern);
3340     }
3341 
3342     // ----------------------------------------------------------------------------------------------
3343     // look for L1 tracks (extended) matched to the tracking particle
3344     if (Displaced == "Displaced" || Displaced == "Both") {
3345       L1TrackPtrCollection matchedTracks = MCTruthTTTrackExtendedHandle->findTTTrackPtrs(tp_ptr);
3346 
3347       int nMatch = 0;
3348       int i_track = -1;
3349       float i_chi2dof = 99999;
3350 
3351       if (!matchedTracks.empty()) {
3352         if (DebugMode && (matchedTracks.size() > 1))
3353           edm::LogVerbatim("Tracklet") << "TrackingParticle has more than one matched L1 track!";
3354 
3355         // ----------------------------------------------------------------------------------------------
3356         // loop over matched L1 tracks
3357         // here, "match" means tracks that can be associated to a TrackingParticle with at least one hit of at least one of its clusters
3358         // https://twiki.cern.ch/twiki/bin/viewauth/CMS/SLHCTrackerTriggerSWTools#MC_truth_for_TTTrack
3359 
3360         for (int it = 0; it < (int)matchedTracks.size(); it++) {
3361           bool tmp_trk_genuine = false;
3362           bool tmp_trk_loosegenuine = false;
3363           if (MCTruthTTTrackExtendedHandle->isGenuine(matchedTracks.at(it)))
3364             tmp_trk_genuine = true;
3365           if (MCTruthTTTrackExtendedHandle->isLooselyGenuine(matchedTracks.at(it)))
3366             tmp_trk_loosegenuine = true;
3367           if (!tmp_trk_loosegenuine)
3368             continue;
3369 
3370           if (DebugMode) {
3371             if (MCTruthTTTrackExtendedHandle->findTrackingParticlePtr(matchedTracks.at(it)).isNull()) {
3372               edm::LogVerbatim("Tracklet") << "track matched to TP is NOT uniquely matched to a TP";
3373             } else {
3374               edm::Ptr<TrackingParticle> my_tp =
3375                   MCTruthTTTrackExtendedHandle->findTrackingParticlePtr(matchedTracks.at(it));
3376               edm::LogVerbatim("Tracklet") << "TP matched to track matched to TP ... tp pt = " << my_tp->p4().pt()
3377                                            << " eta = " << my_tp->momentum().eta()
3378                                            << " phi = " << my_tp->momentum().phi() << " z0 = " << my_tp->vertex().z();
3379             }
3380             edm::LogVerbatim("Tracklet") << "   ... matched L1 track has pt = "
3381                                          << matchedTracks.at(it)->momentum().perp()
3382                                          << " eta = " << matchedTracks.at(it)->momentum().eta()
3383                                          << " phi = " << matchedTracks.at(it)->momentum().phi()
3384                                          << " chi2 = " << matchedTracks.at(it)->chi2()
3385                                          << " consistency = " << matchedTracks.at(it)->stubPtConsistency()
3386                                          << " z0 = " << matchedTracks.at(it)->z0()
3387                                          << " nstub = " << matchedTracks.at(it)->getStubRefs().size();
3388             if (tmp_trk_genuine)
3389               edm::LogVerbatim("Tracklet") << "    (genuine!) ";
3390             if (tmp_trk_loosegenuine)
3391               edm::LogVerbatim("Tracklet") << "    (loose genuine!) ";
3392           }
3393 
3394           std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
3395               stubRefs = matchedTracks.at(it)->getStubRefs();
3396           int tmp_trk_nstub = stubRefs.size();
3397 
3398           if (tmp_trk_nstub < L1Tk_minNStub)
3399             continue;
3400 
3401           float dmatch_pt = 999;
3402           float dmatch_eta = 999;
3403           float dmatch_phi = 999;
3404           int match_id = 999;
3405 
3406           edm::Ptr<TrackingParticle> my_tp =
3407               MCTruthTTTrackExtendedHandle->findTrackingParticlePtr(matchedTracks.at(it));
3408           dmatch_pt = std::abs(my_tp->p4().pt() - tmp_tp_pt);
3409           dmatch_eta = std::abs(my_tp->p4().eta() - tmp_tp_eta);
3410           dmatch_phi = std::abs(my_tp->p4().phi() - tmp_tp_phi);
3411           match_id = my_tp->pdgId();
3412           float tmp_trk_chi2dof = matchedTracks.at(it)->chi2Red();
3413 
3414           // ensure that track is uniquely matched to the TP we are looking at!
3415           if (dmatch_pt < 0.1 && dmatch_eta < 0.1 && dmatch_phi < 0.1 && tmp_tp_pdgid == match_id && tmp_trk_genuine) {
3416             nMatch++;
3417             if (i_track < 0 || tmp_trk_chi2dof < i_chi2dof) {
3418               i_track = it;
3419               i_chi2dof = tmp_trk_chi2dof;
3420             }
3421           }
3422 
3423         }  // end loop over matched L1 tracks
3424       }  // end has at least 1 matched L1 track
3425       // ----------------------------------------------------------------------------------------------
3426 
3427       float tmp_matchtrkExt_pt = -999;
3428       float tmp_matchtrkExt_eta = -999;
3429       float tmp_matchtrkExt_phi = -999;
3430       float tmp_matchtrkExt_z0 = -999;
3431       float tmp_matchtrkExt_d0 = -999;
3432       float tmp_matchtrkExt_rinv = -999;
3433       float tmp_matchtrkExt_chi2 = -999;
3434       float tmp_matchtrkExt_chi2dof = -999;
3435       float tmp_matchtrkExt_chi2rphi = -999;
3436       float tmp_matchtrkExt_chi2rz = -999;
3437       float tmp_matchtrkExt_bendchi2 = -999;
3438       float tmp_matchtrkExt_MVA = -999;
3439       int tmp_matchtrkExt_nstub = -999;
3440       int tmp_matchtrkExt_dhits = -999;
3441       int tmp_matchtrkExt_lhits = -999;
3442       int tmp_matchtrkExt_seed = -999;
3443       int tmp_matchtrkExt_hitpattern = -999;
3444       int tmp_matchtrkExt_nFitPars = -999;
3445 
3446       float tmp_matchtrkExtEmu_pt = -999;
3447       float tmp_matchtrkExtEmu_eta = -999;
3448       float tmp_matchtrkExtEmu_phi = -999;
3449       float tmp_matchtrkExtEmu_d0 = -999;
3450       float tmp_matchtrkExtEmu_rho = -999;
3451       float tmp_matchtrkExtEmu_z0 = -999;
3452       float tmp_matchtrkExtEmu_chi2rphi = -999;
3453       float tmp_matchtrkExtEmu_chi2rz = -999;
3454       float tmp_matchtrkExtEmu_bendchi2 = -999;
3455       float tmp_matchtrkExtEmu_MVA = -999;
3456       int tmp_matchtrkExtEmu_nstub = -999;
3457 
3458       if (nMatch > 1 && DebugMode)
3459         edm::LogVerbatim("Tracklet") << "WARNING *** 2 or more matches to genuine L1 tracks ***";
3460 
3461       if (nMatch > 0) {
3462         int index = getSelectedTrackPtrIndex(matchedTracks.at(i_track), TTTrackExtendedHandle);
3463         L1TrackRef l1track_ref(TTTrackExtendedGTTHandle, index);
3464         tmp_matchtrkExtEmu_pt = DoublePtFromBits(*l1track_ref);
3465         tmp_matchtrkExtEmu_eta = DoubleEtaFromBits(*l1track_ref);
3466         tmp_matchtrkExtEmu_phi = DoublePhiFromBits(*l1track_ref);
3467         tmp_matchtrkExtEmu_z0 = l1track_ref->getZ0();
3468         tmp_matchtrkExtEmu_d0 = l1track_ref->getD0();
3469         tmp_matchtrkExtEmu_rho = ChargeFromBits(*l1track_ref) * convertPtToR(tmp_matchtrkExtEmu_pt);
3470         tmp_matchtrkExtEmu_chi2rphi = l1track_ref->getChi2RPhi();
3471         tmp_matchtrkExtEmu_chi2rz = l1track_ref->getChi2RZ();
3472         tmp_matchtrkExtEmu_bendchi2 = l1track_ref->getBendChi2();
3473         tmp_matchtrkExtEmu_MVA = l1track_ref->getMVAQuality();
3474         tmp_matchtrkExtEmu_nstub = l1track_ref->getNStubs();
3475 
3476         tmp_matchtrkExt_pt = matchedTracks.at(i_track)->momentum().perp();
3477         tmp_matchtrkExt_eta = matchedTracks.at(i_track)->momentum().eta();
3478         tmp_matchtrkExt_phi = matchedTracks.at(i_track)->momentum().phi();
3479         tmp_matchtrkExt_z0 = matchedTracks.at(i_track)->z0();
3480         tmp_matchtrkExt_nFitPars = matchedTracks.at(i_track)->nFitPars();
3481 
3482         if (tmp_matchtrkExt_nFitPars == 5) {
3483           float tmp_matchtrkExt_x0 = matchedTracks.at(i_track)->POCA().x();
3484           float tmp_matchtrkExt_y0 = matchedTracks.at(i_track)->POCA().y();
3485           tmp_matchtrkExt_d0 =
3486               -tmp_matchtrkExt_x0 * sin(tmp_matchtrkExt_phi) + tmp_matchtrkExt_y0 * cos(tmp_matchtrkExt_phi);
3487           // tmp_matchtrkExt_d0 = matchedTracks.at(i_track)->d0();
3488         }
3489 
3490         tmp_matchtrkExt_rinv = matchedTracks.at(i_track)->rInv();
3491         tmp_matchtrkExt_chi2 = matchedTracks.at(i_track)->chi2();
3492         tmp_matchtrkExt_chi2dof = matchedTracks.at(i_track)->chi2Red();
3493         tmp_matchtrkExt_chi2rphi = matchedTracks.at(i_track)->chi2XYRed();
3494         tmp_matchtrkExt_chi2rz = matchedTracks.at(i_track)->chi2ZRed();
3495         tmp_matchtrkExt_bendchi2 = matchedTracks.at(i_track)->stubPtConsistency();
3496         tmp_matchtrkExt_MVA = matchedTracks.at(i_track)->trkMVA1();
3497         tmp_matchtrkExt_nstub = (int)matchedTracks.at(i_track)->getStubRefs().size();
3498         tmp_matchtrkExt_seed = (int)matchedTracks.at(i_track)->trackSeedType();
3499         tmp_matchtrkExt_hitpattern = (int)matchedTracks.at(i_track)->hitPattern();
3500 
3501         // ------------------------------------------------------------------------------------------
3502         tmp_matchtrkExt_dhits = 0;
3503         tmp_matchtrkExt_lhits = 0;
3504 
3505         std::vector<edm::Ref<edmNew::DetSetVector<TTStub<Ref_Phase2TrackerDigi_>>, TTStub<Ref_Phase2TrackerDigi_>>>
3506             stubRefs = matchedTracks.at(i_track)->getStubRefs();
3507         int tmp_nstub = stubRefs.size();
3508 
3509         for (int is = 0; is < tmp_nstub; is++) {
3510           DetId detIdStub = tGeom.idToDet((stubRefs.at(is)->clusterRef(0))->getDetId())->geographicalId();
3511           int layer = -999999;
3512           if (detIdStub.subdetId() == StripSubdetector::TOB) {
3513             layer = static_cast<int>(tTopo.layer(detIdStub));
3514             tmp_matchtrkExt_lhits += pow(10, layer - 1);
3515           } else if (detIdStub.subdetId() == StripSubdetector::TID) {
3516             layer = static_cast<int>(tTopo.layer(detIdStub));
3517             tmp_matchtrkExt_dhits += pow(10, layer - 1);
3518           }
3519         }
3520       }
3521 
3522       // m_tp_nmatch->push_back(nMatch); //modify to be matches for ext
3523       m_matchtrkExt_pt->push_back(tmp_matchtrkExt_pt);
3524       m_matchtrkExt_eta->push_back(tmp_matchtrkExt_eta);
3525       m_matchtrkExt_phi->push_back(tmp_matchtrkExt_phi);
3526       m_matchtrkExt_z0->push_back(tmp_matchtrkExt_z0);
3527       m_matchtrkExt_d0->push_back(tmp_matchtrkExt_d0);
3528       m_matchtrkExt_rinv->push_back(tmp_matchtrkExt_rinv);
3529       m_matchtrkExt_chi2->push_back(tmp_matchtrkExt_chi2);
3530       m_matchtrkExt_chi2dof->push_back(tmp_matchtrkExt_chi2dof);
3531       m_matchtrkExt_chi2rphi->push_back(tmp_matchtrkExt_chi2rphi);
3532       m_matchtrkExt_chi2rz->push_back(tmp_matchtrkExt_chi2rz);
3533       m_matchtrkExt_bendchi2->push_back(tmp_matchtrkExt_bendchi2);
3534       m_matchtrkExt_MVA->push_back(tmp_matchtrkExt_MVA);
3535       m_matchtrkExt_nstub->push_back(tmp_matchtrkExt_nstub);
3536       m_matchtrkExt_dhits->push_back(tmp_matchtrkExt_dhits);
3537       m_matchtrkExt_lhits->push_back(tmp_matchtrkExt_lhits);
3538       m_matchtrkExt_seed->push_back(tmp_matchtrkExt_seed);
3539       m_matchtrkExt_hitpattern->push_back(tmp_matchtrkExt_hitpattern);
3540 
3541       m_matchtrkExtEmu_pt->push_back(tmp_matchtrkExtEmu_pt);
3542       m_matchtrkExtEmu_eta->push_back(tmp_matchtrkExtEmu_eta);
3543       m_matchtrkExtEmu_phi->push_back(tmp_matchtrkExtEmu_phi);
3544       m_matchtrkExtEmu_d0->push_back(tmp_matchtrkExtEmu_d0);
3545       m_matchtrkExtEmu_rho->push_back(tmp_matchtrkExtEmu_rho);
3546       m_matchtrkExtEmu_z0->push_back(tmp_matchtrkExtEmu_z0);
3547       m_matchtrkExtEmu_chi2rphi->push_back(tmp_matchtrkExtEmu_chi2rphi);
3548       m_matchtrkExtEmu_chi2rz->push_back(tmp_matchtrkExtEmu_chi2rz);
3549       m_matchtrkExtEmu_bendchi2->push_back(tmp_matchtrkExtEmu_bendchi2);
3550       m_matchtrkExtEmu_MVA->push_back(tmp_matchtrkExtEmu_MVA);
3551       m_matchtrkExtEmu_nstub->push_back(tmp_matchtrkExtEmu_nstub);
3552     }
3553   }  //end loop tracking particles
3554   trueTkMET = sqrt(trueTkMETx * trueTkMETx + trueTkMETy * trueTkMETy);
3555 
3556   if (L1PrimaryVertexHandle.isValid()) {
3557     for (vtxIter = L1PrimaryVertexHandle->begin(); vtxIter != L1PrimaryVertexHandle->end(); ++vtxIter) {
3558       m_pv_L1reco->push_back(vtxIter->z0());
3559       m_pv_L1reco_sum->push_back(vtxIter->pt());
3560     }
3561   } else
3562     edm::LogWarning("DataNotFound") << "\nWarning: L1PrimaryVertexHandle not found" << std::endl;
3563 
3564   if (L1PrimaryVertexEmuHandle.isValid()) {
3565     for (vtxEmuIter = L1PrimaryVertexEmuHandle->begin(); vtxEmuIter != L1PrimaryVertexEmuHandle->end(); ++vtxEmuIter) {
3566       m_pv_L1reco_emu->push_back(vtxEmuIter->z0());
3567       m_pv_L1reco_sum_emu->push_back(vtxEmuIter->pt());
3568     }
3569   } else
3570     edm::LogWarning("DataNotFound") << "\nWarning: L1PrimaryVertexEmuHandle not found" << std::endl;
3571 
3572   if (SaveTrackSums) {
3573     if (Displaced == "Prompt" || Displaced == "Both") {
3574       if (L1TkMETHandle.isValid()) {
3575         trkMET = L1TkMETHandle->begin()->etMiss();
3576         trkMETPhi = L1TkMETHandle->begin()->p4().phi();
3577       } else {
3578         edm::LogWarning("DataNotFound") << "\nWarning: tkMET handle not found" << std::endl;
3579       }
3580 
3581       if (L1TkMETEmuHandle.isValid()) {
3582         trkMETEmu = L1TkMETEmuHandle->begin()->hwPt() * l1tmetemu::kStepMETwordEt;
3583         trkMETEmuPhi = L1TkMETEmuHandle->begin()->hwPhi() * l1tmetemu::kStepMETwordPhi;
3584       } else {
3585         edm::LogWarning("DataNotFound") << "\nWarning: tkMETEmu handle not found" << std::endl;
3586       }
3587 
3588       if (L1TkMHTHandle.isValid()) {
3589         trkMHT = L1TkMHTHandle->begin()->EtMiss();
3590         trkHT = L1TkMHTHandle->begin()->etTotal();
3591       } else
3592         edm::LogWarning("DataNotFound") << "\nWarning: tkMHT handle not found" << std::endl;
3593 
3594       if (L1TkMHTEmuHandle.isValid()) {
3595         trkMHTEmu = L1TkMHTEmuHandle->begin()->p4().energy();
3596         trkHTEmu = L1TkMHTEmuHandle->begin()->hwPt() * l1tmhtemu::kStepMHT;
3597         trkMHTEmuPhi = L1TkMHTEmuHandle->begin()->hwPhi() * l1tmhtemu::kStepMHTPhi - M_PI;
3598       } else
3599         edm::LogWarning("DataNotFound") << "\nWarning: tkMHTEmu handle not found" << std::endl;
3600     }  //end prompt-track quantities
3601 
3602     if (Displaced == "Displaced" || Displaced == "Both") {
3603       if (L1TkMETExtendedHandle.isValid()) {
3604         trkMETExt = L1TkMETExtendedHandle->begin()->etMiss();
3605         trkMETPhiExt = L1TkMETExtendedHandle->begin()->p4().phi();
3606       } else {
3607         edm::LogWarning("DataNotFound") << "\nWarning: tkMETExtended handle not found" << std::endl;
3608       }
3609 
3610       if (L1TkMHTExtendedHandle.isValid()) {
3611         trkMHTExt = L1TkMHTExtendedHandle->begin()->EtMiss();
3612         trkHTExt = L1TkMHTExtendedHandle->begin()->etTotal();
3613       } else {
3614         edm::LogWarning("DataNotFound") << "\nWarning: tkMHTExtended handle not found" << std::endl;
3615       }
3616 
3617       if (L1TkMHTEmuExtendedHandle.isValid()) {
3618         trkMHTEmuExt = L1TkMHTEmuExtendedHandle->begin()->p4().energy();
3619         trkHTEmuExt = L1TkMHTEmuExtendedHandle->begin()->hwPt() * l1tmhtemu::kStepMHT;
3620         trkMHTEmuPhiExt = L1TkMHTEmuExtendedHandle->begin()->hwPhi() * l1tmhtemu::kStepMHTPhi;
3621       } else
3622         edm::LogWarning("DataNotFound") << "\nWarning: tkMHTEmuExtended handle not found" << std::endl;
3623     }  //end displaced-track quantities
3624   }
3625 
3626   if (SaveTrackJets) {
3627     if (GenJetHandle.isValid()) {
3628       for (auto jetIter = GenJetHandle->begin(); jetIter != GenJetHandle->end(); ++jetIter) {
3629         m_genjet_phi->push_back(jetIter->phi());
3630         m_genjet_eta->push_back(jetIter->eta());
3631         m_genjet_pt->push_back(jetIter->pt());
3632         m_genjet_p->push_back(jetIter->p());
3633       }
3634     }
3635     if (TrackFastJetsHandle.isValid() && (Displaced == "Prompt" || Displaced == "Both")) {
3636       for (jetIter = TrackFastJetsHandle->begin(); jetIter != TrackFastJetsHandle->end(); ++jetIter) {
3637         m_trkfastjet_vz->push_back(jetIter->jetVtx());
3638         m_trkfastjet_ntracks->push_back(jetIter->trkPtrs().size());
3639         m_trkfastjet_phi->push_back(jetIter->phi());
3640         m_trkfastjet_eta->push_back(jetIter->eta());
3641         m_trkfastjet_pt->push_back(jetIter->pt());
3642         m_trkfastjet_p->push_back(jetIter->p());
3643       }
3644     }
3645     if (TrackFastJetsExtendedHandle.isValid() && (Displaced == "Displaced" || Displaced == "Both")) {
3646       for (jetIter = TrackFastJetsExtendedHandle->begin(); jetIter != TrackFastJetsExtendedHandle->end(); ++jetIter) {
3647         m_trkfastjetExt_vz->push_back(jetIter->jetVtx());
3648         m_trkfastjetExt_ntracks->push_back(jetIter->trkPtrs().size());
3649         m_trkfastjetExt_phi->push_back(jetIter->phi());
3650         m_trkfastjetExt_eta->push_back(jetIter->eta());
3651         m_trkfastjetExt_pt->push_back(jetIter->pt());
3652         m_trkfastjetExt_p->push_back(jetIter->p());
3653       }
3654     }
3655     if (!TrackJetsHandle.isValid() && (Displaced == "Prompt" || Displaced == "Both"))
3656       edm::LogWarning("DataNotFound") << "\nWarning: TrackJetsHandle not found" << std::endl;
3657     if (!TrackJetsExtendedHandle.isValid() && (Displaced == "Displaced" || Displaced == "Both"))
3658       edm::LogWarning("DataNotFound") << "\nWarning: TrackJetsExtendedHandle not found" << std::endl;
3659     if (TrackJetsHandle.isValid() && (Displaced == "Prompt" || Displaced == "Both")) {
3660       for (jetIter = TrackJetsHandle->begin(); jetIter != TrackJetsHandle->end(); ++jetIter) {
3661         m_trkjet_vz->push_back(jetIter->jetVtx());
3662         m_trkjet_ntracks->push_back(jetIter->ntracks());
3663         m_trkjet_phi->push_back(jetIter->phi());
3664         m_trkjet_eta->push_back(jetIter->eta());
3665         m_trkjet_pt->push_back(jetIter->pt());
3666         m_trkjet_p->push_back(jetIter->p());
3667         m_trkjet_nDisplaced->push_back(jetIter->nDisptracks());
3668         m_trkjet_nTight->push_back(jetIter->nTighttracks());
3669         m_trkjet_nTightDisplaced->push_back(jetIter->nTightDisptracks());
3670       }
3671     }
3672     for (tripletIter = TrackTripletsHandle->begin(); tripletIter != TrackTripletsHandle->end(); ++tripletIter) {
3673       m_triplet_phi->push_back(tripletIter->phi());
3674       m_triplet_eta->push_back(tripletIter->eta());
3675       m_triplet_pt->push_back(tripletIter->pt());
3676       m_triplet_mass->push_back(tripletIter->mass());
3677       m_triplet_charge->push_back(tripletIter->getTripletCharge());
3678       m_triplet_dmassmax->push_back(tripletIter->getPairMassMax());
3679       m_triplet_dmassmin->push_back(tripletIter->getPairMassMin());
3680       m_triplet_dzmax->push_back(tripletIter->getPairDzMax());
3681       m_triplet_dzmin->push_back(tripletIter->getPairDzMin());
3682       m_triplet_trk1pt->push_back(tripletIter->trkPtr(0)->momentum().perp());
3683       m_triplet_trk1eta->push_back(tripletIter->trkPtr(0)->momentum().eta());
3684       m_triplet_trk1phi->push_back(tripletIter->trkPtr(0)->momentum().phi());
3685       m_triplet_trk1z->push_back(tripletIter->trkPtr(0)->z0());
3686       m_triplet_trk1npar->push_back(tripletIter->trkPtr(0)->nFitPars());
3687       m_triplet_trk1mva->push_back(tripletIter->trkPtr(0)->trkMVA1());
3688       m_triplet_trk2pt->push_back(tripletIter->trkPtr(1)->momentum().perp());
3689       m_triplet_trk2eta->push_back(tripletIter->trkPtr(1)->momentum().eta());
3690       m_triplet_trk2phi->push_back(tripletIter->trkPtr(1)->momentum().phi());
3691       m_triplet_trk2z->push_back(tripletIter->trkPtr(1)->z0());
3692       m_triplet_trk2npar->push_back(tripletIter->trkPtr(1)->nFitPars());
3693       m_triplet_trk2mva->push_back(tripletIter->trkPtr(1)->trkMVA1());
3694       m_triplet_trk3pt->push_back(tripletIter->trkPtr(2)->momentum().perp());
3695       m_triplet_trk3eta->push_back(tripletIter->trkPtr(2)->momentum().eta());
3696       m_triplet_trk3phi->push_back(tripletIter->trkPtr(2)->momentum().phi());
3697       m_triplet_trk3z->push_back(tripletIter->trkPtr(2)->z0());
3698       m_triplet_trk3npar->push_back(tripletIter->trkPtr(2)->nFitPars());
3699       m_triplet_trk3mva->push_back(tripletIter->trkPtr(2)->trkMVA1());
3700     }
3701     if (TrackJetsExtendedHandle.isValid() && (Displaced == "Displaced" || Displaced == "Both")) {
3702       for (jetIter = TrackJetsExtendedHandle->begin(); jetIter != TrackJetsExtendedHandle->end(); ++jetIter) {
3703         m_trkjetExt_vz->push_back(jetIter->jetVtx());
3704         m_trkjetExt_ntracks->push_back(jetIter->ntracks());
3705         m_trkjetExt_phi->push_back(jetIter->phi());
3706         m_trkjetExt_eta->push_back(jetIter->eta());
3707         m_trkjetExt_pt->push_back(jetIter->pt());
3708         m_trkjetExt_p->push_back(jetIter->p());
3709         m_trkjetExt_nDisplaced->push_back(jetIter->nDisptracks());
3710         m_trkjetExt_nTight->push_back(jetIter->nTighttracks());
3711         m_trkjetExt_nTightDisplaced->push_back(jetIter->nTightDisptracks());
3712       }
3713     }
3714 
3715     if (!TrackJetsEmuHandle.isValid() && (Displaced == "Prompt" || Displaced == "Both"))
3716       edm::LogWarning("DataNotFound") << "\nWarning: TrackJetsEmuHandle not found" << std::endl;
3717     else if (TrackJetsEmuHandle.isValid() && (Displaced == "Prompt" || Displaced == "Both")) {
3718       for (jetemIter = TrackJetsEmuHandle->begin(); jetemIter != TrackJetsEmuHandle->end(); ++jetemIter) {
3719         m_trkjetem_ntracks->push_back(jetemIter->nt());
3720         m_trkjetem_phi->push_back(jetemIter->glbphi());
3721         m_trkjetem_eta->push_back(jetemIter->glbeta());
3722         m_trkjetem_pt->push_back(jetemIter->pt());
3723         m_trkjetem_z->push_back(jetemIter->z0());
3724         m_trkjetem_nxtracks->push_back(jetemIter->xt());
3725       }
3726     }
3727     if (!TrackJetsExtendedEmuHandle.isValid() && (Displaced == "Displaced" || Displaced == "Both"))
3728       edm::LogWarning("DataNotFound") << "\nWarning: TrackJetsExtendedEmuHandle not found" << std::endl;
3729     else if (TrackJetsExtendedEmuHandle.isValid() && (Displaced == "Displaced" || Displaced == "Both")) {
3730       for (jetemIter = TrackJetsExtendedEmuHandle->begin(); jetemIter != TrackJetsExtendedEmuHandle->end();
3731            ++jetemIter) {
3732         m_trkjetemExt_ntracks->push_back(jetemIter->nt());
3733         m_trkjetemExt_phi->push_back(jetemIter->glbphi());
3734         m_trkjetemExt_eta->push_back(jetemIter->glbeta());
3735         m_trkjetemExt_pt->push_back(jetemIter->pt());
3736         m_trkjetemExt_z->push_back(jetemIter->z0());
3737         m_trkjetemExt_nxtracks->push_back(jetemIter->xt());
3738       }
3739     }
3740   }  // end track jets
3741 
3742   eventTree->Fill();
3743 }  // end of analyze()
3744 
3745 int L1TrackObjectNtupleMaker::getSelectedTrackIndex(const L1TrackRef& trackRef,
3746                                                     const edm::Handle<L1TrackRefCollection>& selectedTrackRefs) const {
3747   auto it = std::find_if(selectedTrackRefs->begin(), selectedTrackRefs->end(), [&trackRef](L1TrackRef const& obj) {
3748     return obj == trackRef;
3749   });
3750   if (it != selectedTrackRefs->end())
3751     return std::distance(selectedTrackRefs->begin(), it);
3752   else
3753     return -1;
3754 }
3755 
3756 int L1TrackObjectNtupleMaker::getSelectedTrackPtrIndex(const L1TrackPtr& trackPtr,
3757                                                        const edm::Handle<L1TrackCollection>& trackCollection) const {
3758   for (uint i = 0; i < trackCollection->size(); i++) {
3759     L1TrackPtr l1track_ptr(trackCollection, i);
3760     if (trackPtr == l1track_ptr)
3761       return (int)i;
3762   }
3763   return -1;
3764 }
3765 
3766 ///////////////////////////
3767 // DEFINE THIS AS A PLUG-IN
3768 DEFINE_FWK_MODULE(L1TrackObjectNtupleMaker);
[ 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!