File indexing completed on 2022-02-21 23:14:28
0001 #include "TTreeValidation.h"
0002 #include "Event.h"
0003 #include "RecoTracker/MkFitCore/interface/Config.h"
0004 #include "RecoTracker/MkFitCore/standalone/ConfigStandalone.h"
0005 #include "RecoTracker/MkFitCore/interface/IterationConfig.h"
0006
0007 #ifndef NO_ROOT
0008
0009 namespace mkfit {
0010
0011 TTreeValidation::TTreeValidation(std::string fileName, const TrackerInfo* trk_info) {
0012 std::lock_guard<std::mutex> locker(glock_);
0013 gROOT->ProcessLine("#include <vector>");
0014
0015 ntotallayers_fit_ = trk_info->n_layers();
0016
0017
0018
0019
0020
0021
0022 TDirectory::TContext contextEraser;
0023 f_ = std::unique_ptr<TFile>(TFile::Open(fileName.c_str(), "recreate"));
0024
0025 if (Config::sim_val_for_cmssw || Config::sim_val) {
0026 TTreeValidation::initializeEfficiencyTree();
0027 TTreeValidation::initializeFakeRateTree();
0028 }
0029 if (Config::cmssw_val) {
0030 TTreeValidation::initializeCMSSWEfficiencyTree();
0031 TTreeValidation::initializeCMSSWFakeRateTree();
0032 }
0033 if (Config::fit_val) {
0034 for (int i = 0; i < nfvs_; ++i)
0035 fvs_[i].resize(ntotallayers_fit_);
0036 TTreeValidation::initializeFitTree();
0037 }
0038 TTreeValidation::initializeConfigTree();
0039 }
0040
0041 void TTreeValidation::initializeEfficiencyTree() {
0042
0043 efftree_ = std::make_unique<TTree>("efftree", "efftree");
0044 efftree_->SetDirectory(0);
0045
0046 efftree_->Branch("evtID", &evtID_eff_);
0047 efftree_->Branch("mcID", &mcID_eff_);
0048
0049 efftree_->Branch("nHits_mc", &nHits_mc_eff_);
0050 efftree_->Branch("nLayers_mc", &nLayers_mc_eff_);
0051 efftree_->Branch("lastlyr_mc", &lastlyr_mc_eff_);
0052
0053 efftree_->Branch("seedID_seed", &seedID_seed_eff_);
0054 efftree_->Branch("seedID_build", &seedID_build_eff_);
0055 efftree_->Branch("seedID_fit", &seedID_fit_eff_);
0056
0057 efftree_->Branch("x_mc_gen", &x_mc_gen_eff_);
0058 efftree_->Branch("y_mc_gen", &y_mc_gen_eff_);
0059 efftree_->Branch("z_mc_gen", &z_mc_gen_eff_);
0060
0061 efftree_->Branch("pt_mc_gen", &pt_mc_gen_eff_);
0062 efftree_->Branch("phi_mc_gen", &phi_mc_gen_eff_);
0063 efftree_->Branch("eta_mc_gen", &eta_mc_gen_eff_);
0064
0065 efftree_->Branch("mcmask_seed", &mcmask_seed_eff_);
0066 efftree_->Branch("mcmask_build", &mcmask_build_eff_);
0067 efftree_->Branch("mcmask_fit", &mcmask_fit_eff_);
0068
0069 efftree_->Branch("mcTSmask_seed", &mcTSmask_seed_eff_);
0070 efftree_->Branch("mcTSmask_build", &mcTSmask_build_eff_);
0071 efftree_->Branch("mcTSmask_fit", &mcTSmask_fit_eff_);
0072
0073 efftree_->Branch("xhit_seed", &xhit_seed_eff_);
0074 efftree_->Branch("xhit_build", &xhit_build_eff_);
0075 efftree_->Branch("xhit_fit", &xhit_fit_eff_);
0076
0077 efftree_->Branch("yhit_seed", &yhit_seed_eff_);
0078 efftree_->Branch("yhit_build", &yhit_build_eff_);
0079 efftree_->Branch("yhit_fit", &yhit_fit_eff_);
0080
0081 efftree_->Branch("zhit_seed", &zhit_seed_eff_);
0082 efftree_->Branch("zhit_build", &zhit_build_eff_);
0083 efftree_->Branch("zhit_fit", &zhit_fit_eff_);
0084
0085 efftree_->Branch("pt_mc_seed", &pt_mc_seed_eff_);
0086 efftree_->Branch("pt_seed", &pt_seed_eff_);
0087 efftree_->Branch("ept_seed", &ept_seed_eff_);
0088 efftree_->Branch("pt_mc_build", &pt_mc_build_eff_);
0089 efftree_->Branch("pt_build", &pt_build_eff_);
0090 efftree_->Branch("ept_build", &ept_build_eff_);
0091 efftree_->Branch("pt_mc_fit", &pt_mc_fit_eff_);
0092 efftree_->Branch("pt_fit", &pt_fit_eff_);
0093 efftree_->Branch("ept_fit", &ept_fit_eff_);
0094
0095 efftree_->Branch("phi_mc_seed", &phi_mc_seed_eff_);
0096 efftree_->Branch("phi_seed", &phi_seed_eff_);
0097 efftree_->Branch("ephi_seed", &ephi_seed_eff_);
0098 efftree_->Branch("phi_mc_build", &phi_mc_build_eff_);
0099 efftree_->Branch("phi_build", &phi_build_eff_);
0100 efftree_->Branch("ephi_build", &ephi_build_eff_);
0101 efftree_->Branch("phi_mc_fit", &phi_mc_fit_eff_);
0102 efftree_->Branch("phi_fit", &phi_fit_eff_);
0103 efftree_->Branch("ephi_fit", &ephi_fit_eff_);
0104
0105 efftree_->Branch("eta_mc_seed", &eta_mc_seed_eff_);
0106 efftree_->Branch("eta_seed", &eta_seed_eff_);
0107 efftree_->Branch("eeta_seed", &eeta_seed_eff_);
0108 efftree_->Branch("eta_mc_build", &eta_mc_build_eff_);
0109 efftree_->Branch("eta_build", &eta_build_eff_);
0110 efftree_->Branch("eeta_build", &eeta_build_eff_);
0111 efftree_->Branch("eta_mc_fit", &eta_mc_fit_eff_);
0112 efftree_->Branch("eta_fit", &eta_fit_eff_);
0113 efftree_->Branch("eeta_fit", &eeta_fit_eff_);
0114
0115 efftree_->Branch("nHits_seed", &nHits_seed_eff_);
0116 efftree_->Branch("nHits_build", &nHits_build_eff_);
0117 efftree_->Branch("nHits_fit", &nHits_fit_eff_);
0118
0119 efftree_->Branch("nLayers_seed", &nLayers_seed_eff_);
0120 efftree_->Branch("nLayers_build", &nLayers_build_eff_);
0121 efftree_->Branch("nLayers_fit", &nLayers_fit_eff_);
0122
0123 efftree_->Branch("nHitsMatched_seed", &nHitsMatched_seed_eff_);
0124 efftree_->Branch("nHitsMatched_build", &nHitsMatched_build_eff_);
0125 efftree_->Branch("nHitsMatched_fit", &nHitsMatched_fit_eff_);
0126
0127 efftree_->Branch("fracHitsMatched_seed", &fracHitsMatched_seed_eff_);
0128 efftree_->Branch("fracHitsMatched_build", &fracHitsMatched_build_eff_);
0129 efftree_->Branch("fracHitsMatched_fit", &fracHitsMatched_fit_eff_);
0130
0131 efftree_->Branch("lastlyr_seed", &lastlyr_seed_eff_);
0132 efftree_->Branch("lastlyr_build", &lastlyr_build_eff_);
0133 efftree_->Branch("lastlyr_fit", &lastlyr_fit_eff_);
0134
0135 efftree_->Branch("dphi_seed", &dphi_seed_eff_);
0136 efftree_->Branch("dphi_build", &dphi_build_eff_);
0137 efftree_->Branch("dphi_fit", &dphi_fit_eff_);
0138
0139 efftree_->Branch("hitchi2_seed", &hitchi2_seed_eff_);
0140 efftree_->Branch("hitchi2_build", &hitchi2_build_eff_);
0141 efftree_->Branch("hitchi2_fit", &hitchi2_fit_eff_);
0142
0143 efftree_->Branch("score_seed", &score_seed_eff_);
0144 efftree_->Branch("score_build", &score_build_eff_);
0145 efftree_->Branch("score_fit", &score_fit_eff_);
0146
0147 efftree_->Branch("helixchi2_seed", &helixchi2_seed_eff_);
0148 efftree_->Branch("helixchi2_build", &helixchi2_build_eff_);
0149 efftree_->Branch("helixchi2_fit", &helixchi2_fit_eff_);
0150
0151 efftree_->Branch("duplmask_seed", &duplmask_seed_eff_);
0152 efftree_->Branch("duplmask_build", &duplmask_build_eff_);
0153 efftree_->Branch("duplmask_fit", &duplmask_fit_eff_);
0154
0155 efftree_->Branch("nTkMatches_seed", &nTkMatches_seed_eff_);
0156 efftree_->Branch("nTkMatches_build", &nTkMatches_build_eff_);
0157 efftree_->Branch("nTkMatches_fit", &nTkMatches_fit_eff_);
0158
0159 efftree_->Branch("itermask_seed", &itermask_seed_eff_);
0160 efftree_->Branch("itermask_build", &itermask_build_eff_);
0161 efftree_->Branch("itermask_fit", &itermask_fit_eff_);
0162 efftree_->Branch("iterduplmask_seed", &iterduplmask_seed_eff_);
0163 efftree_->Branch("iterduplmask_build", &iterduplmask_build_eff_);
0164 efftree_->Branch("iterduplmask_fit", &iterduplmask_fit_eff_);
0165 efftree_->Branch("algo_seed", &algo_seed_eff_);
0166
0167 if (Config::keepHitInfo) {
0168 efftree_->Branch("hitlyrs_mc", &hitlyrs_mc_eff_);
0169 efftree_->Branch("hitlyrs_seed", &hitlyrs_seed_eff_);
0170 efftree_->Branch("hitlyrs_build", &hitlyrs_build_eff_);
0171 efftree_->Branch("hitlyrs_fit", &hitlyrs_fit_eff_);
0172
0173 efftree_->Branch("hitidxs_mc", &hitidxs_mc_eff_);
0174 efftree_->Branch("hitidxs_seed", &hitidxs_seed_eff_);
0175 efftree_->Branch("hitidxs_build", &hitidxs_build_eff_);
0176 efftree_->Branch("hitidxs_fit", &hitidxs_fit_eff_);
0177
0178 efftree_->Branch("hitmcTkIDs_mc", &hitmcTkIDs_mc_eff_);
0179 efftree_->Branch("hitmcTkIDs_seed", &hitmcTkIDs_seed_eff_);
0180 efftree_->Branch("hitmcTkIDs_build", &hitmcTkIDs_build_eff_);
0181 efftree_->Branch("hitmcTkIDs_fit", &hitmcTkIDs_fit_eff_);
0182
0183 efftree_->Branch("hitxs_mc", &hitxs_mc_eff_);
0184 efftree_->Branch("hitxs_seed", &hitxs_seed_eff_);
0185 efftree_->Branch("hitxs_build", &hitxs_build_eff_);
0186 efftree_->Branch("hitxs_fit", &hitxs_fit_eff_);
0187
0188 efftree_->Branch("hitys_mc", &hitys_mc_eff_);
0189 efftree_->Branch("hitys_seed", &hitys_seed_eff_);
0190 efftree_->Branch("hitys_build", &hitys_build_eff_);
0191 efftree_->Branch("hitys_fit", &hitys_fit_eff_);
0192
0193 efftree_->Branch("hitzs_mc", &hitzs_mc_eff_);
0194 efftree_->Branch("hitzs_seed", &hitzs_seed_eff_);
0195 efftree_->Branch("hitzs_build", &hitzs_build_eff_);
0196 efftree_->Branch("hitzs_fit", &hitzs_fit_eff_);
0197 }
0198 }
0199
0200 void TTreeValidation::initializeFakeRateTree() {
0201
0202 frtree_ = std::make_unique<TTree>("frtree", "frtree");
0203 frtree_->SetDirectory(0);
0204
0205 frtree_->Branch("evtID", &evtID_FR_);
0206 frtree_->Branch("seedID", &seedID_FR_);
0207
0208 frtree_->Branch("seedmask_seed", &seedmask_seed_FR_);
0209 frtree_->Branch("seedmask_build", &seedmask_build_FR_);
0210 frtree_->Branch("seedmask_fit", &seedmask_fit_FR_);
0211
0212 frtree_->Branch("xhit_seed", &xhit_seed_FR_);
0213 frtree_->Branch("xhit_build", &xhit_build_FR_);
0214 frtree_->Branch("xhit_fit", &xhit_fit_FR_);
0215
0216 frtree_->Branch("yhit_seed", &yhit_seed_FR_);
0217 frtree_->Branch("yhit_build", &yhit_build_FR_);
0218 frtree_->Branch("yhit_fit", &yhit_fit_FR_);
0219
0220 frtree_->Branch("zhit_seed", &zhit_seed_FR_);
0221 frtree_->Branch("zhit_build", &zhit_build_FR_);
0222 frtree_->Branch("zhit_fit", &zhit_fit_FR_);
0223
0224 frtree_->Branch("pt_seed", &pt_seed_FR_);
0225 frtree_->Branch("ept_seed", &ept_seed_FR_);
0226 frtree_->Branch("pt_build", &pt_build_FR_);
0227 frtree_->Branch("ept_build", &ept_build_FR_);
0228 frtree_->Branch("pt_fit", &pt_fit_FR_);
0229 frtree_->Branch("ept_fit", &ept_fit_FR_);
0230
0231 frtree_->Branch("phi_seed", &phi_seed_FR_);
0232 frtree_->Branch("ephi_seed", &ephi_seed_FR_);
0233 frtree_->Branch("phi_build", &phi_build_FR_);
0234 frtree_->Branch("ephi_build", &ephi_build_FR_);
0235 frtree_->Branch("phi_fit", &phi_fit_FR_);
0236 frtree_->Branch("ephi_fit", &ephi_fit_FR_);
0237
0238 frtree_->Branch("eta_seed", &eta_seed_FR_);
0239 frtree_->Branch("eeta_seed", &eeta_seed_FR_);
0240 frtree_->Branch("eta_build", &eta_build_FR_);
0241 frtree_->Branch("eeta_build", &eeta_build_FR_);
0242 frtree_->Branch("eta_fit", &eta_fit_FR_);
0243 frtree_->Branch("eeta_fit", &eeta_fit_FR_);
0244
0245 frtree_->Branch("nHits_seed", &nHits_seed_FR_);
0246 frtree_->Branch("nHits_build", &nHits_build_FR_);
0247 frtree_->Branch("nHits_fit", &nHits_fit_FR_);
0248
0249 frtree_->Branch("nLayers_seed", &nLayers_seed_FR_);
0250 frtree_->Branch("nLayers_build", &nLayers_build_FR_);
0251 frtree_->Branch("nLayers_fit", &nLayers_fit_FR_);
0252
0253 frtree_->Branch("nHitsMatched_seed", &nHitsMatched_seed_FR_);
0254 frtree_->Branch("nHitsMatched_build", &nHitsMatched_build_FR_);
0255 frtree_->Branch("nHitsMatched_fit", &nHitsMatched_fit_FR_);
0256
0257 frtree_->Branch("fracHitsMatched_seed", &fracHitsMatched_seed_FR_);
0258 frtree_->Branch("fracHitsMatched_build", &fracHitsMatched_build_FR_);
0259 frtree_->Branch("fracHitsMatched_fit", &fracHitsMatched_fit_FR_);
0260
0261 frtree_->Branch("lastlyr_seed", &lastlyr_seed_FR_);
0262 frtree_->Branch("lastlyr_build", &lastlyr_build_FR_);
0263 frtree_->Branch("lastlyr_fit", &lastlyr_fit_FR_);
0264
0265 frtree_->Branch("dphi_seed", &dphi_seed_FR_);
0266 frtree_->Branch("dphi_build", &dphi_build_FR_);
0267 frtree_->Branch("dphi_fit", &dphi_fit_FR_);
0268
0269 frtree_->Branch("hitchi2_seed", &hitchi2_seed_FR_);
0270 frtree_->Branch("hitchi2_build", &hitchi2_build_FR_);
0271 frtree_->Branch("hitchi2_fit", &hitchi2_fit_FR_);
0272
0273 frtree_->Branch("score_seed", &score_seed_FR_);
0274 frtree_->Branch("score_build", &score_build_FR_);
0275 frtree_->Branch("score_fit", &score_fit_FR_);
0276
0277
0278 frtree_->Branch("mcID_seed", &mcID_seed_FR_);
0279 frtree_->Branch("mcID_build", &mcID_build_FR_);
0280 frtree_->Branch("mcID_fit", &mcID_fit_FR_);
0281
0282 frtree_->Branch("mcmask_seed", &mcmask_seed_FR_);
0283 frtree_->Branch("mcmask_build", &mcmask_build_FR_);
0284 frtree_->Branch("mcmask_fit", &mcmask_fit_FR_);
0285
0286 frtree_->Branch("mcTSmask_seed", &mcTSmask_seed_FR_);
0287 frtree_->Branch("mcTSmask_build", &mcTSmask_build_FR_);
0288 frtree_->Branch("mcTSmask_fit", &mcTSmask_fit_FR_);
0289
0290 frtree_->Branch("pt_mc_seed", &pt_mc_seed_FR_);
0291 frtree_->Branch("pt_mc_build", &pt_mc_build_FR_);
0292 frtree_->Branch("pt_mc_fit", &pt_mc_fit_FR_);
0293
0294 frtree_->Branch("phi_mc_seed", &phi_mc_seed_FR_);
0295 frtree_->Branch("phi_mc_build", &phi_mc_build_FR_);
0296 frtree_->Branch("phi_mc_fit", &phi_mc_fit_FR_);
0297
0298 frtree_->Branch("eta_mc_seed", &eta_mc_seed_FR_);
0299 frtree_->Branch("eta_mc_build", &eta_mc_build_FR_);
0300 frtree_->Branch("eta_mc_fit", &eta_mc_fit_FR_);
0301
0302 frtree_->Branch("nHits_mc_seed", &nHits_mc_seed_FR_);
0303 frtree_->Branch("nHits_mc_build", &nHits_mc_build_FR_);
0304 frtree_->Branch("nHits_mc_fit", &nHits_mc_fit_FR_);
0305
0306 frtree_->Branch("nLayers_mc_seed", &nLayers_mc_seed_FR_);
0307 frtree_->Branch("nLayers_mc_build", &nLayers_mc_build_FR_);
0308 frtree_->Branch("nLayers_mc_fit", &nLayers_mc_fit_FR_);
0309
0310 frtree_->Branch("lastlyr_mc_seed", &lastlyr_mc_seed_FR_);
0311 frtree_->Branch("lastlyr_mc_build", &lastlyr_mc_build_FR_);
0312 frtree_->Branch("lastlyr_mc_fit", &lastlyr_mc_fit_FR_);
0313
0314 frtree_->Branch("helixchi2_seed", &helixchi2_seed_FR_);
0315 frtree_->Branch("helixchi2_build", &helixchi2_build_FR_);
0316 frtree_->Branch("helixchi2_fit", &helixchi2_fit_FR_);
0317
0318 frtree_->Branch("duplmask_seed", &duplmask_seed_FR_);
0319 frtree_->Branch("duplmask_build", &duplmask_build_FR_);
0320 frtree_->Branch("duplmask_fit", &duplmask_fit_FR_);
0321
0322 frtree_->Branch("iTkMatches_seed", &iTkMatches_seed_FR_);
0323 frtree_->Branch("iTkMatches_build", &iTkMatches_build_FR_);
0324 frtree_->Branch("iTkMatches_fit", &iTkMatches_fit_FR_);
0325
0326 frtree_->Branch("algorithm", &algorithm_FR_);
0327
0328 if (Config::keepHitInfo) {
0329 frtree_->Branch("hitlyrs_seed", &hitlyrs_seed_FR_);
0330 frtree_->Branch("hitlyrs_mc_seed", &hitlyrs_mc_seed_FR_);
0331 frtree_->Branch("hitlyrs_build", &hitlyrs_build_FR_);
0332 frtree_->Branch("hitlyrs_mc_build", &hitlyrs_mc_build_FR_);
0333 frtree_->Branch("hitlyrs_fit", &hitlyrs_fit_FR_);
0334 frtree_->Branch("hitlyrs_mc_fit", &hitlyrs_mc_fit_FR_);
0335
0336 frtree_->Branch("hitidxs_seed", &hitidxs_seed_FR_);
0337 frtree_->Branch("hitidxs_mc_seed", &hitidxs_mc_seed_FR_);
0338 frtree_->Branch("hitidxs_build", &hitidxs_build_FR_);
0339 frtree_->Branch("hitidxs_mc_build", &hitidxs_mc_build_FR_);
0340 frtree_->Branch("hitidxs_fit", &hitidxs_fit_FR_);
0341 frtree_->Branch("hitidxs_mc_fit", &hitidxs_mc_fit_FR_);
0342
0343 frtree_->Branch("hitmcTkIDs_seed", &hitmcTkIDs_seed_FR_);
0344 frtree_->Branch("hitmcTkIDs_mc_seed", &hitmcTkIDs_mc_seed_FR_);
0345 frtree_->Branch("hitmcTkIDs_build", &hitmcTkIDs_build_FR_);
0346 frtree_->Branch("hitmcTkIDs_mc_build", &hitmcTkIDs_mc_build_FR_);
0347 frtree_->Branch("hitmcTkIDs_fit", &hitmcTkIDs_fit_FR_);
0348 frtree_->Branch("hitmcTkIDs_mc_fit", &hitmcTkIDs_mc_fit_FR_);
0349
0350 frtree_->Branch("hitxs_seed", &hitxs_seed_FR_);
0351 frtree_->Branch("hitxs_mc_seed", &hitxs_mc_seed_FR_);
0352 frtree_->Branch("hitxs_build", &hitxs_build_FR_);
0353 frtree_->Branch("hitxs_mc_build", &hitxs_mc_build_FR_);
0354 frtree_->Branch("hitxs_fit", &hitxs_fit_FR_);
0355 frtree_->Branch("hitxs_mc_fit", &hitxs_mc_fit_FR_);
0356
0357 frtree_->Branch("hitys_seed", &hitys_seed_FR_);
0358 frtree_->Branch("hitys_mc_seed", &hitys_mc_seed_FR_);
0359 frtree_->Branch("hitys_build", &hitys_build_FR_);
0360 frtree_->Branch("hitys_mc_build", &hitys_mc_build_FR_);
0361 frtree_->Branch("hitys_fit", &hitys_fit_FR_);
0362 frtree_->Branch("hitys_mc_fit", &hitys_mc_fit_FR_);
0363
0364 frtree_->Branch("hitzs_seed", &hitzs_seed_FR_);
0365 frtree_->Branch("hitzs_mc_seed", &hitzs_mc_seed_FR_);
0366 frtree_->Branch("hitzs_build", &hitzs_build_FR_);
0367 frtree_->Branch("hitzs_mc_build", &hitzs_mc_build_FR_);
0368 frtree_->Branch("hitzs_fit", &hitzs_fit_FR_);
0369 frtree_->Branch("hitzs_mc_fit", &hitzs_mc_fit_FR_);
0370 }
0371 }
0372
0373 void TTreeValidation::initializeConfigTree() {
0374
0375 configtree_ = std::make_unique<TTree>("configtree", "configtree");
0376 configtree_->SetDirectory(0);
0377
0378 configtree_->Branch("Ntracks", &Ntracks_);
0379 configtree_->Branch("Nevents", &Nevents_);
0380
0381 configtree_->Branch("nLayers", &nLayers_);
0382
0383 configtree_->Branch("nlayers_per_seed", &nlayers_per_seed_);
0384 configtree_->Branch("maxCand", &maxCand_);
0385 configtree_->Branch("chi2Cut_min", &chi2Cut_min_);
0386 configtree_->Branch("nSigma", &nSigma_);
0387 configtree_->Branch("minDPhi", &minDPhi_);
0388 configtree_->Branch("maxDPhi", &maxDPhi_);
0389 configtree_->Branch("minDEta", &minDEta_);
0390 configtree_->Branch("maxDEta", &maxDEta_);
0391
0392 configtree_->Branch("beamspotX", &beamspotX_);
0393 configtree_->Branch("beamspotY", &beamspotY_);
0394 configtree_->Branch("beamspotZ", &beamspotZ_);
0395
0396 configtree_->Branch("minSimPt", &minSimPt_);
0397 configtree_->Branch("maxSimPt", &maxSimPt_);
0398
0399 configtree_->Branch("hitposerrXY", &hitposerrXY_);
0400 configtree_->Branch("hitposerrZ", &hitposerrZ_);
0401 configtree_->Branch("hitposerrR", &hitposerrR_);
0402
0403 configtree_->Branch("varXY", &varXY_);
0404 configtree_->Branch("varZ", &varZ_);
0405
0406 configtree_->Branch("ptinverr049", &ptinverr049_);
0407 configtree_->Branch("phierr049", &phierr049_);
0408 configtree_->Branch("thetaerr049", &thetaerr049_);
0409 configtree_->Branch("ptinverr012", &ptinverr012_);
0410 configtree_->Branch("phierr012", &phierr012_);
0411 configtree_->Branch("thetaerr012", &thetaerr012_);
0412 }
0413
0414 void TTreeValidation::initializeCMSSWEfficiencyTree() {
0415
0416 cmsswefftree_ = std::make_unique<TTree>("cmsswefftree", "cmsswefftree");
0417 cmsswefftree_->SetDirectory(0);
0418
0419 cmsswefftree_->Branch("evtID", &evtID_ceff_);
0420 cmsswefftree_->Branch("cmsswID", &cmsswID_ceff_);
0421 cmsswefftree_->Branch("seedID_cmssw", &seedID_cmssw_ceff_);
0422
0423
0424 cmsswefftree_->Branch("x_cmssw", &x_cmssw_ceff_);
0425 cmsswefftree_->Branch("y_cmssw", &y_cmssw_ceff_);
0426 cmsswefftree_->Branch("z_cmssw", &z_cmssw_ceff_);
0427
0428 cmsswefftree_->Branch("pt_cmssw", &pt_cmssw_ceff_);
0429 cmsswefftree_->Branch("phi_cmssw", &phi_cmssw_ceff_);
0430 cmsswefftree_->Branch("eta_cmssw", &eta_cmssw_ceff_);
0431
0432 cmsswefftree_->Branch("nHits_cmssw", &nHits_cmssw_ceff_);
0433 cmsswefftree_->Branch("nLayers_cmssw", &nLayers_cmssw_ceff_);
0434 cmsswefftree_->Branch("lastlyr_cmssw", &lastlyr_cmssw_ceff_);
0435
0436
0437 cmsswefftree_->Branch("cmsswmask_build", &cmsswmask_build_ceff_);
0438 cmsswefftree_->Branch("seedID_build", &seedID_build_ceff_);
0439 cmsswefftree_->Branch("mcTrackID_build", &mcTrackID_build_ceff_);
0440
0441 cmsswefftree_->Branch("pt_build", &pt_build_ceff_);
0442 cmsswefftree_->Branch("ept_build", &ept_build_ceff_);
0443 cmsswefftree_->Branch("phi_build", &phi_build_ceff_);
0444 cmsswefftree_->Branch("ephi_build", &ephi_build_ceff_);
0445 cmsswefftree_->Branch("eta_build", &eta_build_ceff_);
0446 cmsswefftree_->Branch("eeta_build", &eeta_build_ceff_);
0447
0448 cmsswefftree_->Branch("x_mc_build", &x_mc_build_ceff_);
0449 cmsswefftree_->Branch("y_mc_build", &y_mc_build_ceff_);
0450 cmsswefftree_->Branch("z_mc_build", &z_mc_build_ceff_);
0451 cmsswefftree_->Branch("pt_mc_build", &pt_mc_build_ceff_);
0452 cmsswefftree_->Branch("phi_mc_build", &phi_mc_build_ceff_);
0453 cmsswefftree_->Branch("eta_mc_build", &eta_mc_build_ceff_);
0454
0455 cmsswefftree_->Branch("nHits_build", &nHits_build_ceff_);
0456 cmsswefftree_->Branch("nLayers_build", &nLayers_build_ceff_);
0457 cmsswefftree_->Branch("nHitsMatched_build", &nHitsMatched_build_ceff_);
0458 cmsswefftree_->Branch("fracHitsMatched_build", &fracHitsMatched_build_ceff_);
0459 cmsswefftree_->Branch("lastlyr_build", &lastlyr_build_ceff_);
0460
0461 cmsswefftree_->Branch("xhit_build", &xhit_build_ceff_);
0462 cmsswefftree_->Branch("yhit_build", &yhit_build_ceff_);
0463 cmsswefftree_->Branch("zhit_build", &zhit_build_ceff_);
0464
0465 cmsswefftree_->Branch("hitchi2_build", &hitchi2_build_ceff_);
0466 cmsswefftree_->Branch("helixchi2_build", &helixchi2_build_ceff_);
0467 cmsswefftree_->Branch("score_build", &score_build_ceff_);
0468 cmsswefftree_->Branch("dphi_build", &dphi_build_ceff_);
0469
0470 cmsswefftree_->Branch("duplmask_build", &duplmask_build_ceff_);
0471 cmsswefftree_->Branch("nTkMatches_build", &nTkMatches_build_ceff_);
0472
0473 cmsswefftree_->Branch("itermask_build", &itermask_build_ceff_);
0474 cmsswefftree_->Branch("iterduplmask_build", &iterduplmask_build_ceff_);
0475
0476
0477 cmsswefftree_->Branch("cmsswmask_fit", &cmsswmask_fit_ceff_);
0478 cmsswefftree_->Branch("seedID_fit", &seedID_fit_ceff_);
0479 cmsswefftree_->Branch("mcTrackID_fit", &mcTrackID_fit_ceff_);
0480
0481 cmsswefftree_->Branch("pt_fit", &pt_fit_ceff_);
0482 cmsswefftree_->Branch("ept_fit", &ept_fit_ceff_);
0483 cmsswefftree_->Branch("phi_fit", &phi_fit_ceff_);
0484 cmsswefftree_->Branch("ephi_fit", &ephi_fit_ceff_);
0485 cmsswefftree_->Branch("eta_fit", &eta_fit_ceff_);
0486 cmsswefftree_->Branch("eeta_fit", &eeta_fit_ceff_);
0487
0488 cmsswefftree_->Branch("x_mc_fit", &x_mc_fit_ceff_);
0489 cmsswefftree_->Branch("y_mc_fit", &y_mc_fit_ceff_);
0490 cmsswefftree_->Branch("z_mc_fit", &z_mc_fit_ceff_);
0491 cmsswefftree_->Branch("pt_mc_fit", &pt_mc_fit_ceff_);
0492 cmsswefftree_->Branch("phi_mc_fit", &phi_mc_fit_ceff_);
0493 cmsswefftree_->Branch("eta_mc_fit", &eta_mc_fit_ceff_);
0494
0495 cmsswefftree_->Branch("nHits_fit", &nHits_fit_ceff_);
0496 cmsswefftree_->Branch("nLayers_fit", &nLayers_fit_ceff_);
0497 cmsswefftree_->Branch("nHitsMatched_fit", &nHitsMatched_fit_ceff_);
0498 cmsswefftree_->Branch("fracHitsMatched_fit", &fracHitsMatched_fit_ceff_);
0499 cmsswefftree_->Branch("lastlyr_fit", &lastlyr_fit_ceff_);
0500
0501 cmsswefftree_->Branch("xhit_fit", &xhit_fit_ceff_);
0502 cmsswefftree_->Branch("yhit_fit", &yhit_fit_ceff_);
0503 cmsswefftree_->Branch("zhit_fit", &zhit_fit_ceff_);
0504
0505 cmsswefftree_->Branch("hitchi2_fit", &hitchi2_fit_ceff_);
0506 cmsswefftree_->Branch("helixchi2_fit", &helixchi2_fit_ceff_);
0507 cmsswefftree_->Branch("score_fit", &score_fit_ceff_);
0508 cmsswefftree_->Branch("dphi_fit", &dphi_fit_ceff_);
0509
0510 cmsswefftree_->Branch("duplmask_fit", &duplmask_fit_ceff_);
0511 cmsswefftree_->Branch("nTkMatches_fit", &nTkMatches_fit_ceff_);
0512
0513 cmsswefftree_->Branch("itermask_fit", &itermask_fit_ceff_);
0514 cmsswefftree_->Branch("iterduplmask_fit", &iterduplmask_fit_ceff_);
0515
0516 cmsswefftree_->Branch("algo_seed", &algo_seed_ceff_);
0517
0518 if (Config::keepHitInfo) {
0519 cmsswefftree_->Branch("hitlyrs_cmssw", &hitlyrs_cmssw_ceff_);
0520 cmsswefftree_->Branch("hitlyrs_build", &hitlyrs_build_ceff_);
0521 cmsswefftree_->Branch("hitlyrs_mc_build", &hitlyrs_mc_build_ceff_);
0522 cmsswefftree_->Branch("hitlyrs_fit", &hitlyrs_fit_ceff_);
0523 cmsswefftree_->Branch("hitlyrs_mc_fit", &hitlyrs_mc_fit_ceff_);
0524
0525 cmsswefftree_->Branch("hitidxs_cmssw", &hitidxs_cmssw_ceff_);
0526 cmsswefftree_->Branch("hitidxs_build", &hitidxs_build_ceff_);
0527 cmsswefftree_->Branch("hitidxs_mc_build", &hitidxs_mc_build_ceff_);
0528 cmsswefftree_->Branch("hitidxs_fit", &hitidxs_fit_ceff_);
0529 cmsswefftree_->Branch("hitidxs_mc_fit", &hitidxs_mc_fit_ceff_);
0530 }
0531 }
0532
0533 void TTreeValidation::initializeCMSSWFakeRateTree() {
0534
0535 cmsswfrtree_ = std::make_unique<TTree>("cmsswfrtree", "cmsswfrtree");
0536 cmsswfrtree_->SetDirectory(0);
0537
0538 cmsswfrtree_->Branch("evtID", &evtID_cFR_);
0539 cmsswfrtree_->Branch("seedID", &seedID_cFR_);
0540 cmsswfrtree_->Branch("mcTrackID", &mcTrackID_cFR_);
0541
0542
0543 cmsswfrtree_->Branch("x_mc", &x_mc_cFR_);
0544 cmsswfrtree_->Branch("y_mc", &y_mc_cFR_);
0545 cmsswfrtree_->Branch("z_mc", &z_mc_cFR_);
0546 cmsswfrtree_->Branch("pt_mc", &pt_mc_cFR_);
0547 cmsswfrtree_->Branch("phi_mc", &phi_mc_cFR_);
0548 cmsswfrtree_->Branch("eta_mc", &eta_mc_cFR_);
0549
0550
0551 cmsswfrtree_->Branch("cmsswID_build", &cmsswID_build_cFR_);
0552 cmsswfrtree_->Branch("cmsswmask_build", &cmsswmask_build_cFR_);
0553
0554 cmsswfrtree_->Branch("pt_build", &pt_build_cFR_);
0555 cmsswfrtree_->Branch("ept_build", &ept_build_cFR_);
0556 cmsswfrtree_->Branch("phi_build", &phi_build_cFR_);
0557 cmsswfrtree_->Branch("ephi_build", &ephi_build_cFR_);
0558 cmsswfrtree_->Branch("eta_build", &eta_build_cFR_);
0559 cmsswfrtree_->Branch("eeta_build", &eeta_build_cFR_);
0560
0561 cmsswfrtree_->Branch("nHits_build", &nHits_build_cFR_);
0562 cmsswfrtree_->Branch("nLayers_build", &nLayers_build_cFR_);
0563 cmsswfrtree_->Branch("nHitsMatched_build", &nHitsMatched_build_cFR_);
0564 cmsswfrtree_->Branch("fracHitsMatched_build", &fracHitsMatched_build_cFR_);
0565 cmsswfrtree_->Branch("lastlyr_build", &lastlyr_build_cFR_);
0566
0567 cmsswfrtree_->Branch("xhit_build", &xhit_build_cFR_);
0568 cmsswfrtree_->Branch("yhit_build", &yhit_build_cFR_);
0569 cmsswfrtree_->Branch("zhit_build", &zhit_build_cFR_);
0570
0571 cmsswfrtree_->Branch("hitchi2_build", &hitchi2_build_cFR_);
0572 cmsswfrtree_->Branch("helixchi2_build", &helixchi2_build_cFR_);
0573 cmsswfrtree_->Branch("score_build", &score_build_cFR_);
0574 cmsswfrtree_->Branch("dphi_build", &dphi_build_cFR_);
0575
0576 cmsswfrtree_->Branch("duplmask_build", &duplmask_build_cFR_);
0577 cmsswfrtree_->Branch("iTkMatches_build", &iTkMatches_build_cFR_);
0578
0579 cmsswfrtree_->Branch("seedID_cmssw_build", &seedID_cmssw_build_cFR_);
0580
0581 cmsswfrtree_->Branch("x_cmssw_build", &x_cmssw_build_cFR_);
0582 cmsswfrtree_->Branch("y_cmssw_build", &y_cmssw_build_cFR_);
0583 cmsswfrtree_->Branch("z_cmssw_build", &z_cmssw_build_cFR_);
0584
0585 cmsswfrtree_->Branch("pt_cmssw_build", &pt_cmssw_build_cFR_);
0586 cmsswfrtree_->Branch("phi_cmssw_build", &phi_cmssw_build_cFR_);
0587 cmsswfrtree_->Branch("eta_cmssw_build", &eta_cmssw_build_cFR_);
0588
0589 cmsswfrtree_->Branch("nHits_cmssw_build", &nHits_cmssw_build_cFR_);
0590 cmsswfrtree_->Branch("nLayers_cmssw_build", &nLayers_cmssw_build_cFR_);
0591 cmsswfrtree_->Branch("lastlyr_cmssw_build", &lastlyr_cmssw_build_cFR_);
0592
0593
0594 cmsswfrtree_->Branch("cmsswID_fit", &cmsswID_fit_cFR_);
0595 cmsswfrtree_->Branch("cmsswmask_fit", &cmsswmask_fit_cFR_);
0596
0597 cmsswfrtree_->Branch("pt_fit", &pt_fit_cFR_);
0598 cmsswfrtree_->Branch("ept_fit", &ept_fit_cFR_);
0599 cmsswfrtree_->Branch("phi_fit", &phi_fit_cFR_);
0600 cmsswfrtree_->Branch("ephi_fit", &ephi_fit_cFR_);
0601 cmsswfrtree_->Branch("eta_fit", &eta_fit_cFR_);
0602 cmsswfrtree_->Branch("eeta_fit", &eeta_fit_cFR_);
0603
0604 cmsswfrtree_->Branch("nHits_fit", &nHits_fit_cFR_);
0605 cmsswfrtree_->Branch("nLayers_fit", &nLayers_fit_cFR_);
0606 cmsswfrtree_->Branch("nHitsMatched_fit", &nHitsMatched_fit_cFR_);
0607 cmsswfrtree_->Branch("fracHitsMatched_fit", &fracHitsMatched_fit_cFR_);
0608 cmsswfrtree_->Branch("lastlyr_fit", &lastlyr_fit_cFR_);
0609
0610 cmsswfrtree_->Branch("xhit_fit", &xhit_fit_cFR_);
0611 cmsswfrtree_->Branch("yhit_fit", &yhit_fit_cFR_);
0612 cmsswfrtree_->Branch("zhit_fit", &zhit_fit_cFR_);
0613
0614 cmsswfrtree_->Branch("hitchi2_fit", &hitchi2_fit_cFR_);
0615 cmsswfrtree_->Branch("helixchi2_fit", &helixchi2_fit_cFR_);
0616 cmsswfrtree_->Branch("score_fit", &score_fit_cFR_);
0617 cmsswfrtree_->Branch("dphi_fit", &dphi_fit_cFR_);
0618
0619 cmsswfrtree_->Branch("duplmask_fit", &duplmask_fit_cFR_);
0620 cmsswfrtree_->Branch("iTkMatches_fit", &iTkMatches_fit_cFR_);
0621
0622 cmsswfrtree_->Branch("seedID_cmssw_fit", &seedID_cmssw_fit_cFR_);
0623
0624 cmsswfrtree_->Branch("x_cmssw_fit", &x_cmssw_fit_cFR_);
0625 cmsswfrtree_->Branch("y_cmssw_fit", &y_cmssw_fit_cFR_);
0626 cmsswfrtree_->Branch("z_cmssw_fit", &z_cmssw_fit_cFR_);
0627
0628 cmsswfrtree_->Branch("pt_cmssw_fit", &pt_cmssw_fit_cFR_);
0629 cmsswfrtree_->Branch("phi_cmssw_fit", &phi_cmssw_fit_cFR_);
0630 cmsswfrtree_->Branch("eta_cmssw_fit", &eta_cmssw_fit_cFR_);
0631
0632 cmsswfrtree_->Branch("nHits_cmssw_fit", &nHits_cmssw_fit_cFR_);
0633 cmsswfrtree_->Branch("nLayers_cmssw_fit", &nLayers_cmssw_fit_cFR_);
0634 cmsswfrtree_->Branch("lastlyr_cmssw_fit", &lastlyr_cmssw_fit_cFR_);
0635
0636 cmsswfrtree_->Branch("algorithm", &algorithm_cFR_);
0637
0638 if (Config::keepHitInfo) {
0639 cmsswfrtree_->Branch("hitlyrs_mc", &hitlyrs_mc_cFR_);
0640 cmsswfrtree_->Branch("hitlyrs_build", &hitlyrs_build_cFR_);
0641 cmsswfrtree_->Branch("hitlyrs_cmssw_build", &hitlyrs_cmssw_build_cFR_);
0642 cmsswfrtree_->Branch("hitlyrs_fit", &hitlyrs_fit_cFR_);
0643 cmsswfrtree_->Branch("hitlyrs_cmssw_fit", &hitlyrs_cmssw_fit_cFR_);
0644
0645 cmsswfrtree_->Branch("hitidxs_mc", &hitidxs_mc_cFR_);
0646 cmsswfrtree_->Branch("hitidxs_build", &hitidxs_build_cFR_);
0647 cmsswfrtree_->Branch("hitidxs_cmssw_build", &hitidxs_cmssw_build_cFR_);
0648 cmsswfrtree_->Branch("hitidxs_fit", &hitidxs_fit_cFR_);
0649 cmsswfrtree_->Branch("hitidxs_cmssw_fit", &hitidxs_cmssw_fit_cFR_);
0650 }
0651 }
0652
0653 void TTreeValidation::initializeFitTree() {
0654 fittree_ = std::make_unique<TTree>("fittree", "fittree");
0655 fittree_->SetDirectory(0);
0656
0657 fittree_->Branch("ntotallayers", &ntotallayers_fit_, "ntotallayers_fit_/I");
0658 fittree_->Branch("tkid", &tkid_fit_, "tkid_fit_/I");
0659 fittree_->Branch("evtid", &evtid_fit_, "evtid_fit_/I");
0660
0661 fittree_->Branch("z_prop", &z_prop_fit_, "z_prop_fit_[ntotallayers_fit_]/F");
0662 fittree_->Branch("ez_prop", &ez_prop_fit_, "ez_prop_fit_[ntotallayers_fit_]/F");
0663 fittree_->Branch("z_hit", &z_hit_fit_, "z_hit_fit_[ntotallayers_fit_]/F");
0664 fittree_->Branch("ez_hit", &ez_hit_fit_, "ez_hit_fit_[ntotallayers_fit_]/F");
0665 fittree_->Branch("z_sim", &z_sim_fit_, "z_sim_fit_[ntotallayers_fit_]/F");
0666 fittree_->Branch("ez_sim", &ez_sim_fit_, "ez_sim_fit_[ntotallayers_fit_]/F");
0667
0668 fittree_->Branch("pphi_prop", &pphi_prop_fit_, "pphi_prop_fit_[ntotallayers_fit_]/F");
0669 fittree_->Branch("epphi_prop", &epphi_prop_fit_, "epphi_prop_fit_[ntotallayers_fit_]/F");
0670 fittree_->Branch("pphi_hit", &pphi_hit_fit_, "pphi_hit_fit_[ntotallayers_fit_]/F");
0671 fittree_->Branch("epphi_hit", &epphi_hit_fit_, "epphi_hit_fit_[ntotallayers_fit_]/F");
0672 fittree_->Branch("pphi_sim", &pphi_sim_fit_, "pphi_sim_fit_[ntotallayers_fit_]/F");
0673 fittree_->Branch("epphi_sim", &epphi_sim_fit_, "epphi_sim_fit_[ntotallayers_fit_]/F");
0674
0675 fittree_->Branch("pt_up", &pt_up_fit_, "pt_up_fit_[ntotallayers_fit_]/F");
0676 fittree_->Branch("ept_up", &ept_up_fit_, "ept_up_fit_[ntotallayers_fit_]/F");
0677 fittree_->Branch("pt_sim", &pt_sim_fit_, "pt_sim_fit_[ntotallayers_fit_]/F");
0678 fittree_->Branch("ept_sim", &ept_sim_fit_, "ept_sim_fit_[ntotallayers_fit_]/F");
0679
0680 fittree_->Branch("mphi_up", &mphi_up_fit_, "mphi_up_fit_[ntotallayers_fit_]/F");
0681 fittree_->Branch("emphi_up", &emphi_up_fit_, "emphi_up_fit_[ntotallayers_fit_]/F");
0682 fittree_->Branch("mphi_sim", &mphi_sim_fit_, "mphi_sim_fit_[ntotallayers_fit_]/F");
0683 fittree_->Branch("emphi_sim", &emphi_sim_fit_, "emphi_sim_fit_[ntotallayers_fit_]/F");
0684
0685 fittree_->Branch("meta_up", &meta_up_fit_, "meta_up_fit_[ntotallayers_fit_]/F");
0686 fittree_->Branch("emeta_up", &emeta_up_fit_, "emeta_up_fit_[ntotallayers_fit_]/F");
0687 fittree_->Branch("meta_sim", &meta_sim_fit_, "meta_sim_fit_[ntotallayers_fit_]/F");
0688 fittree_->Branch("emeta_sim", &emeta_sim_fit_, "emeta_sim_fit_[ntotallayers_fit_]/F");
0689 }
0690
0691 void TTreeValidation::alignTracks(TrackVec& evt_tracks, TrackExtraVec& evt_extras, bool alignExtra) {
0692 std::lock_guard<std::mutex> locker(glock_);
0693
0694
0695 if (alignExtra) {
0696 TrackExtraVec trackExtra_tmp(evt_tracks.size());
0697
0698
0699 for (int itrack = 0; itrack < (int)evt_tracks.size(); itrack++) {
0700 trackExtra_tmp[itrack] = evt_extras[evt_tracks[itrack].label()];
0701 }
0702
0703
0704 evt_extras = trackExtra_tmp;
0705 }
0706
0707
0708 for (int itrack = 0; itrack < (int)evt_tracks.size(); itrack++) {
0709 evt_tracks[itrack].setLabel(itrack);
0710 }
0711 }
0712
0713 void TTreeValidation::collectFitInfo(const FitVal& tmpfitval, int tkid, int layer) {
0714 std::lock_guard<std::mutex> locker(glock_);
0715
0716 fitValTkMapMap_[tkid][layer] = tmpfitval;
0717 }
0718
0719 void TTreeValidation::resetValidationMaps() {
0720 std::lock_guard<std::mutex> locker(glock_);
0721
0722 fitValTkMapMap_.clear();
0723
0724
0725 simToSeedMap_.clear();
0726 simToBuildMap_.clear();
0727 simToFitMap_.clear();
0728
0729
0730 seedToBuildMap_.clear();
0731 seedToFitMap_.clear();
0732
0733
0734 cmsswToBuildMap_.clear();
0735 cmsswToFitMap_.clear();
0736
0737
0738 seedToCmsswMap_.clear();
0739 cmsswToSeedMap_.clear();
0740
0741
0742 buildToCmsswMap_.clear();
0743
0744
0745 buildToFitMap_.clear();
0746 fitToBuildMap_.clear();
0747
0748
0749 candToSeedMapDumbCMSSW_.clear();
0750 fitToSeedMapDumbCMSSW_.clear();
0751 }
0752
0753 void TTreeValidation::setTrackExtras(Event& ev) {
0754 std::lock_guard<std::mutex> locker(glock_);
0755
0756 const auto& layerhits = ev.layerHits_;
0757
0758 if (Config::sim_val_for_cmssw || Config::sim_val) {
0759 const auto& simhits = ev.simHitsInfo_;
0760 const auto& simtracks = ev.simTracks_;
0761 const auto& seedtracks = ev.seedTracks_;
0762 auto& seedextras = ev.seedTracksExtra_;
0763 const auto& buildtracks = ev.candidateTracks_;
0764 auto& buildextras = ev.candidateTracksExtra_;
0765 const auto& fittracks = ev.fitTracks_;
0766 auto& fitextras = ev.fitTracksExtra_;
0767
0768
0769 for (int itrack = 0; itrack < (int)seedtracks.size(); itrack++) {
0770 const auto& track = seedtracks[itrack];
0771 auto& extra = seedextras[itrack];
0772
0773 extra.findMatchingSeedHits(track, track, layerhits);
0774 extra.setMCTrackIDInfo(
0775 track,
0776 layerhits,
0777 simhits,
0778 simtracks,
0779 true,
0780 (Config::seedInput == simSeeds));
0781 }
0782
0783
0784 for (int itrack = 0; itrack < (int)buildtracks.size(); itrack++) {
0785 const auto& track = buildtracks[itrack];
0786 auto& extra = buildextras[itrack];
0787
0788 if (Config::sim_val) {
0789 extra.findMatchingSeedHits(track, seedtracks[track.label()], layerhits);
0790 } else if (Config::sim_val_for_cmssw) {
0791 extra.findMatchingSeedHits(track, seedtracks[candToSeedMapDumbCMSSW_[track.label()]], layerhits);
0792 }
0793
0794 extra.setMCTrackIDInfo(track, layerhits, simhits, simtracks, false, (Config::seedInput == simSeeds));
0795 }
0796
0797
0798 for (int itrack = 0; itrack < (int)fittracks.size(); itrack++) {
0799 const auto& track = fittracks[itrack];
0800 auto& extra = fitextras[itrack];
0801
0802 if (Config::sim_val) {
0803 extra.findMatchingSeedHits(track, seedtracks[track.label()], layerhits);
0804 } else if (Config::sim_val_for_cmssw) {
0805 extra.findMatchingSeedHits(track, seedtracks[fitToSeedMapDumbCMSSW_[track.label()]], layerhits);
0806 }
0807
0808 extra.setMCTrackIDInfo(track, layerhits, simhits, simtracks, false, (Config::seedInput == simSeeds));
0809 }
0810 }
0811
0812 if (Config::cmssw_val) {
0813
0814 storeSeedAndMCID(ev);
0815
0816 const auto& cmsswtracks = ev.cmsswTracks_;
0817 const auto& cmsswextras = ev.cmsswTracksExtra_;
0818 const auto& seedtracks = ev.seedTracks_;
0819 const auto& buildtracks = ev.candidateTracks_;
0820 auto& buildextras = ev.candidateTracksExtra_;
0821 const auto& fittracks = ev.fitTracks_;
0822 auto& fitextras = ev.fitTracksExtra_;
0823
0824
0825 RedTrackVec reducedCMSSW;
0826 LayIdxIDVecMapMap cmsswHitIDMap;
0827 setupCMSSWMatching(ev, reducedCMSSW, cmsswHitIDMap);
0828
0829
0830 for (int itrack = 0; itrack < (int)buildtracks.size(); itrack++) {
0831 const auto& track = buildtracks[itrack];
0832 auto& extra = buildextras[itrack];
0833
0834
0835 extra.findMatchingSeedHits(track,
0836 seedtracks[track.label()],
0837 layerhits);
0838
0839 if (Config::cmsswMatchingFW == trkParamBased) {
0840 extra.setCMSSWTrackIDInfoByTrkParams(track, layerhits, cmsswtracks, reducedCMSSW, true);
0841 } else if (Config::cmsswMatchingFW == hitBased) {
0842 extra.setCMSSWTrackIDInfoByHits(track,
0843 cmsswHitIDMap,
0844 cmsswtracks,
0845 cmsswextras,
0846 reducedCMSSW,
0847 -1);
0848 } else if (Config::cmsswMatchingFW == labelBased)
0849 {
0850 extra.setCMSSWTrackIDInfoByHits(track,
0851 cmsswHitIDMap,
0852 cmsswtracks,
0853 cmsswextras,
0854 reducedCMSSW,
0855 reducedCMSSW[cmsswtracks[buildToCmsswMap_[track.label()]].label()].label());
0856 } else {
0857 std::cerr << "Specified CMSSW validation, but using an incorrect matching option! Exiting..." << std::endl;
0858 exit(1);
0859 }
0860 }
0861
0862
0863 for (int itrack = 0; itrack < (int)fittracks.size(); itrack++) {
0864 const auto& track = fittracks[itrack];
0865 auto& extra = fitextras[itrack];
0866
0867
0868 extra.findMatchingSeedHits(track,
0869 seedtracks[track.label()],
0870 layerhits);
0871
0872 if (Config::cmsswMatchingBK == trkParamBased) {
0873 extra.setCMSSWTrackIDInfoByTrkParams(track, layerhits, cmsswtracks, reducedCMSSW, true);
0874 } else if (Config::cmsswMatchingBK == hitBased) {
0875 extra.setCMSSWTrackIDInfoByHits(track,
0876 cmsswHitIDMap,
0877 cmsswtracks,
0878 cmsswextras,
0879 reducedCMSSW,
0880 -1);
0881 } else if (Config::cmsswMatchingBK == labelBased)
0882 {
0883 extra.setCMSSWTrackIDInfoByHits(
0884 track,
0885 cmsswHitIDMap,
0886 cmsswtracks,
0887 cmsswextras,
0888 reducedCMSSW,
0889 reducedCMSSW[cmsswtracks[buildToCmsswMap_[fitToBuildMap_[track.label()]]].label()].label());
0890 } else {
0891 std::cerr << "Specified CMSSW validation, but using an incorrect matching option! Exiting..." << std::endl;
0892 exit(1);
0893 }
0894 }
0895 }
0896 }
0897
0898 void TTreeValidation::makeSimTkToRecoTksMaps(Event& ev) {
0899 std::lock_guard<std::mutex> locker(glock_);
0900
0901 TTreeValidation::mapRefTkToRecoTks(ev.seedTracks_, ev.seedTracksExtra_, simToSeedMap_);
0902 TTreeValidation::mapRefTkToRecoTks(ev.candidateTracks_, ev.candidateTracksExtra_, simToBuildMap_);
0903 TTreeValidation::mapRefTkToRecoTks(ev.fitTracks_, ev.fitTracksExtra_, simToFitMap_);
0904 }
0905
0906 void TTreeValidation::mapRefTkToRecoTks(const TrackVec& evt_tracks,
0907 TrackExtraVec& evt_extras,
0908 TkIDToTkIDVecMap& refTkMap) {
0909 for (auto itrack = 0; itrack < (int)evt_tracks.size(); ++itrack) {
0910 auto&& track(evt_tracks[itrack]);
0911 auto&& extra(evt_extras[itrack]);
0912 if (Config::sim_val_for_cmssw || Config::sim_val) {
0913 if (extra.mcTrackID() >= 0)
0914 {
0915 refTkMap[extra.mcTrackID()].push_back(
0916 track.label());
0917 }
0918 }
0919 if (Config::cmssw_val) {
0920 if (extra.cmsswTrackID() >= 0)
0921 {
0922 refTkMap[extra.cmsswTrackID()].push_back(
0923 track.label());
0924 }
0925 }
0926 }
0927
0928 for (auto&& refTkMatches : refTkMap) {
0929 if (refTkMatches.second.size() < 2)
0930 {
0931 auto& extra(evt_extras[refTkMatches.second[0]]);
0932 extra.setDuplicateInfo(0, bool(false));
0933 } else
0934 {
0935
0936
0937 TrackVec tmpMatches;
0938 for (auto&& label :
0939 refTkMatches.second)
0940 {
0941 tmpMatches.emplace_back(evt_tracks[label]);
0942 }
0943
0944 std::sort(tmpMatches.begin(), tmpMatches.end(), sortByScoreCand);
0945 for (auto itrack = 0; itrack < (int)tmpMatches.size();
0946 itrack++)
0947 {
0948 refTkMatches.second[itrack] = tmpMatches[itrack].label();
0949 }
0950
0951 int duplicateID = 0;
0952 for (auto&& label : refTkMatches.second)
0953 {
0954 auto& extra(evt_extras[label]);
0955 extra.setDuplicateInfo(duplicateID, bool(true));
0956 duplicateID++;
0957 }
0958 }
0959 }
0960 }
0961
0962 void TTreeValidation::makeSeedTkToRecoTkMaps(Event& ev) {
0963 std::lock_guard<std::mutex> locker(glock_);
0964
0965 TTreeValidation::mapSeedTkToRecoTk(ev.candidateTracks_, ev.candidateTracksExtra_, seedToBuildMap_);
0966 TTreeValidation::mapSeedTkToRecoTk(ev.fitTracks_, ev.fitTracksExtra_, seedToFitMap_);
0967 }
0968
0969 void TTreeValidation::mapSeedTkToRecoTk(const TrackVec& evt_tracks,
0970 const TrackExtraVec& evt_extras,
0971 TkIDToTkIDMap& seedTkMap) {
0972 for (auto&& track : evt_tracks) {
0973 seedTkMap[evt_extras[track.label()].seedID()] = track.label();
0974 }
0975 }
0976
0977 void TTreeValidation::makeRecoTkToRecoTkMaps(Event& ev) {
0978 std::lock_guard<std::mutex> locker(glock_);
0979 TTreeValidation::makeRecoTkToRecoTkMap(
0980 buildToFitMap_, ev.candidateTracks_, ev.candidateTracksExtra_, ev.fitTracks_, ev.fitTracksExtra_);
0981 TTreeValidation::makeRecoTkToRecoTkMap(
0982 fitToBuildMap_, ev.fitTracks_, ev.fitTracksExtra_, ev.candidateTracks_, ev.candidateTracksExtra_);
0983 }
0984
0985 void TTreeValidation::makeRecoTkToRecoTkMap(TkIDToTkIDMap& refToPairMap,
0986 const TrackVec& reftracks,
0987 const TrackExtraVec& refextras,
0988 const TrackVec& pairtracks,
0989 const TrackExtraVec& pairextras) {
0990
0991
0992 for (auto&& reftrack : reftracks) {
0993 const auto& refextra = refextras[reftrack.label()];
0994 for (auto&& pairtrack : pairtracks) {
0995 const auto& pairextra = pairextras[pairtrack.label()];
0996 if (refextra.seedID() == pairextra.seedID()) {
0997 refToPairMap[reftrack.label()] = pairtrack.label();
0998 break;
0999 }
1000 }
1001 }
1002 }
1003
1004 void TTreeValidation::makeCMSSWTkToRecoTksMaps(Event& ev) {
1005 std::lock_guard<std::mutex> locker(glock_);
1006
1007 TTreeValidation::mapRefTkToRecoTks(ev.candidateTracks_, ev.candidateTracksExtra_, cmsswToBuildMap_);
1008 TTreeValidation::mapRefTkToRecoTks(ev.fitTracks_, ev.fitTracksExtra_, cmsswToFitMap_);
1009 }
1010
1011 void TTreeValidation::makeSeedTkToCMSSWTkMap(Event& ev) {
1012 const auto& seedtracks = ev.seedTracks_;
1013 const auto& cmsswtracks = ev.cmsswTracks_;
1014 for (int itrack = 0; itrack < (int)seedtracks.size(); itrack++) {
1015 for (auto&& cmsswtrack : cmsswtracks) {
1016 if (cmsswtrack.label() == itrack) {
1017 seedToCmsswMap_[seedtracks[itrack].label()] = cmsswtrack.label();
1018 break;
1019 }
1020 }
1021 }
1022 }
1023
1024 void TTreeValidation::makeCMSSWTkToSeedTkMap(Event& ev) {
1025 const auto& seedtracks = ev.seedTracks_;
1026
1027 for (const auto& seedToCmsswPair : seedToCmsswMap_) {
1028 const auto seedlabel =
1029 seedToCmsswPair
1030 .first;
1031 const auto cmsswlabel = seedToCmsswPair.second;
1032
1033 for (int itrack = 0; itrack < (int)seedtracks.size(); itrack++) {
1034 const auto& seedtrack = seedtracks[itrack];
1035 if (seedtrack.label() == seedlabel) {
1036 cmsswToSeedMap_[cmsswlabel] = itrack;
1037 break;
1038 }
1039 }
1040 }
1041 }
1042
1043 void TTreeValidation::makeRecoTkToSeedTkMapsDumbCMSSW(Event& ev) {
1044 std::lock_guard<std::mutex> locker(glock_);
1045
1046 TTreeValidation::makeRecoTkToSeedTkMapDumbCMSSW(
1047 ev.candidateTracksExtra_, ev.seedTracksExtra_, candToSeedMapDumbCMSSW_);
1048 TTreeValidation::makeRecoTkToSeedTkMapDumbCMSSW(ev.fitTracksExtra_, ev.seedTracksExtra_, fitToSeedMapDumbCMSSW_);
1049 }
1050
1051 void TTreeValidation::makeRecoTkToSeedTkMapDumbCMSSW(const TrackExtraVec& recoextras,
1052 const TrackExtraVec& seedextras,
1053 TkIDToTkIDMap& recoToSeedMap) {
1054 for (int itrack = 0; itrack < (int)recoextras.size(); itrack++) {
1055 const auto reco_seedID = recoextras[itrack].seedID();
1056 for (int jtrack = 0; jtrack < (int)seedextras.size(); jtrack++) {
1057 const auto seed_seedID = seedextras[jtrack].seedID();
1058 if (reco_seedID == seed_seedID) {
1059 recoToSeedMap[itrack] = jtrack;
1060 break;
1061 }
1062 }
1063 }
1064 }
1065
1066 void TTreeValidation::setTrackScoresDumbCMSSW(Event& ev) {
1067 auto& seedtracks = ev.seedTracks_;
1068 auto& candtracks = ev.candidateTracks_;
1069 auto& fittracks = ev.fitTracks_;
1070
1071
1072 for (auto& seedtrack : seedtracks) {
1073 seedtrack.setScore(getScoreCand(seedtrack));
1074 }
1075
1076
1077 for (const auto& candToSeedPair : candToSeedMapDumbCMSSW_) {
1078 auto& candtrack = candtracks[candToSeedPair.first];
1079
1080 candtrack.setScore(getScoreCand(candtrack));
1081 }
1082 for (const auto& fitToSeedPair : fitToSeedMapDumbCMSSW_) {
1083 auto& fittrack = fittracks[fitToSeedPair.first];
1084
1085 fittrack.setScore(getScoreCand(fittrack));
1086 }
1087 }
1088
1089 void TTreeValidation::storeSeedAndMCID(Event& ev) {
1090 const auto& buildtracks = ev.candidateTracks_;
1091 auto& buildextras = ev.candidateTracksExtra_;
1092
1093 const auto& fittracks = ev.fitTracks_;
1094 auto& fitextras = ev.fitTracksExtra_;
1095
1096 const auto& cmsswtracks = ev.cmsswTracks_;
1097 auto& cmsswextras = ev.cmsswTracksExtra_;
1098
1099
1100 int newlabel = -1;
1101 for (int itrack = 0; itrack < (int)buildtracks.size(); itrack++) {
1102 auto& extra = buildextras[itrack];
1103 const int seedID = extra.seedID();
1104
1105 extra.setmcTrackID(seedID);
1106
1107 if (seedToCmsswMap_.count(seedID)) {
1108 extra.setseedID(seedToCmsswMap_[seedID]);
1109 if (Config::cmsswMatchingFW == labelBased || Config::cmsswMatchingBK == labelBased) {
1110 for (int ctrack = 0; ctrack < (int)cmsswextras.size(); ctrack++) {
1111 if (cmsswextras[ctrack].seedID() == extra.seedID()) {
1112 buildToCmsswMap_[itrack] = cmsswtracks[ctrack].label();
1113 break;
1114 }
1115 }
1116 }
1117 } else {
1118 extra.setseedID(--newlabel);
1119 }
1120 }
1121
1122
1123 for (int itrack = 0; itrack < (int)fittracks.size(); itrack++) {
1124 auto& extra = fitextras[itrack];
1125
1126 extra.setmcTrackID(buildextras[fitToBuildMap_[itrack]].mcTrackID());
1127 extra.setseedID(buildextras[fitToBuildMap_[itrack]].seedID());
1128 }
1129 }
1130
1131 void TTreeValidation::setupCMSSWMatching(const Event& ev,
1132 RedTrackVec& reducedCMSSW,
1133 LayIdxIDVecMapMap& cmsswHitIDMap) {
1134
1135 const auto& layerhits = ev.layerHits_;
1136 const auto& cmsswtracks = ev.cmsswTracks_;
1137 auto& cmsswextras = ev.cmsswTracksExtra_;
1138 const auto& seedtracks = ev.seedTracks_;
1139
1140
1141 reducedCMSSW.resize(cmsswtracks.size());
1142
1143 for (int itrack = 0; itrack < (int)cmsswtracks.size(); itrack++) {
1144
1145 auto& cmsswextra = cmsswextras[itrack];
1146 const auto& cmsswtrack = cmsswtracks[itrack];
1147 const auto& seedtrack = seedtracks[cmsswToSeedMap_[cmsswtrack.label()]];
1148
1149
1150 cmsswextra.findMatchingSeedHits(cmsswtrack, seedtrack, layerhits);
1151
1152
1153 const auto seedID = cmsswextra.seedID();
1154 const auto& params = cmsswtrack.parameters();
1155 SVector2 tmpv(params[3], params[5]);
1156
1157 HitLayerMap tmpmap;
1158 for (int ihit = 0; ihit < cmsswtrack.nTotalHits(); ihit++) {
1159 const int lyr = cmsswtrack.getHitLyr(ihit);
1160 const int idx = cmsswtrack.getHitIdx(ihit);
1161
1162
1163 if (cmsswextra.isSeedHit(lyr, idx))
1164 continue;
1165
1166 if (lyr >= 0 && idx >= 0) {
1167 tmpmap[lyr].push_back(idx);
1168 cmsswHitIDMap[lyr][idx].push_back(cmsswtrack.label());
1169 }
1170 }
1171
1172
1173 reducedCMSSW[itrack] = ReducedTrack(cmsswtrack.label(), seedID, tmpv, cmsswtrack.momPhi(), tmpmap);
1174 }
1175 }
1176
1177 int TTreeValidation::getLastFoundHit(const int trackMCHitID, const int mcTrackID, const Event& ev) {
1178 int mcHitID = -1;
1179 if (ev.simHitsInfo_[trackMCHitID].mcTrackID() == mcTrackID) {
1180 mcHitID = trackMCHitID;
1181 } else {
1182 mcHitID = ev.simTracks_[mcTrackID].getMCHitIDFromLayer(ev.layerHits_, ev.simHitsInfo_[trackMCHitID].layer());
1183 }
1184 return mcHitID;
1185 }
1186
1187 int TTreeValidation::getMaskAssignment(const int refID) {
1188
1189 auto refmask = -99;
1190
1191 if (refID >= 0)
1192 {
1193 refmask = 1;
1194 } else if (refID == -10) {
1195 refmask = -2;
1196 } else {
1197 if (Config::inclusiveShorts)
1198 {
1199 if (refID == -1 || refID == -5 || refID == -8 || refID == -9) {
1200 refmask = 0;
1201 } else if (refID == -2) {
1202 refmask = 2;
1203 } else
1204 {
1205 refmask = -1;
1206 }
1207 } else
1208 {
1209 if (refID == -1 || refID == -9) {
1210 refmask = 0;
1211 } else if (Config::mtvLikeValidation && refID == -4) {
1212 refmask = 2;
1213 } else
1214 {
1215 refmask = -1;
1216 }
1217 }
1218 }
1219
1220 return refmask;
1221 }
1222
1223 void TTreeValidation::resetFitBranches() {
1224 for (int ilayer = 0; ilayer < ntotallayers_fit_; ++ilayer) {
1225 z_prop_fit_[ilayer] = -1000.f;
1226 ez_prop_fit_[ilayer] = -1000.f;
1227 z_hit_fit_[ilayer] = -1000.f;
1228 ez_hit_fit_[ilayer] = -1000.f;
1229 z_sim_fit_[ilayer] = -1000.f;
1230 ez_sim_fit_[ilayer] = -1000.f;
1231
1232 pphi_prop_fit_[ilayer] = -1000.f;
1233 epphi_prop_fit_[ilayer] = -1000.f;
1234 pphi_hit_fit_[ilayer] = -1000.f;
1235 epphi_hit_fit_[ilayer] = -1000.f;
1236 pphi_sim_fit_[ilayer] = -1000.f;
1237 epphi_sim_fit_[ilayer] = -1000.f;
1238
1239 pt_up_fit_[ilayer] = -1000.f;
1240 ept_up_fit_[ilayer] = -1000.f;
1241 pt_sim_fit_[ilayer] = -1000.f;
1242 ept_sim_fit_[ilayer] = -1000.f;
1243
1244 mphi_up_fit_[ilayer] = -1000.f;
1245 emphi_up_fit_[ilayer] = -1000.f;
1246 mphi_sim_fit_[ilayer] = -1000.f;
1247 emphi_sim_fit_[ilayer] = -1000.f;
1248
1249 meta_up_fit_[ilayer] = -1000.f;
1250 emeta_up_fit_[ilayer] = -1000.f;
1251 meta_sim_fit_[ilayer] = -1000.f;
1252 emeta_sim_fit_[ilayer] = -1000.f;
1253 }
1254 }
1255
1256 void TTreeValidation::fillFitTree(const Event& ev) {
1257 std::lock_guard<std::mutex> locker(glock_);
1258
1259 evtid_fit_ = ev.evtID();
1260 const auto& simtracks = ev.simTracks_;
1261 const auto& layerhits = ev.layerHits_;
1262 const auto& simtrackstates = ev.simTrackStates_;
1263
1264 for (auto&& fitvalmapmap : fitValTkMapMap_) {
1265 TTreeValidation::resetFitBranches();
1266
1267 tkid_fit_ = fitvalmapmap.first;
1268
1269 const auto& simtrack = simtracks[tkid_fit_];
1270 const auto& fitvalmap = fitvalmapmap.second;
1271 for (int ilayer = 0; ilayer < ntotallayers_fit_; ++ilayer) {
1272 if (fitvalmap.count(ilayer)) {
1273 const auto& hit = layerhits[ilayer][simtrack.getHitIdx(ilayer)];
1274 const auto& initTS = simtrackstates.at(hit.mcHitID());
1275 const auto& fitval = fitvalmap.at(ilayer);
1276
1277 z_hit_fit_[ilayer] = hit.z();
1278 ez_hit_fit_[ilayer] = std::sqrt(hit.ezz());
1279 z_sim_fit_[ilayer] = initTS.z();
1280 ez_sim_fit_[ilayer] = initTS.ezz();
1281 z_prop_fit_[ilayer] = fitval.ppz;
1282 ez_prop_fit_[ilayer] = fitval.eppz;
1283
1284 pphi_hit_fit_[ilayer] = hit.phi();
1285 epphi_hit_fit_[ilayer] = std::sqrt(hit.ephi());
1286 pphi_sim_fit_[ilayer] = initTS.posPhi();
1287 epphi_sim_fit_[ilayer] = initTS.eposPhi();
1288 pphi_prop_fit_[ilayer] = fitval.ppphi;
1289 epphi_prop_fit_[ilayer] = fitval.eppphi;
1290
1291 pt_up_fit_[ilayer] = fitval.upt;
1292 ept_up_fit_[ilayer] = fitval.eupt;
1293 pt_sim_fit_[ilayer] = initTS.pT();
1294 ept_sim_fit_[ilayer] = initTS.epT();
1295
1296 mphi_up_fit_[ilayer] = fitval.umphi;
1297 emphi_up_fit_[ilayer] = fitval.eumphi;
1298 mphi_sim_fit_[ilayer] = initTS.momPhi();
1299 emphi_sim_fit_[ilayer] = initTS.emomPhi();
1300
1301 meta_up_fit_[ilayer] = fitval.umeta;
1302 emeta_up_fit_[ilayer] = fitval.eumeta;
1303 meta_sim_fit_[ilayer] = initTS.momEta();
1304 emeta_sim_fit_[ilayer] = initTS.emomEta();
1305 }
1306 }
1307 fittree_->Fill();
1308 }
1309 }
1310
1311 void TTreeValidation::fillFullHitInfo(const Event& ev,
1312 const Track& track,
1313 std::vector<int>& lyrs,
1314 std::vector<int>& idxs,
1315 std::vector<int>& mcTkIDs,
1316 std::vector<float>& xs,
1317 std::vector<float>& ys,
1318 std::vector<float>& zs) {
1319
1320 const auto& layerHits = ev.layerHits_;
1321 const auto& simHitsInfo = ev.simHitsInfo_;
1322
1323
1324 const auto nTotalHits = track.nTotalHits();
1325 lyrs.resize(nTotalHits);
1326 idxs.resize(nTotalHits);
1327 mcTkIDs.resize(nTotalHits, -99);
1328 xs.resize(nTotalHits, -9999.f);
1329 ys.resize(nTotalHits, -9999.f);
1330 zs.resize(nTotalHits, -9999.f);
1331
1332
1333 for (auto ihit = 0; ihit < nTotalHits; ihit++) {
1334 const auto lyr = track.getHitLyr(ihit);
1335 const auto idx = track.getHitIdx(ihit);
1336
1337 lyrs[ihit] = lyr;
1338 idxs[ihit] = idx;
1339
1340 if (lyr < 0)
1341 continue;
1342 if (idx < 0)
1343 continue;
1344
1345 const auto& hit = layerHits[lyr][idx];
1346 mcTkIDs[ihit] = hit.mcTrackID(simHitsInfo);
1347 xs[ihit] = hit.x();
1348 ys[ihit] = hit.y();
1349 zs[ihit] = hit.z();
1350 }
1351 }
1352
1353 void TTreeValidation::fillMinHitInfo(const Track& track, std::vector<int>& lyrs, std::vector<int>& idxs) {
1354 for (int ihit = 0; ihit < track.nTotalHits(); ihit++) {
1355 lyrs.emplace_back(track.getHitLyr(ihit));
1356 idxs.emplace_back(track.getHitIdx(ihit));
1357 }
1358 }
1359
1360 void TTreeValidation::fillEfficiencyTree(const Event& ev) {
1361 std::lock_guard<std::mutex> locker(glock_);
1362
1363 const auto ievt = ev.evtID();
1364 const auto& evt_sim_tracks = ev.simTracks_;
1365 const auto& evt_seed_tracks = ev.seedTracks_;
1366 const auto& evt_seed_extras = ev.seedTracksExtra_;
1367 const auto& evt_build_tracks = ev.candidateTracks_;
1368 const auto& evt_build_extras = ev.candidateTracksExtra_;
1369 const auto& evt_fit_tracks = ev.fitTracks_;
1370 const auto& evt_fit_extras = ev.fitTracksExtra_;
1371 const auto& evt_layer_hits = ev.layerHits_;
1372 const auto& evt_sim_trackstates = ev.simTrackStates_;
1373
1374 unsigned int count = 0;
1375 for (const auto& simtrack : evt_sim_tracks) {
1376
1377 if (Config::keepHitInfo) {
1378 hitlyrs_mc_eff_.clear();
1379 hitlyrs_seed_eff_.clear();
1380 hitlyrs_build_eff_.clear();
1381 hitlyrs_fit_eff_.clear();
1382
1383 hitidxs_mc_eff_.clear();
1384 hitidxs_seed_eff_.clear();
1385 hitidxs_build_eff_.clear();
1386 hitidxs_fit_eff_.clear();
1387
1388 hitmcTkIDs_mc_eff_.clear();
1389 hitmcTkIDs_seed_eff_.clear();
1390 hitmcTkIDs_build_eff_.clear();
1391 hitmcTkIDs_fit_eff_.clear();
1392
1393 hitxs_mc_eff_.clear();
1394 hitxs_seed_eff_.clear();
1395 hitxs_build_eff_.clear();
1396 hitxs_fit_eff_.clear();
1397
1398 hitys_mc_eff_.clear();
1399 hitys_seed_eff_.clear();
1400 hitys_build_eff_.clear();
1401 hitys_fit_eff_.clear();
1402
1403 hitzs_mc_eff_.clear();
1404 hitzs_seed_eff_.clear();
1405 hitzs_build_eff_.clear();
1406 hitzs_fit_eff_.clear();
1407 }
1408
1409 evtID_eff_ = ievt;
1410 mcID_eff_ = simtrack.label();
1411
1412
1413 x_mc_gen_eff_ = simtrack.x();
1414 y_mc_gen_eff_ = simtrack.y();
1415 z_mc_gen_eff_ = simtrack.z();
1416
1417 pt_mc_gen_eff_ = simtrack.pT();
1418 phi_mc_gen_eff_ = simtrack.momPhi();
1419 eta_mc_gen_eff_ = simtrack.momEta();
1420 nHits_mc_eff_ = simtrack.nFoundHits();
1421 nLayers_mc_eff_ = simtrack.nUniqueLayers();
1422 lastlyr_mc_eff_ = simtrack.getLastFoundHitLyr();
1423
1424 itermask_seed_eff_ = 0;
1425 itermask_build_eff_ = 0;
1426 itermask_fit_eff_ = 0;
1427 iterduplmask_seed_eff_ = 0;
1428 iterduplmask_build_eff_ = 0;
1429 iterduplmask_fit_eff_ = 0;
1430 algo_seed_eff_ = 0;
1431
1432 if (Config::mtvRequireSeeds) {
1433 for (auto aa : ev.simTracksExtra_[count].seedAlgos()) {
1434 algo_seed_eff_ = (algo_seed_eff_ | (1 << aa));
1435 }
1436 }
1437 count++;
1438
1439
1440 if (Config::keepHitInfo)
1441 TTreeValidation::fillFullHitInfo(ev,
1442 simtrack,
1443 hitlyrs_mc_eff_,
1444 hitidxs_mc_eff_,
1445 hitmcTkIDs_mc_eff_,
1446 hitxs_mc_eff_,
1447 hitys_mc_eff_,
1448 hitzs_mc_eff_);
1449
1450
1451 if (simToSeedMap_.count(mcID_eff_) &&
1452 simtrack
1453 .isFindable())
1454 {
1455 for (unsigned int ii = 0; ii < simToSeedMap_[mcID_eff_].size(); ii++) {
1456 const int theAlgo = evt_seed_tracks[simToSeedMap_[mcID_eff_][ii]].algoint();
1457 if ((itermask_seed_eff_ >> theAlgo) & 1)
1458 iterduplmask_seed_eff_ = (iterduplmask_seed_eff_ | (1 << theAlgo));
1459 itermask_seed_eff_ = (itermask_seed_eff_ | (1 << theAlgo));
1460 }
1461 const auto& seedtrack =
1462 evt_seed_tracks[simToSeedMap_[mcID_eff_][0]];
1463 const auto& seedextra = evt_seed_extras[seedtrack.label()];
1464 mcmask_seed_eff_ = 1;
1465
1466 seedID_seed_eff_ = seedextra.seedID();
1467
1468
1469 const int mcHitID =
1470 TTreeValidation::getLastFoundHit(seedtrack.getLastFoundMCHitID(evt_layer_hits), mcID_eff_, ev);
1471 if (mcHitID >= 0 && Config::readSimTrackStates) {
1472 const TrackState& initLayTS = evt_sim_trackstates[mcHitID];
1473
1474 pt_mc_seed_eff_ = initLayTS.pT();
1475 phi_mc_seed_eff_ = initLayTS.momPhi();
1476 eta_mc_seed_eff_ = initLayTS.momEta();
1477 helixchi2_seed_eff_ = computeHelixChi2(initLayTS.parameters, seedtrack.parameters(), seedtrack.errors());
1478
1479 mcTSmask_seed_eff_ = 1;
1480 } else if (Config::tryToSaveSimInfo)
1481 {
1482
1483 pt_mc_seed_eff_ = pt_mc_gen_eff_;
1484 phi_mc_seed_eff_ = phi_mc_gen_eff_;
1485 eta_mc_seed_eff_ = eta_mc_gen_eff_;
1486 helixchi2_seed_eff_ = computeHelixChi2(simtrack.parameters(), seedtrack.parameters(), seedtrack.errors());
1487
1488 mcTSmask_seed_eff_ = 0;
1489 } else {
1490 pt_mc_seed_eff_ = -101;
1491 phi_mc_seed_eff_ = -101;
1492 eta_mc_seed_eff_ = -101;
1493 helixchi2_seed_eff_ = -101;
1494
1495 mcTSmask_seed_eff_ = -2;
1496 }
1497
1498
1499 const Hit& lasthit = evt_layer_hits[seedtrack.getLastFoundHitLyr()][seedtrack.getLastFoundHitIdx()];
1500 xhit_seed_eff_ = lasthit.x();
1501 yhit_seed_eff_ = lasthit.y();
1502 zhit_seed_eff_ = lasthit.z();
1503
1504 pt_seed_eff_ = seedtrack.pT();
1505 ept_seed_eff_ = seedtrack.epT();
1506 phi_seed_eff_ = seedtrack.momPhi();
1507 ephi_seed_eff_ = seedtrack.emomPhi();
1508 eta_seed_eff_ = seedtrack.momEta();
1509 eeta_seed_eff_ = seedtrack.emomEta();
1510
1511
1512 nHits_seed_eff_ = seedtrack.nFoundHits();
1513 nLayers_seed_eff_ = seedtrack.nUniqueLayers();
1514 nHitsMatched_seed_eff_ = seedextra.nHitsMatched();
1515 fracHitsMatched_seed_eff_ = seedextra.fracHitsMatched();
1516 lastlyr_seed_eff_ = seedtrack.getLastFoundHitLyr();
1517
1518
1519 dphi_seed_eff_ = seedextra.dPhi();
1520
1521
1522 hitchi2_seed_eff_ = seedtrack.chi2();
1523 score_seed_eff_ = seedtrack.score();
1524
1525 duplmask_seed_eff_ = seedextra.isDuplicate();
1526 nTkMatches_seed_eff_ = simToSeedMap_[mcID_eff_].size();
1527
1528
1529 if (Config::keepHitInfo)
1530 TTreeValidation::fillFullHitInfo(ev,
1531 seedtrack,
1532 hitlyrs_seed_eff_,
1533 hitidxs_seed_eff_,
1534 hitmcTkIDs_seed_eff_,
1535 hitxs_seed_eff_,
1536 hitys_seed_eff_,
1537 hitzs_seed_eff_);
1538 } else
1539 {
1540 mcmask_seed_eff_ = (simtrack.isFindable() ? 0 : -1);
1541
1542 seedID_seed_eff_ = -99;
1543
1544 pt_mc_seed_eff_ = -99;
1545 phi_mc_seed_eff_ = -99;
1546 eta_mc_seed_eff_ = -99;
1547 helixchi2_seed_eff_ = -99;
1548
1549 mcTSmask_seed_eff_ = -1;
1550
1551 xhit_seed_eff_ = -2000;
1552 yhit_seed_eff_ = -2000;
1553 zhit_seed_eff_ = -2000;
1554
1555 pt_seed_eff_ = -99;
1556 ept_seed_eff_ = -99;
1557 phi_seed_eff_ = -99;
1558 ephi_seed_eff_ = -99;
1559 eta_seed_eff_ = -99;
1560 eeta_seed_eff_ = -99;
1561
1562 nHits_seed_eff_ = -99;
1563 nLayers_seed_eff_ = -99;
1564 nHitsMatched_seed_eff_ = -99;
1565 fracHitsMatched_seed_eff_ = -99;
1566 lastlyr_seed_eff_ = -99;
1567
1568 dphi_seed_eff_ = -99;
1569
1570 hitchi2_seed_eff_ = -99;
1571 score_seed_eff_ = -17000;
1572
1573 duplmask_seed_eff_ = -1;
1574 nTkMatches_seed_eff_ = -99;
1575 }
1576
1577
1578 if (simToBuildMap_.count(mcID_eff_) &&
1579 simtrack
1580 .isFindable())
1581 {
1582 for (unsigned int ii = 0; ii < simToBuildMap_[mcID_eff_].size(); ii++) {
1583 const int theAlgo = evt_build_tracks[simToBuildMap_[mcID_eff_][ii]].algoint();
1584 if ((itermask_build_eff_ >> theAlgo) & 1)
1585 iterduplmask_build_eff_ = (iterduplmask_build_eff_ | (1 << theAlgo));
1586 itermask_build_eff_ = (itermask_build_eff_ | (1 << theAlgo));
1587 }
1588 const auto& buildtrack =
1589 evt_build_tracks[simToBuildMap_[mcID_eff_][0]];
1590 const auto& buildextra =
1591 evt_build_extras[buildtrack.label()];
1592 mcmask_build_eff_ = 1;
1593
1594 seedID_build_eff_ = buildextra.seedID();
1595
1596
1597 const int mcHitID =
1598 TTreeValidation::getLastFoundHit(buildtrack.getLastFoundMCHitID(evt_layer_hits), mcID_eff_, ev);
1599 if (mcHitID >= 0 && Config::readSimTrackStates) {
1600 const TrackState& initLayTS = evt_sim_trackstates[mcHitID];
1601
1602 pt_mc_build_eff_ = initLayTS.pT();
1603 phi_mc_build_eff_ = initLayTS.momPhi();
1604 eta_mc_build_eff_ = initLayTS.momEta();
1605 helixchi2_build_eff_ = computeHelixChi2(initLayTS.parameters, buildtrack.parameters(), buildtrack.errors());
1606
1607 mcTSmask_build_eff_ = 1;
1608 } else if (Config::tryToSaveSimInfo)
1609 {
1610
1611 pt_mc_build_eff_ = pt_mc_gen_eff_;
1612 phi_mc_build_eff_ = phi_mc_gen_eff_;
1613 eta_mc_build_eff_ = eta_mc_gen_eff_;
1614 helixchi2_build_eff_ = computeHelixChi2(simtrack.parameters(), buildtrack.parameters(), buildtrack.errors());
1615
1616 mcTSmask_build_eff_ = 0;
1617 } else {
1618 pt_mc_build_eff_ = -101;
1619 phi_mc_build_eff_ = -101;
1620 eta_mc_build_eff_ = -101;
1621 helixchi2_build_eff_ = -101;
1622
1623 mcTSmask_build_eff_ = -2;
1624 }
1625
1626
1627 const Hit& lasthit = evt_layer_hits[buildtrack.getLastFoundHitLyr()][buildtrack.getLastFoundHitIdx()];
1628 xhit_build_eff_ = lasthit.x();
1629 yhit_build_eff_ = lasthit.y();
1630 zhit_build_eff_ = lasthit.z();
1631
1632 pt_build_eff_ = buildtrack.pT();
1633 ept_build_eff_ = buildtrack.epT();
1634 phi_build_eff_ = buildtrack.momPhi();
1635 ephi_build_eff_ = buildtrack.emomPhi();
1636 eta_build_eff_ = buildtrack.momEta();
1637 eeta_build_eff_ = buildtrack.emomEta();
1638
1639 nHits_build_eff_ = buildtrack.nFoundHits();
1640 nLayers_build_eff_ = buildtrack.nUniqueLayers();
1641 nHitsMatched_build_eff_ = buildextra.nHitsMatched();
1642 fracHitsMatched_build_eff_ = buildextra.fracHitsMatched();
1643 lastlyr_build_eff_ = buildtrack.getLastFoundHitLyr();
1644
1645
1646 dphi_build_eff_ = buildextra.dPhi();
1647
1648
1649 hitchi2_build_eff_ = buildtrack.chi2();
1650 score_build_eff_ = buildtrack.score();
1651
1652 duplmask_build_eff_ = buildextra.isDuplicate();
1653 nTkMatches_build_eff_ = simToBuildMap_[mcID_eff_].size();
1654
1655
1656 if (Config::keepHitInfo)
1657 TTreeValidation::fillFullHitInfo(ev,
1658 buildtrack,
1659 hitlyrs_build_eff_,
1660 hitidxs_build_eff_,
1661 hitmcTkIDs_build_eff_,
1662 hitxs_build_eff_,
1663 hitys_build_eff_,
1664 hitzs_build_eff_);
1665 } else
1666 {
1667 mcmask_build_eff_ = (simtrack.isFindable() ? 0 : -1);
1668
1669 seedID_build_eff_ = -99;
1670
1671 pt_mc_build_eff_ = -99;
1672 phi_mc_build_eff_ = -99;
1673 eta_mc_build_eff_ = -99;
1674 helixchi2_build_eff_ = -99;
1675
1676 mcTSmask_build_eff_ = -1;
1677
1678 xhit_build_eff_ = -2000;
1679 yhit_build_eff_ = -2000;
1680 zhit_build_eff_ = -2000;
1681
1682 pt_build_eff_ = -99;
1683 ept_build_eff_ = -99;
1684 phi_build_eff_ = -99;
1685 ephi_build_eff_ = -99;
1686 eta_build_eff_ = -99;
1687 eeta_build_eff_ = -99;
1688
1689 nHits_build_eff_ = -99;
1690 nLayers_build_eff_ = -99;
1691 nHitsMatched_build_eff_ = -99;
1692 fracHitsMatched_build_eff_ = -99;
1693 lastlyr_build_eff_ = -99;
1694
1695 dphi_build_eff_ = -99;
1696
1697 hitchi2_build_eff_ = -99;
1698 score_build_eff_ = -17000;
1699
1700 duplmask_build_eff_ = -1;
1701 nTkMatches_build_eff_ = -99;
1702 }
1703
1704
1705 if (simToFitMap_.count(mcID_eff_) &&
1706 simtrack
1707 .isFindable())
1708 {
1709 for (unsigned int ii = 0; ii < simToFitMap_[mcID_eff_].size(); ii++) {
1710 const int theAlgo = evt_fit_tracks[simToFitMap_[mcID_eff_][ii]].algoint();
1711 if ((itermask_fit_eff_ >> theAlgo) & 1)
1712 iterduplmask_fit_eff_ = (iterduplmask_fit_eff_ | (1 << theAlgo));
1713 itermask_fit_eff_ = (itermask_fit_eff_ | (1 << theAlgo));
1714 }
1715 const auto& fittrack =
1716 evt_fit_tracks[simToFitMap_[mcID_eff_][0]];
1717 const auto& fitextra = evt_fit_extras[fittrack.label()];
1718 mcmask_fit_eff_ = 1;
1719
1720 seedID_fit_eff_ = fitextra.seedID();
1721
1722
1723 const int mcHitID =
1724 TTreeValidation::getLastFoundHit(fittrack.getLastFoundMCHitID(evt_layer_hits), mcID_eff_, ev);
1725 if (mcHitID >= 0 && Config::readSimTrackStates) {
1726 const TrackState& initLayTS = evt_sim_trackstates[mcHitID];
1727
1728 pt_mc_fit_eff_ = initLayTS.pT();
1729 phi_mc_fit_eff_ = initLayTS.momPhi();
1730 eta_mc_fit_eff_ = initLayTS.momEta();
1731 helixchi2_fit_eff_ = computeHelixChi2(initLayTS.parameters, fittrack.parameters(), fittrack.errors());
1732
1733 mcTSmask_fit_eff_ = 1;
1734 } else if (Config::tryToSaveSimInfo)
1735 {
1736
1737 pt_mc_fit_eff_ = pt_mc_gen_eff_;
1738 phi_mc_fit_eff_ = phi_mc_gen_eff_;
1739 eta_mc_fit_eff_ = eta_mc_gen_eff_;
1740 helixchi2_fit_eff_ = computeHelixChi2(simtrack.parameters(), fittrack.parameters(), fittrack.errors());
1741
1742 mcTSmask_fit_eff_ = 0;
1743 } else {
1744 pt_mc_fit_eff_ = -101;
1745 phi_mc_fit_eff_ = -101;
1746 eta_mc_fit_eff_ = -101;
1747 helixchi2_fit_eff_ = -101;
1748
1749 mcTSmask_fit_eff_ = -2;
1750 }
1751
1752
1753 const Hit& lasthit = evt_layer_hits[fittrack.getLastFoundHitLyr()][fittrack.getLastFoundHitIdx()];
1754 xhit_fit_eff_ = lasthit.x();
1755 yhit_fit_eff_ = lasthit.y();
1756 zhit_fit_eff_ = lasthit.z();
1757
1758 pt_fit_eff_ = fittrack.pT();
1759 ept_fit_eff_ = fittrack.epT();
1760 phi_fit_eff_ = fittrack.momPhi();
1761 ephi_fit_eff_ = fittrack.emomPhi();
1762 eta_fit_eff_ = fittrack.momEta();
1763 eeta_fit_eff_ = fittrack.emomEta();
1764
1765
1766 nHits_fit_eff_ = fittrack.nFoundHits();
1767 nLayers_fit_eff_ = fittrack.nUniqueLayers();
1768 nHitsMatched_fit_eff_ = fitextra.nHitsMatched();
1769 fracHitsMatched_fit_eff_ = fitextra.fracHitsMatched();
1770 lastlyr_fit_eff_ = fittrack.getLastFoundHitLyr();
1771
1772
1773 dphi_fit_eff_ = fitextra.dPhi();
1774
1775
1776 hitchi2_fit_eff_ = fittrack.chi2();
1777 score_fit_eff_ = fittrack.score();
1778
1779 duplmask_fit_eff_ = fitextra.isDuplicate();
1780 nTkMatches_fit_eff_ = simToFitMap_[mcID_eff_].size();
1781
1782
1783 if (Config::keepHitInfo)
1784 TTreeValidation::fillFullHitInfo(ev,
1785 fittrack,
1786 hitlyrs_fit_eff_,
1787 hitidxs_fit_eff_,
1788 hitmcTkIDs_fit_eff_,
1789 hitxs_fit_eff_,
1790 hitys_fit_eff_,
1791 hitzs_fit_eff_);
1792 } else
1793 {
1794 mcmask_fit_eff_ = (simtrack.isFindable() ? 0 : -1);
1795
1796 seedID_fit_eff_ = -99;
1797
1798 pt_mc_fit_eff_ = -99;
1799 phi_mc_fit_eff_ = -99;
1800 eta_mc_fit_eff_ = -99;
1801 helixchi2_fit_eff_ = -99;
1802
1803 mcTSmask_fit_eff_ = -1;
1804
1805 xhit_fit_eff_ = -2000;
1806 yhit_fit_eff_ = -2000;
1807 zhit_fit_eff_ = -2000;
1808
1809 pt_fit_eff_ = -99;
1810 ept_fit_eff_ = -99;
1811 phi_fit_eff_ = -99;
1812 ephi_fit_eff_ = -99;
1813 eta_fit_eff_ = -99;
1814 eeta_fit_eff_ = -99;
1815
1816 nHits_fit_eff_ = -99;
1817 nLayers_fit_eff_ = -99;
1818 nHitsMatched_fit_eff_ = -99;
1819 fracHitsMatched_fit_eff_ = -99;
1820 lastlyr_fit_eff_ = -99;
1821
1822 dphi_fit_eff_ = -99;
1823
1824 hitchi2_fit_eff_ = -99;
1825 score_fit_eff_ = -17000;
1826
1827 duplmask_fit_eff_ = -1;
1828 nTkMatches_fit_eff_ = -99;
1829 }
1830
1831 efftree_->Fill();
1832 }
1833 }
1834
1835 void TTreeValidation::fillFakeRateTree(const Event& ev) {
1836 std::lock_guard<std::mutex> locker(glock_);
1837
1838 const auto ievt = ev.evtID();
1839 const auto& evt_sim_tracks =
1840 ev.simTracks_;
1841 const auto& evt_seed_tracks = ev.seedTracks_;
1842 const auto& evt_seed_extras = ev.seedTracksExtra_;
1843 const auto& evt_build_tracks = ev.candidateTracks_;
1844 const auto& evt_build_extras = ev.candidateTracksExtra_;
1845 const auto& evt_fit_tracks = ev.fitTracks_;
1846 const auto& evt_fit_extras = ev.fitTracksExtra_;
1847 const auto& evt_layer_hits = ev.layerHits_;
1848 const auto& evt_sim_trackstates = ev.simTrackStates_;
1849
1850 for (const auto& seedtrack : evt_seed_tracks) {
1851 if (Config::keepHitInfo) {
1852 hitlyrs_seed_FR_.clear();
1853 hitlyrs_mc_seed_FR_.clear();
1854 hitlyrs_build_FR_.clear();
1855 hitlyrs_mc_build_FR_.clear();
1856 hitlyrs_fit_FR_.clear();
1857 hitlyrs_mc_fit_FR_.clear();
1858
1859 hitidxs_seed_FR_.clear();
1860 hitidxs_mc_seed_FR_.clear();
1861 hitidxs_build_FR_.clear();
1862 hitidxs_mc_build_FR_.clear();
1863 hitidxs_fit_FR_.clear();
1864 hitidxs_mc_fit_FR_.clear();
1865
1866 hitmcTkIDs_seed_FR_.clear();
1867 hitmcTkIDs_mc_seed_FR_.clear();
1868 hitmcTkIDs_build_FR_.clear();
1869 hitmcTkIDs_mc_build_FR_.clear();
1870 hitmcTkIDs_fit_FR_.clear();
1871 hitmcTkIDs_mc_fit_FR_.clear();
1872
1873 hitxs_seed_FR_.clear();
1874 hitxs_mc_seed_FR_.clear();
1875 hitxs_build_FR_.clear();
1876 hitxs_mc_build_FR_.clear();
1877 hitxs_fit_FR_.clear();
1878 hitxs_mc_fit_FR_.clear();
1879
1880 hitys_seed_FR_.clear();
1881 hitys_mc_seed_FR_.clear();
1882 hitys_build_FR_.clear();
1883 hitys_mc_build_FR_.clear();
1884 hitys_fit_FR_.clear();
1885 hitys_mc_fit_FR_.clear();
1886
1887 hitzs_seed_FR_.clear();
1888 hitzs_mc_seed_FR_.clear();
1889 hitzs_build_FR_.clear();
1890 hitzs_mc_build_FR_.clear();
1891 hitzs_fit_FR_.clear();
1892 hitzs_mc_fit_FR_.clear();
1893 }
1894
1895 evtID_FR_ = ievt;
1896
1897
1898 const auto& seedextra = evt_seed_extras[seedtrack.label()];
1899 seedID_FR_ = seedextra.seedID();
1900 seedmask_seed_FR_ =
1901 1;
1902
1903
1904
1905 xhit_seed_FR_ = 0;
1906 yhit_seed_FR_ = 0;
1907 zhit_seed_FR_ = 0;
1908
1909 pt_seed_FR_ = seedtrack.pT();
1910 ept_seed_FR_ = seedtrack.epT();
1911 phi_seed_FR_ = seedtrack.momPhi();
1912 ephi_seed_FR_ = seedtrack.emomPhi();
1913 eta_seed_FR_ = seedtrack.momEta();
1914 eeta_seed_FR_ = seedtrack.emomEta();
1915
1916 nHits_seed_FR_ = seedtrack.nFoundHits();
1917 nLayers_seed_FR_ = seedtrack.nUniqueLayers();
1918 nHitsMatched_seed_FR_ = seedextra.nHitsMatched();
1919 fracHitsMatched_seed_FR_ = seedextra.fracHitsMatched();
1920 lastlyr_seed_FR_ = seedtrack.getLastFoundHitLyr();
1921
1922 algorithm_FR_ = seedtrack.algoint();
1923
1924
1925 dphi_seed_FR_ = seedextra.dPhi();
1926
1927
1928 hitchi2_seed_FR_ = seedtrack.chi2();
1929 score_seed_FR_ = seedtrack.score();
1930
1931 if (Config::keepHitInfo)
1932 TTreeValidation::fillFullHitInfo(ev,
1933 seedtrack,
1934 hitlyrs_seed_FR_,
1935 hitidxs_seed_FR_,
1936 hitmcTkIDs_seed_FR_,
1937 hitxs_seed_FR_,
1938 hitys_seed_FR_,
1939 hitzs_seed_FR_);
1940
1941
1942 mcID_seed_FR_ = seedextra.mcTrackID();
1943 mcmask_seed_FR_ = TTreeValidation::getMaskAssignment(mcID_seed_FR_);
1944
1945 if (mcmask_seed_FR_ == 1)
1946 {
1947 const auto& simtrack = evt_sim_tracks[mcID_seed_FR_];
1948
1949 const int mcHitID =
1950 TTreeValidation::getLastFoundHit(seedtrack.getLastFoundMCHitID(evt_layer_hits), mcID_seed_FR_, ev);
1951 if (mcHitID >= 0 && Config::readSimTrackStates) {
1952 const TrackState& initLayTS = evt_sim_trackstates[mcHitID];
1953 pt_mc_seed_FR_ = initLayTS.pT();
1954 phi_mc_seed_FR_ = initLayTS.momPhi();
1955 eta_mc_seed_FR_ = initLayTS.momEta();
1956 helixchi2_seed_FR_ = computeHelixChi2(initLayTS.parameters, seedtrack.parameters(), seedtrack.errors());
1957
1958 mcTSmask_seed_FR_ = 1;
1959 } else if (Config::tryToSaveSimInfo) {
1960 pt_mc_seed_FR_ = simtrack.pT();
1961 phi_mc_seed_FR_ = simtrack.momPhi();
1962 eta_mc_seed_FR_ = simtrack.momEta();
1963 helixchi2_seed_FR_ = computeHelixChi2(simtrack.parameters(), seedtrack.parameters(), seedtrack.errors());
1964
1965 mcTSmask_seed_FR_ = 0;
1966 } else {
1967 pt_mc_seed_FR_ = -101;
1968 phi_mc_seed_FR_ = -101;
1969 eta_mc_seed_FR_ = -101;
1970 helixchi2_seed_FR_ = -101;
1971
1972 mcTSmask_seed_FR_ = -2;
1973 }
1974
1975 nHits_mc_seed_FR_ = simtrack.nFoundHits();
1976 nLayers_mc_seed_FR_ = simtrack.nUniqueLayers();
1977 lastlyr_mc_seed_FR_ = simtrack.getLastFoundHitLyr();
1978
1979 duplmask_seed_FR_ = seedextra.isDuplicate();
1980 iTkMatches_seed_FR_ =
1981 seedextra
1982 .duplicateID();
1983
1984 if (Config::keepHitInfo)
1985 TTreeValidation::fillFullHitInfo(ev,
1986 simtrack,
1987 hitlyrs_mc_seed_FR_,
1988 hitidxs_mc_seed_FR_,
1989 hitmcTkIDs_mc_seed_FR_,
1990 hitxs_mc_seed_FR_,
1991 hitys_mc_seed_FR_,
1992 hitzs_mc_seed_FR_);
1993 } else {
1994
1995 pt_mc_seed_FR_ = -99;
1996 phi_mc_seed_FR_ = -99;
1997 eta_mc_seed_FR_ = -99;
1998 helixchi2_seed_FR_ = -99;
1999
2000 mcTSmask_seed_FR_ = -1;
2001
2002 nHits_mc_seed_FR_ = -99;
2003 nLayers_mc_seed_FR_ = -99;
2004 lastlyr_mc_seed_FR_ = -99;
2005
2006 duplmask_seed_FR_ = -1;
2007 iTkMatches_seed_FR_ = -99;
2008 }
2009
2010
2011
2012
2013 if (seedToBuildMap_.count(seedID_FR_)) {
2014 seedmask_build_FR_ = 1;
2015
2016 const auto& buildtrack = evt_build_tracks[seedToBuildMap_[seedID_FR_]];
2017 const auto& buildextra = evt_build_extras[buildtrack.label()];
2018
2019
2020 const Hit& lasthit = evt_layer_hits[buildtrack.getLastFoundHitLyr()][buildtrack.getLastFoundHitIdx()];
2021 xhit_build_FR_ = lasthit.x();
2022 yhit_build_FR_ = lasthit.y();
2023 zhit_build_FR_ = lasthit.z();
2024
2025 pt_build_FR_ = buildtrack.pT();
2026 ept_build_FR_ = buildtrack.epT();
2027 phi_build_FR_ = buildtrack.momPhi();
2028 ephi_build_FR_ = buildtrack.emomPhi();
2029 eta_build_FR_ = buildtrack.momEta();
2030 eeta_build_FR_ = buildtrack.emomEta();
2031
2032 nHits_build_FR_ = buildtrack.nFoundHits();
2033 nLayers_build_FR_ = buildtrack.nUniqueLayers();
2034 nHitsMatched_build_FR_ = buildextra.nHitsMatched();
2035 fracHitsMatched_build_FR_ = buildextra.fracHitsMatched();
2036 lastlyr_build_FR_ = buildtrack.getLastFoundHitLyr();
2037
2038
2039 dphi_build_FR_ = buildextra.dPhi();
2040
2041
2042 hitchi2_build_FR_ = buildtrack.chi2();
2043 score_build_FR_ = buildtrack.score();
2044
2045 if (Config::keepHitInfo)
2046 TTreeValidation::fillFullHitInfo(ev,
2047 buildtrack,
2048 hitlyrs_build_FR_,
2049 hitidxs_build_FR_,
2050 hitmcTkIDs_build_FR_,
2051 hitxs_build_FR_,
2052 hitys_build_FR_,
2053 hitzs_build_FR_);
2054
2055
2056 mcID_build_FR_ = buildextra.mcTrackID();
2057 mcmask_build_FR_ = TTreeValidation::getMaskAssignment(mcID_build_FR_);
2058
2059 if (mcmask_build_FR_ == 1)
2060 {
2061 const auto& simtrack = evt_sim_tracks[mcID_build_FR_];
2062
2063 const int mcHitID =
2064 TTreeValidation::getLastFoundHit(buildtrack.getLastFoundMCHitID(evt_layer_hits), mcID_build_FR_, ev);
2065 if (mcHitID >= 0 && Config::readSimTrackStates) {
2066 const TrackState& initLayTS = evt_sim_trackstates[mcHitID];
2067 pt_mc_build_FR_ = initLayTS.pT();
2068 phi_mc_build_FR_ = initLayTS.momPhi();
2069 eta_mc_build_FR_ = initLayTS.momEta();
2070 helixchi2_build_FR_ = computeHelixChi2(initLayTS.parameters, buildtrack.parameters(), buildtrack.errors());
2071
2072 mcTSmask_build_FR_ = 1;
2073 } else if (Config::tryToSaveSimInfo) {
2074 pt_mc_build_FR_ = simtrack.pT();
2075 phi_mc_build_FR_ = simtrack.momPhi();
2076 eta_mc_build_FR_ = simtrack.momEta();
2077 helixchi2_build_FR_ = computeHelixChi2(simtrack.parameters(), buildtrack.parameters(), buildtrack.errors());
2078
2079 mcTSmask_build_FR_ = 0;
2080 } else {
2081 pt_mc_build_FR_ = -101;
2082 phi_mc_build_FR_ = -101;
2083 eta_mc_build_FR_ = -101;
2084 helixchi2_build_FR_ = -101;
2085
2086 mcTSmask_build_FR_ = -2;
2087 }
2088
2089 nHits_mc_build_FR_ = simtrack.nFoundHits();
2090 nLayers_mc_build_FR_ = simtrack.nUniqueLayers();
2091 lastlyr_mc_build_FR_ = simtrack.getLastFoundHitLyr();
2092
2093 duplmask_build_FR_ = buildextra.isDuplicate();
2094 iTkMatches_build_FR_ =
2095 buildextra
2096 .duplicateID();
2097
2098 if (Config::keepHitInfo)
2099 TTreeValidation::fillFullHitInfo(ev,
2100 simtrack,
2101 hitlyrs_mc_build_FR_,
2102 hitidxs_mc_build_FR_,
2103 hitmcTkIDs_mc_build_FR_,
2104 hitxs_mc_build_FR_,
2105 hitys_mc_build_FR_,
2106 hitzs_mc_build_FR_);
2107 } else
2108 {
2109
2110 pt_mc_build_FR_ = -99;
2111 phi_mc_build_FR_ = -99;
2112 eta_mc_build_FR_ = -99;
2113 helixchi2_build_FR_ = -99;
2114
2115 mcTSmask_build_FR_ = -1;
2116
2117 nHits_mc_build_FR_ = -99;
2118 nLayers_mc_build_FR_ = -99;
2119 lastlyr_mc_build_FR_ = -99;
2120
2121 duplmask_build_FR_ = -1;
2122 iTkMatches_build_FR_ = -99;
2123 }
2124 }
2125
2126 else
2127 {
2128 seedmask_build_FR_ = 0;
2129
2130
2131 xhit_build_FR_ = -3000;
2132 yhit_build_FR_ = -3000;
2133 zhit_build_FR_ = -3000;
2134
2135
2136 pt_build_FR_ = -100;
2137 ept_build_FR_ = -100;
2138 phi_build_FR_ = -100;
2139 ephi_build_FR_ = -100;
2140 eta_build_FR_ = -100;
2141 eeta_build_FR_ = -100;
2142
2143 nHits_build_FR_ = -100;
2144 nLayers_build_FR_ = -100;
2145 nHitsMatched_build_FR_ = -100;
2146 fracHitsMatched_build_FR_ = -100;
2147 lastlyr_build_FR_ = -100;
2148
2149 dphi_build_FR_ = -100;
2150
2151 hitchi2_build_FR_ = -100;
2152 score_build_FR_ = -5001;
2153
2154
2155 mcmask_build_FR_ = -2;
2156 mcID_build_FR_ = -100;
2157
2158 pt_mc_build_FR_ = -100;
2159 phi_mc_build_FR_ = -100;
2160 eta_mc_build_FR_ = -100;
2161 helixchi2_build_FR_ = -100;
2162
2163 mcTSmask_build_FR_ = -3;
2164
2165 nHits_mc_build_FR_ = -100;
2166 nLayers_mc_build_FR_ = -100;
2167 lastlyr_mc_build_FR_ = -100;
2168
2169 duplmask_build_FR_ = -2;
2170 iTkMatches_build_FR_ = -100;
2171 }
2172
2173
2174 if (seedToFitMap_.count(seedID_FR_)) {
2175 seedmask_fit_FR_ = 1;
2176
2177 const auto& fittrack = evt_fit_tracks[seedToFitMap_[seedID_FR_]];
2178 const auto& fitextra = evt_fit_extras[fittrack.label()];
2179
2180
2181 const Hit& lasthit = evt_layer_hits[fittrack.getLastFoundHitLyr()][fittrack.getLastFoundHitIdx()];
2182 xhit_fit_FR_ = lasthit.x();
2183 yhit_fit_FR_ = lasthit.y();
2184 zhit_fit_FR_ = lasthit.z();
2185
2186 pt_fit_FR_ = fittrack.pT();
2187 ept_fit_FR_ = fittrack.epT();
2188 phi_fit_FR_ = fittrack.momPhi();
2189 ephi_fit_FR_ = fittrack.emomPhi();
2190 eta_fit_FR_ = fittrack.momEta();
2191 eeta_fit_FR_ = fittrack.emomEta();
2192
2193 nHits_fit_FR_ = fittrack.nFoundHits();
2194 nLayers_fit_FR_ = fittrack.nUniqueLayers();
2195 nHitsMatched_fit_FR_ = fitextra.nHitsMatched();
2196 fracHitsMatched_fit_FR_ = fitextra.fracHitsMatched();
2197 lastlyr_fit_FR_ = fittrack.getLastFoundHitLyr();
2198
2199
2200 dphi_fit_FR_ = fitextra.dPhi();
2201
2202
2203 hitchi2_fit_FR_ = fittrack.chi2();
2204 score_fit_FR_ = fittrack.score();
2205
2206 if (Config::keepHitInfo)
2207 TTreeValidation::fillFullHitInfo(ev,
2208 fittrack,
2209 hitlyrs_fit_FR_,
2210 hitidxs_fit_FR_,
2211 hitmcTkIDs_fit_FR_,
2212 hitxs_fit_FR_,
2213 hitys_fit_FR_,
2214 hitzs_fit_FR_);
2215
2216
2217 mcID_fit_FR_ = fitextra.mcTrackID();
2218 mcmask_fit_FR_ = TTreeValidation::getMaskAssignment(mcID_fit_FR_);
2219
2220 if (mcmask_fit_FR_ == 1)
2221 {
2222 const auto& simtrack = evt_sim_tracks[mcID_fit_FR_];
2223
2224 const int mcHitID = TTreeValidation::getLastFoundHit(
2225 fittrack.getLastFoundMCHitID(evt_layer_hits), mcID_fit_FR_, ev);
2226 if (mcHitID >= 0 && Config::readSimTrackStates) {
2227 const TrackState& initLayTS = evt_sim_trackstates[mcHitID];
2228 pt_mc_fit_FR_ = initLayTS.pT();
2229 phi_mc_fit_FR_ = initLayTS.momPhi();
2230 eta_mc_fit_FR_ = initLayTS.momEta();
2231 helixchi2_fit_FR_ = computeHelixChi2(initLayTS.parameters, fittrack.parameters(), fittrack.errors());
2232
2233 mcTSmask_fit_FR_ = 1;
2234 } else if (Config::tryToSaveSimInfo) {
2235 pt_mc_fit_FR_ = simtrack.pT();
2236 phi_mc_fit_FR_ = simtrack.momPhi();
2237 eta_mc_fit_FR_ = simtrack.momEta();
2238 helixchi2_fit_FR_ = computeHelixChi2(simtrack.parameters(), fittrack.parameters(), fittrack.errors());
2239
2240 mcTSmask_fit_FR_ = 0;
2241 } else {
2242 pt_mc_fit_FR_ = -101;
2243 phi_mc_fit_FR_ = -101;
2244 eta_mc_fit_FR_ = -101;
2245 helixchi2_fit_FR_ = -101;
2246
2247 mcTSmask_fit_FR_ = -2;
2248 }
2249
2250 nHits_mc_fit_FR_ = simtrack.nFoundHits();
2251 nLayers_mc_fit_FR_ = simtrack.nUniqueLayers();
2252 lastlyr_mc_fit_FR_ = simtrack.getLastFoundHitLyr();
2253
2254 duplmask_fit_FR_ = fitextra.isDuplicate();
2255 iTkMatches_fit_FR_ =
2256 fitextra
2257 .duplicateID();
2258
2259 if (Config::keepHitInfo)
2260 TTreeValidation::fillFullHitInfo(ev,
2261 simtrack,
2262 hitlyrs_mc_fit_FR_,
2263 hitidxs_mc_fit_FR_,
2264 hitmcTkIDs_mc_fit_FR_,
2265 hitxs_mc_fit_FR_,
2266 hitys_mc_fit_FR_,
2267 hitzs_mc_fit_FR_);
2268 } else
2269 {
2270
2271 pt_mc_fit_FR_ = -99;
2272 phi_mc_fit_FR_ = -99;
2273 eta_mc_fit_FR_ = -99;
2274 helixchi2_fit_FR_ = -99;
2275
2276 mcTSmask_fit_FR_ = -1;
2277
2278 nHits_mc_fit_FR_ = -99;
2279 nLayers_mc_fit_FR_ = -99;
2280 lastlyr_mc_fit_FR_ = -99;
2281
2282 duplmask_fit_FR_ = -1;
2283 iTkMatches_fit_FR_ = -99;
2284 }
2285 }
2286
2287 else
2288 {
2289 seedmask_fit_FR_ = 0;
2290
2291
2292 xhit_fit_FR_ = -3000;
2293 yhit_fit_FR_ = -3000;
2294 zhit_fit_FR_ = -3000;
2295
2296
2297 pt_fit_FR_ = -100;
2298 ept_fit_FR_ = -100;
2299 phi_fit_FR_ = -100;
2300 ephi_fit_FR_ = -100;
2301 eta_fit_FR_ = -100;
2302 eeta_fit_FR_ = -100;
2303
2304 nHits_fit_FR_ = -100;
2305 nLayers_fit_FR_ = -100;
2306 nHitsMatched_fit_FR_ = -100;
2307 fracHitsMatched_fit_FR_ = -100;
2308 lastlyr_fit_FR_ = -100;
2309
2310 dphi_fit_FR_ = -100;
2311
2312 hitchi2_fit_FR_ = -100;
2313 score_fit_FR_ = -5001;
2314
2315
2316 mcmask_fit_FR_ = -2;
2317 mcID_fit_FR_ = -100;
2318
2319 pt_mc_fit_FR_ = -100;
2320 phi_mc_fit_FR_ = -100;
2321 eta_mc_fit_FR_ = -100;
2322 helixchi2_fit_FR_ = -100;
2323
2324 mcTSmask_fit_FR_ = -3;
2325
2326 nHits_mc_fit_FR_ = -100;
2327 nLayers_mc_fit_FR_ = -100;
2328 lastlyr_mc_fit_FR_ = -100;
2329
2330 duplmask_fit_FR_ = -2;
2331 iTkMatches_fit_FR_ = -100;
2332 }
2333
2334 frtree_->Fill();
2335 }
2336 }
2337
2338 void TTreeValidation::fillConfigTree() {
2339 std::lock_guard<std::mutex> locker(glock_);
2340
2341 Ntracks_ = Config::nTracks;
2342 Nevents_ = Config::nEvents;
2343
2344 nLayers_ = Config::nLayers;
2345
2346 nlayers_per_seed_ = Config::ItrInfo[0].m_params.nlayers_per_seed;
2347 maxCand_ = Config::ItrInfo[0].m_params.maxCandsPerSeed;
2348 chi2Cut_min_ = Config::ItrInfo[0].m_params.chi2Cut_min;
2349 nSigma_ = Config::nSigma;
2350 minDPhi_ = Config::minDPhi;
2351 maxDPhi_ = Config::maxDPhi;
2352 minDEta_ = Config::minDEta;
2353 maxDEta_ = Config::maxDEta;
2354
2355 beamspotX_ = Config::beamspotX;
2356 beamspotY_ = Config::beamspotY;
2357 beamspotZ_ = Config::beamspotZ;
2358
2359 minSimPt_ = Config::minSimPt;
2360 maxSimPt_ = Config::maxSimPt;
2361
2362 hitposerrXY_ = Config::hitposerrXY;
2363 hitposerrZ_ = Config::hitposerrZ;
2364 hitposerrR_ = Config::hitposerrR;
2365 varXY_ = Config::varXY;
2366 varZ_ = Config::varZ;
2367
2368 ptinverr049_ = Config::ptinverr049;
2369 phierr049_ = Config::phierr049;
2370 thetaerr049_ = Config::thetaerr049;
2371 ptinverr012_ = Config::ptinverr012;
2372 phierr012_ = Config::phierr012;
2373 thetaerr012_ = Config::thetaerr012;
2374
2375 configtree_->Fill();
2376 }
2377
2378 void TTreeValidation::fillCMSSWEfficiencyTree(const Event& ev) {
2379 std::lock_guard<std::mutex> locker(glock_);
2380
2381 const auto ievt = ev.evtID();
2382 const auto& evt_sim_tracks = ev.simTracks_;
2383 const auto& evt_cmssw_tracks = ev.cmsswTracks_;
2384 const auto& evt_cmssw_extras = ev.cmsswTracksExtra_;
2385 const auto& evt_build_tracks = ev.candidateTracks_;
2386 const auto& evt_build_extras = ev.candidateTracksExtra_;
2387 const auto& evt_fit_tracks = ev.fitTracks_;
2388 const auto& evt_fit_extras = ev.fitTracksExtra_;
2389 const auto& evt_layer_hits = ev.layerHits_;
2390
2391 for (const auto& cmsswtrack : evt_cmssw_tracks) {
2392
2393 if (Config::keepHitInfo) {
2394 hitlyrs_cmssw_ceff_.clear();
2395 hitlyrs_build_ceff_.clear();
2396 hitlyrs_mc_build_ceff_.clear();
2397 hitlyrs_fit_ceff_.clear();
2398 hitlyrs_mc_fit_ceff_.clear();
2399
2400 hitidxs_cmssw_ceff_.clear();
2401 hitidxs_build_ceff_.clear();
2402 hitidxs_mc_build_ceff_.clear();
2403 hitidxs_fit_ceff_.clear();
2404 hitidxs_mc_fit_ceff_.clear();
2405 }
2406
2407 const auto& cmsswextra = evt_cmssw_extras[cmsswtrack.label()];
2408
2409 evtID_ceff_ = ievt;
2410 cmsswID_ceff_ = cmsswtrack.label();
2411 seedID_cmssw_ceff_ = cmsswextra.seedID();
2412
2413
2414 x_cmssw_ceff_ = cmsswtrack.x();
2415 y_cmssw_ceff_ = cmsswtrack.y();
2416 z_cmssw_ceff_ = cmsswtrack.z();
2417
2418 pt_cmssw_ceff_ = cmsswtrack.pT();
2419 phi_cmssw_ceff_ = cmsswtrack.momPhi();
2420 eta_cmssw_ceff_ = cmsswtrack.momEta();
2421
2422 nHits_cmssw_ceff_ = cmsswtrack.nFoundHits();
2423 nLayers_cmssw_ceff_ = cmsswtrack.nUniqueLayers();
2424 lastlyr_cmssw_ceff_ = cmsswtrack.getLastFoundHitLyr();
2425
2426 itermask_build_ceff_ = 0;
2427 itermask_fit_ceff_ = 0;
2428 iterduplmask_build_ceff_ = 0;
2429 iterduplmask_fit_ceff_ = 0;
2430 algo_seed_ceff_ = 0;
2431
2432 for (auto aa : cmsswextra.seedAlgos())
2433 algo_seed_ceff_ = (algo_seed_ceff_ | (1 << aa));
2434
2435 if (Config::keepHitInfo)
2436 TTreeValidation::fillMinHitInfo(cmsswtrack, hitlyrs_cmssw_ceff_, hitidxs_cmssw_ceff_);
2437
2438
2439 if (cmsswToBuildMap_.count(cmsswID_ceff_) &&
2440 cmsswtrack
2441 .isFindable())
2442 {
2443 for (unsigned int ii = 0; ii < cmsswToBuildMap_[cmsswID_ceff_].size(); ii++) {
2444 const int theAlgo = evt_build_tracks[cmsswToBuildMap_[cmsswID_ceff_][ii]].algoint();
2445 if ((itermask_build_ceff_ >> theAlgo) & 1)
2446 iterduplmask_build_ceff_ = (iterduplmask_build_ceff_ | (1 << theAlgo));
2447 itermask_build_ceff_ = (itermask_build_ceff_ | (1 << theAlgo));
2448 }
2449
2450 const auto& buildtrack =
2451 evt_build_tracks[cmsswToBuildMap_[cmsswID_ceff_][0]];
2452 const auto& buildextra =
2453 evt_build_extras[buildtrack.label()];
2454 cmsswmask_build_ceff_ = 1;
2455
2456 seedID_build_ceff_ = buildextra.seedID();
2457 mcTrackID_build_ceff_ = buildextra.mcTrackID();
2458
2459
2460 pt_build_ceff_ = buildtrack.pT();
2461 ept_build_ceff_ = buildtrack.epT();
2462 phi_build_ceff_ = buildtrack.momPhi();
2463 ephi_build_ceff_ = buildtrack.emomPhi();
2464 eta_build_ceff_ = buildtrack.momEta();
2465 eeta_build_ceff_ = buildtrack.emomEta();
2466
2467
2468 if (mcTrackID_build_ceff_ >= 0) {
2469 const auto& simtrack = evt_sim_tracks[mcTrackID_build_ceff_];
2470 x_mc_build_ceff_ = simtrack.x();
2471 y_mc_build_ceff_ = simtrack.y();
2472 z_mc_build_ceff_ = simtrack.z();
2473 pt_mc_build_ceff_ = simtrack.pT();
2474 phi_mc_build_ceff_ = simtrack.momPhi();
2475 eta_mc_build_ceff_ = simtrack.momEta();
2476
2477 if (Config::keepHitInfo)
2478 TTreeValidation::fillMinHitInfo(simtrack, hitlyrs_mc_build_ceff_, hitidxs_mc_build_ceff_);
2479 } else {
2480 x_mc_build_ceff_ = -1000;
2481 y_mc_build_ceff_ = -1000;
2482 z_mc_build_ceff_ = -1000;
2483 pt_mc_build_ceff_ = -99;
2484 phi_mc_build_ceff_ = -99;
2485 eta_mc_build_ceff_ = -99;
2486 }
2487
2488
2489 nHits_build_ceff_ = buildtrack.nFoundHits();
2490 nLayers_build_ceff_ = buildtrack.nUniqueLayers();
2491 nHitsMatched_build_ceff_ = buildextra.nHitsMatched();
2492 fracHitsMatched_build_ceff_ = buildextra.fracHitsMatched();
2493 lastlyr_build_ceff_ = buildtrack.getLastFoundHitLyr();
2494
2495
2496 const Hit& lasthit = evt_layer_hits[buildtrack.getLastFoundHitLyr()][buildtrack.getLastFoundHitIdx()];
2497 xhit_build_ceff_ = lasthit.x();
2498 yhit_build_ceff_ = lasthit.y();
2499 zhit_build_ceff_ = lasthit.z();
2500
2501
2502 hitchi2_build_ceff_ = buildtrack.chi2();
2503 helixchi2_build_ceff_ = buildextra.helixChi2();
2504 score_build_ceff_ = buildtrack.score();
2505
2506
2507 dphi_build_ceff_ = buildextra.dPhi();
2508
2509
2510 duplmask_build_ceff_ = buildextra.isDuplicate();
2511 nTkMatches_build_ceff_ = cmsswToBuildMap_[cmsswID_ceff_].size();
2512
2513 if (Config::keepHitInfo)
2514 TTreeValidation::fillMinHitInfo(buildtrack, hitlyrs_build_ceff_, hitidxs_build_ceff_);
2515 } else
2516 {
2517 cmsswmask_build_ceff_ = (cmsswtrack.isFindable() ? 0 : -1);
2518
2519 seedID_build_ceff_ = -99;
2520 mcTrackID_build_ceff_ = -99;
2521
2522 pt_build_ceff_ = -99;
2523 ept_build_ceff_ = -99;
2524 phi_build_ceff_ = -99;
2525 ephi_build_ceff_ = -99;
2526 eta_build_ceff_ = -99;
2527 eeta_build_ceff_ = -99;
2528
2529 x_mc_build_ceff_ = -2000;
2530 y_mc_build_ceff_ = -2000;
2531 z_mc_build_ceff_ = -2000;
2532 pt_mc_build_ceff_ = -99;
2533 phi_mc_build_ceff_ = -99;
2534 eta_mc_build_ceff_ = -99;
2535
2536 nHits_build_ceff_ = -99;
2537 nLayers_build_ceff_ = -99;
2538 nHitsMatched_build_ceff_ = -99;
2539 fracHitsMatched_build_ceff_ = -99;
2540 lastlyr_build_ceff_ = -99;
2541
2542 xhit_build_ceff_ = -2000;
2543 yhit_build_ceff_ = -2000;
2544 zhit_build_ceff_ = -2000;
2545
2546 hitchi2_build_ceff_ = -99;
2547 helixchi2_build_ceff_ = -99;
2548 score_build_ceff_ = -17000;
2549
2550 dphi_build_ceff_ = -99;
2551
2552 duplmask_build_ceff_ = -1;
2553 nTkMatches_build_ceff_ = -99;
2554 }
2555
2556
2557 if (cmsswToFitMap_.count(cmsswID_ceff_) &&
2558 cmsswtrack
2559 .isFindable())
2560 {
2561 for (unsigned int ii = 0; ii < cmsswToFitMap_[cmsswID_ceff_].size(); ii++) {
2562 const int theAlgo = evt_build_tracks[cmsswToFitMap_[cmsswID_ceff_][ii]].algoint();
2563 if ((itermask_fit_ceff_ >> theAlgo) & 1)
2564 iterduplmask_fit_ceff_ = (iterduplmask_fit_ceff_ | (1 << theAlgo));
2565 itermask_fit_ceff_ = (itermask_fit_ceff_ | (1 << theAlgo));
2566 }
2567
2568 const auto& fittrack =
2569 evt_fit_tracks[cmsswToFitMap_[cmsswID_ceff_][0]];
2570 const auto& fitextra = evt_fit_extras[fittrack.label()];
2571 cmsswmask_fit_ceff_ = 1;
2572
2573 seedID_fit_ceff_ = fitextra.seedID();
2574 mcTrackID_fit_ceff_ = fitextra.mcTrackID();
2575
2576
2577 pt_fit_ceff_ = fittrack.pT();
2578 ept_fit_ceff_ = fittrack.epT();
2579 phi_fit_ceff_ = fittrack.momPhi();
2580 ephi_fit_ceff_ = fittrack.emomPhi();
2581 eta_fit_ceff_ = fittrack.momEta();
2582 eeta_fit_ceff_ = fittrack.emomEta();
2583
2584
2585 if (mcTrackID_fit_ceff_ >= 0) {
2586 const auto& simtrack = evt_sim_tracks[mcTrackID_fit_ceff_];
2587 x_mc_fit_ceff_ = simtrack.x();
2588 y_mc_fit_ceff_ = simtrack.y();
2589 z_mc_fit_ceff_ = simtrack.z();
2590 pt_mc_fit_ceff_ = simtrack.pT();
2591 phi_mc_fit_ceff_ = simtrack.momPhi();
2592 eta_mc_fit_ceff_ = simtrack.momEta();
2593
2594 if (Config::keepHitInfo)
2595 TTreeValidation::fillMinHitInfo(simtrack, hitlyrs_mc_fit_ceff_, hitidxs_mc_fit_ceff_);
2596 } else {
2597 x_mc_fit_ceff_ = -1000;
2598 y_mc_fit_ceff_ = -1000;
2599 z_mc_fit_ceff_ = -1000;
2600 pt_mc_fit_ceff_ = -99;
2601 phi_mc_fit_ceff_ = -99;
2602 eta_mc_fit_ceff_ = -99;
2603 }
2604
2605
2606 nHits_fit_ceff_ = fittrack.nFoundHits();
2607 nLayers_fit_ceff_ = fittrack.nUniqueLayers();
2608 nHitsMatched_fit_ceff_ = fitextra.nHitsMatched();
2609 fracHitsMatched_fit_ceff_ = fitextra.fracHitsMatched();
2610 lastlyr_fit_ceff_ = fittrack.getLastFoundHitLyr();
2611
2612
2613 const Hit& lasthit = evt_layer_hits[fittrack.getLastFoundHitLyr()][fittrack.getLastFoundHitIdx()];
2614 xhit_fit_ceff_ = lasthit.x();
2615 yhit_fit_ceff_ = lasthit.y();
2616 zhit_fit_ceff_ = lasthit.z();
2617
2618
2619 hitchi2_fit_ceff_ = fittrack.chi2();
2620 helixchi2_fit_ceff_ = fitextra.helixChi2();
2621 score_fit_ceff_ = fittrack.score();
2622
2623
2624 dphi_fit_ceff_ = fitextra.dPhi();
2625
2626
2627 duplmask_fit_ceff_ = fitextra.isDuplicate();
2628 nTkMatches_fit_ceff_ = cmsswToFitMap_[cmsswID_ceff_].size();
2629
2630 if (Config::keepHitInfo)
2631 TTreeValidation::fillMinHitInfo(fittrack, hitlyrs_fit_ceff_, hitidxs_fit_ceff_);
2632 } else
2633 {
2634 cmsswmask_fit_ceff_ = (cmsswtrack.isFindable() ? 0 : -1);
2635
2636 seedID_fit_ceff_ = -99;
2637 mcTrackID_fit_ceff_ = -99;
2638
2639 pt_fit_ceff_ = -99;
2640 ept_fit_ceff_ = -99;
2641 phi_fit_ceff_ = -99;
2642 ephi_fit_ceff_ = -99;
2643 eta_fit_ceff_ = -99;
2644 eeta_fit_ceff_ = -99;
2645
2646 x_mc_fit_ceff_ = -2000;
2647 y_mc_fit_ceff_ = -2000;
2648 z_mc_fit_ceff_ = -2000;
2649 pt_mc_fit_ceff_ = -99;
2650 phi_mc_fit_ceff_ = -99;
2651 eta_mc_fit_ceff_ = -99;
2652
2653 nHits_fit_ceff_ = -99;
2654 nLayers_fit_ceff_ = -99;
2655 nHitsMatched_fit_ceff_ = -99;
2656 fracHitsMatched_fit_ceff_ = -99;
2657 lastlyr_fit_ceff_ = -99;
2658
2659 xhit_fit_ceff_ = -2000;
2660 yhit_fit_ceff_ = -2000;
2661 zhit_fit_ceff_ = -2000;
2662
2663 hitchi2_fit_ceff_ = -99;
2664 helixchi2_fit_ceff_ = -99;
2665 score_fit_ceff_ = -17000;
2666
2667 dphi_fit_ceff_ = -99;
2668
2669 duplmask_fit_ceff_ = -1;
2670 nTkMatches_fit_ceff_ = -99;
2671 }
2672
2673 cmsswefftree_->Fill();
2674 }
2675 }
2676
2677 void TTreeValidation::fillCMSSWFakeRateTree(const Event& ev) {
2678 std::lock_guard<std::mutex> locker(glock_);
2679
2680 auto ievt = ev.evtID();
2681 const auto& evt_sim_tracks = ev.simTracks_;
2682 const auto& evt_cmssw_tracks = ev.cmsswTracks_;
2683 const auto& evt_cmssw_extras = ev.cmsswTracksExtra_;
2684 const auto& evt_build_tracks = ev.candidateTracks_;
2685 const auto& evt_build_extras = ev.candidateTracksExtra_;
2686 const auto& evt_fit_tracks = ev.fitTracks_;
2687 const auto& evt_fit_extras = ev.fitTracksExtra_;
2688 const auto& evt_layer_hits = ev.layerHits_;
2689
2690 for (const auto& buildtrack : evt_build_tracks) {
2691 if (Config::keepHitInfo) {
2692 hitlyrs_mc_cFR_.clear();
2693 hitlyrs_build_cFR_.clear();
2694 hitlyrs_cmssw_build_cFR_.clear();
2695 hitlyrs_fit_cFR_.clear();
2696 hitlyrs_cmssw_fit_cFR_.clear();
2697
2698 hitidxs_mc_cFR_.clear();
2699 hitidxs_build_cFR_.clear();
2700 hitidxs_cmssw_build_cFR_.clear();
2701 hitidxs_fit_cFR_.clear();
2702 hitidxs_cmssw_fit_cFR_.clear();
2703 }
2704
2705 algorithm_cFR_ = buildtrack.algoint();
2706
2707 const auto& buildextra = evt_build_extras[buildtrack.label()];
2708
2709
2710 evtID_cFR_ = ievt;
2711 seedID_cFR_ = buildextra.seedID();
2712 mcTrackID_cFR_ = buildextra.mcTrackID();
2713
2714
2715 pt_build_cFR_ = buildtrack.pT();
2716 ept_build_cFR_ = buildtrack.epT();
2717 phi_build_cFR_ = buildtrack.momPhi();
2718 ephi_build_cFR_ = buildtrack.emomPhi();
2719 eta_build_cFR_ = buildtrack.momEta();
2720 eeta_build_cFR_ = buildtrack.emomEta();
2721
2722
2723 if (mcTrackID_cFR_ >= 0) {
2724 const auto& simtrack = evt_sim_tracks[mcTrackID_cFR_];
2725 x_mc_cFR_ = simtrack.x();
2726 y_mc_cFR_ = simtrack.y();
2727 z_mc_cFR_ = simtrack.z();
2728 pt_mc_cFR_ = simtrack.pT();
2729 phi_mc_cFR_ = simtrack.momPhi();
2730 eta_mc_cFR_ = simtrack.momEta();
2731
2732 if (Config::keepHitInfo)
2733 TTreeValidation::fillMinHitInfo(simtrack, hitlyrs_mc_cFR_, hitidxs_mc_cFR_);
2734 } else {
2735 x_mc_cFR_ = -1000;
2736 y_mc_cFR_ = -1000;
2737 z_mc_cFR_ = -1000;
2738 pt_mc_cFR_ = -99;
2739 phi_mc_cFR_ = -99;
2740 eta_mc_cFR_ = -99;
2741 }
2742
2743
2744 nHits_build_cFR_ = buildtrack.nFoundHits();
2745 nLayers_build_cFR_ = buildtrack.nUniqueLayers();
2746 nHitsMatched_build_cFR_ = buildextra.nHitsMatched();
2747 fracHitsMatched_build_cFR_ = buildextra.fracHitsMatched();
2748 lastlyr_build_cFR_ = buildtrack.getLastFoundHitLyr();
2749
2750
2751 const Hit& lasthit = evt_layer_hits[buildtrack.getLastFoundHitLyr()][buildtrack.getLastFoundHitIdx()];
2752 xhit_build_cFR_ = lasthit.x();
2753 yhit_build_cFR_ = lasthit.y();
2754 zhit_build_cFR_ = lasthit.z();
2755
2756
2757 hitchi2_build_cFR_ = buildtrack.chi2();
2758 helixchi2_build_cFR_ = buildextra.helixChi2();
2759 score_build_cFR_ = buildtrack.score();
2760
2761
2762 dphi_build_cFR_ = buildextra.dPhi();
2763
2764 if (Config::keepHitInfo)
2765 TTreeValidation::fillMinHitInfo(buildtrack, hitlyrs_build_cFR_, hitidxs_build_cFR_);
2766
2767
2768 cmsswID_build_cFR_ = buildextra.cmsswTrackID();
2769 cmsswmask_build_cFR_ = TTreeValidation::getMaskAssignment(cmsswID_build_cFR_);
2770
2771 if (cmsswmask_build_cFR_ == 1)
2772 {
2773 const auto& cmsswtrack = evt_cmssw_tracks[cmsswID_build_cFR_];
2774 const auto& cmsswextra = evt_cmssw_extras[cmsswtrack.label()];
2775
2776 seedID_cmssw_build_cFR_ = cmsswextra.seedID();
2777
2778 x_cmssw_build_cFR_ = cmsswtrack.x();
2779 y_cmssw_build_cFR_ = cmsswtrack.y();
2780 z_cmssw_build_cFR_ = cmsswtrack.z();
2781
2782 pt_cmssw_build_cFR_ = cmsswtrack.pT();
2783 phi_cmssw_build_cFR_ = cmsswtrack.momPhi();
2784 eta_cmssw_build_cFR_ = cmsswtrack.momEta();
2785
2786 nHits_cmssw_build_cFR_ = cmsswtrack.nFoundHits();
2787 nLayers_cmssw_build_cFR_ = cmsswtrack.nUniqueLayers();
2788 lastlyr_cmssw_build_cFR_ = cmsswtrack.getLastFoundHitLyr();
2789
2790
2791 duplmask_build_cFR_ = buildextra.isDuplicate();
2792 iTkMatches_build_cFR_ = buildextra.duplicateID();
2793
2794 if (Config::keepHitInfo)
2795 TTreeValidation::fillMinHitInfo(cmsswtrack, hitlyrs_cmssw_build_cFR_, hitidxs_cmssw_build_cFR_);
2796 } else
2797 {
2798 seedID_cmssw_build_cFR_ = -99;
2799
2800 x_cmssw_build_cFR_ = -2000;
2801 y_cmssw_build_cFR_ = -2000;
2802 z_cmssw_build_cFR_ = -2000;
2803
2804 pt_cmssw_build_cFR_ = -99;
2805 phi_cmssw_build_cFR_ = -99;
2806 eta_cmssw_build_cFR_ = -99;
2807
2808 nHits_cmssw_build_cFR_ = -99;
2809 nLayers_cmssw_build_cFR_ = -99;
2810 lastlyr_cmssw_build_cFR_ = -99;
2811
2812 duplmask_build_cFR_ = -1;
2813 iTkMatches_build_cFR_ = -99;
2814 }
2815
2816
2817 if (buildToFitMap_.count(buildtrack.label())) {
2818 const auto& fittrack = evt_fit_tracks[buildToFitMap_[buildtrack.label()]];
2819 const auto& fitextra = evt_fit_extras[fittrack.label()];
2820
2821
2822 pt_fit_cFR_ = fittrack.pT();
2823 ept_fit_cFR_ = fittrack.epT();
2824 phi_fit_cFR_ = fittrack.momPhi();
2825 ephi_fit_cFR_ = fittrack.emomPhi();
2826 eta_fit_cFR_ = fittrack.momEta();
2827 eeta_fit_cFR_ = fittrack.emomEta();
2828
2829
2830 nHits_fit_cFR_ = fittrack.nFoundHits();
2831 nLayers_fit_cFR_ = fittrack.nUniqueLayers();
2832 nHitsMatched_fit_cFR_ = fitextra.nHitsMatched();
2833 fracHitsMatched_fit_cFR_ = fitextra.fracHitsMatched();
2834 lastlyr_fit_cFR_ = fittrack.getLastFoundHitLyr();
2835
2836
2837 const Hit& lasthit = evt_layer_hits[fittrack.getLastFoundHitLyr()][fittrack.getLastFoundHitIdx()];
2838 xhit_fit_cFR_ = lasthit.x();
2839 yhit_fit_cFR_ = lasthit.y();
2840 zhit_fit_cFR_ = lasthit.z();
2841
2842
2843 hitchi2_fit_cFR_ = fittrack.chi2();
2844 helixchi2_fit_cFR_ = fitextra.helixChi2();
2845 score_fit_cFR_ = fittrack.score();
2846
2847
2848 dphi_fit_cFR_ = fitextra.dPhi();
2849
2850 if (Config::keepHitInfo)
2851 TTreeValidation::fillMinHitInfo(buildtrack, hitlyrs_fit_cFR_, hitidxs_fit_cFR_);
2852
2853
2854 cmsswID_fit_cFR_ = fitextra.cmsswTrackID();
2855 cmsswmask_fit_cFR_ = TTreeValidation::getMaskAssignment(cmsswID_fit_cFR_);
2856
2857 if (cmsswmask_fit_cFR_ == 1)
2858 {
2859 const auto& cmsswtrack = evt_cmssw_tracks[cmsswID_fit_cFR_];
2860 const auto& cmsswextra = evt_cmssw_extras[cmsswtrack.label()];
2861
2862 seedID_cmssw_fit_cFR_ = cmsswextra.seedID();
2863
2864 x_cmssw_fit_cFR_ = cmsswtrack.x();
2865 y_cmssw_fit_cFR_ = cmsswtrack.y();
2866 z_cmssw_fit_cFR_ = cmsswtrack.z();
2867
2868 pt_cmssw_fit_cFR_ = cmsswtrack.pT();
2869 phi_cmssw_fit_cFR_ = cmsswtrack.momPhi();
2870 eta_cmssw_fit_cFR_ = cmsswtrack.momEta();
2871
2872 nHits_cmssw_fit_cFR_ = cmsswtrack.nFoundHits();
2873 nLayers_cmssw_fit_cFR_ = cmsswtrack.nUniqueLayers();
2874 lastlyr_cmssw_fit_cFR_ = cmsswtrack.getLastFoundHitLyr();
2875
2876
2877 duplmask_fit_cFR_ = fitextra.isDuplicate();
2878 iTkMatches_fit_cFR_ = fitextra.duplicateID();
2879
2880 if (Config::keepHitInfo)
2881 TTreeValidation::fillMinHitInfo(fittrack, hitlyrs_cmssw_fit_cFR_, hitidxs_cmssw_fit_cFR_);
2882 } else
2883 {
2884 seedID_cmssw_fit_cFR_ = -99;
2885
2886 x_cmssw_fit_cFR_ = -2000;
2887 y_cmssw_fit_cFR_ = -2000;
2888 z_cmssw_fit_cFR_ = -2000;
2889
2890 pt_cmssw_fit_cFR_ = -99;
2891 phi_cmssw_fit_cFR_ = -99;
2892 eta_cmssw_fit_cFR_ = -99;
2893
2894 nHits_cmssw_fit_cFR_ = -99;
2895 nLayers_cmssw_fit_cFR_ = -99;
2896 lastlyr_cmssw_fit_cFR_ = -99;
2897
2898 duplmask_fit_cFR_ = -1;
2899 iTkMatches_fit_cFR_ = -99;
2900 }
2901 } else
2902 {
2903 pt_fit_cFR_ = -100;
2904 ept_fit_cFR_ = -100;
2905 phi_fit_cFR_ = -100;
2906 ephi_fit_cFR_ = -100;
2907 eta_fit_cFR_ = -100;
2908 eeta_fit_cFR_ = -100;
2909
2910 nHits_fit_cFR_ = -100;
2911 nLayers_fit_cFR_ = -100;
2912 nHitsMatched_fit_cFR_ = -100;
2913 fracHitsMatched_fit_cFR_ = -100;
2914 lastlyr_fit_cFR_ = -100;
2915
2916 xhit_fit_cFR_ = -3000;
2917 yhit_fit_cFR_ = -3000;
2918 zhit_fit_cFR_ = -3000;
2919
2920 hitchi2_fit_cFR_ = -100;
2921 helixchi2_fit_cFR_ = -100;
2922 score_fit_cFR_ = -5001;
2923 dphi_fit_cFR_ = -100;
2924
2925 cmsswID_fit_cFR_ = -100;
2926 cmsswmask_fit_cFR_ = -2;
2927
2928 seedID_cmssw_fit_cFR_ = -100;
2929
2930 x_cmssw_fit_cFR_ = -3000;
2931 y_cmssw_fit_cFR_ = -3000;
2932 z_cmssw_fit_cFR_ = -3000;
2933
2934 pt_cmssw_fit_cFR_ = -100;
2935 phi_cmssw_fit_cFR_ = -100;
2936 eta_cmssw_fit_cFR_ = -100;
2937
2938 nHits_cmssw_fit_cFR_ = -100;
2939 nLayers_cmssw_fit_cFR_ = -100;
2940 lastlyr_cmssw_fit_cFR_ = -100;
2941
2942 duplmask_fit_cFR_ = -2;
2943 iTkMatches_fit_cFR_ = -100;
2944 }
2945
2946 cmsswfrtree_->Fill();
2947 }
2948 }
2949
2950 void TTreeValidation::saveTTrees() {
2951 std::lock_guard<std::mutex> locker(glock_);
2952 f_->cd();
2953
2954 if (Config::sim_val_for_cmssw || Config::sim_val) {
2955 efftree_->SetDirectory(f_.get());
2956 efftree_->Write();
2957
2958 frtree_->SetDirectory(f_.get());
2959 frtree_->Write();
2960 }
2961 if (Config::cmssw_val) {
2962 cmsswefftree_->SetDirectory(f_.get());
2963 cmsswefftree_->Write();
2964
2965 cmsswfrtree_->SetDirectory(f_.get());
2966 cmsswfrtree_->Write();
2967 }
2968 if (Config::fit_val) {
2969 fittree_->SetDirectory(f_.get());
2970 fittree_->Write();
2971 }
2972
2973 configtree_->SetDirectory(f_.get());
2974 configtree_->Write();
2975 }
2976
2977 }
2978 #endif