File indexing completed on 2025-08-05 08:15:18
0001
0002 #include "TrackClusterEvaluator.h"
0003
0004 #include <fun4all/Fun4AllReturnCodes.h>
0005 #include <fun4all/Fun4AllServer.h>
0006 #include <g4main/PHG4Hit.h>
0007 #include <g4main/PHG4Particle.h>
0008 #include <g4main/PHG4TruthInfoContainer.h>
0009 #include <g4main/PHG4VtxPoint.h>
0010 #include <phool/PHCompositeNode.h>
0011 #include <phool/getClass.h>
0012
0013 #include <trackbase/ActsSurfaceMaps.h>
0014 #include <trackbase/ActsTrackingGeometry.h>
0015 #include <trackbase/TrkrCluster.h>
0016 #include <trackbase/TrkrClusterContainer.h>
0017 #include <trackbase/TrkrClusterHitAssoc.h>
0018 #include <trackbase/TrkrHit.h>
0019 #include <trackbase/TrkrHitSet.h>
0020 #include <trackbase/TrkrHitSetContainer.h>
0021
0022 #include <trackbase_historic/ActsTransformations.h>
0023 #include <trackbase_historic/SvtxTrack.h>
0024 #include <trackbase_historic/SvtxTrackMap.h>
0025 #include <trackbase_historic/SvtxVertex.h>
0026 #include <trackbase_historic/SvtxVertexMap.h>
0027
0028 #include <g4eval/SvtxEvalStack.h>
0029 #include <g4eval/SvtxTrackEval.h>
0030 #include <g4eval/SvtxTruthEval.h>
0031
0032 #include <phool/PHCompositeNode.h>
0033
0034 #include <TFile.h>
0035 #include <TTree.h>
0036 #include <TVector3.h>
0037
0038
0039 TrackClusterEvaluator::TrackClusterEvaluator(const std::string &name)
0040 : SubsysReco(name)
0041 {
0042
0043 }
0044
0045
0046 TrackClusterEvaluator::~TrackClusterEvaluator()
0047 {
0048
0049 }
0050
0051
0052 int TrackClusterEvaluator::Init(PHCompositeNode*)
0053 {
0054
0055 return Fun4AllReturnCodes::EVENT_OK;
0056 }
0057
0058
0059 int TrackClusterEvaluator::InitRun(PHCompositeNode *topNode)
0060 {
0061 int returnval = getNodes(topNode);
0062 event = m_proc * m_nevent;
0063 m_outfile = new TFile(m_outfilename.c_str(), "RECREATE");
0064 setupTrees();
0065
0066 return returnval;
0067 }
0068
0069
0070 int TrackClusterEvaluator::process_event(PHCompositeNode *topNode)
0071 {
0072 if (!m_svtxevalstack)
0073 {
0074 m_svtxevalstack = new SvtxEvalStack(topNode);
0075 m_svtxevalstack->set_strict(false);
0076 m_svtxevalstack->set_verbosity(Verbosity());
0077 m_svtxevalstack->set_use_initial_vertex(true);
0078 m_svtxevalstack->set_use_genfit_vertex(false);
0079 m_svtxevalstack->next_event(topNode);
0080 }
0081 else
0082 {
0083 m_svtxevalstack->next_event(topNode);
0084 }
0085
0086 if (Verbosity() > 0)
0087 {
0088 std::cout << "Analyzing truth " << std::endl;
0089 }
0090 if (m_truthContainer)
0091 {
0092 processTruthTracks(topNode);
0093 }
0094 if (Verbosity() > 0)
0095 {
0096 std::cout << "Analyzing reco " << std::endl;
0097 }
0098 if (m_trackMap)
0099 {
0100 processRecoTracks(topNode);
0101 }
0102
0103 event++;
0104
0105 return Fun4AllReturnCodes::EVENT_OK;
0106 }
0107
0108 void TrackClusterEvaluator::processTruthTracks(PHCompositeNode *topNode)
0109 {
0110 SvtxTruthEval *trutheval = m_svtxevalstack->get_truth_eval();
0111 SvtxClusterEval *clustereval = m_svtxevalstack->get_cluster_eval();
0112 SvtxTrackEval *trackeval = m_svtxevalstack->get_track_eval();
0113 auto surfmaps = findNode::getClass<ActsSurfaceMaps>(topNode, "ActsSurfaceMaps");
0114 auto tgeometry = findNode::getClass<ActsTrackingGeometry>(topNode, "ActsTrackingGeometry");
0115
0116 PHG4TruthInfoContainer::ConstRange range = m_truthContainer->GetParticleRange();
0117
0118 if (m_scanForPrimaries)
0119 {
0120 range = m_truthContainer->GetPrimaryParticleRange();
0121 }
0122
0123 gntracks = m_truthContainer->GetNumPrimaryVertexParticles();
0124
0125 ActsTransformations actsTransformer;
0126
0127 for (PHG4TruthInfoContainer::ConstIterator iter = range.first;
0128 iter != range.second; ++iter)
0129 {
0130 PHG4Particle *g4particle = iter->second;
0131 resetTreeValues();
0132
0133 if (m_scanForEmbedded)
0134 {
0135 if (trutheval->get_embed(g4particle) <= 0)
0136 {
0137 continue;
0138 }
0139 }
0140
0141 gtrackID = g4particle->get_track_id();
0142
0143 gflavor = g4particle->get_pid();
0144
0145 std::set<TrkrDefs::cluskey> g4clusters = clustereval->all_clusters_from(g4particle);
0146 gnmaps = 0;
0147 gnintt = 0;
0148 gntpc = 0;
0149 gnmms = 0;
0150
0151 for (const auto &g4cluster : g4clusters)
0152 {
0153 auto cluster = m_clusterContainer->findCluster(g4cluster);
0154 std::shared_ptr<TrkrCluster> truthCluster = clustereval->max_truth_cluster_by_energy(g4cluster);
0155
0156 gclusterkeys.push_back(g4cluster);
0157 auto global = actsTransformer.getGlobalPosition(cluster, surfmaps, tgeometry);
0158 if (truthCluster)
0159 {
0160 tgclusterx.push_back(truthCluster->getX());
0161 tgclustery.push_back(truthCluster->getY());
0162 tgclusterz.push_back(truthCluster->getZ());
0163 }
0164 else
0165 {
0166 tgclusterx.push_back(NAN);
0167 tgclustery.push_back(NAN);
0168 tgclusterz.push_back(NAN);
0169 }
0170
0171 gclusterx.push_back(global(0));
0172 gclustery.push_back(global(1));
0173 gclusterz.push_back(global(2));
0174 gclusterrphierr.push_back(cluster->getActsLocalError(0, 0));
0175 gclusterzerr.push_back(cluster->getActsLocalError(1, 1));
0176
0177 unsigned int layer = TrkrDefs::getLayer(g4cluster);
0178 if (layer < 3)
0179 {
0180 gnmaps++;
0181 }
0182 else if (layer < 7)
0183 {
0184 gnintt++;
0185 }
0186 else if (layer < 55)
0187 {
0188 gntpc++;
0189 }
0190 else
0191 {
0192 gnmms++;
0193 }
0194 }
0195
0196 gpx = g4particle->get_px();
0197 gpy = g4particle->get_py();
0198 gpz = g4particle->get_pz();
0199 gpt = sqrt(gpx * gpx + gpy * gpy);
0200 TVector3 gv(gpx, gpy, gpz);
0201 geta = gv.Eta();
0202 gphi = gv.Phi();
0203
0204 PHG4VtxPoint *vtx = trutheval->get_vertex(g4particle);
0205 gvx = vtx->get_x();
0206 gvy = vtx->get_y();
0207 gvz = vtx->get_z();
0208 gvt = vtx->get_t();
0209
0210 gembed = trutheval->get_embed(g4particle);
0211 gprimary = trutheval->is_primary(g4particle);
0212
0213 auto track = trackeval->best_track_from(g4particle);
0214 if (track)
0215 {
0216 trackID = track->get_id();
0217
0218 px = track->get_px();
0219 py = track->get_py();
0220 pz = track->get_pz();
0221 quality = track->get_quality();
0222 TVector3 v(px, py, pz);
0223 pt = v.Pt();
0224 phi = v.Phi();
0225 eta = v.Eta();
0226 charge = track->get_charge();
0227 dca3dxy = track->get_dca3d_xy();
0228 dca3dz = track->get_dca3d_z();
0229 nmaps = 0;
0230 nintt = 0;
0231 ntpc = 0;
0232 nmms = 0;
0233
0234 for (SvtxTrack::ConstClusterKeyIter iter = track->begin_cluster_keys();
0235 iter != track->end_cluster_keys();
0236 ++iter)
0237 {
0238 TrkrDefs::cluskey ckey = *iter;
0239 auto tcluster = m_clusterContainer->findCluster(ckey);
0240 std::shared_ptr<TrkrCluster> truthCluster = clustereval->max_truth_cluster_by_energy(ckey);
0241 unsigned int layer = TrkrDefs::getLayer(ckey);
0242 if (layer < 3)
0243 {
0244 nmaps++;
0245 }
0246 else if (layer < 7)
0247 {
0248 nintt++;
0249 }
0250 else if (layer < 55)
0251 {
0252 ntpc++;
0253 }
0254 else
0255 {
0256 nmms++;
0257 }
0258
0259 clusterkeys.push_back(ckey);
0260 auto glob = actsTransformer.getGlobalPosition(tcluster, surfmaps, tgeometry);
0261
0262 if (truthCluster)
0263 {
0264 tclusterx.push_back(truthCluster->getX());
0265 tclustery.push_back(truthCluster->getY());
0266 tclusterz.push_back(truthCluster->getZ());
0267 }
0268 else
0269 {
0270 tclusterx.push_back(NAN);
0271 tclustery.push_back(NAN);
0272 tclusterz.push_back(NAN);
0273 }
0274 clusterx.push_back(glob(0));
0275 clustery.push_back(glob(1));
0276 clusterz.push_back(glob(2));
0277 clusterrphierr.push_back(tcluster->getActsLocalError(0, 0));
0278 clusterzerr.push_back(tcluster->getActsLocalError(1, 1));
0279 }
0280
0281 pcax = track->get_x();
0282 pcay = track->get_y();
0283 pcaz = track->get_z();
0284 }
0285
0286 auto matchedTracks = trackeval->all_tracks_from(g4particle);
0287
0288 for(const auto& track : matchedTracks)
0289 {
0290 dtrackID = track->get_id();
0291
0292 dpx = track->get_px();
0293 dpy = track->get_py();
0294 dpz = track->get_pz();
0295 dpt = track->get_pt();
0296 dpcax = track->get_x();
0297 dpcay = track->get_y();
0298 dpcaz = track->get_z();
0299 ddca3dxy = track->get_dca3d_xy();
0300 ddca3dz = track->get_dca3d_z();
0301 TVector3 vec;
0302 vec.SetXYZ(dpx,dpy,dpz);
0303 deta = vec.Eta();
0304 dphi = vec.Phi();
0305 dcharge = track->get_charge();
0306 dquality = track->get_quality();
0307
0308 int nmmaps = 0, nmintt=0, nmtpc=0, nmmms=0;
0309 for (SvtxTrack::ConstClusterKeyIter iter = track->begin_cluster_keys();
0310 iter != track->end_cluster_keys();
0311 ++iter)
0312 {
0313 TrkrDefs::cluskey ckey = *iter;
0314
0315 auto tcluster = m_clusterContainer->findCluster(ckey);
0316 unsigned int layer = TrkrDefs::getLayer(ckey);
0317 dclusterkeys.push_back(ckey);
0318 auto glob = actsTransformer.getGlobalPosition(tcluster, surfmaps, tgeometry);
0319 dclusterx.push_back(glob(0));
0320 dclustery.push_back(glob(1));
0321 dclusterz.push_back(glob(2));
0322 if (layer < 3)
0323 { nmmaps++; }
0324 else if (layer < 7)
0325 { nmintt++; }
0326 else if (layer < 55)
0327 { nmtpc++; }
0328 else
0329 { nmmms++; }
0330
0331 }
0332
0333 dnmaps = nmmaps;
0334 dnintt = nmintt;
0335 dntpc = nmtpc;
0336 dnmms = nmmms;
0337 m_duplicatetree->Fill();
0338
0339
0340 dclusterrphierr.clear();
0341 dclusterzerr.clear();
0342 dclusterkeys.clear();
0343 dclusterx.clear();
0344 dclustery.clear();
0345 dclusterz.clear();
0346 }
0347
0348 m_truthtree->Fill();
0349
0350 }
0351 }
0352
0353 void TrackClusterEvaluator::processRecoTracks(PHCompositeNode *topNode)
0354 {
0355 SvtxTruthEval *trutheval = m_svtxevalstack->get_truth_eval();
0356 SvtxClusterEval *clustereval = m_svtxevalstack->get_cluster_eval();
0357 SvtxTrackEval *trackeval = m_svtxevalstack->get_track_eval();
0358 auto surfmaps = findNode::getClass<ActsSurfaceMaps>(topNode, "ActsSurfaceMaps");
0359 auto tgeometry = findNode::getClass<ActsTrackingGeometry>(topNode, "ActsTrackingGeometry");
0360
0361 ActsTransformations actsTransformer;
0362
0363 for (const auto &[key, track] : *m_trackMap)
0364 {
0365 resetTreeValues();
0366 if(Verbosity() > 0)
0367 track->identify();
0368
0369 trackID = track->get_id();
0370
0371 px = track->get_px();
0372 py = track->get_py();
0373 pz = track->get_pz();
0374 quality = track->get_quality();
0375 TVector3 v(px, py, pz);
0376 pt = v.Pt();
0377 phi = v.Phi();
0378 eta = v.Eta();
0379 charge = track->get_charge();
0380 dca3dxy = track->get_dca3d_xy();
0381 dca3dz = track->get_dca3d_z();
0382 nmaps = 0;
0383 nintt = 0;
0384 ntpc = 0;
0385 nmms = 0;
0386
0387 for (SvtxTrack::ConstClusterKeyIter iter = track->begin_cluster_keys();
0388 iter != track->end_cluster_keys();
0389 ++iter)
0390 {
0391 TrkrDefs::cluskey ckey = *iter;
0392 auto tcluster = m_clusterContainer->findCluster(ckey);
0393 auto truthCluster = clustereval->max_truth_cluster_by_energy(ckey);
0394 unsigned int layer = TrkrDefs::getLayer(ckey);
0395 if (layer < 3)
0396 {
0397 nmaps++;
0398 }
0399 else if (layer < 7)
0400 {
0401 nintt++;
0402 }
0403 else if (layer < 55)
0404 {
0405 ntpc++;
0406 }
0407 else
0408 {
0409 nmms++;
0410 }
0411
0412 clusterkeys.push_back(ckey);
0413 auto glob = actsTransformer.getGlobalPosition(tcluster, surfmaps, tgeometry);
0414 clusterx.push_back(glob(0));
0415 clustery.push_back(glob(1));
0416 clusterz.push_back(glob(2));
0417 if (truthCluster)
0418 {
0419 tclusterx.push_back(truthCluster->getX());
0420 tclustery.push_back(truthCluster->getY());
0421 tclusterz.push_back(truthCluster->getZ());
0422 }
0423 else
0424 {
0425 tclusterx.push_back(NAN);
0426 tclustery.push_back(NAN);
0427 tclusterz.push_back(NAN);
0428 }
0429 clusterrphierr.push_back(tcluster->getActsLocalError(0, 0));
0430 clusterzerr.push_back(tcluster->getActsLocalError(1, 1));
0431 }
0432
0433 pcax = track->get_x();
0434 pcay = track->get_y();
0435 pcaz = track->get_z();
0436
0437 if (m_trackMatch)
0438 {
0439 auto allpart = trackeval->all_truth_particles(track);
0440
0441 PHG4Particle *g4particle = trackeval->max_truth_particle_by_nclusters(track);
0442
0443 if(g4particle) {
0444 auto matched_track = trackeval->best_track_from(g4particle);
0445
0446 if(matched_track)
0447 {
0448 matchedTrackID = matched_track->get_id();
0449
0450 }
0451
0452 auto matchedtracks = trackeval->all_tracks_from(g4particle);
0453 for(const auto ttrack : matchedtracks)
0454 {
0455 matchedRecoTracksID.push_back(ttrack->get_id());
0456 }
0457 if(matchedtracks.size() > 1)
0458 { isDuplicate = 1; }
0459 }
0460 if (m_scanForEmbedded)
0461 {
0462 if (trutheval->get_embed(g4particle) <= 0) continue;
0463 }
0464
0465 gtrackID = g4particle->get_track_id();
0466 gflavor = g4particle->get_pid();
0467
0468 std::set<TrkrDefs::cluskey> g4clusters = clustereval->all_clusters_from(g4particle);
0469
0470 gnmaps = 0;
0471 gnintt = 0;
0472 gntpc = 0;
0473 gnmms = 0;
0474 for (const auto &g4cluster : g4clusters)
0475 {
0476 auto cluster = m_clusterContainer->findCluster(g4cluster);
0477 gclusterkeys.push_back(g4cluster);
0478 auto truthCluster = clustereval->max_truth_cluster_by_energy(g4cluster);
0479 auto global = actsTransformer.getGlobalPosition(cluster, surfmaps, tgeometry);
0480 gclusterx.push_back(global(0));
0481 gclustery.push_back(global(1));
0482 gclusterz.push_back(global(2));
0483 if (truthCluster)
0484 {
0485 tgclusterx.push_back(truthCluster->getX());
0486 tgclustery.push_back(truthCluster->getY());
0487 tgclusterz.push_back(truthCluster->getZ());
0488 }
0489 else
0490 {
0491 tgclusterx.push_back(NAN);
0492 tgclustery.push_back(NAN);
0493 tgclusterz.push_back(NAN);
0494 }
0495 gclusterrphierr.push_back(cluster->getActsLocalError(0, 0));
0496 gclusterzerr.push_back(cluster->getActsLocalError(1, 1));
0497
0498 unsigned int layer = TrkrDefs::getLayer(g4cluster);
0499 if (layer < 3)
0500 {
0501 gnmaps++;
0502 }
0503 else if (layer < 7)
0504 {
0505 gnintt++;
0506 }
0507 else if (layer < 55)
0508 {
0509 gntpc++;
0510 }
0511 else
0512 {
0513 gnmms++;
0514 }
0515 }
0516
0517 gpx = g4particle->get_px();
0518 gpy = g4particle->get_py();
0519 gpz = g4particle->get_pz();
0520
0521 TVector3 tpart(gpx, gpy, gpz);
0522 gpt = tpart.Pt();
0523 geta = tpart.Eta();
0524 gphi = tpart.Phi();
0525
0526 PHG4VtxPoint *vtx = trutheval->get_vertex(g4particle);
0527 gvx = vtx->get_x();
0528 gvy = vtx->get_y();
0529 gvz = vtx->get_z();
0530 gvt = vtx->get_t();
0531
0532 gembed = trutheval->get_embed(g4particle);
0533 gprimary = trutheval->is_primary(g4particle);
0534 }
0535 m_recotree->Fill();
0536 }
0537 }
0538
0539 void TrackClusterEvaluator::clearVectors()
0540 {
0541 matchedRecoTracksID.clear();
0542 dclusterkeys.clear();
0543 dclusterx.clear();
0544 dclustery.clear();
0545 dclusterz.clear();
0546 dclusterrphierr.clear();
0547 dclusterzerr.clear();
0548 tgclusterx.clear();
0549 tgclustery.clear();
0550 tgclusterz.clear();
0551 tclusterx.clear();
0552 tclustery.clear();
0553 tclusterz.clear();
0554 gclusterkeys.clear();
0555 gclusterx.clear();
0556 gclustery.clear();
0557 gclusterz.clear();
0558 gclusterrphierr.clear();
0559 gclusterzerr.clear();
0560 clusterkeys.clear();
0561 clusterx.clear();
0562 clustery.clear();
0563 clusterz.clear();
0564 clusterrphierr.clear();
0565 clusterzerr.clear();
0566 }
0567
0568
0569 int TrackClusterEvaluator::ResetEvent(PHCompositeNode *topNode)
0570 {
0571 return Fun4AllReturnCodes::EVENT_OK;
0572 }
0573
0574
0575 int TrackClusterEvaluator::EndRun(const int runnumber)
0576 {
0577 return Fun4AllReturnCodes::EVENT_OK;
0578 }
0579
0580
0581 int TrackClusterEvaluator::End(PHCompositeNode *topNode)
0582 {
0583 m_outfile->cd();
0584 m_truthtree->Write();
0585 m_recotree->Write();
0586 m_outfile->Write();
0587 m_outfile->Close();
0588
0589 return Fun4AllReturnCodes::EVENT_OK;
0590 }
0591
0592
0593 int TrackClusterEvaluator::Reset(PHCompositeNode *topNode)
0594 {
0595 return Fun4AllReturnCodes::EVENT_OK;
0596 }
0597
0598 int TrackClusterEvaluator::getNodes(PHCompositeNode *topNode)
0599 {
0600 m_truthContainer = findNode::getClass<PHG4TruthInfoContainer>(topNode, "G4TruthInfo");
0601 if (!m_truthContainer)
0602 {
0603 std::cout << "No truth info available, can't continue." << std::endl;
0604 return Fun4AllReturnCodes::ABORTEVENT;
0605 }
0606
0607 m_trackMap = findNode::getClass<SvtxTrackMap>(topNode, m_trackMapName);
0608 std::cout << "Accessing map name " << m_trackMapName << std::endl;
0609 if (!m_trackMap)
0610 {
0611 std::cout << "No track map available, can't continue. " << std::endl;
0612 return Fun4AllReturnCodes::ABORTEVENT;
0613 }
0614
0615 m_clusterContainer = findNode::getClass<TrkrClusterContainer>(topNode, "TRKR_CLUSTER");
0616 if (!m_clusterContainer)
0617 {
0618 std::cout << "No cluster container available, can't continue." << std::endl;
0619 return Fun4AllReturnCodes::ABORTEVENT;
0620 }
0621
0622 return Fun4AllReturnCodes::EVENT_OK;
0623 }
0624
0625
0626 void TrackClusterEvaluator::Print(const std::string &what) const
0627 {
0628 std::cout << "TrackClusterEvaluator::Print(const std::string &what) const Printing info for " << what << std::endl;
0629 }
0630
0631 void TrackClusterEvaluator::setupTrees()
0632 {
0633 m_recotree = new TTree("recotracks", "a tree with reconstructed tracks");
0634 m_truthtree = new TTree("truthtracks", "a tree with truth tracks");
0635 m_duplicatetree = new TTree("duplicatetracks","a tree with truth->reco-duplicates");
0636
0637 m_duplicatetree->Branch("event", &event, "event/I");
0638 m_duplicatetree->Branch("gntracks", &gntracks, "gntracks/I");
0639 m_duplicatetree->Branch("gtrackID", >rackID, "gtrackID/I");
0640 m_duplicatetree->Branch("gflavor", &gflavor, "gflavor/I");
0641 m_duplicatetree->Branch("gnmaps", &gnmaps, "gnmaps/I");
0642 m_duplicatetree->Branch("gnintt", &gnintt, "gnintt/I");
0643 m_duplicatetree->Branch("gntpc", &gntpc, "gntpc/I");
0644 m_duplicatetree->Branch("gnmms", &gnmms, "gnmms/I");
0645 m_duplicatetree->Branch("gpx", &gpx, "gpx/F");
0646 m_duplicatetree->Branch("gpy", &gpy, "gpy/F");
0647 m_duplicatetree->Branch("gpz", &gpz, "gpz/F");
0648 m_duplicatetree->Branch("gpt", &gpt, "gpt/F");
0649 m_duplicatetree->Branch("geta", &geta, "geta/F");
0650 m_duplicatetree->Branch("gphi", &gphi, "gphi/F");
0651 m_duplicatetree->Branch("gvx", &gvx, "gvx/F");
0652 m_duplicatetree->Branch("gvy", &gvy, "gvy/F");
0653 m_duplicatetree->Branch("gvz", &gvz, "gvz/F");
0654 m_duplicatetree->Branch("gvt", &gvt, "gvt/F");
0655 m_duplicatetree->Branch("gembed", &gembed, "gembed/I");
0656 m_duplicatetree->Branch("gprimary", &gprimary, "gprimary/I");
0657 m_duplicatetree->Branch("gclusterkeys", &gclusterkeys);
0658 m_duplicatetree->Branch("gclusterx", &gclusterx);
0659 m_duplicatetree->Branch("gclustery", &gclustery);
0660 m_duplicatetree->Branch("gclusterz", &gclusterz);
0661 m_duplicatetree->Branch("tgclusterx", &tgclusterx);
0662 m_duplicatetree->Branch("tgclustery", &tgclustery);
0663 m_duplicatetree->Branch("tgclusterz", &tgclusterz);
0664 m_duplicatetree->Branch("gclusterrphierr", &gclusterrphierr);
0665 m_duplicatetree->Branch("gclusterzerr", &gclusterzerr);
0666 m_duplicatetree->Branch("dtrackID", &dtrackID, "dtrackID/I");
0667 m_duplicatetree->Branch("dpx", &dpx, "dpx/F");
0668 m_duplicatetree->Branch("dpy", &dpy, "dpy/F");
0669 m_duplicatetree->Branch("dpz", &dpz, "dpz/F");
0670 m_duplicatetree->Branch("dpt", &dpt, "dpt/F");
0671 m_duplicatetree->Branch("deta", &deta, "deta/F");
0672 m_duplicatetree->Branch("dphi", &dphi, "dphi/F");
0673 m_duplicatetree->Branch("dcharge", &dcharge, "dcharge/I");
0674 m_duplicatetree->Branch("dquality", &dquality, "dquality/F");
0675 m_duplicatetree->Branch("dnmaps", &dnmaps, "dnmaps/I");
0676 m_duplicatetree->Branch("dnintt", &dnintt, "dnintt/I");
0677 m_duplicatetree->Branch("dntpc", &dntpc, "dntpc/I");
0678 m_duplicatetree->Branch("dnmms", &dnmms, "dnmms/I");
0679 m_duplicatetree->Branch("ddca3dxy", &ddca3dxy, "ddca3dxy/F");
0680 m_duplicatetree->Branch("ddca3dz", &ddca3dz, "ddca3dz/F");
0681 m_duplicatetree->Branch("dpcax", &dpcax, "dpcax/F");
0682 m_duplicatetree->Branch("dpcay", &dpcay, "dpcay/F");
0683 m_duplicatetree->Branch("dpcaz", &dpcaz, "dpcaz/F");
0684 m_duplicatetree->Branch("dclusterkeys", &dclusterkeys);
0685 m_duplicatetree->Branch("dclusterx", &dclusterx);
0686 m_duplicatetree->Branch("dclustery", &dclustery);
0687 m_duplicatetree->Branch("dclusterz", &dclusterz);
0688 m_duplicatetree->Branch("dclusterrphierr", &dclusterrphierr);
0689 m_duplicatetree->Branch("dclusterzerr", &dclusterzerr);
0690
0691
0692 m_truthtree->Branch("event", &event, "event/I");
0693 m_truthtree->Branch("gntracks", &gntracks, "gntracks/I");
0694 m_truthtree->Branch("gtrackID", >rackID, "gtrackID/I");
0695 m_truthtree->Branch("gflavor", &gflavor, "gflavor/I");
0696 m_truthtree->Branch("gnmaps", &gnmaps, "gnmaps/I");
0697 m_truthtree->Branch("gnintt", &gnintt, "gnintt/I");
0698 m_truthtree->Branch("gntpc", &gntpc, "gntpc/I");
0699 m_truthtree->Branch("gnmms", &gnmms, "gnmms/I");
0700 m_truthtree->Branch("gpx", &gpx, "gpx/F");
0701 m_truthtree->Branch("gpy", &gpy, "gpy/F");
0702 m_truthtree->Branch("gpz", &gpz, "gpz/F");
0703 m_truthtree->Branch("gpt", &gpt, "gpt/F");
0704 m_truthtree->Branch("geta", &geta, "geta/F");
0705 m_truthtree->Branch("gphi", &gphi, "gphi/F");
0706 m_truthtree->Branch("gvx", &gvx, "gvx/F");
0707 m_truthtree->Branch("gvy", &gvy, "gvy/F");
0708 m_truthtree->Branch("gvz", &gvz, "gvz/F");
0709 m_truthtree->Branch("gvt", &gvt, "gvt/F");
0710 m_truthtree->Branch("gembed", &gembed, "gembed/I");
0711 m_truthtree->Branch("gprimary", &gprimary, "gprimary/I");
0712 m_truthtree->Branch("gclusterkeys", &gclusterkeys);
0713 m_truthtree->Branch("gclusterx", &gclusterx);
0714 m_truthtree->Branch("gclustery", &gclustery);
0715 m_truthtree->Branch("gclusterz", &gclusterz);
0716 m_truthtree->Branch("tgclusterx", &tgclusterx);
0717 m_truthtree->Branch("tgclustery", &tgclustery);
0718 m_truthtree->Branch("tgclusterz", &tgclusterz);
0719 m_truthtree->Branch("gclusterrphierr", &gclusterrphierr);
0720 m_truthtree->Branch("gclusterzerr", &gclusterzerr);
0721 m_truthtree->Branch("trackID", &trackID, "trackID/I");
0722 m_truthtree->Branch("px", &px, "px/F");
0723 m_truthtree->Branch("py", &py, "py/F");
0724 m_truthtree->Branch("pz", &pz, "pz/F");
0725 m_truthtree->Branch("pt", &pt, "pt/F");
0726 m_truthtree->Branch("eta", &eta, "eta/F");
0727 m_truthtree->Branch("phi", &phi, "phi/F");
0728 m_truthtree->Branch("charge", &charge, "charge/I");
0729 m_truthtree->Branch("quality", &quality, "quality/F");
0730 m_truthtree->Branch("nmaps", &nmaps, "nmaps/I");
0731 m_truthtree->Branch("nintt", &nintt, "nintt/I");
0732 m_truthtree->Branch("ntpc", &ntpc, "ntpc/I");
0733 m_truthtree->Branch("nmms", &nmms, "nmms/I");
0734 m_truthtree->Branch("dca3dxy", &dca3dxy, "dca3dxy/F");
0735 m_truthtree->Branch("dca3dz", &dca3dz, "dca3dz/F");
0736 m_truthtree->Branch("pcax", &pcax, "pcax/F");
0737 m_truthtree->Branch("pcay", &pcay, "pcay/F");
0738 m_truthtree->Branch("pcaz", &pcaz, "pcaz/F");
0739 m_truthtree->Branch("clusterkeys", &clusterkeys);
0740 m_truthtree->Branch("clusterx", &clusterx);
0741 m_truthtree->Branch("clustery", &clustery);
0742 m_truthtree->Branch("clusterz", &clusterz);
0743 m_truthtree->Branch("tclusterx", &tclusterx);
0744 m_truthtree->Branch("tclustery", &tclustery);
0745 m_truthtree->Branch("tclusterz", &tclusterz);
0746 m_truthtree->Branch("clusterrphierr", &clusterrphierr);
0747 m_truthtree->Branch("clusterzerr", &clusterzerr);
0748
0749 m_recotree->Branch("event", &event, "event/I");
0750 m_recotree->Branch("trackID", &trackID, "trackID/I");
0751 m_recotree->Branch("isDuplicate",&isDuplicate, "isDuplicate/I");
0752 m_recotree->Branch("matchedRecoTracksID", &matchedRecoTracksID);
0753 m_recotree->Branch("px", &px, "px/F");
0754 m_recotree->Branch("py", &py, "py/F");
0755 m_recotree->Branch("pz", &pz, "pz/F");
0756 m_recotree->Branch("pt", &pt, "pt/F");
0757 m_recotree->Branch("eta", &eta, "eta/F");
0758 m_recotree->Branch("phi", &phi, "phi/F");
0759 m_recotree->Branch("charge", &charge, "charge/I");
0760 m_recotree->Branch("quality", &quality, "quality/F");
0761 m_recotree->Branch("nmaps", &nmaps, "nmaps/I");
0762 m_recotree->Branch("nintt", &nintt, "nintt/I");
0763 m_recotree->Branch("ntpc", &ntpc, "ntpc/I");
0764 m_recotree->Branch("nmms", &nmms, "nmms/I");
0765 m_recotree->Branch("dca3dxy", &dca3dxy, "dca3dxy/F");
0766 m_recotree->Branch("dca3dz", &dca3dz, "dca3dz/F");
0767 m_recotree->Branch("pcax", &pcax, "pcax/F");
0768 m_recotree->Branch("pcay", &pcay, "pcay/F");
0769 m_recotree->Branch("pcaz", &pcaz, "pcaz/F");
0770 m_recotree->Branch("clusterkeys", &clusterkeys);
0771 m_recotree->Branch("clusterx", &clusterx);
0772 m_recotree->Branch("clustery", &clustery);
0773 m_recotree->Branch("clusterz", &clusterz);
0774 m_recotree->Branch("tclusterx", &tclusterx);
0775 m_recotree->Branch("tclustery", &tclustery);
0776 m_recotree->Branch("tclusterz", &tclusterz);
0777 m_recotree->Branch("clusterrphierr", &clusterrphierr);
0778 m_recotree->Branch("clusterzerr", &clusterzerr);
0779 m_recotree->Branch("matchedTrackID",&matchedTrackID, "matchedTrackID/I");
0780 m_recotree->Branch("gntracks", &gntracks, "gntracks/I");
0781 m_recotree->Branch("gtrackID", >rackID, "gtrackID/I");
0782 m_recotree->Branch("gnmaps", &gnmaps, "gnmaps/I");
0783 m_recotree->Branch("gnintt", &gnintt, "gnintt/I");
0784 m_recotree->Branch("gntpc", &gntpc, "gntpc/I");
0785 m_recotree->Branch("gnmms", &gnmms, "gnmms/I");
0786 m_recotree->Branch("gpx", &gpx, "gpx/F");
0787 m_recotree->Branch("gpy", &gpy, "gpy/F");
0788 m_recotree->Branch("gpz", &gpz, "gpz/F");
0789 m_recotree->Branch("gpt", &gpt, "gpt/F");
0790 m_recotree->Branch("geta", &geta, "geta/F");
0791 m_recotree->Branch("gphi", &gphi, "gphi/F");
0792 m_recotree->Branch("gvx", &gvx, "gvx/F");
0793 m_recotree->Branch("gvy", &gvy, "gvy/F");
0794 m_recotree->Branch("gvz", &gvz, "gvz/F");
0795 m_recotree->Branch("gvt", &gvt, "gvt/F");
0796 m_recotree->Branch("gembed", &gembed, "gembed/I");
0797 m_recotree->Branch("gprimary", &gprimary, "gprimary/I");
0798 m_recotree->Branch("gclusterkeys", &gclusterkeys);
0799 m_recotree->Branch("gclusterx", &gclusterx);
0800 m_recotree->Branch("gclustery", &gclustery);
0801 m_recotree->Branch("gclusterz", &gclusterz);
0802 m_recotree->Branch("tgclusterx", &tgclusterx);
0803 m_recotree->Branch("tgclustery", &tgclustery);
0804 m_recotree->Branch("tgclusterz", &tgclusterz);
0805 m_recotree->Branch("gclusterrphierr", &gclusterrphierr);
0806 m_recotree->Branch("gclusterzerr", &gclusterzerr);
0807 }
0808
0809 void TrackClusterEvaluator::resetTreeValues()
0810 {
0811 clearVectors();
0812 matchedTrackID = -9999;
0813 isDuplicate = -9999;
0814 gflavor = -9999;
0815 gntracks = -9999;
0816 gtrackID = -9999;
0817 gnmaps = -9999;
0818 gnintt = -9999;
0819 gntpc = -9999;
0820 gnmms = -9999;
0821 gpx = -9999;
0822 gpy = -9999;
0823 gpz = -9999;
0824 gpt = -9999;
0825 geta = -9999;
0826 gphi = -9999;
0827 gvx = -9999;
0828 gvy = -9999;
0829 gvz = -9999;
0830 gvt = -9999;
0831 gembed = -9999;
0832 gprimary = -9999;
0833 trackID = -9999;
0834 px = -9999;
0835 py = -9999;
0836 pz = -9999;
0837 pt = -9999;
0838 eta = -9999;
0839 phi = -9999;
0840 charge = -9999;
0841 quality = -9999;
0842 nmaps = -9999;
0843 nintt = -9999;
0844 ntpc = -9999;
0845 nmms = -9999;
0846 dca3dxy = -9999;
0847 dca3dz = -9999;
0848 pcax = -9999;
0849 pcay = -9999;
0850 pcaz = -9999;
0851 dtrackID = -9999;
0852 dpx = -9999;
0853 dpy = -9999;
0854 dpz = -9999;
0855 dpt = -9999;
0856 deta = -9999;
0857 dphi = -9999;
0858 dcharge = -9999;
0859 dquality = -9999;
0860 dnmaps = -9999;
0861 dnintt = -9999;
0862 dntpc = -9999;
0863 dnmms = -9999;
0864 ddca3dxy = -9999;
0865 ddca3dz = -9999;
0866 dpcax = -9999;
0867 dpcay = -9999;
0868 dpcaz = -9999;
0869 }
