Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2024-06-22 02:24:00 

0001 // Original Authors:  Philipp Zehetner, Wahid Redjeb
0002 
0003 #include "TTree.h"
0004 #include "TFile.h"
0005 
0006 #include <iostream>
0007 #include <fstream>
0008 #include <sstream>
0009 #include <variant>
0010 
0011 #include <memory>  // unique_ptr
0012 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
0013 #include "FWCore/ParameterSet/interface/PluginDescription.h"
0014 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0015 #include "FWCore/Utilities/interface/ESGetToken.h"
0016 #include "FWCore/Framework/interface/ESHandle.h"
0017 #include "FWCore/Framework/interface/Frameworkfwd.h"
0018 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0019 #include "FWCore/Framework/interface/Event.h"
0020 #include "FWCore/Framework/interface/MakerMacros.h"
0021 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0022 #include "FWCore/ServiceRegistry/interface/Service.h"
0023 
0024 #include "DataFormats/CaloRecHit/interface/CaloCluster.h"
0025 #include "DataFormats/HGCalReco/interface/Trackster.h"
0026 #include "DataFormats/HGCalReco/interface/TICLCandidate.h"
0027 #include "DataFormats/MuonReco/interface/Muon.h"
0028 #include "DataFormats/TrackReco/interface/Track.h"
0029 #include "DataFormats/TrackReco/interface/TrackFwd.h"
0030 #include "DataFormats/DetId/interface/DetId.h"
0031 #include "DataFormats/Math/interface/Point3D.h"
0032 #include "DataFormats/GeometrySurface/interface/BoundDisk.h"
0033 #include "DataFormats/HGCalReco/interface/Common.h"
0034 #include "SimDataFormats/CaloAnalysis/interface/CaloParticle.h"
0035 #include "SimDataFormats/CaloAnalysis/interface/SimCluster.h"
0036 
0037 #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h"
0038 #include "RecoParticleFlow/PFProducer/interface/PFMuonAlgo.h"
0039 #include "TrackingTools/TrajectoryState/interface/TrajectoryStateTransform.h"
0040 #include "TrackingTools/GeomPropagators/interface/Propagator.h"
0041 #include "TrackingTools/Records/interface/TrackingComponentsRecord.h"
0042 
0043 #include "MagneticField/Engine/interface/MagneticField.h"
0044 #include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
0045 
0046 #include "Geometry/HGCalCommonData/interface/HGCalDDDConstants.h"
0047 #include "Geometry/Records/interface/IdealGeometryRecord.h"
0048 #include "Geometry/CommonDetUnit/interface/GeomDet.h"
0049 
0050 #include "Geometry/CaloGeometry/interface/CaloGeometry.h"
0051 #include "Geometry/Records/interface/CaloGeometryRecord.h"
0052 #include "RecoLocalCalo/HGCalRecAlgos/interface/RecHitTools.h"
0053 
0054 #include "SimDataFormats/Associations/interface/TracksterToSimTracksterHitLCAssociator.h"
0055 
0056 // TFileService
0057 #include "FWCore/ServiceRegistry/interface/Service.h"
0058 #include "CommonTools/UtilAlgos/interface/TFileService.h"
0059 
0060 class TICLDumper : public edm::one::EDAnalyzer<edm::one::WatchRuns, edm::one::SharedResources> {
0061 public:
0062   explicit TICLDumper(const edm::ParameterSet&);
0063   ~TICLDumper() override;
0064   static void fillDescriptions(edm::ConfigurationDescriptions& descriptions);
0065   typedef ticl::Vector Vector;
0066   typedef std::vector<double> Vec;
0067 
0068 private:
0069   void beginJob() override;
0070   void beginRun(const edm::Run&, const edm::EventSetup&) override;
0071 
0072   void initialize(const HGCalDDDConstants* hgcons,
0073                   const hgcal::RecHitTools rhtools,
0074                   const edm::ESHandle<MagneticField> bfieldH,
0075                   const edm::ESHandle<Propagator> propH);
0076   void buildLayers();
0077 
0078   void analyze(const edm::Event&, const edm::EventSetup&) override;
0079   void endRun(edm::Run const& iEvent, edm::EventSetup const&) override{};
0080   void endJob() override;
0081 
0082   // Define Tokens
0083   const edm::EDGetTokenT<std::vector<ticl::Trackster>> tracksters_token_;
0084   const edm::EDGetTokenT<std::vector<ticl::Trackster>> tracksters_in_candidate_token_;
0085   const edm::EDGetTokenT<std::vector<reco::CaloCluster>> layer_clusters_token_;
0086   const edm::EDGetTokenT<std::vector<TICLCandidate>> ticl_candidates_token_;
0087   const edm::EDGetTokenT<std::vector<reco::Track>> tracks_token_;
0088   const edm::EDGetTokenT<std::vector<bool>> tracks_mask_token_;
0089   const edm::EDGetTokenT<edm::ValueMap<float>> tracks_time_token_;
0090   const edm::EDGetTokenT<edm::ValueMap<float>> tracks_time_quality_token_;
0091   const edm::EDGetTokenT<edm::ValueMap<float>> tracks_time_err_token_;
0092   const edm::EDGetTokenT<edm::ValueMap<float>> tracks_beta_token_;
0093   const edm::EDGetTokenT<edm::ValueMap<float>> tracks_time_mtd_token_;
0094   const edm::EDGetTokenT<edm::ValueMap<float>> tracks_time_mtd_err_token_;
0095   const edm::EDGetTokenT<edm::ValueMap<GlobalPoint>> tracks_pos_mtd_token_;
0096   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_x_token_;
0097   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_y_token_;
0098   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_z_token_;
0099   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_eta_token_;
0100   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_phi_token_;
0101   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_px_token_;
0102   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_py_token_;
0103   const edm::EDGetTokenT<std::vector<double>> hgcaltracks_pz_token_;
0104   const edm::EDGetTokenT<std::vector<ticl::Trackster>> tracksters_merged_token_;
0105   const edm::EDGetTokenT<std::vector<reco::Muon>> muons_token_;
0106   const edm::EDGetTokenT<edm::ValueMap<std::pair<float, float>>> clustersTime_token_;
0107   const edm::EDGetTokenT<std::vector<int>> tracksterSeeds_token_;
0108   edm::ESGetToken<CaloGeometry, CaloGeometryRecord> caloGeometry_token_;
0109   const edm::EDGetTokenT<std::vector<ticl::Trackster>> simTracksters_SC_token_;
0110   const edm::EDGetTokenT<std::vector<ticl::Trackster>> simTracksters_CP_token_;
0111   const edm::EDGetTokenT<std::vector<ticl::Trackster>> simTracksters_PU_token_;
0112   const edm::EDGetTokenT<std::vector<TICLCandidate>> simTICLCandidate_token_;
0113   const edm::EDGetTokenT<ticl::RecoToSimCollectionSimTracksters> tsRecoToSimSC_token_;
0114   const edm::EDGetTokenT<ticl::SimToRecoCollectionSimTracksters> tsSimToRecoSC_token_;
0115   const edm::EDGetTokenT<ticl::RecoToSimCollectionSimTracksters> tsRecoToSimCP_token_;
0116   const edm::EDGetTokenT<ticl::SimToRecoCollectionSimTracksters> tsSimToRecoCP_token_;
0117   const edm::EDGetTokenT<ticl::RecoToSimCollectionSimTracksters> MergeRecoToSimSC_token_;
0118   const edm::EDGetTokenT<ticl::SimToRecoCollectionSimTracksters> MergeSimToRecoSC_token_;
0119   const edm::EDGetTokenT<ticl::RecoToSimCollectionSimTracksters> MergeRecoToSimCP_token_;
0120   const edm::EDGetTokenT<ticl::SimToRecoCollectionSimTracksters> MergeSimToRecoCP_token_;
0121   const edm::EDGetTokenT<ticl::RecoToSimCollectionSimTracksters> MergeRecoToSimPU_token_;
0122   const edm::EDGetTokenT<ticl::SimToRecoCollectionSimTracksters> MergeSimToRecoPU_token_;
0123   const edm::EDGetTokenT<std::vector<SimCluster>> simclusters_token_;
0124   const edm::EDGetTokenT<std::vector<CaloParticle>> caloparticles_token_;
0125 
0126   const edm::ESGetToken<CaloGeometry, CaloGeometryRecord> geometry_token_;
0127   const std::string detector_;
0128   const std::string propName_;
0129   const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> bfield_token_;
0130   const edm::ESGetToken<Propagator, TrackingComponentsRecord> propagator_token_;
0131   hgcal::RecHitTools rhtools_;
0132   edm::ESGetToken<HGCalDDDConstants, IdealGeometryRecord> hdc_token_;
0133   const HGCalDDDConstants* hgcons_;
0134   std::unique_ptr<GeomDet> firstDisk_[2];
0135   std::unique_ptr<GeomDet> interfaceDisk_[2];
0136   edm::ESHandle<MagneticField> bfield_;
0137   edm::ESHandle<Propagator> propagator_;
0138   bool saveLCs_;
0139   bool saveCLUE3DTracksters_;
0140   bool saveTrackstersMerged_;
0141   bool saveSimTrackstersSC_;
0142   bool saveSimTrackstersCP_;
0143   bool saveTICLCandidate_;
0144   bool saveSimTICLCandidate_;
0145   bool saveTracks_;
0146   bool saveAssociations_;
0147 
0148   // Output tree
0149   TTree* tree_;
0150 
0151   void clearVariables();
0152 
0153   // Variables for branches
0154   unsigned int ev_event_;
0155   unsigned int ntracksters_;
0156   unsigned int nclusters_;
0157   unsigned int stsSC_ntracksters_;
0158   unsigned int stsCP_ntracksters_;
0159   size_t nsimTrackstersSC;
0160   size_t nsimTrackstersCP;
0161 
0162   std::vector<float> trackster_time;
0163   std::vector<float> trackster_timeError;
0164   std::vector<float> trackster_regressed_energy;
0165   std::vector<float> trackster_raw_energy;
0166   std::vector<float> trackster_raw_em_energy;
0167   std::vector<float> trackster_raw_pt;
0168   std::vector<float> trackster_raw_em_pt;
0169   std::vector<float> trackster_barycenter_x;
0170   std::vector<float> trackster_barycenter_y;
0171   std::vector<float> trackster_barycenter_z;
0172   std::vector<float> trackster_EV1;
0173   std::vector<float> trackster_EV2;
0174   std::vector<float> trackster_EV3;
0175   std::vector<float> trackster_eVector0_x;
0176   std::vector<float> trackster_eVector0_y;
0177   std::vector<float> trackster_eVector0_z;
0178   std::vector<float> trackster_sigmaPCA1;
0179   std::vector<float> trackster_sigmaPCA2;
0180   std::vector<float> trackster_sigmaPCA3;
0181   std::vector<float> trackster_barycenter_eta;
0182   std::vector<float> trackster_barycenter_phi;
0183   std::vector<std::vector<float>> trackster_id_probabilities;
0184   std::vector<std::vector<uint32_t>> trackster_vertices_indexes;
0185   std::vector<std::vector<float>> trackster_vertices_x;
0186   std::vector<std::vector<float>> trackster_vertices_y;
0187   std::vector<std::vector<float>> trackster_vertices_z;
0188   std::vector<std::vector<float>> trackster_vertices_time;
0189   std::vector<std::vector<float>> trackster_vertices_timeErr;
0190   std::vector<std::vector<float>> trackster_vertices_energy;
0191   std::vector<std::vector<float>> trackster_vertices_correctedEnergy;
0192   std::vector<std::vector<float>> trackster_vertices_correctedEnergyUncertainty;
0193   std::vector<std::vector<float>> trackster_vertices_multiplicity;
0194 
0195   std::vector<float> stsSC_trackster_time;
0196   std::vector<float> stsSC_trackster_timeBoundary;
0197   std::vector<float> stsSC_trackster_timeError;
0198   std::vector<float> stsSC_trackster_regressed_energy;
0199   std::vector<float> stsSC_trackster_regressed_pt;
0200   std::vector<float> stsSC_trackster_raw_energy;
0201   std::vector<float> stsSC_trackster_raw_em_energy;
0202   std::vector<float> stsSC_trackster_raw_pt;
0203   std::vector<float> stsSC_trackster_raw_em_pt;
0204   std::vector<float> stsSC_trackster_barycenter_x;
0205   std::vector<float> stsSC_trackster_barycenter_y;
0206   std::vector<float> stsSC_trackster_barycenter_z;
0207   std::vector<float> stsSC_trackster_barycenter_eta;
0208   std::vector<float> stsSC_trackster_barycenter_phi;
0209   std::vector<float> stsSC_trackster_EV1;
0210   std::vector<float> stsSC_trackster_EV2;
0211   std::vector<float> stsSC_trackster_EV3;
0212   std::vector<float> stsSC_trackster_eVector0_x;
0213   std::vector<float> stsSC_trackster_eVector0_y;
0214   std::vector<float> stsSC_trackster_eVector0_z;
0215   std::vector<float> stsSC_trackster_sigmaPCA1;
0216   std::vector<float> stsSC_trackster_sigmaPCA2;
0217   std::vector<float> stsSC_trackster_sigmaPCA3;
0218   std::vector<int> stsSC_pdgID;
0219   std::vector<int> stsSC_trackIdx;
0220   std::vector<float> stsSC_trackTime;
0221   std::vector<float> stsSC_boundaryX;
0222   std::vector<float> stsSC_boundaryY;
0223   std::vector<float> stsSC_boundaryZ;
0224   std::vector<float> stsSC_boundaryEta;
0225   std::vector<float> stsSC_boundaryPhi;
0226   std::vector<float> stsSC_boundaryPx;
0227   std::vector<float> stsSC_boundaryPy;
0228   std::vector<float> stsSC_boundaryPz;
0229   std::vector<float> stsSC_track_boundaryX;
0230   std::vector<float> stsSC_track_boundaryY;
0231   std::vector<float> stsSC_track_boundaryZ;
0232   std::vector<float> stsSC_track_boundaryEta;
0233   std::vector<float> stsSC_track_boundaryPhi;
0234   std::vector<float> stsSC_track_boundaryPx;
0235   std::vector<float> stsSC_track_boundaryPy;
0236   std::vector<float> stsSC_track_boundaryPz;
0237   std::vector<std::vector<float>> stsSC_trackster_id_probabilities;
0238   std::vector<std::vector<uint32_t>> stsSC_trackster_vertices_indexes;
0239   std::vector<std::vector<float>> stsSC_trackster_vertices_x;
0240   std::vector<std::vector<float>> stsSC_trackster_vertices_y;
0241   std::vector<std::vector<float>> stsSC_trackster_vertices_z;
0242   std::vector<std::vector<float>> stsSC_trackster_vertices_time;
0243   std::vector<std::vector<float>> stsSC_trackster_vertices_timeErr;
0244   std::vector<std::vector<float>> stsSC_trackster_vertices_energy;
0245   std::vector<std::vector<float>> stsSC_trackster_vertices_correctedEnergy;
0246   std::vector<std::vector<float>> stsSC_trackster_vertices_correctedEnergyUncertainty;
0247   std::vector<std::vector<float>> stsSC_trackster_vertices_multiplicity;
0248   std::vector<float> stsCP_trackster_time;
0249   std::vector<float> stsCP_trackster_timeBoundary;
0250   std::vector<float> stsCP_trackster_timeError;
0251   std::vector<float> stsCP_trackster_regressed_energy;
0252   std::vector<float> stsCP_trackster_regressed_pt;
0253   std::vector<float> stsCP_trackster_raw_energy;
0254   std::vector<float> stsCP_trackster_raw_em_energy;
0255   std::vector<float> stsCP_trackster_raw_pt;
0256   std::vector<float> stsCP_trackster_raw_em_pt;
0257   std::vector<float> stsCP_trackster_barycenter_x;
0258   std::vector<float> stsCP_trackster_barycenter_y;
0259   std::vector<float> stsCP_trackster_barycenter_z;
0260   std::vector<float> stsCP_trackster_barycenter_eta;
0261   std::vector<float> stsCP_trackster_barycenter_phi;
0262   std::vector<float> stsCP_trackster_EV1;
0263   std::vector<float> stsCP_trackster_EV2;
0264   std::vector<float> stsCP_trackster_EV3;
0265   std::vector<float> stsCP_trackster_eVector0_x;
0266   std::vector<float> stsCP_trackster_eVector0_y;
0267   std::vector<float> stsCP_trackster_eVector0_z;
0268   std::vector<float> stsCP_trackster_sigmaPCA1;
0269   std::vector<float> stsCP_trackster_sigmaPCA2;
0270   std::vector<float> stsCP_trackster_sigmaPCA3;
0271   std::vector<int> stsCP_pdgID;
0272   std::vector<int> stsCP_trackIdx;
0273   std::vector<float> stsCP_trackTime;
0274   std::vector<float> stsCP_boundaryX;
0275   std::vector<float> stsCP_boundaryY;
0276   std::vector<float> stsCP_boundaryZ;
0277   std::vector<float> stsCP_boundaryEta;
0278   std::vector<float> stsCP_boundaryPhi;
0279   std::vector<float> stsCP_boundaryPx;
0280   std::vector<float> stsCP_boundaryPy;
0281   std::vector<float> stsCP_boundaryPz;
0282   std::vector<float> stsCP_track_boundaryX;
0283   std::vector<float> stsCP_track_boundaryY;
0284   std::vector<float> stsCP_track_boundaryZ;
0285   std::vector<float> stsCP_track_boundaryEta;
0286   std::vector<float> stsCP_track_boundaryPhi;
0287   std::vector<float> stsCP_track_boundaryPx;
0288   std::vector<float> stsCP_track_boundaryPy;
0289   std::vector<float> stsCP_track_boundaryPz;
0290   std::vector<std::vector<float>> stsCP_trackster_id_probabilities;
0291   std::vector<std::vector<uint32_t>> stsCP_trackster_vertices_indexes;
0292   std::vector<std::vector<float>> stsCP_trackster_vertices_x;
0293   std::vector<std::vector<float>> stsCP_trackster_vertices_y;
0294   std::vector<std::vector<float>> stsCP_trackster_vertices_z;
0295   std::vector<std::vector<float>> stsCP_trackster_vertices_time;
0296   std::vector<std::vector<float>> stsCP_trackster_vertices_timeErr;
0297   std::vector<std::vector<float>> stsCP_trackster_vertices_energy;
0298   std::vector<std::vector<float>> stsCP_trackster_vertices_correctedEnergy;
0299   std::vector<std::vector<float>> stsCP_trackster_vertices_correctedEnergyUncertainty;
0300   std::vector<std::vector<float>> stsCP_trackster_vertices_multiplicity;
0301 
0302   std::vector<float> simTICLCandidate_raw_energy;
0303   std::vector<float> simTICLCandidate_regressed_energy;
0304   std::vector<std::vector<int>> simTICLCandidate_simTracksterCPIndex;
0305   std::vector<float> simTICLCandidate_boundaryX;
0306   std::vector<float> simTICLCandidate_boundaryY;
0307   std::vector<float> simTICLCandidate_boundaryZ;
0308   std::vector<float> simTICLCandidate_boundaryPx;
0309   std::vector<float> simTICLCandidate_boundaryPy;
0310   std::vector<float> simTICLCandidate_boundaryPz;
0311   std::vector<float> simTICLCandidate_caloParticleMass;
0312   std::vector<float> simTICLCandidate_time;
0313   std::vector<int> simTICLCandidate_pdgId;
0314   std::vector<int> simTICLCandidate_charge;
0315   std::vector<int> simTICLCandidate_track_in_candidate;
0316 
0317   // from TICLCandidate, product of linking
0318   size_t nCandidates;
0319   std::vector<int> candidate_charge;
0320   std::vector<int> candidate_pdgId;
0321   std::vector<float> candidate_energy;
0322   std::vector<float> candidate_raw_energy;
0323   std::vector<double> candidate_px;
0324   std::vector<double> candidate_py;
0325   std::vector<double> candidate_pz;
0326   std::vector<float> candidate_time;
0327   std::vector<float> candidate_time_err;
0328   std::vector<std::vector<float>> candidate_id_probabilities;
0329   std::vector<std::vector<uint32_t>> tracksters_in_candidate;
0330   std::vector<int> track_in_candidate;
0331 
0332   // merged tracksters
0333   size_t nTrackstersMerged;
0334   std::vector<float> tracksters_merged_time;
0335   std::vector<float> tracksters_merged_timeError;
0336   std::vector<float> tracksters_merged_regressed_energy;
0337   std::vector<float> tracksters_merged_raw_energy;
0338   std::vector<float> tracksters_merged_raw_em_energy;
0339   std::vector<float> tracksters_merged_raw_pt;
0340   std::vector<float> tracksters_merged_raw_em_pt;
0341   std::vector<float> tracksters_merged_barycenter_x;
0342   std::vector<float> tracksters_merged_barycenter_y;
0343   std::vector<float> tracksters_merged_barycenter_z;
0344   std::vector<float> tracksters_merged_barycenter_eta;
0345   std::vector<float> tracksters_merged_barycenter_phi;
0346   std::vector<float> tracksters_merged_EV1;
0347   std::vector<float> tracksters_merged_EV2;
0348   std::vector<float> tracksters_merged_EV3;
0349   std::vector<float> tracksters_merged_eVector0_x;
0350   std::vector<float> tracksters_merged_eVector0_y;
0351   std::vector<float> tracksters_merged_eVector0_z;
0352   std::vector<float> tracksters_merged_sigmaPCA1;
0353   std::vector<float> tracksters_merged_sigmaPCA2;
0354   std::vector<float> tracksters_merged_sigmaPCA3;
0355   std::vector<std::vector<uint32_t>> tracksters_merged_vertices_indexes;
0356   std::vector<std::vector<float>> tracksters_merged_vertices_x;
0357   std::vector<std::vector<float>> tracksters_merged_vertices_y;
0358   std::vector<std::vector<float>> tracksters_merged_vertices_z;
0359   std::vector<std::vector<float>> tracksters_merged_vertices_time;
0360   std::vector<std::vector<float>> tracksters_merged_vertices_timeErr;
0361   std::vector<std::vector<float>> tracksters_merged_vertices_energy;
0362   std::vector<std::vector<float>> tracksters_merged_vertices_correctedEnergy;
0363   std::vector<std::vector<float>> tracksters_merged_vertices_correctedEnergyUncertainty;
0364   std::vector<std::vector<float>> tracksters_merged_vertices_multiplicity;
0365   std::vector<std::vector<float>> tracksters_merged_id_probabilities;
0366 
0367   // associations
0368   std::vector<std::vector<uint32_t>> trackstersCLUE3D_recoToSim_SC;
0369   std::vector<std::vector<float>> trackstersCLUE3D_recoToSim_SC_score;
0370   std::vector<std::vector<float>> trackstersCLUE3D_recoToSim_SC_sharedE;
0371   std::vector<std::vector<uint32_t>> trackstersCLUE3D_simToReco_SC;
0372   std::vector<std::vector<float>> trackstersCLUE3D_simToReco_SC_score;
0373   std::vector<std::vector<float>> trackstersCLUE3D_simToReco_SC_sharedE;
0374 
0375   std::vector<std::vector<uint32_t>> trackstersCLUE3D_recoToSim_CP;
0376   std::vector<std::vector<float>> trackstersCLUE3D_recoToSim_CP_score;
0377   std::vector<std::vector<float>> trackstersCLUE3D_recoToSim_CP_sharedE;
0378   std::vector<std::vector<uint32_t>> trackstersCLUE3D_simToReco_CP;
0379   std::vector<std::vector<float>> trackstersCLUE3D_simToReco_CP_score;
0380   std::vector<std::vector<float>> trackstersCLUE3D_simToReco_CP_sharedE;
0381 
0382   std::vector<std::vector<uint32_t>> MergeTracksters_recoToSim_SC;
0383   std::vector<std::vector<float>> MergeTracksters_recoToSim_SC_score;
0384   std::vector<std::vector<float>> MergeTracksters_recoToSim_SC_sharedE;
0385   std::vector<std::vector<uint32_t>> MergeTracksters_simToReco_SC;
0386   std::vector<std::vector<float>> MergeTracksters_simToReco_SC_score;
0387   std::vector<std::vector<float>> MergeTracksters_simToReco_SC_sharedE;
0388 
0389   std::vector<std::vector<uint32_t>> MergeTracksters_recoToSim_CP;
0390   std::vector<std::vector<float>> MergeTracksters_recoToSim_CP_score;
0391   std::vector<std::vector<float>> MergeTracksters_recoToSim_CP_sharedE;
0392   std::vector<std::vector<uint32_t>> MergeTracksters_simToReco_CP;
0393   std::vector<std::vector<float>> MergeTracksters_simToReco_CP_score;
0394   std::vector<std::vector<float>> MergeTracksters_simToReco_CP_sharedE;
0395 
0396   std::vector<std::vector<uint32_t>> MergeTracksters_recoToSim_PU;
0397   std::vector<std::vector<float>> MergeTracksters_recoToSim_PU_score;
0398   std::vector<std::vector<float>> MergeTracksters_recoToSim_PU_sharedE;
0399   std::vector<std::vector<uint32_t>> MergeTracksters_simToReco_PU;
0400   std::vector<std::vector<float>> MergeTracksters_simToReco_PU_score;
0401   std::vector<std::vector<float>> MergeTracksters_simToReco_PU_sharedE;
0402 
0403   std::vector<uint32_t> cluster_seedID;
0404   std::vector<float> cluster_energy;
0405   std::vector<float> cluster_correctedEnergy;
0406   std::vector<float> cluster_correctedEnergyUncertainty;
0407   std::vector<float> cluster_position_x;
0408   std::vector<float> cluster_position_y;
0409   std::vector<float> cluster_position_z;
0410   std::vector<float> cluster_position_eta;
0411   std::vector<float> cluster_position_phi;
0412   std::vector<unsigned int> cluster_layer_id;
0413   std::vector<int> cluster_type;
0414   std::vector<float> cluster_time;
0415   std::vector<float> cluster_timeErr;
0416   std::vector<uint32_t> cluster_number_of_hits;
0417 
0418   std::vector<unsigned int> track_id;
0419   std::vector<float> track_hgcal_x;
0420   std::vector<float> track_hgcal_y;
0421   std::vector<float> track_hgcal_z;
0422   std::vector<float> track_hgcal_px;
0423   std::vector<float> track_hgcal_py;
0424   std::vector<float> track_hgcal_pz;
0425   std::vector<float> track_hgcal_eta;
0426   std::vector<float> track_hgcal_phi;
0427   std::vector<float> track_hgcal_pt;
0428   std::vector<float> track_pt;
0429   std::vector<int> track_quality;
0430   std::vector<int> track_missing_outer_hits;
0431   std::vector<int> track_missing_inner_hits;
0432   std::vector<int> track_charge;
0433   std::vector<double> track_time;
0434   std::vector<float> track_time_quality;
0435   std::vector<float> track_time_err;
0436   std::vector<float> track_beta;
0437   std::vector<float> track_time_mtd;
0438   std::vector<float> track_time_mtd_err;
0439   std::vector<GlobalPoint> track_pos_mtd;
0440   std::vector<int> track_nhits;
0441   std::vector<int> track_isMuon;
0442   std::vector<int> track_isTrackerMuon;
0443 
0444   TTree* trackster_tree_;
0445   TTree* cluster_tree_;
0446   TTree* candidate_tree_;
0447   TTree* tracksters_merged_tree_;
0448   TTree* associations_tree_;
0449   TTree* simtrackstersSC_tree_;
0450   TTree* simtrackstersCP_tree_;
0451   TTree* tracks_tree_;
0452   TTree* simTICLCandidate_tree;
0453 };
0454 
0455 void TICLDumper::clearVariables() {
0456   // event info
0457   ntracksters_ = 0;
0458   nclusters_ = 0;
0459 
0460   trackster_time.clear();
0461   trackster_timeError.clear();
0462   trackster_regressed_energy.clear();
0463   trackster_raw_energy.clear();
0464   trackster_raw_em_energy.clear();
0465   trackster_raw_pt.clear();
0466   trackster_raw_em_pt.clear();
0467   trackster_barycenter_x.clear();
0468   trackster_barycenter_y.clear();
0469   trackster_barycenter_z.clear();
0470   trackster_EV1.clear();
0471   trackster_EV2.clear();
0472   trackster_EV3.clear();
0473   trackster_eVector0_x.clear();
0474   trackster_eVector0_y.clear();
0475   trackster_eVector0_z.clear();
0476   trackster_sigmaPCA1.clear();
0477   trackster_sigmaPCA2.clear();
0478   trackster_sigmaPCA3.clear();
0479   trackster_barycenter_eta.clear();
0480   trackster_barycenter_phi.clear();
0481   trackster_id_probabilities.clear();
0482   trackster_vertices_indexes.clear();
0483   trackster_vertices_x.clear();
0484   trackster_vertices_y.clear();
0485   trackster_vertices_z.clear();
0486   trackster_vertices_time.clear();
0487   trackster_vertices_timeErr.clear();
0488   trackster_vertices_energy.clear();
0489   trackster_vertices_correctedEnergy.clear();
0490   trackster_vertices_correctedEnergyUncertainty.clear();
0491   trackster_vertices_multiplicity.clear();
0492 
0493   stsSC_trackster_time.clear();
0494   stsSC_trackster_timeBoundary.clear();
0495   stsSC_trackster_timeError.clear();
0496   stsSC_trackster_regressed_energy.clear();
0497   stsSC_trackster_regressed_pt.clear();
0498   stsSC_trackster_raw_energy.clear();
0499   stsSC_trackster_raw_em_energy.clear();
0500   stsSC_trackster_raw_pt.clear();
0501   stsSC_trackster_raw_em_pt.clear();
0502   stsSC_trackster_barycenter_x.clear();
0503   stsSC_trackster_barycenter_y.clear();
0504   stsSC_trackster_barycenter_z.clear();
0505   stsSC_trackster_EV1.clear();
0506   stsSC_trackster_EV2.clear();
0507   stsSC_trackster_EV3.clear();
0508   stsSC_trackster_eVector0_x.clear();
0509   stsSC_trackster_eVector0_y.clear();
0510   stsSC_trackster_eVector0_z.clear();
0511   stsSC_trackster_sigmaPCA1.clear();
0512   stsSC_trackster_sigmaPCA2.clear();
0513   stsSC_trackster_sigmaPCA3.clear();
0514   stsSC_trackster_barycenter_eta.clear();
0515   stsSC_trackster_barycenter_phi.clear();
0516   stsSC_pdgID.clear();
0517   stsSC_trackIdx.clear();
0518   stsSC_trackTime.clear();
0519   stsSC_boundaryX.clear();
0520   stsSC_boundaryY.clear();
0521   stsSC_boundaryZ.clear();
0522   stsSC_boundaryEta.clear();
0523   stsSC_boundaryPhi.clear();
0524   stsSC_boundaryPx.clear();
0525   stsSC_boundaryPy.clear();
0526   stsSC_boundaryPz.clear();
0527   stsSC_track_boundaryX.clear();
0528   stsSC_track_boundaryY.clear();
0529   stsSC_track_boundaryZ.clear();
0530   stsSC_track_boundaryEta.clear();
0531   stsSC_track_boundaryPhi.clear();
0532   stsSC_track_boundaryPx.clear();
0533   stsSC_track_boundaryPy.clear();
0534   stsSC_track_boundaryPz.clear();
0535   stsSC_trackster_id_probabilities.clear();
0536   stsSC_trackster_vertices_indexes.clear();
0537   stsSC_trackster_vertices_x.clear();
0538   stsSC_trackster_vertices_y.clear();
0539   stsSC_trackster_vertices_z.clear();
0540   stsSC_trackster_vertices_time.clear();
0541   stsSC_trackster_vertices_timeErr.clear();
0542   stsSC_trackster_vertices_energy.clear();
0543   stsSC_trackster_vertices_correctedEnergy.clear();
0544   stsSC_trackster_vertices_correctedEnergyUncertainty.clear();
0545   stsSC_trackster_vertices_multiplicity.clear();
0546 
0547   stsCP_trackster_time.clear();
0548   stsCP_trackster_timeBoundary.clear();
0549   stsCP_trackster_timeError.clear();
0550   stsCP_trackster_regressed_energy.clear();
0551   stsCP_trackster_regressed_pt.clear();
0552   stsCP_trackster_raw_energy.clear();
0553   stsCP_trackster_raw_em_energy.clear();
0554   stsCP_trackster_raw_pt.clear();
0555   stsCP_trackster_raw_em_pt.clear();
0556   stsCP_trackster_barycenter_x.clear();
0557   stsCP_trackster_barycenter_y.clear();
0558   stsCP_trackster_barycenter_z.clear();
0559   stsCP_trackster_sigmaPCA1.clear();
0560   stsCP_trackster_sigmaPCA2.clear();
0561   stsCP_trackster_sigmaPCA3.clear();
0562   stsCP_trackster_barycenter_eta.clear();
0563   stsCP_trackster_barycenter_phi.clear();
0564   stsCP_pdgID.clear();
0565   stsCP_trackIdx.clear();
0566   stsCP_trackTime.clear();
0567   stsCP_boundaryX.clear();
0568   stsCP_boundaryY.clear();
0569   stsCP_boundaryZ.clear();
0570   stsCP_boundaryEta.clear();
0571   stsCP_boundaryPhi.clear();
0572   stsCP_boundaryPx.clear();
0573   stsCP_boundaryPy.clear();
0574   stsCP_boundaryPz.clear();
0575   stsCP_track_boundaryX.clear();
0576   stsCP_track_boundaryY.clear();
0577   stsCP_track_boundaryZ.clear();
0578   stsCP_track_boundaryEta.clear();
0579   stsCP_track_boundaryPhi.clear();
0580   stsCP_track_boundaryPx.clear();
0581   stsCP_track_boundaryPy.clear();
0582   stsCP_track_boundaryPz.clear();
0583   stsCP_trackster_id_probabilities.clear();
0584   stsCP_trackster_vertices_indexes.clear();
0585   stsCP_trackster_vertices_x.clear();
0586   stsCP_trackster_vertices_y.clear();
0587   stsCP_trackster_vertices_z.clear();
0588   stsCP_trackster_vertices_time.clear();
0589   stsCP_trackster_vertices_timeErr.clear();
0590   stsCP_trackster_vertices_energy.clear();
0591   stsCP_trackster_vertices_correctedEnergy.clear();
0592   stsCP_trackster_vertices_correctedEnergyUncertainty.clear();
0593   stsCP_trackster_vertices_multiplicity.clear();
0594 
0595   simTICLCandidate_raw_energy.clear();
0596   simTICLCandidate_regressed_energy.clear();
0597   simTICLCandidate_simTracksterCPIndex.clear();
0598   simTICLCandidate_boundaryX.clear();
0599   simTICLCandidate_boundaryY.clear();
0600   simTICLCandidate_boundaryZ.clear();
0601   simTICLCandidate_boundaryPx.clear();
0602   simTICLCandidate_boundaryPy.clear();
0603   simTICLCandidate_boundaryPz.clear();
0604   simTICLCandidate_time.clear();
0605   simTICLCandidate_caloParticleMass.clear();
0606   simTICLCandidate_pdgId.clear();
0607   simTICLCandidate_charge.clear();
0608   simTICLCandidate_track_in_candidate.clear();
0609 
0610   nCandidates = 0;
0611   candidate_charge.clear();
0612   candidate_pdgId.clear();
0613   candidate_energy.clear();
0614   candidate_raw_energy.clear();
0615   candidate_px.clear();
0616   candidate_py.clear();
0617   candidate_pz.clear();
0618   candidate_time.clear();
0619   candidate_time_err.clear();
0620   candidate_id_probabilities.clear();
0621   tracksters_in_candidate.clear();
0622   track_in_candidate.clear();
0623 
0624   nTrackstersMerged = 0;
0625   tracksters_merged_time.clear();
0626   tracksters_merged_timeError.clear();
0627   tracksters_merged_regressed_energy.clear();
0628   tracksters_merged_raw_energy.clear();
0629   tracksters_merged_raw_em_energy.clear();
0630   tracksters_merged_raw_pt.clear();
0631   tracksters_merged_raw_em_pt.clear();
0632   tracksters_merged_barycenter_x.clear();
0633   tracksters_merged_barycenter_y.clear();
0634   tracksters_merged_barycenter_z.clear();
0635   tracksters_merged_barycenter_eta.clear();
0636   tracksters_merged_barycenter_phi.clear();
0637   tracksters_merged_EV1.clear();
0638   tracksters_merged_EV2.clear();
0639   tracksters_merged_EV3.clear();
0640   tracksters_merged_eVector0_x.clear();
0641   tracksters_merged_eVector0_y.clear();
0642   tracksters_merged_eVector0_z.clear();
0643   tracksters_merged_sigmaPCA1.clear();
0644   tracksters_merged_sigmaPCA2.clear();
0645   tracksters_merged_sigmaPCA3.clear();
0646   tracksters_merged_id_probabilities.clear();
0647   tracksters_merged_time.clear();
0648   tracksters_merged_timeError.clear();
0649   tracksters_merged_regressed_energy.clear();
0650   tracksters_merged_raw_energy.clear();
0651   tracksters_merged_raw_em_energy.clear();
0652   tracksters_merged_raw_pt.clear();
0653   tracksters_merged_raw_em_pt.clear();
0654 
0655   tracksters_merged_vertices_indexes.clear();
0656   tracksters_merged_vertices_x.clear();
0657   tracksters_merged_vertices_y.clear();
0658   tracksters_merged_vertices_z.clear();
0659   tracksters_merged_vertices_time.clear();
0660   tracksters_merged_vertices_timeErr.clear();
0661   tracksters_merged_vertices_energy.clear();
0662   tracksters_merged_vertices_correctedEnergy.clear();
0663   tracksters_merged_vertices_correctedEnergyUncertainty.clear();
0664   tracksters_merged_vertices_multiplicity.clear();
0665 
0666   trackstersCLUE3D_recoToSim_SC.clear();
0667   trackstersCLUE3D_recoToSim_SC_score.clear();
0668   trackstersCLUE3D_recoToSim_SC_sharedE.clear();
0669   trackstersCLUE3D_simToReco_SC.clear();
0670   trackstersCLUE3D_simToReco_SC_score.clear();
0671   trackstersCLUE3D_simToReco_SC_sharedE.clear();
0672 
0673   trackstersCLUE3D_recoToSim_CP.clear();
0674   trackstersCLUE3D_recoToSim_CP_score.clear();
0675   trackstersCLUE3D_recoToSim_CP_sharedE.clear();
0676   trackstersCLUE3D_simToReco_CP.clear();
0677   trackstersCLUE3D_simToReco_CP_score.clear();
0678   trackstersCLUE3D_simToReco_CP_sharedE.clear();
0679 
0680   MergeTracksters_recoToSim_SC.clear();
0681   MergeTracksters_recoToSim_SC_score.clear();
0682   MergeTracksters_recoToSim_SC_sharedE.clear();
0683   MergeTracksters_simToReco_SC.clear();
0684   MergeTracksters_simToReco_SC_score.clear();
0685   MergeTracksters_simToReco_SC_sharedE.clear();
0686 
0687   MergeTracksters_recoToSim_CP.clear();
0688   MergeTracksters_recoToSim_CP_score.clear();
0689   MergeTracksters_recoToSim_CP_sharedE.clear();
0690   MergeTracksters_simToReco_CP.clear();
0691   MergeTracksters_simToReco_CP_score.clear();
0692   MergeTracksters_simToReco_CP_sharedE.clear();
0693 
0694   MergeTracksters_recoToSim_PU.clear();
0695   MergeTracksters_recoToSim_PU_score.clear();
0696   MergeTracksters_recoToSim_PU_sharedE.clear();
0697   MergeTracksters_simToReco_PU.clear();
0698   MergeTracksters_simToReco_PU_score.clear();
0699   MergeTracksters_simToReco_PU_sharedE.clear();
0700 
0701   nsimTrackstersSC = 0;
0702 
0703   cluster_seedID.clear();
0704   cluster_energy.clear();
0705   cluster_correctedEnergy.clear();
0706   cluster_correctedEnergyUncertainty.clear();
0707   cluster_position_x.clear();
0708   cluster_position_y.clear();
0709   cluster_position_z.clear();
0710   cluster_position_eta.clear();
0711   cluster_position_phi.clear();
0712   cluster_layer_id.clear();
0713   cluster_type.clear();
0714   cluster_time.clear();
0715   cluster_timeErr.clear();
0716   cluster_number_of_hits.clear();
0717 
0718   track_id.clear();
0719   track_hgcal_x.clear();
0720   track_hgcal_y.clear();
0721   track_hgcal_z.clear();
0722   track_hgcal_eta.clear();
0723   track_hgcal_phi.clear();
0724   track_hgcal_px.clear();
0725   track_hgcal_py.clear();
0726   track_hgcal_pz.clear();
0727   track_hgcal_pt.clear();
0728   track_quality.clear();
0729   track_pt.clear();
0730   track_missing_outer_hits.clear();
0731   track_missing_inner_hits.clear();
0732   track_charge.clear();
0733   track_time.clear();
0734   track_time_quality.clear();
0735   track_time_err.clear();
0736   track_beta.clear();
0737   track_time_mtd.clear();
0738   track_time_mtd_err.clear();
0739   track_pos_mtd.clear();
0740   track_nhits.clear();
0741   track_isMuon.clear();
0742   track_isTrackerMuon.clear();
0743 };
0744 
0745 TICLDumper::TICLDumper(const edm::ParameterSet& ps)
0746     : tracksters_token_(consumes<std::vector<ticl::Trackster>>(ps.getParameter<edm::InputTag>("trackstersclue3d"))),
0747       tracksters_in_candidate_token_(
0748           consumes<std::vector<ticl::Trackster>>(ps.getParameter<edm::InputTag>("trackstersInCand"))),
0749       layer_clusters_token_(consumes<std::vector<reco::CaloCluster>>(ps.getParameter<edm::InputTag>("layerClusters"))),
0750       ticl_candidates_token_(consumes<std::vector<TICLCandidate>>(ps.getParameter<edm::InputTag>("ticlcandidates"))),
0751       tracks_token_(consumes<std::vector<reco::Track>>(ps.getParameter<edm::InputTag>("tracks"))),
0752       tracks_time_token_(consumes<edm::ValueMap<float>>(ps.getParameter<edm::InputTag>("tracksTime"))),
0753       tracks_time_quality_token_(consumes<edm::ValueMap<float>>(ps.getParameter<edm::InputTag>("tracksTimeQual"))),
0754       tracks_time_err_token_(consumes<edm::ValueMap<float>>(ps.getParameter<edm::InputTag>("tracksTimeErr"))),
0755       tracks_beta_token_(consumes<edm::ValueMap<float>>(ps.getParameter<edm::InputTag>("tracksBeta"))),
0756       tracks_time_mtd_token_(consumes<edm::ValueMap<float>>(ps.getParameter<edm::InputTag>("tracksTimeMtd"))),
0757       tracks_time_mtd_err_token_(consumes<edm::ValueMap<float>>(ps.getParameter<edm::InputTag>("tracksTimeMtdErr"))),
0758       tracks_pos_mtd_token_(consumes<edm::ValueMap<GlobalPoint>>(ps.getParameter<edm::InputTag>("tracksPosMtd"))),
0759       tracksters_merged_token_(
0760           consumes<std::vector<ticl::Trackster>>(ps.getParameter<edm::InputTag>("trackstersmerged"))),
0761       muons_token_(consumes<std::vector<reco::Muon>>(ps.getParameter<edm::InputTag>("muons"))),
0762       clustersTime_token_(
0763           consumes<edm::ValueMap<std::pair<float, float>>>(ps.getParameter<edm::InputTag>("layer_clustersTime"))),
0764       caloGeometry_token_(esConsumes<CaloGeometry, CaloGeometryRecord, edm::Transition::BeginRun>()),
0765       simTracksters_SC_token_(
0766           consumes<std::vector<ticl::Trackster>>(ps.getParameter<edm::InputTag>("simtrackstersSC"))),
0767       simTracksters_CP_token_(
0768           consumes<std::vector<ticl::Trackster>>(ps.getParameter<edm::InputTag>("simtrackstersCP"))),
0769       simTracksters_PU_token_(
0770           consumes<std::vector<ticl::Trackster>>(ps.getParameter<edm::InputTag>("simtrackstersPU"))),
0771       simTICLCandidate_token_(
0772           consumes<std::vector<TICLCandidate>>(ps.getParameter<edm::InputTag>("simTICLCandidates"))),
0773       tsRecoToSimSC_token_(
0774           consumes<ticl::RecoToSimCollectionSimTracksters>(ps.getParameter<edm::InputTag>("recoToSimAssociatorSC"))),
0775       tsSimToRecoSC_token_(
0776           consumes<ticl::SimToRecoCollectionSimTracksters>(ps.getParameter<edm::InputTag>("simToRecoAssociatorSC"))),
0777       tsRecoToSimCP_token_(
0778           consumes<ticl::RecoToSimCollectionSimTracksters>(ps.getParameter<edm::InputTag>("recoToSimAssociatorCP"))),
0779       tsSimToRecoCP_token_(
0780           consumes<ticl::SimToRecoCollectionSimTracksters>(ps.getParameter<edm::InputTag>("simToRecoAssociatorCP"))),
0781       MergeRecoToSimSC_token_(consumes<ticl::RecoToSimCollectionSimTracksters>(
0782           ps.getParameter<edm::InputTag>("MergerecoToSimAssociatorSC"))),
0783       MergeSimToRecoSC_token_(consumes<ticl::SimToRecoCollectionSimTracksters>(
0784           ps.getParameter<edm::InputTag>("MergesimToRecoAssociatorSC"))),
0785       MergeRecoToSimCP_token_(consumes<ticl::RecoToSimCollectionSimTracksters>(
0786           ps.getParameter<edm::InputTag>("MergerecoToSimAssociatorCP"))),
0787       MergeSimToRecoCP_token_(consumes<ticl::SimToRecoCollectionSimTracksters>(
0788           ps.getParameter<edm::InputTag>("MergesimToRecoAssociatorCP"))),
0789       MergeRecoToSimPU_token_(consumes<ticl::RecoToSimCollectionSimTracksters>(
0790           ps.getParameter<edm::InputTag>("MergerecoToSimAssociatorPU"))),
0791       MergeSimToRecoPU_token_(consumes<ticl::SimToRecoCollectionSimTracksters>(
0792           ps.getParameter<edm::InputTag>("MergesimToRecoAssociatorPU"))),
0793       simclusters_token_(consumes(ps.getParameter<edm::InputTag>("simclusters"))),
0794       caloparticles_token_(consumes(ps.getParameter<edm::InputTag>("caloparticles"))),
0795       geometry_token_(esConsumes<CaloGeometry, CaloGeometryRecord, edm::Transition::BeginRun>()),
0796       detector_(ps.getParameter<std::string>("detector")),
0797       propName_(ps.getParameter<std::string>("propagator")),
0798       bfield_token_(esConsumes<MagneticField, IdealMagneticFieldRecord, edm::Transition::BeginRun>()),
0799       propagator_token_(
0800           esConsumes<Propagator, TrackingComponentsRecord, edm::Transition::BeginRun>(edm::ESInputTag("", propName_))),
0801       saveLCs_(ps.getParameter<bool>("saveLCs")),
0802       saveCLUE3DTracksters_(ps.getParameter<bool>("saveCLUE3DTracksters")),
0803       saveTrackstersMerged_(ps.getParameter<bool>("saveTrackstersMerged")),
0804       saveSimTrackstersSC_(ps.getParameter<bool>("saveSimTrackstersSC")),
0805       saveSimTrackstersCP_(ps.getParameter<bool>("saveSimTrackstersCP")),
0806       saveTICLCandidate_(ps.getParameter<bool>("saveSimTICLCandidate")),
0807       saveSimTICLCandidate_(ps.getParameter<bool>("saveSimTICLCandidate")),
0808       saveTracks_(ps.getParameter<bool>("saveTracks")),
0809       saveAssociations_(ps.getParameter<bool>("saveAssociations")) {
0810   std::string detectorName_ = (detector_ == "HFNose") ? "HGCalHFNoseSensitive" : "HGCalEESensitive";
0811   hdc_token_ =
0812       esConsumes<HGCalDDDConstants, IdealGeometryRecord, edm::Transition::BeginRun>(edm::ESInputTag("", detectorName_));
0813 };
0814 
0815 TICLDumper::~TICLDumper() { clearVariables(); };
0816 
0817 void TICLDumper::beginRun(edm::Run const&, edm::EventSetup const& es) {
0818   const CaloGeometry& geom = es.getData(caloGeometry_token_);
0819   rhtools_.setGeometry(geom);
0820 
0821   edm::ESHandle<HGCalDDDConstants> hdc = es.getHandle(hdc_token_);
0822   hgcons_ = hdc.product();
0823   edm::ESHandle<MagneticField> bfield_ = es.getHandle(bfield_token_);
0824   edm::ESHandle<Propagator> propagator = es.getHandle(propagator_token_);
0825   initialize(hgcons_, rhtools_, bfield_, propagator);
0826 }
0827 
0828 // Define tree and branches
0829 void TICLDumper::beginJob() {
0830   edm::Service<TFileService> fs;
0831   if (saveCLUE3DTracksters_) {
0832     trackster_tree_ = fs->make<TTree>("tracksters", "TICL tracksters");
0833     trackster_tree_->Branch("event", &ev_event_);
0834     trackster_tree_->Branch("NClusters", &nclusters_);
0835     trackster_tree_->Branch("NTracksters", &ntracksters_);
0836     trackster_tree_->Branch("time", &trackster_time);
0837     trackster_tree_->Branch("timeError", &trackster_timeError);
0838     trackster_tree_->Branch("regressed_energy", &trackster_regressed_energy);
0839     trackster_tree_->Branch("raw_energy", &trackster_raw_energy);
0840     trackster_tree_->Branch("raw_em_energy", &trackster_raw_em_energy);
0841     trackster_tree_->Branch("raw_pt", &trackster_raw_pt);
0842     trackster_tree_->Branch("raw_em_pt", &trackster_raw_em_pt);
0843     trackster_tree_->Branch("barycenter_x", &trackster_barycenter_x);
0844     trackster_tree_->Branch("barycenter_y", &trackster_barycenter_y);
0845     trackster_tree_->Branch("barycenter_z", &trackster_barycenter_z);
0846     trackster_tree_->Branch("barycenter_eta", &trackster_barycenter_eta);
0847     trackster_tree_->Branch("barycenter_phi", &trackster_barycenter_phi);
0848     trackster_tree_->Branch("EV1", &trackster_EV1);
0849     trackster_tree_->Branch("EV2", &trackster_EV2);
0850     trackster_tree_->Branch("EV3", &trackster_EV3);
0851     trackster_tree_->Branch("eVector0_x", &trackster_eVector0_x);
0852     trackster_tree_->Branch("eVector0_y", &trackster_eVector0_y);
0853     trackster_tree_->Branch("eVector0_z", &trackster_eVector0_z);
0854     trackster_tree_->Branch("sigmaPCA1", &trackster_sigmaPCA1);
0855     trackster_tree_->Branch("sigmaPCA2", &trackster_sigmaPCA2);
0856     trackster_tree_->Branch("sigmaPCA3", &trackster_sigmaPCA3);
0857     trackster_tree_->Branch("id_probabilities", &trackster_id_probabilities);
0858     trackster_tree_->Branch("vertices_indexes", &trackster_vertices_indexes);
0859     trackster_tree_->Branch("vertices_x", &trackster_vertices_x);
0860     trackster_tree_->Branch("vertices_y", &trackster_vertices_y);
0861     trackster_tree_->Branch("vertices_z", &trackster_vertices_z);
0862     trackster_tree_->Branch("vertices_time", &trackster_vertices_time);
0863     trackster_tree_->Branch("vertices_timeErr", &trackster_vertices_timeErr);
0864     trackster_tree_->Branch("vertices_energy", &trackster_vertices_energy);
0865     trackster_tree_->Branch("vertices_correctedEnergy", &trackster_vertices_correctedEnergy);
0866     trackster_tree_->Branch("vertices_correctedEnergyUncertainty", &trackster_vertices_correctedEnergyUncertainty);
0867     trackster_tree_->Branch("vertices_multiplicity", &trackster_vertices_multiplicity);
0868   }
0869   if (saveLCs_) {
0870     cluster_tree_ = fs->make<TTree>("clusters", "TICL tracksters");
0871     cluster_tree_->Branch("seedID", &cluster_seedID);
0872     cluster_tree_->Branch("energy", &cluster_energy);
0873     cluster_tree_->Branch("correctedEnergy", &cluster_correctedEnergy);
0874     cluster_tree_->Branch("correctedEnergyUncertainty", &cluster_correctedEnergyUncertainty);
0875     cluster_tree_->Branch("position_x", &cluster_position_x);
0876     cluster_tree_->Branch("position_y", &cluster_position_y);
0877     cluster_tree_->Branch("position_z", &cluster_position_z);
0878     cluster_tree_->Branch("position_eta", &cluster_position_eta);
0879     cluster_tree_->Branch("position_phi", &cluster_position_phi);
0880     cluster_tree_->Branch("cluster_layer_id", &cluster_layer_id);
0881     cluster_tree_->Branch("cluster_type", &cluster_type);
0882     cluster_tree_->Branch("cluster_time", &cluster_time);
0883     cluster_tree_->Branch("cluster_timeErr", &cluster_timeErr);
0884     cluster_tree_->Branch("cluster_number_of_hits", &cluster_number_of_hits);
0885   }
0886   if (saveTICLCandidate_) {
0887     candidate_tree_ = fs->make<TTree>("candidates", "TICL candidates");
0888     candidate_tree_->Branch("NCandidates", &nCandidates);
0889     candidate_tree_->Branch("candidate_charge", &candidate_charge);
0890     candidate_tree_->Branch("candidate_pdgId", &candidate_pdgId);
0891     candidate_tree_->Branch("candidate_id_probabilities", &candidate_id_probabilities);
0892     candidate_tree_->Branch("candidate_time", &candidate_time);
0893     candidate_tree_->Branch("candidate_timeErr", &candidate_time_err);
0894     candidate_tree_->Branch("candidate_energy", &candidate_energy);
0895     candidate_tree_->Branch("candidate_raw_energy", &candidate_raw_energy);
0896     candidate_tree_->Branch("candidate_px", &candidate_px);
0897     candidate_tree_->Branch("candidate_py", &candidate_py);
0898     candidate_tree_->Branch("candidate_pz", &candidate_pz);
0899     candidate_tree_->Branch("track_in_candidate", &track_in_candidate);
0900     candidate_tree_->Branch("tracksters_in_candidate", &tracksters_in_candidate);
0901   }
0902   if (saveTrackstersMerged_) {
0903     tracksters_merged_tree_ = fs->make<TTree>("trackstersMerged", "TICL tracksters merged");
0904     tracksters_merged_tree_->Branch("event", &ev_event_);
0905     tracksters_merged_tree_->Branch("time", &tracksters_merged_time);
0906     tracksters_merged_tree_->Branch("timeError", &tracksters_merged_timeError);
0907     tracksters_merged_tree_->Branch("regressed_energy", &tracksters_merged_regressed_energy);
0908     tracksters_merged_tree_->Branch("raw_energy", &tracksters_merged_raw_energy);
0909     tracksters_merged_tree_->Branch("raw_em_energy", &tracksters_merged_raw_em_energy);
0910     tracksters_merged_tree_->Branch("raw_pt", &tracksters_merged_raw_pt);
0911     tracksters_merged_tree_->Branch("raw_em_pt", &tracksters_merged_raw_em_pt);
0912     tracksters_merged_tree_->Branch("NTrackstersMerged", &nTrackstersMerged);
0913     tracksters_merged_tree_->Branch("barycenter_x", &tracksters_merged_barycenter_x);
0914     tracksters_merged_tree_->Branch("barycenter_y", &tracksters_merged_barycenter_y);
0915     tracksters_merged_tree_->Branch("barycenter_z", &tracksters_merged_barycenter_z);
0916     tracksters_merged_tree_->Branch("barycenter_eta", &tracksters_merged_barycenter_eta);
0917     tracksters_merged_tree_->Branch("barycenter_phi", &tracksters_merged_barycenter_phi);
0918     tracksters_merged_tree_->Branch("EV1", &tracksters_merged_EV1);
0919     tracksters_merged_tree_->Branch("EV2", &tracksters_merged_EV2);
0920     tracksters_merged_tree_->Branch("EV3", &tracksters_merged_EV3);
0921     tracksters_merged_tree_->Branch("eVector0_x", &tracksters_merged_eVector0_x);
0922     tracksters_merged_tree_->Branch("eVector0_y", &tracksters_merged_eVector0_y);
0923     tracksters_merged_tree_->Branch("eVector0_z", &tracksters_merged_eVector0_z);
0924     tracksters_merged_tree_->Branch("sigmaPCA1", &tracksters_merged_sigmaPCA1);
0925     tracksters_merged_tree_->Branch("sigmaPCA2", &tracksters_merged_sigmaPCA2);
0926     tracksters_merged_tree_->Branch("sigmaPCA3", &tracksters_merged_sigmaPCA3);
0927     tracksters_merged_tree_->Branch("id_probabilities", &tracksters_merged_id_probabilities);
0928     tracksters_merged_tree_->Branch("vertices_indexes", &tracksters_merged_vertices_indexes);
0929     tracksters_merged_tree_->Branch("vertices_x", &tracksters_merged_vertices_x);
0930     tracksters_merged_tree_->Branch("vertices_y", &tracksters_merged_vertices_y);
0931     tracksters_merged_tree_->Branch("vertices_z", &tracksters_merged_vertices_z);
0932     tracksters_merged_tree_->Branch("vertices_time", &tracksters_merged_vertices_time);
0933     tracksters_merged_tree_->Branch("vertices_timeErr", &tracksters_merged_vertices_timeErr);
0934     tracksters_merged_tree_->Branch("vertices_energy", &tracksters_merged_vertices_energy);
0935     tracksters_merged_tree_->Branch("vertices_correctedEnergy", &tracksters_merged_vertices_correctedEnergy);
0936     tracksters_merged_tree_->Branch("vertices_correctedEnergyUncertainty",
0937                                     &tracksters_merged_vertices_correctedEnergyUncertainty);
0938     tracksters_merged_tree_->Branch("vertices_multiplicity", &tracksters_merged_vertices_multiplicity);
0939   }
0940   if (saveAssociations_) {
0941     associations_tree_ = fs->make<TTree>("associations", "Associations");
0942     associations_tree_->Branch("tsCLUE3D_recoToSim_SC", &trackstersCLUE3D_recoToSim_SC);
0943     associations_tree_->Branch("tsCLUE3D_recoToSim_SC_score", &trackstersCLUE3D_recoToSim_SC_score);
0944     associations_tree_->Branch("tsCLUE3D_recoToSim_SC_sharedE", &trackstersCLUE3D_recoToSim_SC_sharedE);
0945     associations_tree_->Branch("tsCLUE3D_simToReco_SC", &trackstersCLUE3D_simToReco_SC);
0946     associations_tree_->Branch("tsCLUE3D_simToReco_SC_score", &trackstersCLUE3D_simToReco_SC_score);
0947     associations_tree_->Branch("tsCLUE3D_simToReco_SC_sharedE", &trackstersCLUE3D_simToReco_SC_sharedE);
0948 
0949     associations_tree_->Branch("tsCLUE3D_recoToSim_CP", &trackstersCLUE3D_recoToSim_CP);
0950     associations_tree_->Branch("tsCLUE3D_recoToSim_CP_score", &trackstersCLUE3D_recoToSim_CP_score);
0951     associations_tree_->Branch("tsCLUE3D_recoToSim_CP_sharedE", &trackstersCLUE3D_recoToSim_CP_sharedE);
0952     associations_tree_->Branch("tsCLUE3D_simToReco_CP", &trackstersCLUE3D_simToReco_CP);
0953     associations_tree_->Branch("tsCLUE3D_simToReco_CP_score", &trackstersCLUE3D_simToReco_CP_score);
0954     associations_tree_->Branch("tsCLUE3D_simToReco_CP_sharedE", &trackstersCLUE3D_simToReco_CP_sharedE);
0955 
0956     associations_tree_->Branch("Mergetstracksters_recoToSim_SC", &MergeTracksters_recoToSim_SC);
0957     associations_tree_->Branch("Mergetstracksters_recoToSim_SC_score", &MergeTracksters_recoToSim_SC_score);
0958     associations_tree_->Branch("Mergetstracksters_recoToSim_SC_sharedE", &MergeTracksters_recoToSim_SC_sharedE);
0959     associations_tree_->Branch("Mergetstracksters_simToReco_SC", &MergeTracksters_simToReco_SC);
0960     associations_tree_->Branch("Mergetstracksters_simToReco_SC_score", &MergeTracksters_simToReco_SC_score);
0961     associations_tree_->Branch("Mergetstracksters_simToReco_SC_sharedE", &MergeTracksters_simToReco_SC_sharedE);
0962 
0963     associations_tree_->Branch("Mergetracksters_recoToSim_CP", &MergeTracksters_recoToSim_CP);
0964     associations_tree_->Branch("Mergetracksters_recoToSim_CP_score", &MergeTracksters_recoToSim_CP_score);
0965     associations_tree_->Branch("Mergetracksters_recoToSim_CP_sharedE", &MergeTracksters_recoToSim_CP_sharedE);
0966     associations_tree_->Branch("Mergetracksters_simToReco_CP", &MergeTracksters_simToReco_CP);
0967     associations_tree_->Branch("Mergetracksters_simToReco_CP_score", &MergeTracksters_simToReco_CP_score);
0968     associations_tree_->Branch("Mergetracksters_simToReco_CP_sharedE", &MergeTracksters_simToReco_CP_sharedE);
0969 
0970     associations_tree_->Branch("Mergetracksters_recoToSim_PU", &MergeTracksters_recoToSim_PU);
0971     associations_tree_->Branch("Mergetracksters_recoToSim_PU_score", &MergeTracksters_recoToSim_PU_score);
0972     associations_tree_->Branch("Mergetracksters_recoToSim_PU_sharedE", &MergeTracksters_recoToSim_PU_sharedE);
0973     associations_tree_->Branch("Mergetracksters_simToReco_PU", &MergeTracksters_simToReco_PU);
0974     associations_tree_->Branch("Mergetracksters_simToReco_PU_score", &MergeTracksters_simToReco_PU_score);
0975     associations_tree_->Branch("Mergetracksters_simToReco_PU_sharedE", &MergeTracksters_simToReco_PU_sharedE);
0976   }
0977 
0978   if (saveSimTrackstersSC_) {
0979     simtrackstersSC_tree_ = fs->make<TTree>("simtrackstersSC", "TICL simTracksters SC");
0980     simtrackstersSC_tree_->Branch("event", &ev_event_);
0981     simtrackstersSC_tree_->Branch("NTracksters", &stsSC_ntracksters_);
0982     simtrackstersSC_tree_->Branch("time", &stsSC_trackster_time);
0983     simtrackstersSC_tree_->Branch("timeBoundary", &stsSC_trackster_timeBoundary);
0984     simtrackstersSC_tree_->Branch("timeError", &stsSC_trackster_timeError);
0985     simtrackstersSC_tree_->Branch("regressed_energy", &stsSC_trackster_regressed_energy);
0986     simtrackstersSC_tree_->Branch("regressed_pt", &stsSC_trackster_regressed_pt);
0987     simtrackstersSC_tree_->Branch("raw_energy", &stsSC_trackster_raw_energy);
0988     simtrackstersSC_tree_->Branch("raw_em_energy", &stsSC_trackster_raw_em_energy);
0989     simtrackstersSC_tree_->Branch("raw_pt", &stsSC_trackster_raw_pt);
0990     simtrackstersSC_tree_->Branch("raw_em_pt", &stsSC_trackster_raw_em_pt);
0991     simtrackstersSC_tree_->Branch("barycenter_x", &stsSC_trackster_barycenter_x);
0992     simtrackstersSC_tree_->Branch("barycenter_y", &stsSC_trackster_barycenter_y);
0993     simtrackstersSC_tree_->Branch("barycenter_z", &stsSC_trackster_barycenter_z);
0994     simtrackstersSC_tree_->Branch("barycenter_eta", &stsSC_trackster_barycenter_eta);
0995     simtrackstersSC_tree_->Branch("barycenter_phi", &stsSC_trackster_barycenter_phi);
0996     simtrackstersSC_tree_->Branch("EV1", &stsSC_trackster_EV1);
0997     simtrackstersSC_tree_->Branch("EV2", &stsSC_trackster_EV2);
0998     simtrackstersSC_tree_->Branch("EV3", &stsSC_trackster_EV3);
0999     simtrackstersSC_tree_->Branch("eVector0_x", &stsSC_trackster_eVector0_x);
1000     simtrackstersSC_tree_->Branch("eVector0_y", &stsSC_trackster_eVector0_y);
1001     simtrackstersSC_tree_->Branch("eVector0_z", &stsSC_trackster_eVector0_z);
1002     simtrackstersSC_tree_->Branch("sigmaPCA1", &stsSC_trackster_sigmaPCA1);
1003     simtrackstersSC_tree_->Branch("sigmaPCA2", &stsSC_trackster_sigmaPCA2);
1004     simtrackstersSC_tree_->Branch("sigmaPCA3", &stsSC_trackster_sigmaPCA3);
1005     simtrackstersSC_tree_->Branch("pdgID", &stsSC_pdgID);
1006     simtrackstersSC_tree_->Branch("trackIdx", &stsSC_trackIdx);
1007     simtrackstersSC_tree_->Branch("trackTime", &stsSC_trackTime);
1008     simtrackstersSC_tree_->Branch("boundaryX", &stsSC_boundaryX);
1009     simtrackstersSC_tree_->Branch("boundaryY", &stsSC_boundaryY);
1010     simtrackstersSC_tree_->Branch("boundaryZ", &stsSC_boundaryZ);
1011     simtrackstersSC_tree_->Branch("boundaryEta", &stsSC_boundaryEta);
1012     simtrackstersSC_tree_->Branch("boundaryPhi", &stsSC_boundaryPhi);
1013     simtrackstersSC_tree_->Branch("boundaryPx", &stsSC_boundaryPx);
1014     simtrackstersSC_tree_->Branch("boundaryPy", &stsSC_boundaryPy);
1015     simtrackstersSC_tree_->Branch("boundaryPz", &stsSC_boundaryPz);
1016     simtrackstersSC_tree_->Branch("track_boundaryX", &stsSC_track_boundaryX);
1017     simtrackstersSC_tree_->Branch("track_boundaryY", &stsSC_track_boundaryY);
1018     simtrackstersSC_tree_->Branch("track_boundaryZ", &stsSC_track_boundaryZ);
1019     simtrackstersSC_tree_->Branch("track_boundaryEta", &stsSC_track_boundaryEta);
1020     simtrackstersSC_tree_->Branch("track_boundaryPhi", &stsSC_track_boundaryPhi);
1021     simtrackstersSC_tree_->Branch("track_boundaryPx", &stsSC_track_boundaryPx);
1022     simtrackstersSC_tree_->Branch("track_boundaryPy", &stsSC_track_boundaryPy);
1023     simtrackstersSC_tree_->Branch("track_boundaryPz", &stsSC_track_boundaryPz);
1024     simtrackstersSC_tree_->Branch("id_probabilities", &stsSC_trackster_id_probabilities);
1025     simtrackstersSC_tree_->Branch("vertices_indexes", &stsSC_trackster_vertices_indexes);
1026     simtrackstersSC_tree_->Branch("vertices_x", &stsSC_trackster_vertices_x);
1027     simtrackstersSC_tree_->Branch("vertices_y", &stsSC_trackster_vertices_y);
1028     simtrackstersSC_tree_->Branch("vertices_z", &stsSC_trackster_vertices_z);
1029     simtrackstersSC_tree_->Branch("vertices_time", &stsSC_trackster_vertices_time);
1030     simtrackstersSC_tree_->Branch("vertices_timeErr", &stsSC_trackster_vertices_timeErr);
1031     simtrackstersSC_tree_->Branch("vertices_energy", &stsSC_trackster_vertices_energy);
1032     simtrackstersSC_tree_->Branch("vertices_correctedEnergy", &stsSC_trackster_vertices_correctedEnergy);
1033     simtrackstersSC_tree_->Branch("vertices_correctedEnergyUncertainty",
1034                                   &stsSC_trackster_vertices_correctedEnergyUncertainty);
1035     simtrackstersSC_tree_->Branch("vertices_multiplicity", &stsSC_trackster_vertices_multiplicity);
1036     simtrackstersSC_tree_->Branch("NsimTrackstersSC", &nsimTrackstersSC);
1037   }
1038   if (saveSimTrackstersCP_) {
1039     simtrackstersCP_tree_ = fs->make<TTree>("simtrackstersCP", "TICL simTracksters CP");
1040     simtrackstersCP_tree_->Branch("event", &ev_event_);
1041     simtrackstersCP_tree_->Branch("NTracksters", &stsCP_ntracksters_);
1042     simtrackstersCP_tree_->Branch("time", &stsCP_trackster_time);
1043     simtrackstersCP_tree_->Branch("timeBoundary", &stsCP_trackster_timeBoundary);
1044     simtrackstersCP_tree_->Branch("timeError", &stsCP_trackster_timeError);
1045     simtrackstersCP_tree_->Branch("regressed_energy", &stsCP_trackster_regressed_energy);
1046     simtrackstersCP_tree_->Branch("regressed_pt", &stsCP_trackster_regressed_pt);
1047     simtrackstersCP_tree_->Branch("raw_energy", &stsCP_trackster_raw_energy);
1048     simtrackstersCP_tree_->Branch("raw_em_energy", &stsCP_trackster_raw_em_energy);
1049     simtrackstersCP_tree_->Branch("raw_pt", &stsCP_trackster_raw_pt);
1050     simtrackstersCP_tree_->Branch("raw_em_pt", &stsCP_trackster_raw_em_pt);
1051     simtrackstersCP_tree_->Branch("barycenter_x", &stsCP_trackster_barycenter_x);
1052     simtrackstersCP_tree_->Branch("barycenter_y", &stsCP_trackster_barycenter_y);
1053     simtrackstersCP_tree_->Branch("barycenter_z", &stsCP_trackster_barycenter_z);
1054     simtrackstersCP_tree_->Branch("barycenter_eta", &stsCP_trackster_barycenter_eta);
1055     simtrackstersCP_tree_->Branch("barycenter_phi", &stsCP_trackster_barycenter_phi);
1056     simtrackstersCP_tree_->Branch("pdgID", &stsCP_pdgID);
1057     simtrackstersCP_tree_->Branch("trackIdx", &stsCP_trackIdx);
1058     simtrackstersCP_tree_->Branch("trackTime", &stsCP_trackTime);
1059     simtrackstersCP_tree_->Branch("boundaryX", &stsCP_boundaryX);
1060     simtrackstersCP_tree_->Branch("boundaryY", &stsCP_boundaryY);
1061     simtrackstersCP_tree_->Branch("boundaryZ", &stsCP_boundaryZ);
1062     simtrackstersCP_tree_->Branch("boundaryEta", &stsCP_boundaryEta);
1063     simtrackstersCP_tree_->Branch("boundaryPhi", &stsCP_boundaryPhi);
1064     simtrackstersCP_tree_->Branch("boundaryPx", &stsCP_boundaryPx);
1065     simtrackstersCP_tree_->Branch("boundaryPy", &stsCP_boundaryPy);
1066     simtrackstersCP_tree_->Branch("boundaryPz", &stsCP_boundaryPz);
1067     simtrackstersCP_tree_->Branch("track_boundaryX", &stsCP_track_boundaryX);
1068     simtrackstersCP_tree_->Branch("track_boundaryY", &stsCP_track_boundaryY);
1069     simtrackstersCP_tree_->Branch("track_boundaryZ", &stsCP_track_boundaryZ);
1070     simtrackstersCP_tree_->Branch("track_boundaryEta", &stsCP_track_boundaryEta);
1071     simtrackstersCP_tree_->Branch("track_boundaryPhi", &stsCP_track_boundaryPhi);
1072     simtrackstersCP_tree_->Branch("track_boundaryPx", &stsCP_track_boundaryPx);
1073     simtrackstersCP_tree_->Branch("track_boundaryPy", &stsCP_track_boundaryPy);
1074     simtrackstersCP_tree_->Branch("track_boundaryPz", &stsCP_track_boundaryPz);
1075     simtrackstersCP_tree_->Branch("EV1", &stsCP_trackster_EV1);
1076     simtrackstersCP_tree_->Branch("EV2", &stsCP_trackster_EV2);
1077     simtrackstersCP_tree_->Branch("EV3", &stsCP_trackster_EV3);
1078     simtrackstersCP_tree_->Branch("eVector0_x", &stsCP_trackster_eVector0_x);
1079     simtrackstersCP_tree_->Branch("eVector0_y", &stsCP_trackster_eVector0_y);
1080     simtrackstersCP_tree_->Branch("eVector0_z", &stsCP_trackster_eVector0_z);
1081     simtrackstersCP_tree_->Branch("sigmaPCA1", &stsCP_trackster_sigmaPCA1);
1082     simtrackstersCP_tree_->Branch("sigmaPCA2", &stsCP_trackster_sigmaPCA2);
1083     simtrackstersCP_tree_->Branch("sigmaPCA3", &stsCP_trackster_sigmaPCA3);
1084     simtrackstersCP_tree_->Branch("id_probabilities", &stsCP_trackster_id_probabilities);
1085     simtrackstersCP_tree_->Branch("vertices_indexes", &stsCP_trackster_vertices_indexes);
1086     simtrackstersCP_tree_->Branch("vertices_x", &stsCP_trackster_vertices_x);
1087     simtrackstersCP_tree_->Branch("vertices_y", &stsCP_trackster_vertices_y);
1088     simtrackstersCP_tree_->Branch("vertices_z", &stsCP_trackster_vertices_z);
1089     simtrackstersCP_tree_->Branch("vertices_time", &stsCP_trackster_vertices_time);
1090     simtrackstersCP_tree_->Branch("vertices_timeErr", &stsCP_trackster_vertices_timeErr);
1091     simtrackstersCP_tree_->Branch("vertices_energy", &stsCP_trackster_vertices_energy);
1092     simtrackstersCP_tree_->Branch("vertices_correctedEnergy", &stsCP_trackster_vertices_correctedEnergy);
1093     simtrackstersCP_tree_->Branch("vertices_correctedEnergyUncertainty",
1094                                   &stsCP_trackster_vertices_correctedEnergyUncertainty);
1095     simtrackstersCP_tree_->Branch("vertices_multiplicity", &stsCP_trackster_vertices_multiplicity);
1096   }
1097 
1098   if (saveTracks_) {
1099     tracks_tree_ = fs->make<TTree>("tracks", "Tracks");
1100     tracks_tree_->Branch("event", &ev_event_);
1101     tracks_tree_->Branch("track_id", &track_id);
1102     tracks_tree_->Branch("track_hgcal_x", &track_hgcal_x);
1103     tracks_tree_->Branch("track_hgcal_y", &track_hgcal_y);
1104     tracks_tree_->Branch("track_hgcal_z", &track_hgcal_z);
1105     tracks_tree_->Branch("track_hgcal_eta", &track_hgcal_eta);
1106     tracks_tree_->Branch("track_hgcal_phi", &track_hgcal_phi);
1107     tracks_tree_->Branch("track_hgcal_pt", &track_hgcal_pt);
1108     tracks_tree_->Branch("track_pt", &track_pt);
1109     tracks_tree_->Branch("track_missing_outer_hits", &track_missing_outer_hits);
1110     tracks_tree_->Branch("track_missing_inner_hits", &track_missing_inner_hits);
1111     tracks_tree_->Branch("track_quality", &track_quality);
1112     tracks_tree_->Branch("track_charge", &track_charge);
1113     tracks_tree_->Branch("track_time", &track_time);
1114     tracks_tree_->Branch("track_time_quality", &track_time_quality);
1115     tracks_tree_->Branch("track_time_err", &track_time_err);
1116     tracks_tree_->Branch("track_beta", &track_beta);
1117     tracks_tree_->Branch("track_time_mtd", &track_time_mtd);
1118     tracks_tree_->Branch("track_time_mtd_err", &track_time_mtd_err);
1119     tracks_tree_->Branch("track_pos_mtd", &track_pos_mtd);
1120     tracks_tree_->Branch("track_nhits", &track_nhits);
1121     tracks_tree_->Branch("track_isMuon", &track_isMuon);
1122     tracks_tree_->Branch("track_isTrackerMuon", &track_isTrackerMuon);
1123   }
1124 
1125   if (saveSimTICLCandidate_) {
1126     simTICLCandidate_tree = fs->make<TTree>("simTICLCandidate", "Sim TICL Candidate");
1127     simTICLCandidate_tree->Branch("simTICLCandidate_raw_energy", &simTICLCandidate_raw_energy);
1128     simTICLCandidate_tree->Branch("simTICLCandidate_regressed_energy", &simTICLCandidate_regressed_energy);
1129     simTICLCandidate_tree->Branch("simTICLCandidate_simTracksterCPIndex", &simTICLCandidate_simTracksterCPIndex);
1130     simTICLCandidate_tree->Branch("simTICLCandidate_boundaryX", &simTICLCandidate_boundaryX);
1131     simTICLCandidate_tree->Branch("simTICLCandidate_boundaryY", &simTICLCandidate_boundaryY);
1132     simTICLCandidate_tree->Branch("simTICLCandidate_boundaryZ", &simTICLCandidate_boundaryZ);
1133     simTICLCandidate_tree->Branch("simTICLCandidate_boundaryPx", &simTICLCandidate_boundaryPx);
1134     simTICLCandidate_tree->Branch("simTICLCandidate_boundaryPy", &simTICLCandidate_boundaryPy);
1135     simTICLCandidate_tree->Branch("simTICLCandidate_boundaryPz", &simTICLCandidate_boundaryPz);
1136     simTICLCandidate_tree->Branch("simTICLCandidate_time", &simTICLCandidate_time);
1137     simTICLCandidate_tree->Branch("simTICLCandidate_caloParticleMass", &simTICLCandidate_caloParticleMass);
1138     simTICLCandidate_tree->Branch("simTICLCandidate_pdgId", &simTICLCandidate_pdgId);
1139     simTICLCandidate_tree->Branch("simTICLCandidate_charge", &simTICLCandidate_charge);
1140     simTICLCandidate_tree->Branch("simTICLCandidate_track_in_candidate", &simTICLCandidate_track_in_candidate);
1141   }
1142 }
1143 
1144 void TICLDumper::buildLayers() {
1145   // build disks at HGCal front & EM-Had interface for track propagation
1146 
1147   float zVal = hgcons_->waferZ(1, true);
1148   std::pair<float, float> rMinMax = hgcons_->rangeR(zVal, true);
1149 
1150   float zVal_interface = rhtools_.getPositionLayer(rhtools_.lastLayerEE()).z();
1151   std::pair<float, float> rMinMax_interface = hgcons_->rangeR(zVal_interface, true);
1152 
1153   for (int iSide = 0; iSide < 2; ++iSide) {
1154     float zSide = (iSide == 0) ? (-1. * zVal) : zVal;
1155     firstDisk_[iSide] =
1156         std::make_unique<GeomDet>(Disk::build(Disk::PositionType(0, 0, zSide),
1157                                               Disk::RotationType(),
1158                                               SimpleDiskBounds(rMinMax.first, rMinMax.second, zSide - 0.5, zSide + 0.5))
1159                                       .get());
1160 
1161     zSide = (iSide == 0) ? (-1. * zVal_interface) : zVal_interface;
1162     interfaceDisk_[iSide] = std::make_unique<GeomDet>(
1163         Disk::build(Disk::PositionType(0, 0, zSide),
1164                     Disk::RotationType(),
1165                     SimpleDiskBounds(rMinMax_interface.first, rMinMax_interface.second, zSide - 0.5, zSide + 0.5))
1166             .get());
1167   }
1168 }
1169 
1170 void TICLDumper::initialize(const HGCalDDDConstants* hgcons,
1171                             const hgcal::RecHitTools rhtools,
1172                             const edm::ESHandle<MagneticField> bfieldH,
1173                             const edm::ESHandle<Propagator> propH) {
1174   hgcons_ = hgcons;
1175   rhtools_ = rhtools;
1176   buildLayers();
1177 
1178   bfield_ = bfieldH;
1179   propagator_ = propH;
1180 }
1181 void TICLDumper::analyze(const edm::Event& event, const edm::EventSetup& setup) {
1182   ev_event_ += 1;
1183   clearVariables();
1184   auto bFieldProd = bfield_.product();
1185   const Propagator& prop = (*propagator_);
1186   //get all the tracksters
1187   edm::Handle<std::vector<ticl::Trackster>> tracksters_handle;
1188   event.getByToken(tracksters_token_, tracksters_handle);
1189   const auto& tracksters = *tracksters_handle;
1190 
1191   edm::Handle<std::vector<ticl::Trackster>> tracksters_in_candidate_handle;
1192   event.getByToken(tracksters_in_candidate_token_, tracksters_in_candidate_handle);
1193 
1194   //get all the layer clusters
1195   edm::Handle<std::vector<reco::CaloCluster>> layer_clusters_h;
1196   event.getByToken(layer_clusters_token_, layer_clusters_h);
1197   const auto& clusters = *layer_clusters_h;
1198 
1199   edm::Handle<edm::ValueMap<std::pair<float, float>>> clustersTime_h;
1200   event.getByToken(clustersTime_token_, clustersTime_h);
1201   const auto& layerClustersTimes = *clustersTime_h;
1202 
1203   //TICL Candidate
1204   edm::Handle<std::vector<TICLCandidate>> candidates_h;
1205   event.getByToken(ticl_candidates_token_, candidates_h);
1206   const auto& ticlcandidates = *candidates_h;
1207 
1208   //Track
1209   edm::Handle<std::vector<reco::Track>> tracks_h;
1210   event.getByToken(tracks_token_, tracks_h);
1211   const auto& tracks = *tracks_h;
1212 
1213   edm::Handle<edm::ValueMap<float>> trackTime_h;
1214   event.getByToken(tracks_time_token_, trackTime_h);
1215   const auto& trackTime = *trackTime_h;
1216 
1217   edm::Handle<edm::ValueMap<float>> trackTimeErr_h;
1218   event.getByToken(tracks_time_err_token_, trackTimeErr_h);
1219   const auto& trackTimeErr = *trackTimeErr_h;
1220 
1221   edm::Handle<edm::ValueMap<float>> trackBeta_h;
1222   event.getByToken(tracks_beta_token_, trackBeta_h);
1223   const auto& trackBeta = *trackBeta_h;
1224 
1225   edm::Handle<edm::ValueMap<float>> trackTimeQual_h;
1226   event.getByToken(tracks_time_quality_token_, trackTimeQual_h);
1227   const auto& trackTimeQual = *trackTimeQual_h;
1228 
1229   edm::Handle<edm::ValueMap<float>> trackTimeMtd_h;
1230   event.getByToken(tracks_time_mtd_token_, trackTimeMtd_h);
1231   const auto& trackTimeMtd = *trackTimeMtd_h;
1232 
1233   edm::Handle<edm::ValueMap<float>> trackTimeMtdErr_h;
1234   event.getByToken(tracks_time_mtd_err_token_, trackTimeMtdErr_h);
1235   const auto& trackTimeMtdErr = *trackTimeMtdErr_h;
1236 
1237   edm::Handle<edm::ValueMap<GlobalPoint>> trackPosMtd_h;
1238   event.getByToken(tracks_pos_mtd_token_, trackPosMtd_h);
1239   const auto& trackPosMtd = *trackPosMtd_h;
1240 
1241   //Tracksters merged
1242   edm::Handle<std::vector<ticl::Trackster>> tracksters_merged_h;
1243   event.getByToken(tracksters_merged_token_, tracksters_merged_h);
1244   const auto& trackstersmerged = *tracksters_merged_h;
1245 
1246   // muons
1247   edm::Handle<std::vector<reco::Muon>> muons_h;
1248   event.getByToken(muons_token_, muons_h);
1249   auto& muons = *muons_h;
1250 
1251   // simTracksters from SC
1252   edm::Handle<std::vector<ticl::Trackster>> simTrackstersSC_h;
1253   event.getByToken(simTracksters_SC_token_, simTrackstersSC_h);
1254   const auto& simTrackstersSC = *simTrackstersSC_h;
1255 
1256   // simTracksters from CP
1257   edm::Handle<std::vector<ticl::Trackster>> simTrackstersCP_h;
1258   event.getByToken(simTracksters_CP_token_, simTrackstersCP_h);
1259   const auto& simTrackstersCP = *simTrackstersCP_h;
1260 
1261   // simTracksters from PU
1262   edm::Handle<std::vector<ticl::Trackster>> simTrackstersPU_h;
1263   event.getByToken(simTracksters_PU_token_, simTrackstersPU_h);
1264   const auto& simTrackstersPU = *simTrackstersPU_h;
1265 
1266   edm::Handle<std::vector<TICLCandidate>> simTICLCandidates_h;
1267   event.getByToken(simTICLCandidate_token_, simTICLCandidates_h);
1268   const auto& simTICLCandidates = *simTICLCandidates_h;
1269 
1270   // trackster reco to sim SC
1271   edm::Handle<ticl::RecoToSimCollectionSimTracksters> tsRecoToSimSC_h;
1272   event.getByToken(tsRecoToSimSC_token_, tsRecoToSimSC_h);
1273   auto const& tsRecoSimSCMap = *tsRecoToSimSC_h;
1274 
1275   // sim simTrackster SC to reco trackster
1276   edm::Handle<ticl::SimToRecoCollectionSimTracksters> tsSimToRecoSC_h;
1277   event.getByToken(tsSimToRecoSC_token_, tsSimToRecoSC_h);
1278   auto const& tsSimToRecoSCMap = *tsSimToRecoSC_h;
1279 
1280   // trackster reco to sim CP
1281   edm::Handle<ticl::RecoToSimCollectionSimTracksters> tsRecoToSimCP_h;
1282   event.getByToken(tsRecoToSimCP_token_, tsRecoToSimCP_h);
1283   auto const& tsRecoSimCPMap = *tsRecoToSimCP_h;
1284 
1285   // sim simTrackster CP to reco trackster
1286   edm::Handle<ticl::SimToRecoCollectionSimTracksters> tsSimToRecoCP_h;
1287   event.getByToken(tsSimToRecoCP_token_, tsSimToRecoCP_h);
1288   auto const& tsSimToRecoCPMap = *tsSimToRecoCP_h;
1289 
1290   edm::Handle<ticl::RecoToSimCollectionSimTracksters> mergetsRecoToSimSC_h;
1291   event.getByToken(MergeRecoToSimSC_token_, mergetsRecoToSimSC_h);
1292   auto const& MergetsRecoSimSCMap = *mergetsRecoToSimSC_h;
1293 
1294   // sim simTrackster SC to reco trackster
1295   edm::Handle<ticl::SimToRecoCollectionSimTracksters> mergetsSimToRecoSC_h;
1296   event.getByToken(MergeSimToRecoSC_token_, mergetsSimToRecoSC_h);
1297   auto const& MergetsSimToRecoSCMap = *mergetsSimToRecoSC_h;
1298 
1299   // trackster reco to sim CP
1300   edm::Handle<ticl::RecoToSimCollectionSimTracksters> mergetsRecoToSimCP_h;
1301   event.getByToken(MergeRecoToSimCP_token_, mergetsRecoToSimCP_h);
1302   auto const& MergetsRecoSimCPMap = *mergetsRecoToSimCP_h;
1303 
1304   // sim simTrackster CP to reco trackster
1305   edm::Handle<ticl::SimToRecoCollectionSimTracksters> mergetsSimToRecoCP_h;
1306   event.getByToken(MergeSimToRecoCP_token_, mergetsSimToRecoCP_h);
1307   auto const& MergetsSimToRecoCPMap = *mergetsSimToRecoCP_h;
1308 
1309   // trackster reco to sim PU
1310   edm::Handle<ticl::RecoToSimCollectionSimTracksters> mergetsRecoToSimPU_h;
1311   event.getByToken(MergeRecoToSimPU_token_, mergetsRecoToSimPU_h);
1312   auto const& MergetsRecoSimPUMap = *mergetsRecoToSimPU_h;
1313 
1314   // sim simTrackster PU to reco trackster
1315   edm::Handle<ticl::SimToRecoCollectionSimTracksters> mergetsSimToRecoPU_h;
1316   event.getByToken(MergeSimToRecoPU_token_, mergetsSimToRecoPU_h);
1317   auto const& MergetsSimToRecoPUMap = *mergetsSimToRecoPU_h;
1318 
1319   edm::Handle<std::vector<CaloParticle>> caloparticles_h;
1320   event.getByToken(caloparticles_token_, caloparticles_h);
1321   const auto& caloparticles = *caloparticles_h;
1322 
1323   const auto& simclusters = event.get(simclusters_token_);
1324 
1325   ntracksters_ = tracksters.size();
1326   nclusters_ = clusters.size();
1327 
1328   for (auto trackster_iterator = tracksters.begin(); trackster_iterator != tracksters.end(); ++trackster_iterator) {
1329     //per-trackster analysis
1330     trackster_time.push_back(trackster_iterator->time());
1331     trackster_timeError.push_back(trackster_iterator->timeError());
1332     trackster_regressed_energy.push_back(trackster_iterator->regressed_energy());
1333     trackster_raw_energy.push_back(trackster_iterator->raw_energy());
1334     trackster_raw_em_energy.push_back(trackster_iterator->raw_em_energy());
1335     trackster_raw_pt.push_back(trackster_iterator->raw_pt());
1336     trackster_raw_em_pt.push_back(trackster_iterator->raw_em_pt());
1337     trackster_barycenter_x.push_back(trackster_iterator->barycenter().x());
1338     trackster_barycenter_y.push_back(trackster_iterator->barycenter().y());
1339     trackster_barycenter_z.push_back(trackster_iterator->barycenter().z());
1340     trackster_barycenter_eta.push_back(trackster_iterator->barycenter().eta());
1341     trackster_barycenter_phi.push_back(trackster_iterator->barycenter().phi());
1342     trackster_EV1.push_back(trackster_iterator->eigenvalues()[0]);
1343     trackster_EV2.push_back(trackster_iterator->eigenvalues()[1]);
1344     trackster_EV3.push_back(trackster_iterator->eigenvalues()[2]);
1345     trackster_eVector0_x.push_back((trackster_iterator->eigenvectors()[0]).x());
1346     trackster_eVector0_y.push_back((trackster_iterator->eigenvectors()[0]).y());
1347     trackster_eVector0_z.push_back((trackster_iterator->eigenvectors()[0]).z());
1348     trackster_sigmaPCA1.push_back(trackster_iterator->sigmasPCA()[0]);
1349     trackster_sigmaPCA2.push_back(trackster_iterator->sigmasPCA()[1]);
1350     trackster_sigmaPCA3.push_back(trackster_iterator->sigmasPCA()[2]);
1351     std::vector<float> id_probs;
1352     for (size_t i = 0; i < 8; i++)
1353       id_probs.push_back(trackster_iterator->id_probabilities(i));
1354     trackster_id_probabilities.push_back(id_probs);
1355 
1356     // Clusters
1357     std::vector<uint32_t> vertices_indexes;
1358     std::vector<float> vertices_x;
1359     std::vector<float> vertices_y;
1360     std::vector<float> vertices_z;
1361     std::vector<float> vertices_time;
1362     std::vector<float> vertices_timeErr;
1363     std::vector<float> vertices_energy;
1364     std::vector<float> vertices_correctedEnergy;
1365     std::vector<float> vertices_correctedEnergyUncertainty;
1366     for (auto idx : trackster_iterator->vertices()) {
1367       vertices_indexes.push_back(idx);
1368       auto associated_cluster = (*layer_clusters_h)[idx];
1369       vertices_x.push_back(associated_cluster.x());
1370       vertices_y.push_back(associated_cluster.y());
1371       vertices_z.push_back(associated_cluster.z());
1372       vertices_energy.push_back(associated_cluster.energy());
1373       vertices_correctedEnergy.push_back(associated_cluster.correctedEnergy());
1374       vertices_correctedEnergyUncertainty.push_back(associated_cluster.correctedEnergyUncertainty());
1375       vertices_time.push_back(layerClustersTimes.get(idx).first);
1376       vertices_timeErr.push_back(layerClustersTimes.get(idx).second);
1377     }
1378     trackster_vertices_indexes.push_back(vertices_indexes);
1379     trackster_vertices_x.push_back(vertices_x);
1380     trackster_vertices_y.push_back(vertices_y);
1381     trackster_vertices_z.push_back(vertices_z);
1382     trackster_vertices_time.push_back(vertices_time);
1383     trackster_vertices_timeErr.push_back(vertices_timeErr);
1384     trackster_vertices_energy.push_back(vertices_energy);
1385     trackster_vertices_correctedEnergy.push_back(vertices_correctedEnergy);
1386     trackster_vertices_correctedEnergyUncertainty.push_back(vertices_correctedEnergyUncertainty);
1387 
1388     // Multiplicity
1389     std::vector<float> vertices_multiplicity;
1390     for (auto multiplicity : trackster_iterator->vertex_multiplicity()) {
1391       vertices_multiplicity.push_back(multiplicity);
1392     }
1393     trackster_vertices_multiplicity.push_back(vertices_multiplicity);
1394   }
1395 
1396   stsSC_ntracksters_ = simTrackstersSC.size();
1397   using CaloObjectVariant = std::variant<CaloParticle, SimCluster>;
1398   for (auto trackster_iterator = simTrackstersSC.begin(); trackster_iterator != simTrackstersSC.end();
1399        ++trackster_iterator) {
1400     //per-trackster analysis
1401     stsSC_trackster_time.push_back(trackster_iterator->time());
1402     stsSC_trackster_timeBoundary.push_back(trackster_iterator->boundaryTime());
1403     stsSC_trackster_timeError.push_back(trackster_iterator->timeError());
1404     stsSC_trackster_regressed_energy.push_back(trackster_iterator->regressed_energy());
1405     stsSC_trackster_raw_energy.push_back(trackster_iterator->raw_energy());
1406     stsSC_trackster_raw_em_energy.push_back(trackster_iterator->raw_em_energy());
1407     stsSC_trackster_raw_pt.push_back(trackster_iterator->raw_pt());
1408     stsSC_trackster_raw_em_pt.push_back(trackster_iterator->raw_em_pt());
1409     stsSC_trackster_barycenter_x.push_back(trackster_iterator->barycenter().x());
1410     stsSC_trackster_barycenter_y.push_back(trackster_iterator->barycenter().y());
1411     stsSC_trackster_barycenter_z.push_back(trackster_iterator->barycenter().z());
1412     stsSC_trackster_barycenter_eta.push_back(trackster_iterator->barycenter().eta());
1413     stsSC_trackster_barycenter_phi.push_back(trackster_iterator->barycenter().phi());
1414     stsSC_trackster_EV1.push_back(trackster_iterator->eigenvalues()[0]);
1415     stsSC_trackster_EV2.push_back(trackster_iterator->eigenvalues()[1]);
1416     stsSC_trackster_EV3.push_back(trackster_iterator->eigenvalues()[2]);
1417     stsSC_trackster_eVector0_x.push_back((trackster_iterator->eigenvectors()[0]).x());
1418     stsSC_trackster_eVector0_y.push_back((trackster_iterator->eigenvectors()[0]).y());
1419     stsSC_trackster_eVector0_z.push_back((trackster_iterator->eigenvectors()[0]).z());
1420     stsSC_trackster_sigmaPCA1.push_back(trackster_iterator->sigmasPCA()[0]);
1421     stsSC_trackster_sigmaPCA2.push_back(trackster_iterator->sigmasPCA()[1]);
1422     stsSC_trackster_sigmaPCA3.push_back(trackster_iterator->sigmasPCA()[2]);
1423     stsSC_pdgID.push_back(simclusters[trackster_iterator->seedIndex()].pdgId());
1424 
1425     CaloObjectVariant caloObj;
1426     if (trackster_iterator->seedID() == caloparticles_h.id()) {
1427       caloObj = caloparticles[trackster_iterator->seedIndex()];
1428     } else {
1429       caloObj = simclusters[trackster_iterator->seedIndex()];
1430     }
1431 
1432     auto const& simTrack = std::visit([](auto&& obj) { return obj.g4Tracks()[0]; }, caloObj);
1433     auto const& caloPt = std::visit([](auto&& obj) { return obj.pt(); }, caloObj);
1434     stsSC_trackster_regressed_pt.push_back(caloPt);
1435     if (simTrack.crossedBoundary()) {
1436       stsSC_boundaryX.push_back(simTrack.getPositionAtBoundary().x());
1437       stsSC_boundaryY.push_back(simTrack.getPositionAtBoundary().y());
1438       stsSC_boundaryZ.push_back(simTrack.getPositionAtBoundary().z());
1439       stsSC_boundaryEta.push_back(simTrack.getPositionAtBoundary().eta());
1440       stsSC_boundaryPhi.push_back(simTrack.getPositionAtBoundary().phi());
1441       stsSC_boundaryPx.push_back(simTrack.getMomentumAtBoundary().x());
1442       stsSC_boundaryPy.push_back(simTrack.getMomentumAtBoundary().y());
1443       stsSC_boundaryPz.push_back(simTrack.getMomentumAtBoundary().z());
1444     } else {
1445       stsSC_boundaryX.push_back(-999);
1446       stsSC_boundaryY.push_back(-999);
1447       stsSC_boundaryZ.push_back(-999);
1448       stsSC_boundaryEta.push_back(-999);
1449       stsSC_boundaryPhi.push_back(-999);
1450       stsSC_boundaryPx.push_back(-999);
1451       stsSC_boundaryPy.push_back(-999);
1452       stsSC_boundaryPz.push_back(-999);
1453     }
1454     auto const trackIdx = trackster_iterator->trackIdx();
1455     stsSC_trackIdx.push_back(trackIdx);
1456     if (trackIdx != -1) {
1457       const auto& track = tracks[trackIdx];
1458 
1459       int iSide = int(track.eta() > 0);
1460 
1461       const auto& fts = trajectoryStateTransform::outerFreeState((track), bFieldProd);
1462       // to the HGCal front
1463       const auto& tsos = prop.propagate(fts, firstDisk_[iSide]->surface());
1464       if (tsos.isValid()) {
1465         const auto& globalPos = tsos.globalPosition();
1466         const auto& globalMom = tsos.globalMomentum();
1467         stsSC_track_boundaryX.push_back(globalPos.x());
1468         stsSC_track_boundaryY.push_back(globalPos.y());
1469         stsSC_track_boundaryZ.push_back(globalPos.z());
1470         stsSC_track_boundaryEta.push_back(globalPos.eta());
1471         stsSC_track_boundaryPhi.push_back(globalPos.phi());
1472         stsSC_track_boundaryPx.push_back(globalMom.x());
1473         stsSC_track_boundaryPy.push_back(globalMom.y());
1474         stsSC_track_boundaryPz.push_back(globalMom.z());
1475         stsSC_trackTime.push_back(track.t0());
1476       } else {
1477         stsSC_track_boundaryX.push_back(-999);
1478         stsSC_track_boundaryY.push_back(-999);
1479         stsSC_track_boundaryZ.push_back(-999);
1480         stsSC_track_boundaryEta.push_back(-999);
1481         stsSC_track_boundaryPhi.push_back(-999);
1482         stsSC_track_boundaryPx.push_back(-999);
1483         stsSC_track_boundaryPy.push_back(-999);
1484         stsSC_track_boundaryPz.push_back(-999);
1485       }
1486     } else {
1487       stsSC_track_boundaryX.push_back(-999);
1488       stsSC_track_boundaryY.push_back(-999);
1489       stsSC_track_boundaryZ.push_back(-999);
1490       stsSC_track_boundaryEta.push_back(-999);
1491       stsSC_track_boundaryPhi.push_back(-999);
1492       stsSC_track_boundaryPx.push_back(-999);
1493       stsSC_track_boundaryPy.push_back(-999);
1494       stsSC_track_boundaryPz.push_back(-999);
1495     }
1496 
1497     std::vector<float> id_probs;
1498     for (size_t i = 0; i < 8; i++)
1499       id_probs.push_back(trackster_iterator->id_probabilities(i));
1500     stsSC_trackster_id_probabilities.push_back(id_probs);
1501 
1502     // Clusters
1503     std::vector<uint32_t> vertices_indexes;
1504     std::vector<float> vertices_x;
1505     std::vector<float> vertices_y;
1506     std::vector<float> vertices_z;
1507     std::vector<float> vertices_time;
1508     std::vector<float> vertices_timeErr;
1509     std::vector<float> vertices_energy;
1510     std::vector<float> vertices_correctedEnergy;
1511     std::vector<float> vertices_correctedEnergyUncertainty;
1512     for (auto idx : trackster_iterator->vertices()) {
1513       vertices_indexes.push_back(idx);
1514       auto associated_cluster = (*layer_clusters_h)[idx];
1515       vertices_x.push_back(associated_cluster.x());
1516       vertices_y.push_back(associated_cluster.y());
1517       vertices_z.push_back(associated_cluster.z());
1518       vertices_energy.push_back(associated_cluster.energy());
1519       vertices_correctedEnergy.push_back(associated_cluster.correctedEnergy());
1520       vertices_correctedEnergyUncertainty.push_back(associated_cluster.correctedEnergyUncertainty());
1521       vertices_time.push_back(layerClustersTimes.get(idx).first);
1522       vertices_timeErr.push_back(layerClustersTimes.get(idx).second);
1523     }
1524     stsSC_trackster_vertices_indexes.push_back(vertices_indexes);
1525     stsSC_trackster_vertices_x.push_back(vertices_x);
1526     stsSC_trackster_vertices_y.push_back(vertices_y);
1527     stsSC_trackster_vertices_z.push_back(vertices_z);
1528     stsSC_trackster_vertices_time.push_back(vertices_time);
1529     stsSC_trackster_vertices_timeErr.push_back(vertices_timeErr);
1530     stsSC_trackster_vertices_energy.push_back(vertices_energy);
1531     stsSC_trackster_vertices_correctedEnergy.push_back(vertices_correctedEnergy);
1532     stsSC_trackster_vertices_correctedEnergyUncertainty.push_back(vertices_correctedEnergyUncertainty);
1533 
1534     // Multiplicity
1535     std::vector<float> vertices_multiplicity;
1536     for (auto multiplicity : trackster_iterator->vertex_multiplicity()) {
1537       vertices_multiplicity.push_back(multiplicity);
1538     }
1539     stsSC_trackster_vertices_multiplicity.push_back(vertices_multiplicity);
1540   }
1541 
1542   stsCP_ntracksters_ = simTrackstersCP.size();
1543 
1544   for (auto trackster_iterator = simTrackstersCP.begin(); trackster_iterator != simTrackstersCP.end();
1545        ++trackster_iterator) {
1546     //per-trackster analysis
1547     stsCP_trackster_time.push_back(trackster_iterator->time());
1548     stsCP_trackster_timeBoundary.push_back(trackster_iterator->boundaryTime());
1549     stsCP_trackster_timeError.push_back(trackster_iterator->timeError());
1550     stsCP_trackster_regressed_energy.push_back(trackster_iterator->regressed_energy());
1551     stsCP_trackster_raw_energy.push_back(trackster_iterator->raw_energy());
1552     stsCP_trackster_raw_em_energy.push_back(trackster_iterator->raw_em_energy());
1553     stsCP_trackster_raw_pt.push_back(trackster_iterator->raw_pt());
1554     stsCP_trackster_raw_em_pt.push_back(trackster_iterator->raw_em_pt());
1555     stsCP_trackster_barycenter_x.push_back(trackster_iterator->barycenter().x());
1556     stsCP_trackster_barycenter_y.push_back(trackster_iterator->barycenter().y());
1557     stsCP_trackster_barycenter_z.push_back(trackster_iterator->barycenter().z());
1558     stsCP_trackster_barycenter_eta.push_back(trackster_iterator->barycenter().eta());
1559     stsCP_trackster_barycenter_phi.push_back(trackster_iterator->barycenter().phi());
1560     stsCP_trackster_EV1.push_back(trackster_iterator->eigenvalues()[0]);
1561     stsCP_trackster_EV2.push_back(trackster_iterator->eigenvalues()[1]);
1562     stsCP_trackster_EV3.push_back(trackster_iterator->eigenvalues()[2]);
1563     stsCP_trackster_eVector0_x.push_back((trackster_iterator->eigenvectors()[0]).x());
1564     stsCP_trackster_eVector0_y.push_back((trackster_iterator->eigenvectors()[0]).y());
1565     stsCP_trackster_eVector0_z.push_back((trackster_iterator->eigenvectors()[0]).z());
1566     stsCP_trackster_sigmaPCA1.push_back(trackster_iterator->sigmasPCA()[0]);
1567     stsCP_trackster_sigmaPCA2.push_back(trackster_iterator->sigmasPCA()[1]);
1568     stsCP_trackster_sigmaPCA3.push_back(trackster_iterator->sigmasPCA()[2]);
1569     stsCP_pdgID.push_back(caloparticles[trackster_iterator->seedIndex()].pdgId());
1570     CaloObjectVariant caloObj;
1571     if (trackster_iterator->seedID() == caloparticles_h.id()) {
1572       caloObj = caloparticles[trackster_iterator->seedIndex()];
1573     } else {
1574       caloObj = simclusters[trackster_iterator->seedIndex()];
1575     }
1576 
1577     auto const& simTrack = std::visit([](auto&& obj) { return obj.g4Tracks()[0]; }, caloObj);
1578     auto const& caloPt = std::visit([](auto&& obj) { return obj.pt(); }, caloObj);
1579     stsCP_trackster_regressed_pt.push_back(caloPt);
1580 
1581     if (simTrack.crossedBoundary()) {
1582       stsCP_boundaryX.push_back(simTrack.getPositionAtBoundary().x());
1583       stsCP_boundaryY.push_back(simTrack.getPositionAtBoundary().y());
1584       stsCP_boundaryZ.push_back(simTrack.getPositionAtBoundary().z());
1585       stsCP_boundaryEta.push_back(simTrack.getPositionAtBoundary().eta());
1586       stsCP_boundaryPhi.push_back(simTrack.getPositionAtBoundary().phi());
1587       stsCP_boundaryPx.push_back(simTrack.getMomentumAtBoundary().x());
1588       stsCP_boundaryPy.push_back(simTrack.getMomentumAtBoundary().y());
1589       stsCP_boundaryPz.push_back(simTrack.getMomentumAtBoundary().z());
1590     } else {
1591       stsCP_boundaryX.push_back(-999);
1592       stsCP_boundaryY.push_back(-999);
1593       stsCP_boundaryZ.push_back(-999);
1594       stsCP_boundaryEta.push_back(-999);
1595       stsCP_boundaryPhi.push_back(-999);
1596       stsCP_boundaryPx.push_back(-999);
1597       stsCP_boundaryPy.push_back(-999);
1598       stsCP_boundaryPz.push_back(-999);
1599     }
1600     auto const trackIdx = trackster_iterator->trackIdx();
1601     stsCP_trackIdx.push_back(trackIdx);
1602     if (trackIdx != -1) {
1603       const auto& track = tracks[trackIdx];
1604 
1605       int iSide = int(track.eta() > 0);
1606 
1607       const auto& fts = trajectoryStateTransform::outerFreeState((track), bFieldProd);
1608       // to the HGCal front
1609       const auto& tsos = prop.propagate(fts, firstDisk_[iSide]->surface());
1610       if (tsos.isValid()) {
1611         const auto& globalPos = tsos.globalPosition();
1612         const auto& globalMom = tsos.globalMomentum();
1613         stsCP_track_boundaryX.push_back(globalPos.x());
1614         stsCP_track_boundaryY.push_back(globalPos.y());
1615         stsCP_track_boundaryZ.push_back(globalPos.z());
1616         stsCP_track_boundaryEta.push_back(globalPos.eta());
1617         stsCP_track_boundaryPhi.push_back(globalPos.phi());
1618         stsCP_track_boundaryPx.push_back(globalMom.x());
1619         stsCP_track_boundaryPy.push_back(globalMom.y());
1620         stsCP_track_boundaryPz.push_back(globalMom.z());
1621         stsCP_trackTime.push_back(track.t0());
1622       } else {
1623         stsCP_track_boundaryX.push_back(-999);
1624         stsCP_track_boundaryY.push_back(-999);
1625         stsCP_track_boundaryZ.push_back(-999);
1626         stsCP_track_boundaryEta.push_back(-999);
1627         stsCP_track_boundaryPhi.push_back(-999);
1628         stsCP_track_boundaryPx.push_back(-999);
1629         stsCP_track_boundaryPy.push_back(-999);
1630         stsCP_track_boundaryPz.push_back(-999);
1631       }
1632     } else {
1633       stsCP_track_boundaryX.push_back(-999);
1634       stsCP_track_boundaryY.push_back(-999);
1635       stsCP_track_boundaryZ.push_back(-999);
1636       stsCP_track_boundaryEta.push_back(-999);
1637       stsCP_track_boundaryPhi.push_back(-999);
1638       stsCP_track_boundaryPx.push_back(-999);
1639       stsCP_track_boundaryPy.push_back(-999);
1640       stsCP_track_boundaryPz.push_back(-999);
1641     }
1642     std::vector<float> id_probs;
1643     for (size_t i = 0; i < 8; i++)
1644       id_probs.push_back(trackster_iterator->id_probabilities(i));
1645     stsCP_trackster_id_probabilities.push_back(id_probs);
1646 
1647     // Clusters
1648     std::vector<uint32_t> vertices_indexes;
1649     std::vector<float> vertices_x;
1650     std::vector<float> vertices_y;
1651     std::vector<float> vertices_z;
1652     std::vector<float> vertices_time;
1653     std::vector<float> vertices_timeErr;
1654     std::vector<float> vertices_energy;
1655     std::vector<float> vertices_correctedEnergy;
1656     std::vector<float> vertices_correctedEnergyUncertainty;
1657     for (auto idx : trackster_iterator->vertices()) {
1658       vertices_indexes.push_back(idx);
1659       auto associated_cluster = (*layer_clusters_h)[idx];
1660       vertices_x.push_back(associated_cluster.x());
1661       vertices_y.push_back(associated_cluster.y());
1662       vertices_z.push_back(associated_cluster.z());
1663       vertices_energy.push_back(associated_cluster.energy());
1664       vertices_correctedEnergy.push_back(associated_cluster.correctedEnergy());
1665       vertices_correctedEnergyUncertainty.push_back(associated_cluster.correctedEnergyUncertainty());
1666       vertices_time.push_back(layerClustersTimes.get(idx).first);
1667       vertices_timeErr.push_back(layerClustersTimes.get(idx).second);
1668     }
1669     stsCP_trackster_vertices_indexes.push_back(vertices_indexes);
1670     stsCP_trackster_vertices_x.push_back(vertices_x);
1671     stsCP_trackster_vertices_y.push_back(vertices_y);
1672     stsCP_trackster_vertices_z.push_back(vertices_z);
1673     stsCP_trackster_vertices_time.push_back(vertices_time);
1674     stsCP_trackster_vertices_timeErr.push_back(vertices_timeErr);
1675     stsCP_trackster_vertices_energy.push_back(vertices_energy);
1676     stsCP_trackster_vertices_correctedEnergy.push_back(vertices_correctedEnergy);
1677     stsCP_trackster_vertices_correctedEnergyUncertainty.push_back(vertices_correctedEnergyUncertainty);
1678 
1679     // Multiplicity
1680     std::vector<float> vertices_multiplicity;
1681     for (auto multiplicity : trackster_iterator->vertex_multiplicity()) {
1682       vertices_multiplicity.push_back(multiplicity);
1683     }
1684     stsCP_trackster_vertices_multiplicity.push_back(vertices_multiplicity);
1685   }
1686 
1687   simTICLCandidate_track_in_candidate.resize(simTICLCandidates.size(), -1);
1688   for (size_t i = 0; i < simTICLCandidates.size(); ++i) {
1689     auto const& cand = simTICLCandidates[i];
1690 
1691     simTICLCandidate_raw_energy.push_back(cand.rawEnergy());
1692     simTICLCandidate_regressed_energy.push_back(cand.p4().energy());
1693     simTICLCandidate_pdgId.push_back(cand.pdgId());
1694     simTICLCandidate_charge.push_back(cand.charge());
1695     simTICLCandidate_time.push_back(cand.time());
1696     std::vector<int> tmpIdxVec;
1697     for (auto const& simTS : cand.tracksters()) {
1698       auto trackster_idx = simTS.get() - (edm::Ptr<ticl::Trackster>(simTrackstersSC_h, 0)).get();
1699       tmpIdxVec.push_back(trackster_idx);
1700     }
1701     simTICLCandidate_simTracksterCPIndex.push_back(tmpIdxVec);
1702     tmpIdxVec.clear();
1703     auto const& trackPtr = cand.trackPtr();
1704     if (!trackPtr.isNull()) {
1705       auto const& track = *trackPtr;
1706       int iSide = int(track.eta() > 0);
1707       int tk_idx = trackPtr.get() - (edm::Ptr<reco::Track>(tracks_h, 0)).get();
1708       simTICLCandidate_track_in_candidate[i] = tk_idx;
1709 
1710       const auto& fts = trajectoryStateTransform::outerFreeState((track), bFieldProd);
1711       // to the HGCal front
1712       const auto& tsos = prop.propagate(fts, firstDisk_[iSide]->surface());
1713       if (tsos.isValid()) {
1714         const auto& globalPos = tsos.globalPosition();
1715         const auto& globalMom = tsos.globalMomentum();
1716         simTICLCandidate_boundaryX.push_back(globalPos.x());
1717         simTICLCandidate_boundaryY.push_back(globalPos.y());
1718         simTICLCandidate_boundaryZ.push_back(globalPos.z());
1719         simTICLCandidate_boundaryPx.push_back(globalMom.x());
1720         simTICLCandidate_boundaryPy.push_back(globalMom.y());
1721         simTICLCandidate_boundaryPz.push_back(globalMom.z());
1722       } else {
1723         simTICLCandidate_boundaryX.push_back(-999);
1724         simTICLCandidate_boundaryY.push_back(-999);
1725         simTICLCandidate_boundaryZ.push_back(-999);
1726         simTICLCandidate_boundaryPx.push_back(-999);
1727         simTICLCandidate_boundaryPy.push_back(-999);
1728         simTICLCandidate_boundaryPz.push_back(-999);
1729       }
1730     } else {
1731       simTICLCandidate_boundaryX.push_back(-999);
1732       simTICLCandidate_boundaryY.push_back(-999);
1733       simTICLCandidate_boundaryZ.push_back(-999);
1734       simTICLCandidate_boundaryPx.push_back(-999);
1735       simTICLCandidate_boundaryPy.push_back(-999);
1736       simTICLCandidate_boundaryPz.push_back(-999);
1737     }
1738   }
1739 
1740   int c_id = 0;
1741 
1742   for (auto cluster_iterator = clusters.begin(); cluster_iterator != clusters.end(); ++cluster_iterator) {
1743     auto lc_seed = cluster_iterator->seed();
1744     cluster_seedID.push_back(lc_seed);
1745     cluster_energy.push_back(cluster_iterator->energy());
1746     cluster_correctedEnergy.push_back(cluster_iterator->correctedEnergy());
1747     cluster_correctedEnergyUncertainty.push_back(cluster_iterator->correctedEnergyUncertainty());
1748     cluster_position_x.push_back(cluster_iterator->x());
1749     cluster_position_y.push_back(cluster_iterator->y());
1750     cluster_position_z.push_back(cluster_iterator->z());
1751     cluster_position_eta.push_back(cluster_iterator->eta());
1752     cluster_position_phi.push_back(cluster_iterator->phi());
1753     auto haf = cluster_iterator->hitsAndFractions();
1754     auto layerId = rhtools_.getLayerWithOffset(haf[0].first);
1755     cluster_layer_id.push_back(layerId);
1756     uint32_t number_of_hits = cluster_iterator->hitsAndFractions().size();
1757     cluster_number_of_hits.push_back(number_of_hits);
1758     cluster_type.push_back(rhtools_.getCellType(lc_seed));
1759     cluster_timeErr.push_back(layerClustersTimes.get(c_id).second);
1760     cluster_time.push_back(layerClustersTimes.get(c_id).first);
1761     c_id += 1;
1762   }
1763 
1764   tracksters_in_candidate.resize(ticlcandidates.size());
1765   track_in_candidate.resize(ticlcandidates.size(), -1);
1766   nCandidates = ticlcandidates.size();
1767   for (int i = 0; i < static_cast<int>(ticlcandidates.size()); ++i) {
1768     const auto& candidate = ticlcandidates[i];
1769     candidate_charge.push_back(candidate.charge());
1770     candidate_pdgId.push_back(candidate.pdgId());
1771     candidate_energy.push_back(candidate.energy());
1772     candidate_raw_energy.push_back(candidate.rawEnergy());
1773     candidate_px.push_back(candidate.px());
1774     candidate_py.push_back(candidate.py());
1775     candidate_pz.push_back(candidate.pz());
1776     candidate_time.push_back(candidate.time());
1777     candidate_time_err.push_back(candidate.timeError());
1778     std::vector<float> id_probs;
1779     for (int j = 0; j < 8; j++) {
1780       ticl::Trackster::ParticleType type = static_cast<ticl::Trackster::ParticleType>(j);
1781       id_probs.push_back(candidate.id_probability(type));
1782     }
1783     candidate_id_probabilities.push_back(id_probs);
1784 
1785     auto trackster_ptrs = candidate.tracksters();
1786     auto track_ptr = candidate.trackPtr();
1787     for (const auto& ts_ptr : trackster_ptrs) {
1788       auto ts_idx = ts_ptr.get() - (edm::Ptr<ticl::Trackster>(tracksters_in_candidate_handle, 0)).get();
1789       tracksters_in_candidate[i].push_back(ts_idx);
1790     }
1791     if (track_ptr.isNull())
1792       continue;
1793     int tk_idx = track_ptr.get() - (edm::Ptr<reco::Track>(tracks_h, 0)).get();
1794     track_in_candidate[i] = tk_idx;
1795   }
1796 
1797   nTrackstersMerged = trackstersmerged.size();
1798   for (auto trackster_iterator = trackstersmerged.begin(); trackster_iterator != trackstersmerged.end();
1799        ++trackster_iterator) {
1800     tracksters_merged_time.push_back(trackster_iterator->time());
1801     tracksters_merged_timeError.push_back(trackster_iterator->timeError());
1802     tracksters_merged_regressed_energy.push_back(trackster_iterator->regressed_energy());
1803     tracksters_merged_raw_energy.push_back(trackster_iterator->raw_energy());
1804     tracksters_merged_raw_em_energy.push_back(trackster_iterator->raw_em_energy());
1805     tracksters_merged_raw_pt.push_back(trackster_iterator->raw_pt());
1806     tracksters_merged_raw_em_pt.push_back(trackster_iterator->raw_em_pt());
1807     tracksters_merged_barycenter_x.push_back(trackster_iterator->barycenter().x());
1808     tracksters_merged_barycenter_y.push_back(trackster_iterator->barycenter().y());
1809     tracksters_merged_barycenter_z.push_back(trackster_iterator->barycenter().z());
1810     tracksters_merged_barycenter_eta.push_back(trackster_iterator->barycenter().eta());
1811     tracksters_merged_barycenter_phi.push_back(trackster_iterator->barycenter().phi());
1812     tracksters_merged_EV1.push_back(trackster_iterator->eigenvalues()[0]);
1813     tracksters_merged_EV2.push_back(trackster_iterator->eigenvalues()[1]);
1814     tracksters_merged_EV3.push_back(trackster_iterator->eigenvalues()[2]);
1815     tracksters_merged_eVector0_x.push_back((trackster_iterator->eigenvectors()[0]).x());
1816     tracksters_merged_eVector0_y.push_back((trackster_iterator->eigenvectors()[0]).y());
1817     tracksters_merged_eVector0_z.push_back((trackster_iterator->eigenvectors()[0]).z());
1818     tracksters_merged_sigmaPCA1.push_back(trackster_iterator->sigmasPCA()[0]);
1819     tracksters_merged_sigmaPCA2.push_back(trackster_iterator->sigmasPCA()[1]);
1820     tracksters_merged_sigmaPCA3.push_back(trackster_iterator->sigmasPCA()[2]);
1821 
1822     std::vector<float> id_probs;
1823     for (size_t i = 0; i < 8; i++)
1824       id_probs.push_back(trackster_iterator->id_probabilities(i));
1825     tracksters_merged_id_probabilities.push_back(id_probs);
1826 
1827     std::vector<uint32_t> vertices_indexes;
1828     std::vector<float> vertices_x;
1829     std::vector<float> vertices_y;
1830     std::vector<float> vertices_z;
1831     std::vector<float> vertices_time;
1832     std::vector<float> vertices_timeErr;
1833     std::vector<float> vertices_energy;
1834     std::vector<float> vertices_correctedEnergy;
1835     std::vector<float> vertices_correctedEnergyUncertainty;
1836     for (auto idx : trackster_iterator->vertices()) {
1837       vertices_indexes.push_back(idx);
1838       auto associated_cluster = (*layer_clusters_h)[idx];
1839       vertices_x.push_back(associated_cluster.x());
1840       vertices_y.push_back(associated_cluster.y());
1841       vertices_z.push_back(associated_cluster.z());
1842       vertices_energy.push_back(associated_cluster.energy());
1843       vertices_correctedEnergy.push_back(associated_cluster.correctedEnergy());
1844       vertices_correctedEnergyUncertainty.push_back(associated_cluster.correctedEnergyUncertainty());
1845       vertices_time.push_back(layerClustersTimes.get(idx).first);
1846       vertices_timeErr.push_back(layerClustersTimes.get(idx).second);
1847     }
1848     tracksters_merged_vertices_indexes.push_back(vertices_indexes);
1849     tracksters_merged_vertices_x.push_back(vertices_x);
1850     tracksters_merged_vertices_y.push_back(vertices_y);
1851     tracksters_merged_vertices_z.push_back(vertices_z);
1852     tracksters_merged_vertices_time.push_back(vertices_time);
1853     tracksters_merged_vertices_timeErr.push_back(vertices_timeErr);
1854     tracksters_merged_vertices_energy.push_back(vertices_energy);
1855     tracksters_merged_vertices_correctedEnergy.push_back(vertices_correctedEnergy);
1856     tracksters_merged_vertices_correctedEnergyUncertainty.push_back(vertices_correctedEnergyUncertainty);
1857   }
1858 
1859   // Tackster reco->sim associations
1860   trackstersCLUE3D_recoToSim_SC.resize(tracksters.size());
1861   trackstersCLUE3D_recoToSim_SC_score.resize(tracksters.size());
1862   trackstersCLUE3D_recoToSim_SC_sharedE.resize(tracksters.size());
1863   for (size_t i = 0; i < tracksters.size(); ++i) {
1864     const edm::Ref<ticl::TracksterCollection> tsRef(tracksters_handle, i);
1865 
1866     // CLUE3D -> STS-SC
1867     const auto stsSC_iter = tsRecoSimSCMap.find(tsRef);
1868     if (stsSC_iter != tsRecoSimSCMap.end()) {
1869       const auto& stsSCassociated = stsSC_iter->val;
1870       for (auto& sts : stsSCassociated) {
1871         auto sts_id = (sts.first).get() - (edm::Ref<ticl::TracksterCollection>(simTrackstersSC_h, 0)).get();
1872         trackstersCLUE3D_recoToSim_SC[i].push_back(sts_id);
1873         trackstersCLUE3D_recoToSim_SC_score[i].push_back(sts.second.second);
1874         trackstersCLUE3D_recoToSim_SC_sharedE[i].push_back(sts.second.first);
1875       }
1876     }
1877   }
1878 
1879   // SimTracksters
1880   nsimTrackstersSC = simTrackstersSC.size();
1881   trackstersCLUE3D_simToReco_SC.resize(nsimTrackstersSC);
1882   trackstersCLUE3D_simToReco_SC_score.resize(nsimTrackstersSC);
1883   trackstersCLUE3D_simToReco_SC_sharedE.resize(nsimTrackstersSC);
1884   for (size_t i = 0; i < nsimTrackstersSC; ++i) {
1885     const edm::Ref<ticl::TracksterCollection> stsSCRef(simTrackstersSC_h, i);
1886 
1887     // STS-SC -> CLUE3D
1888     const auto ts_iter = tsSimToRecoSCMap.find(stsSCRef);
1889     if (ts_iter != tsSimToRecoSCMap.end()) {
1890       const auto& tsAssociated = ts_iter->val;
1891       for (auto& ts : tsAssociated) {
1892         auto ts_idx = (ts.first).get() - (edm::Ref<ticl::TracksterCollection>(tracksters_handle, 0)).get();
1893         trackstersCLUE3D_simToReco_SC[i].push_back(ts_idx);
1894         trackstersCLUE3D_simToReco_SC_score[i].push_back(ts.second.second);
1895         trackstersCLUE3D_simToReco_SC_sharedE[i].push_back(ts.second.first);
1896       }
1897     }
1898   }
1899 
1900   // Tackster reco->sim associations
1901   trackstersCLUE3D_recoToSim_CP.resize(tracksters.size());
1902   trackstersCLUE3D_recoToSim_CP_score.resize(tracksters.size());
1903   trackstersCLUE3D_recoToSim_CP_sharedE.resize(tracksters.size());
1904   for (size_t i = 0; i < tracksters.size(); ++i) {
1905     const edm::Ref<ticl::TracksterCollection> tsRef(tracksters_handle, i);
1906 
1907     // CLUE3D -> STS-CP
1908     const auto stsCP_iter = tsRecoSimCPMap.find(tsRef);
1909     if (stsCP_iter != tsRecoSimCPMap.end()) {
1910       const auto& stsCPassociated = stsCP_iter->val;
1911       for (auto& sts : stsCPassociated) {
1912         auto sts_id = (sts.first).get() - (edm::Ref<ticl::TracksterCollection>(simTrackstersCP_h, 0)).get();
1913         trackstersCLUE3D_recoToSim_CP[i].push_back(sts_id);
1914         trackstersCLUE3D_recoToSim_CP_score[i].push_back(sts.second.second);
1915         trackstersCLUE3D_recoToSim_CP_sharedE[i].push_back(sts.second.first);
1916       }
1917     }
1918   }
1919 
1920   // SimTracksters
1921   nsimTrackstersCP = simTrackstersCP.size();
1922   trackstersCLUE3D_simToReco_CP.resize(nsimTrackstersCP);
1923   trackstersCLUE3D_simToReco_CP_score.resize(nsimTrackstersCP);
1924   trackstersCLUE3D_simToReco_CP_sharedE.resize(nsimTrackstersCP);
1925   for (size_t i = 0; i < nsimTrackstersCP; ++i) {
1926     const edm::Ref<ticl::TracksterCollection> stsCPRef(simTrackstersCP_h, i);
1927 
1928     // STS-CP -> CLUE3D
1929     const auto ts_iter = tsSimToRecoCPMap.find(stsCPRef);
1930     if (ts_iter != tsSimToRecoCPMap.end()) {
1931       const auto& tsAssociated = ts_iter->val;
1932       for (auto& ts : tsAssociated) {
1933         auto ts_idx = (ts.first).get() - (edm::Ref<ticl::TracksterCollection>(tracksters_handle, 0)).get();
1934         trackstersCLUE3D_simToReco_CP[i].push_back(ts_idx);
1935         trackstersCLUE3D_simToReco_CP_score[i].push_back(ts.second.second);
1936         trackstersCLUE3D_simToReco_CP_sharedE[i].push_back(ts.second.first);
1937       }
1938     }
1939   }
1940 
1941   // Tackster reco->sim associations
1942   MergeTracksters_recoToSim_SC.resize(trackstersmerged.size());
1943   MergeTracksters_recoToSim_SC_score.resize(trackstersmerged.size());
1944   MergeTracksters_recoToSim_SC_sharedE.resize(trackstersmerged.size());
1945   for (size_t i = 0; i < trackstersmerged.size(); ++i) {
1946     const edm::Ref<ticl::TracksterCollection> tsRef(tracksters_merged_h, i);
1947 
1948     // CLUE3D -> STS-SC
1949     const auto stsSC_iter = MergetsRecoSimSCMap.find(tsRef);
1950     if (stsSC_iter != MergetsRecoSimSCMap.end()) {
1951       const auto& stsSCassociated = stsSC_iter->val;
1952       for (auto& sts : stsSCassociated) {
1953         auto sts_id = (sts.first).get() - (edm::Ref<ticl::TracksterCollection>(simTrackstersSC_h, 0)).get();
1954         MergeTracksters_recoToSim_SC[i].push_back(sts_id);
1955         MergeTracksters_recoToSim_SC_score[i].push_back(sts.second.second);
1956         MergeTracksters_recoToSim_SC_sharedE[i].push_back(sts.second.first);
1957       }
1958     }
1959   }
1960 
1961   // SimTracksters
1962   nsimTrackstersSC = simTrackstersSC.size();
1963   MergeTracksters_simToReco_SC.resize(nsimTrackstersSC);
1964   MergeTracksters_simToReco_SC_score.resize(nsimTrackstersSC);
1965   MergeTracksters_simToReco_SC_sharedE.resize(nsimTrackstersSC);
1966   for (size_t i = 0; i < nsimTrackstersSC; ++i) {
1967     const edm::Ref<ticl::TracksterCollection> stsSCRef(simTrackstersSC_h, i);
1968 
1969     // STS-SC -> CLUE3D
1970     const auto ts_iter = MergetsSimToRecoSCMap.find(stsSCRef);
1971     if (ts_iter != MergetsSimToRecoSCMap.end()) {
1972       const auto& tsAssociated = ts_iter->val;
1973       for (auto& ts : tsAssociated) {
1974         auto ts_idx = (ts.first).get() - (edm::Ref<ticl::TracksterCollection>(tracksters_merged_h, 0)).get();
1975         MergeTracksters_simToReco_SC[i].push_back(ts_idx);
1976         MergeTracksters_simToReco_SC_score[i].push_back(ts.second.second);
1977         MergeTracksters_simToReco_SC_sharedE[i].push_back(ts.second.first);
1978       }
1979     }
1980   }
1981 
1982   // Tackster reco->sim associations
1983   MergeTracksters_recoToSim_CP.resize(trackstersmerged.size());
1984   MergeTracksters_recoToSim_CP_score.resize(trackstersmerged.size());
1985   MergeTracksters_recoToSim_CP_sharedE.resize(trackstersmerged.size());
1986   for (size_t i = 0; i < trackstersmerged.size(); ++i) {
1987     const edm::Ref<ticl::TracksterCollection> tsRef(tracksters_merged_h, i);
1988 
1989     // CLUE3D -> STS-CP
1990     const auto stsCP_iter = MergetsRecoSimCPMap.find(tsRef);
1991     if (stsCP_iter != MergetsRecoSimCPMap.end()) {
1992       const auto& stsCPassociated = stsCP_iter->val;
1993       for (auto& sts : stsCPassociated) {
1994         auto sts_id = (sts.first).get() - (edm::Ref<ticl::TracksterCollection>(simTrackstersCP_h, 0)).get();
1995         MergeTracksters_recoToSim_CP[i].push_back(sts_id);
1996         MergeTracksters_recoToSim_CP_score[i].push_back(sts.second.second);
1997         MergeTracksters_recoToSim_CP_sharedE[i].push_back(sts.second.first);
1998       }
1999     }
2000   }
2001 
2002   // Tackster reco->sim associations
2003   MergeTracksters_recoToSim_PU.resize(trackstersmerged.size());
2004   MergeTracksters_recoToSim_PU_score.resize(trackstersmerged.size());
2005   MergeTracksters_recoToSim_PU_sharedE.resize(trackstersmerged.size());
2006   for (size_t i = 0; i < trackstersmerged.size(); ++i) {
2007     const edm::Ref<ticl::TracksterCollection> tsRef(tracksters_merged_h, i);
2008 
2009     // CLUE3D -> STS-PU
2010     const auto stsPU_iter = MergetsRecoSimPUMap.find(tsRef);
2011     if (stsPU_iter != MergetsRecoSimPUMap.end()) {
2012       const auto& stsPUassociated = stsPU_iter->val;
2013       for (auto& sts : stsPUassociated) {
2014         auto sts_id = (sts.first).get() - (edm::Ref<ticl::TracksterCollection>(simTrackstersPU_h, 0)).get();
2015         MergeTracksters_recoToSim_PU[i].push_back(sts_id);
2016         MergeTracksters_recoToSim_PU_score[i].push_back(sts.second.second);
2017         MergeTracksters_recoToSim_PU_sharedE[i].push_back(sts.second.first);
2018       }
2019     }
2020   }
2021 
2022   // SimTracksters
2023   nsimTrackstersCP = simTrackstersCP.size();
2024   MergeTracksters_simToReco_CP.resize(nsimTrackstersCP);
2025   MergeTracksters_simToReco_CP_score.resize(nsimTrackstersCP);
2026   MergeTracksters_simToReco_CP_sharedE.resize(nsimTrackstersCP);
2027   for (size_t i = 0; i < nsimTrackstersCP; ++i) {
2028     const edm::Ref<ticl::TracksterCollection> stsCPRef(simTrackstersCP_h, i);
2029 
2030     // STS-CP -> TrackstersMerge
2031     const auto ts_iter = MergetsSimToRecoCPMap.find(stsCPRef);
2032     if (ts_iter != MergetsSimToRecoCPMap.end()) {
2033       const auto& tsAssociated = ts_iter->val;
2034       for (auto& ts : tsAssociated) {
2035         auto ts_idx = (ts.first).get() - (edm::Ref<ticl::TracksterCollection>(tracksters_merged_h, 0)).get();
2036         MergeTracksters_simToReco_CP[i].push_back(ts_idx);
2037         MergeTracksters_simToReco_CP_score[i].push_back(ts.second.second);
2038         MergeTracksters_simToReco_CP_sharedE[i].push_back(ts.second.first);
2039       }
2040     }
2041   }
2042 
2043   // SimTracksters
2044   auto nsimTrackstersPU = simTrackstersPU.size();
2045   MergeTracksters_simToReco_PU.resize(nsimTrackstersPU);
2046   MergeTracksters_simToReco_PU_score.resize(nsimTrackstersPU);
2047   MergeTracksters_simToReco_PU_sharedE.resize(nsimTrackstersPU);
2048   for (size_t i = 0; i < nsimTrackstersPU; ++i) {
2049     const edm::Ref<ticl::TracksterCollection> stsPURef(simTrackstersPU_h, i);
2050 
2051     // STS-PU -> Tracksters Merge
2052     const auto ts_iter = MergetsSimToRecoPUMap.find(stsPURef);
2053     if (ts_iter != MergetsSimToRecoPUMap.end()) {
2054       const auto& tsAssociated = ts_iter->val;
2055       for (auto& ts : tsAssociated) {
2056         auto ts_idx = (ts.first).get() - (edm::Ref<ticl::TracksterCollection>(tracksters_merged_h, 0)).get();
2057         MergeTracksters_simToReco_PU[i].push_back(ts_idx);
2058         MergeTracksters_simToReco_PU_score[i].push_back(ts.second.second);
2059         MergeTracksters_simToReco_PU_sharedE[i].push_back(ts.second.first);
2060       }
2061     }
2062   }
2063 
2064   //Tracks
2065   for (size_t i = 0; i < tracks.size(); i++) {
2066     const auto& track = tracks[i];
2067     reco::TrackRef trackref = reco::TrackRef(tracks_h, i);
2068     int iSide = int(track.eta() > 0);
2069     const auto& fts = trajectoryStateTransform::outerFreeState((track), bFieldProd);
2070     // to the HGCal front
2071     const auto& tsos = prop.propagate(fts, firstDisk_[iSide]->surface());
2072     if (tsos.isValid()) {
2073       const auto& globalPos = tsos.globalPosition();
2074       const auto& globalMom = tsos.globalMomentum();
2075       track_id.push_back(i);
2076       track_hgcal_x.push_back(globalPos.x());
2077       track_hgcal_y.push_back(globalPos.y());
2078       track_hgcal_z.push_back(globalPos.z());
2079       track_hgcal_eta.push_back(globalPos.eta());
2080       track_hgcal_phi.push_back(globalPos.phi());
2081       track_hgcal_px.push_back(globalMom.x());
2082       track_hgcal_py.push_back(globalMom.y());
2083       track_hgcal_pz.push_back(globalMom.z());
2084       track_hgcal_pt.push_back(globalMom.perp());
2085       track_pt.push_back(track.pt());
2086       track_quality.push_back(track.quality(reco::TrackBase::highPurity));
2087       track_missing_outer_hits.push_back(track.missingOuterHits());
2088       track_missing_inner_hits.push_back(track.missingInnerHits());
2089       track_charge.push_back(track.charge());
2090       track_time.push_back(trackTime[trackref]);
2091       track_time_quality.push_back(trackTimeQual[trackref]);
2092       track_time_err.push_back(trackTimeErr[trackref]);
2093       track_beta.push_back(trackBeta[trackref]);
2094       track_time_mtd.push_back(trackTimeMtd[trackref]);
2095       track_time_mtd_err.push_back(trackTimeMtdErr[trackref]);
2096       track_pos_mtd.push_back(trackPosMtd[trackref]);
2097       track_nhits.push_back(tracks[i].recHitsSize());
2098       int muId = PFMuonAlgo::muAssocToTrack(trackref, *muons_h);
2099       if (muId != -1) {
2100         const reco::MuonRef muonref = reco::MuonRef(muons_h, muId);
2101         track_isMuon.push_back(PFMuonAlgo::isMuon(muonref));
2102         track_isTrackerMuon.push_back(muons[muId].isTrackerMuon());
2103       } else {
2104         track_isMuon.push_back(-1);
2105         track_isTrackerMuon.push_back(-1);
2106       }
2107     }
2108   }
2109 
2110   if (saveCLUE3DTracksters_)
2111     trackster_tree_->Fill();
2112   if (saveLCs_)
2113     cluster_tree_->Fill();
2114   if (saveTICLCandidate_)
2115     candidate_tree_->Fill();
2116   if (saveTrackstersMerged_)
2117     tracksters_merged_tree_->Fill();
2118   if (saveAssociations_)
2119     associations_tree_->Fill();
2120   if (saveSimTrackstersSC_)
2121     simtrackstersSC_tree_->Fill();
2122   if (saveSimTrackstersCP_)
2123     simtrackstersCP_tree_->Fill();
2124   if (saveTracks_)
2125     tracks_tree_->Fill();
2126   if (saveSimTICLCandidate_)
2127     simTICLCandidate_tree->Fill();
2128 }
2129 
2130 void TICLDumper::endJob() {}
2131 
2132 void TICLDumper::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
2133   edm::ParameterSetDescription desc;
2134   desc.add<edm::InputTag>("trackstersclue3d", edm::InputTag("ticlTrackstersCLUE3DHigh"));
2135   desc.add<edm::InputTag>("trackstersInCand", edm::InputTag("ticlTrackstersCLUE3DHigh"));
2136   desc.add<edm::InputTag>("layerClusters", edm::InputTag("hgcalMergeLayerClusters"));
2137   desc.add<edm::InputTag>("layer_clustersTime", edm::InputTag("hgcalMergeLayerClusters", "timeLayerCluster"));
2138   desc.add<edm::InputTag>("ticlcandidates", edm::InputTag("ticlTrackstersMerge"));
2139   desc.add<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
2140   desc.add<edm::InputTag>("tracksTime", edm::InputTag("tofPID:t0"));
2141   desc.add<edm::InputTag>("tracksTimeQual", edm::InputTag("mtdTrackQualityMVA:mtdQualMVA"));
2142   desc.add<edm::InputTag>("tracksTimeErr", edm::InputTag("tofPID:sigmat0"));
2143   desc.add<edm::InputTag>("tracksBeta", edm::InputTag("trackExtenderWithMTD:generalTrackBeta"));
2144   desc.add<edm::InputTag>("tracksTimeMtd", edm::InputTag("trackExtenderWithMTD:generalTracktmtd"));
2145   desc.add<edm::InputTag>("tracksTimeMtdErr", edm::InputTag("trackExtenderWithMTD:generalTracksigmatmtd"));
2146   desc.add<edm::InputTag>("tracksPosMtd", edm::InputTag("trackExtenderWithMTD:generalTrackmtdpos"));
2147   desc.add<edm::InputTag>("trackstersmerged", edm::InputTag("ticlTrackstersMerge"));
2148   desc.add<edm::InputTag>("muons", edm::InputTag("muons1stStep"));
2149   desc.add<edm::InputTag>("simtrackstersSC", edm::InputTag("ticlSimTracksters"));
2150   desc.add<edm::InputTag>("simtrackstersCP", edm::InputTag("ticlSimTracksters", "fromCPs"));
2151   desc.add<edm::InputTag>("simtrackstersPU", edm::InputTag("ticlSimTracksters", "PU"));
2152   desc.add<edm::InputTag>("simTICLCandidates", edm::InputTag("ticlSimTracksters"));
2153   desc.add<edm::InputTag>("recoToSimAssociatorSC",
2154                           edm::InputTag("tracksterSimTracksterAssociationPRbyCLUE3D", "recoToSim"));
2155   desc.add<edm::InputTag>("simToRecoAssociatorSC",
2156                           edm::InputTag("tracksterSimTracksterAssociationPRbyCLUE3D", "simToReco"));
2157   desc.add<edm::InputTag>("recoToSimAssociatorCP",
2158                           edm::InputTag("tracksterSimTracksterAssociationLinkingbyCLUE3D", "recoToSim"));
2159   desc.add<edm::InputTag>("simToRecoAssociatorCP",
2160                           edm::InputTag("tracksterSimTracksterAssociationLinkingbyCLUE3D", "simToReco"));
2161   desc.add<edm::InputTag>("MergerecoToSimAssociatorSC",
2162                           edm::InputTag("tracksterSimTracksterAssociationPR", "recoToSim"));
2163   desc.add<edm::InputTag>("MergesimToRecoAssociatorSC",
2164                           edm::InputTag("tracksterSimTracksterAssociationPR", "simToReco"));
2165   desc.add<edm::InputTag>("MergerecoToSimAssociatorCP",
2166                           edm::InputTag("tracksterSimTracksterAssociationLinking", "recoToSim"));
2167   desc.add<edm::InputTag>("MergesimToRecoAssociatorCP",
2168                           edm::InputTag("tracksterSimTracksterAssociationLinking", "simToReco"));
2169   desc.add<edm::InputTag>("MergerecoToSimAssociatorPU",
2170                           edm::InputTag("tracksterSimTracksterAssociationLinkingPU", "recoToSim"));
2171   desc.add<edm::InputTag>("MergesimToRecoAssociatorPU",
2172                           edm::InputTag("tracksterSimTracksterAssociationLinkingPU", "simToReco"));
2173   desc.add<edm::InputTag>("simclusters", edm::InputTag("mix", "MergedCaloTruth"));
2174   desc.add<edm::InputTag>("caloparticles", edm::InputTag("mix", "MergedCaloTruth"));
2175   desc.add<std::string>("detector", "HGCAL");
2176   desc.add<std::string>("propagator", "PropagatorWithMaterial");
2177 
2178   desc.add<bool>("saveLCs", true);
2179   desc.add<bool>("saveCLUE3DTracksters", true);
2180   desc.add<bool>("saveTrackstersMerged", true);
2181   desc.add<bool>("saveSimTrackstersSC", true);
2182   desc.add<bool>("saveSimTrackstersCP", true);
2183   desc.add<bool>("saveTICLCandidate", true);
2184   desc.add<bool>("saveSimTICLCandidate", true);
2185   desc.add<bool>("saveTracks", true);
2186   desc.add<bool>("saveAssociations", true);
2187   descriptions.add("ticlDumper", desc);
2188 }
2189 
2190 DEFINE_FWK_MODULE(TICLDumper);
[ 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!