Class Reference for E1039 Core & Analysis Software
AnaTrkQA.cxx
Go to the documentation of this file.
1 
10 #include "AnaTrkQA.h"
11 
12 #include <interface_main/SQHit.h>
13 #include <interface_main/SQHit_v1.h>
14 #include <interface_main/SQMCHit_v1.h>
15 #include <interface_main/SQHitMap_v1.h>
16 #include <interface_main/SQHitVector_v1.h>
17 #include <interface_main/SQEvent_v1.h>
18 #include <interface_main/SQRun_v1.h>
19 #include <interface_main/SQSpill_v1.h>
20 #include <interface_main/SQSpillMap_v1.h>
21 
22 #include <ktracker/SRecEvent.h>
23 #include <geom_svc/GeomSvc.h>
24 
25 #include <fun4all/Fun4AllReturnCodes.h>
26 #include <fun4all/PHTFileServer.h>
27 #include <phool/PHNodeIterator.h>
28 #include <phool/PHIODataNode.h>
29 #include <phool/getClass.h>
30 
31 #include <g4main/PHG4TruthInfoContainer.h>
32 #include <g4main/PHG4HitContainer.h>
33 #include <g4main/PHG4Hit.h>
34 #include <g4main/PHG4Particle.h>
35 #include <g4main/PHG4HitDefs.h>
36 #include <g4main/PHG4VtxPoint.h>
37 
38 #include <TFile.h>
39 #include <TTree.h>
40 
41 #include <cstring>
42 #include <cmath>
43 #include <cfloat>
44 #include <stdexcept>
45 #include <limits>
46 #include <tuple>
47 
48 #include <boost/lexical_cast.hpp>
49 
50 #define NDET 62
51 #define LogDebug(exp) std::cout<<"DEBUG: " <<__FILE__<<": "<<__LINE__<<": "<< exp << std::endl
52 #define LogError(exp) std::cout<<"ERROR: " <<__FILE__<<": "<<__LINE__<<": "<< exp << std::endl
53 #define LogWarning(exp) std::cout<<"WARNING: "<<__FILE__<<": "<<__LINE__<<": "<< exp << std::endl
54 
55 using namespace std;
56 
57 AnaTrkQA::AnaTrkQA(const std::string& name) :
58  SubsysReco(name),
59  _hit_container_type("Vector"),
60  _event(0),
61  _run_header(nullptr),
62  _spill_map(nullptr),
63  _event_header(nullptr),
64  _hit_map(nullptr),
65  _hit_vector(nullptr),
66  _out_name("eval.root")
67 {
68 
69 }
70 
71 int AnaTrkQA::Init(PHCompositeNode* topNode) {
72  return Fun4AllReturnCodes::EVENT_OK;
73 }
74 
75 int AnaTrkQA::InitRun(PHCompositeNode* topNode) {
76 
77  ResetEvalVars();
78  InitEvalTree();
79 
80  p_geomSvc = GeomSvc::instance();
81 
82  int ret = GetNodes(topNode);
83  if(ret != Fun4AllReturnCodes::EVENT_OK) return ret;
84 
85  return Fun4AllReturnCodes::EVENT_OK;
86 }
87 
88 int AnaTrkQA::process_event(PHCompositeNode* topNode) {
89 
90  int ret = Fun4AllReturnCodes::ABORTRUN;
91 
92  if(_recEvent) {
93  //ret = RecoEval(topNode);
94  ret = TruthRecoEval(topNode);
95  if (ret != Fun4AllReturnCodes::EVENT_OK) return ret;
96  }
97 
98  ++_event;
99 
100  return ret;
101 }
102 
103 
104 //play ground for Abi==============================================
105 int AnaTrkQA::TruthRecoEval(PHCompositeNode* topNode)
106 {
107  ResetEvalVars();
108 
109  if(_truth) {
110  for(auto iter=_truth->GetPrimaryParticleRange().first;
111  iter!=_truth->GetPrimaryParticleRange().second;
112  ++iter) {
113  PHG4Particle * par = iter->second;
114 
115  int trk_id = par->get_track_id();
116 
117  pid[n_tracks] = par->get_pid();
118  int vtx_id = par->get_vtx_id();
119 
120  PHG4VtxPoint* vtx = _truth->GetVtx(vtx_id);
121  gvx[n_tracks] = vtx->get_x();
122  gvy[n_tracks] = vtx->get_y();
123  gvz[n_tracks] = vtx->get_z();
124 
125  TVector3 mom_truth(par->get_px(), par->get_py(), par->get_pz());
126  gpx[n_tracks] = par->get_px();
127  gpy[n_tracks] = par->get_py();
128  gpz[n_tracks] = par->get_pz();
129  gpt[n_tracks] = mom_truth.Pt();
130  geta[n_tracks] = mom_truth.Eta();
131  gphi[n_tracks] = mom_truth.Phi();
132 
133 
135  TVector3 g_pos_st1;
136  TLorentzVector g_mom_st1;
137  bool st1hit = FindG4HitAtStation(trk_id, g4hc_d1x, &g_pos_st1, &g_mom_st1);
138  if(st1hit){
139 
140  gx_st1[n_tracks] = g_pos_st1.X();
141  gy_st1[n_tracks] = g_pos_st1.Y();
142  gz_st1[n_tracks] = g_pos_st1.Z();
143 
144  gpx_st1[n_tracks] = g_mom_st1.Px();
145  gpy_st1[n_tracks] = g_mom_st1.Py();
146  gpz_st1[n_tracks] = g_mom_st1.Pz();
147  }
148 
149  TVector3 g_pos_st2;
150  TLorentzVector g_mom_st2;
151  bool st2hit = FindG4HitAtStation(trk_id, g4hc_d2xp, &g_pos_st2, &g_mom_st2);
152 
153  TVector3 g_pos_st3;
154  TLorentzVector g_mom_st3;
155 
156  bool st3hit = FindG4HitAtStation(trk_id, g4hc_d3px, &g_pos_st3, &g_mom_st3)|| FindG4HitAtStation(trk_id, g4hc_d3mx, &g_pos_st3, &g_mom_st3);
157 
158  bool prophit = (FindG4HitAtProp(trk_id,g4hc_p1x1)||FindG4HitAtProp(trk_id,g4hc_p1x2)||FindG4HitAtProp(trk_id,g4hc_p1y1)||FindG4HitAtProp(trk_id,g4hc_p1y2)) && (FindG4HitAtProp(trk_id,g4hc_p2x1)||FindG4HitAtProp(trk_id,g4hc_p2x2)||FindG4HitAtProp(trk_id,g4hc_p2y1)||FindG4HitAtProp(trk_id,g4hc_p2y2));//truth having prop hits at station 4
159 
161  if(st1hit && st2hit && st3hit && prophit){
162  ac_gpx[n_tracks] = gpx[n_tracks];
163  ac_gpy[n_tracks] = gpy[n_tracks];
164  ac_gpz[n_tracks] = gpz[n_tracks];
165  }
166 
167 
169  SRecTrack* Best_recTrack = NULL;
170  n_recTracks = _recEvent->getNTracks();
171 
172  // if(_recEvent->getNTracks()>0) Best_recTrack = FindBestMomRecTrack(_recEvent, mom_truth.Mag());
173 
175  vector<int> sqhit_idvec;
176  map<int, vector<int> > rtrkid_hitidvec;
177 
179  for(int ihit=0; ihit<_hit_vector->size(); ++ihit) {
180  SQHit *sqhit = _hit_vector->at(ihit);
181  int sq_detid = sqhit->get_detector_id();
182  if(sq_detid > nChamberPlanes || (sq_detid >= 7 && sq_detid <= 12)) continue;
183  if(trk_id != sqhit->get_track_id()) continue;
184  sqhit_idvec.push_back(sqhit->get_hit_id());
185 
186  }
187 
188  sort(sqhit_idvec.begin(), sqhit_idvec.end());
189 
191  if(n_recTracks>0){
192  for(int i = 0; i < n_recTracks; ++i) {
193  SRecTrack* recTrack = &_recEvent->getTrack(i);
194  rtrkid_hitidvec[i] = vector<int>();
195 
196  int n_rhits = recTrack->getNHits();
197  for(int j = 0; j < n_rhits; ++j) {
198  rtrkid_hitidvec[i].push_back(fabs(recTrack->getHitIndex(j)));
199 
200  }
201 
202  sort(rtrkid_hitidvec[i].begin(), rtrkid_hitidvec[i].end());
203  }
204  }
205 
207  double m_matching_threshold = 0.75;
208  int rtrkid = -1;
209  unsigned int n_match = 0;
210 
211  for(auto it = rtrkid_hitidvec.begin(); it != rtrkid_hitidvec.end(); ++it) {
212  int n_match_new = FindCommonHitIDs(sqhit_idvec, it->second);
213  if(n_match < n_match_new) {
214  n_match = n_match_new;
215  rtrkid = it->first;
216  }
217  }
218 
219  if(rtrkid >= 0 && double(n_match)/double(sqhit_idvec.size()) > m_matching_threshold) {
220  Best_recTrack = &_recEvent->getTrack(rtrkid);
221  }
223 
224 
225  if(Best_recTrack){
226 
227  TVector3 rec_mom = Best_recTrack->getTargetMom();
228 
229  nhits[n_tracks] = Best_recTrack->getNHits();
230  charge[n_tracks] = Best_recTrack->getCharge();
231 
232  TVector3 rec_vtx = Best_recTrack->getTargetPos();
233 
234  rec_vx[n_tracks] = rec_vtx.X();
235  rec_vy[n_tracks] = rec_vtx.Y();
236  rec_vz[n_tracks] = rec_vtx.Z();
237 
238  rec_px[n_tracks] = rec_mom.Px();
239  rec_py[n_tracks] = rec_mom.Py();
240  rec_pz[n_tracks] = rec_mom.Pz();
241  rec_pt[n_tracks] = rec_mom.Pt();
242  rec_eta[n_tracks] = rec_mom.Eta();
243  rec_phi[n_tracks] = rec_mom.Phi();
244 
245  nhits_st1[n_tracks] = Best_recTrack->getNHitsInStation(1);
246  nhits_st2[n_tracks] = Best_recTrack->getNHitsInStation(2);
247  nhits_st3[n_tracks] = Best_recTrack->getNHitsInStation(3);
248 
249  chisq_st1[n_tracks] = Best_recTrack->getChisq();
250  prob_st1[n_tracks] = Best_recTrack->getProb();
251  quality[n_tracks] = Best_recTrack->getQuality();
252 
253 
254 
255  //Old way of getting st. 1 reco values
256  /*double tx, ty, tz;
257  Best_recTrack->getMomentumSt1(tx, ty, tz);
258  px_st1[n_tracks] = tx;
259  py_st1[n_tracks] = ty;
260  pz_st1[n_tracks] = tz;
261 
262  double x, y;
263  Best_recTrack->getPositionSt1(x, y);
264  x_st1[n_tracks] = x;
265  y_st1[n_tracks] = y;
266  */
267  }//if best reco track
268 
269 
270 
271 
273 
274  if(_hit_vector) {
275  for(int ihit=0; ihit<_hit_vector->size(); ++ihit) {
276  SQHit *hit = _hit_vector->at(ihit);
277 
278  int detid = hit->get_detector_id();
279  if(detid > nChamberPlanes || (detid >= 7 && detid <= 12)) continue; //only for the chamber hits
280 
282  if(hit->get_track_id() == trk_id && hit->get_detector_id() ==3 ) {
283 
284  sq_px_st1[n_tracks] = hit->get_truth_px();
285  sq_py_st1[n_tracks] = hit->get_truth_py();
286  sq_pz_st1[n_tracks] = hit->get_truth_pz();
287 
288  sq_x_st1[n_tracks] = hit->get_truth_x();
289  sq_y_st1[n_tracks] = hit->get_truth_y();
290  sq_z_st1[n_tracks] = hit->get_truth_z();
291  sq_pos_st1[n_tracks]=hit->get_pos();
292  sq_drift_st1[n_tracks] = hit->get_drift_distance();
293 
295  if (Best_recTrack){
296  double sq_z_st1 = hit->get_truth_z();
297  int rec_index_st1 = Best_recTrack->getNearestNode(sq_z_st1);
298 
299  double z_rec_st1 = Best_recTrack->getZ(rec_index_st1);
300 
301  if(fabs(sq_z_st1- z_rec_st1>1.)) continue;//to avoid mismatch of nodes
302 
303  double p_rec_st1 = fabs(1./Best_recTrack->getStateVector(rec_index_st1)[0][0]);
304  double tx_rec_st1 = Best_recTrack->getStateVector(rec_index_st1)[1][0];
305  double ty_rec_st1 = Best_recTrack->getStateVector(rec_index_st1)[2][0];
306  double x_rec_st1 = Best_recTrack->getStateVector(rec_index_st1)[3][0];
307  double y_rec_st1 = Best_recTrack->getStateVector(rec_index_st1)[4][0];
308 
309  double x0_st1 = x_rec_st1 - tx_rec_st1 *z_rec_st1;
310  double y0_st1 = y_rec_st1 - ty_rec_st1 *z_rec_st1;
311 
312  rec_p_st1[n_tracks] = p_rec_st1;
313  rec_pz_st1[n_tracks] = p_rec_st1/sqrt(1.+tx_rec_st1*tx_rec_st1+ty_rec_st1*ty_rec_st1);
314  rec_px_st1[n_tracks] = rec_pz_st1[n_tracks]* tx_rec_st1;
315  rec_py_st1[n_tracks] = rec_pz_st1[n_tracks]* ty_rec_st1;
316 
317  rec_x_st1[n_tracks] = x_rec_st1;
318  rec_y_st1[n_tracks] = y_rec_st1;
319  rec_z_st1[n_tracks] = z_rec_st1;
320 
321  rec_drift_st1[n_tracks] = p_geomSvc->getDCA(hit->get_detector_id(), hit->get_element_id(),tx_rec_st1, ty_rec_st1, x0_st1,y0_st1);
322  // Pull distribution work
323  double cov00_st1 = Best_recTrack->getCovariance(rec_index_st1)[0][0];
324  double sq_mom_st1 = sqrt(sq_px_st1[n_tracks]*sq_px_st1[n_tracks]+sq_py_st1[n_tracks]*sq_py_st1[n_tracks]+sq_pz_st1[n_tracks]*sq_pz_st1[n_tracks]);
325  pull_q2p_st1[n_tracks] = (fabs(Best_recTrack->getStateVector(rec_index_st1)[0][0]) - 1./sq_mom_st1)/sqrt(cov00_st1);
326 
327 
328  }
329  }
330 
332 
334  if(hit->get_track_id() == trk_id && hit->get_detector_id() ==15 ) {
335 
336  sq_px_st2[n_tracks] = hit->get_truth_px();
337  sq_py_st2[n_tracks] = hit->get_truth_py();
338  sq_pz_st2[n_tracks] = hit->get_truth_pz();
339 
340  sq_x_st2[n_tracks] = hit->get_truth_x();
341  sq_y_st2[n_tracks] = hit->get_truth_y();
342  sq_z_st2[n_tracks] = hit->get_truth_z();
343 
344  sq_pos_st2[n_tracks]=hit->get_pos();
345  sq_drift_st2[n_tracks] = hit->get_drift_distance();
346 
348  if (Best_recTrack){
349  double sq_z = hit->get_truth_z();
350  int rec_index = Best_recTrack->getNearestNode(sq_z);
351 
352  double rec_z = Best_recTrack->getZ(rec_index);
353 
354  if(fabs(sq_z- rec_z>1.)) continue;
355 
356  double p_rec = fabs(1./Best_recTrack->getStateVector(rec_index)[0][0]);
357  double tx_rec = Best_recTrack->getStateVector(rec_index)[1][0];
358  double ty_rec = Best_recTrack->getStateVector(rec_index)[2][0];
359  double x_rec = Best_recTrack->getStateVector(rec_index)[3][0];
360  double y_rec = Best_recTrack->getStateVector(rec_index)[4][0];
361 
362  double x0 = x_rec - tx_rec *rec_z;
363  double y0 = y_rec - ty_rec *rec_z;
364 
365  rec_p_st2[n_tracks] = p_rec;
366  rec_pz_st2[n_tracks] = p_rec/sqrt(1.+tx_rec*tx_rec+ty_rec*ty_rec);
367  rec_px_st2[n_tracks] = rec_pz_st2[n_tracks]* tx_rec;
368  rec_py_st2 [n_tracks]= rec_pz_st2[n_tracks]* ty_rec;
369 
370 
371  rec_x_st2[n_tracks] = x_rec;
372  rec_y_st2[n_tracks] = y_rec;
373  rec_z_st2[n_tracks] = rec_z;
374 
375  rec_drift_st2[n_tracks] = p_geomSvc->getDCA(hit->get_detector_id(), hit->get_element_id(),tx_rec, ty_rec, x0,y0);
376 
378  double cov00_st2 = Best_recTrack->getCovariance(rec_index)[0][0];
379  double sq_mom_st2 = sqrt(sq_px_st2[n_tracks]*sq_px_st2[n_tracks]+sq_py_st2[n_tracks]*sq_py_st2[n_tracks]+sq_pz_st2[n_tracks]*sq_pz_st2[n_tracks]);
380  pull_q2p_st2[n_tracks] = (fabs(Best_recTrack->getStateVector(rec_index)[0][0]) - 1./sq_mom_st2)/sqrt(cov00_st2);
381 
382  }
383 
384  }//st2. work done
385 
386  //=======================
387 
388 
389  //st. 3 is now D3mXp(id = 27) or D3pXp (id=21)
390  if(hit->get_track_id() == trk_id && (hit->get_detector_id() == 27 ||hit->get_detector_id() == 21)) {
391  sq_px_st3[n_tracks] = hit->get_truth_px();
392  sq_py_st3[n_tracks] = hit->get_truth_py();
393  sq_pz_st3[n_tracks] = hit->get_truth_pz();
394 
395  sq_x_st3[n_tracks] = hit->get_truth_x();
396  sq_y_st3[n_tracks] = hit->get_truth_y();
397  sq_z_st3[n_tracks] = hit->get_truth_z();
398  sq_pos_st3[n_tracks]=hit->get_pos();
399  sq_drift_st3[n_tracks] = hit->get_drift_distance();
400 
402  if (Best_recTrack){
403  double sq_z = hit->get_truth_z();
404  int rec_index = Best_recTrack->getNearestNode(sq_z);
405 
406  double rec_z = Best_recTrack->getZ(rec_index);
407 
408  if(fabs(sq_z- rec_z>1.)) continue;
409 
410  double p_rec = fabs(1./Best_recTrack->getStateVector(rec_index)[0][0]);
411  double tx_rec = Best_recTrack->getStateVector(rec_index)[1][0];
412  double ty_rec = Best_recTrack->getStateVector(rec_index)[2][0];
413  double x_rec = Best_recTrack->getStateVector(rec_index)[3][0];
414  double y_rec = Best_recTrack->getStateVector(rec_index)[4][0];
415 
416  double x0 = x_rec - tx_rec *rec_z;
417  double y0 = y_rec - ty_rec *rec_z;
418 
419  rec_p_st3[n_tracks] = p_rec;
420  rec_pz_st3[n_tracks] = p_rec/sqrt(1.+tx_rec*tx_rec+ty_rec*ty_rec);
421  rec_px_st3[n_tracks] = rec_pz_st3[n_tracks]* tx_rec;
422  rec_py_st3[n_tracks] = rec_pz_st3[n_tracks]* ty_rec;
423 
424  rec_x_st3[n_tracks] = x_rec;
425  rec_y_st3[n_tracks] = y_rec;
426  rec_z_st3[n_tracks] = rec_z;
427  rec_drift_st3[n_tracks] = p_geomSvc->getDCA(hit->get_detector_id(), hit->get_element_id(),tx_rec, ty_rec, x0,y0);
428 
429  // Pull distribution work
430  double cov00_st3 = Best_recTrack->getCovariance(rec_index)[0][0];
431  double sq_mom_st3 = sqrt(sq_px_st3[n_tracks]*sq_px_st3[n_tracks]+sq_py_st3[n_tracks]*sq_py_st3[n_tracks]+sq_pz_st3[n_tracks]*sq_pz_st3[n_tracks]);
432  pull_q2p_st3[n_tracks] = (fabs(Best_recTrack->getStateVector(rec_index)[0][0]) - 1./sq_mom_st3)/sqrt(cov00_st3);
433 
434 
435  }//if best reco track
436 
437  }//st3. work done
438 
439  //=======================
440 
441  }//sqhit vector loop
442 
443  }//if hit vector
444 
445 
446 
447  ++n_tracks;
448  if(n_tracks>=100) break;
449 
450  }//truth loop
451 
452 
453  }//truth condition
454 
455  _qa_tree->Fill();
456 
457 
458  return Fun4AllReturnCodes::EVENT_OK;
459 }
460 
462 int AnaTrkQA::End(PHCompositeNode* topNode) {
463  if(Verbosity() >= Fun4AllBase::VERBOSITY_A_LOT)
464  std::cout << "AnaTrkQA::End" << std::endl;
465 
466  PHTFileServer::get().cd(_out_name.c_str());
467  _qa_tree->Write();
468 
469  return Fun4AllReturnCodes::EVENT_OK;
470 }
471 
472 int AnaTrkQA::InitEvalTree() {
473 
474  PHTFileServer::get().open(_out_name.c_str(), "RECREATE");
475 
477  _qa_tree = new TTree("QA_ana", "QA analsysis of reconstruction and simulation");
478 
479  _qa_tree->Branch("n_tracks", &n_tracks, "n_tracks/I");
480  _qa_tree->Branch("n_recTracks", &n_recTracks, "n_recTracks/I");
481 
483  _qa_tree->Branch("pid", pid, "pid[n_tracks]/I");
484  _qa_tree->Branch("gvx", gvx, "gvx[n_tracks]/F");
485  _qa_tree->Branch("gvy", gvy, "gvy[n_tracks]/F");
486  _qa_tree->Branch("gvz", gvz, "gvz[n_tracks]/F");
487  _qa_tree->Branch("gpx", gpx, "gpx[n_tracks]/F");
488  _qa_tree->Branch("gpy", gpy, "gpy[n_tracks]/F");
489  _qa_tree->Branch("gpz", gpz, "gpz[n_tracks]/F");
490  _qa_tree->Branch("gpt", gpt, "gpt[n_tracks]/F");
491  _qa_tree->Branch("geta", geta, "geta[n_tracks]/F");
492  _qa_tree->Branch("gphi", gphi, "gphi[n_tracks]/F");
493 /*
494  _qa_tree->Branch("gx_st1", gx_st1, "gx_st1[n_tracks]/F");
495  _qa_tree->Branch("gy_st1", gy_st1, "gy_st1[n_tracks]/F");
496  _qa_tree->Branch("gz_st1", gz_st1, "gz_st1[n_tracks]/F");
497  _qa_tree->Branch("gpx_st1", gpx_st1, "gpx_st1[n_tracks]/F");
498  _qa_tree->Branch("gpy_st1", gpy_st1, "gpy_st1[n_tracks]/F");
499  _qa_tree->Branch("gpz_st1", gpz_st1, "gpz_st1[n_tracks]/F");
500 */
502  _qa_tree->Branch("ac_gpx", ac_gpx, "ac_gpx[n_tracks]/F");
503  _qa_tree->Branch("ac_gpy", ac_gpy, "ac_gpy[n_tracks]/F");
504  _qa_tree->Branch("ac_gpz", ac_gpz, "ac_gpz[n_tracks]/F");
505 
506 
508  _qa_tree->Branch("rec_vx", rec_vx, "rec_vx[n_tracks]/F");
509  _qa_tree->Branch("rec_vy", rec_vy, "rec_vy[n_tracks]/F");
510  _qa_tree->Branch("rec_vz", rec_vz, "rec_vz[n_tracks]/F");
511  _qa_tree->Branch("rec_px", rec_px, "rec_px[n_tracks]/F");
512  _qa_tree->Branch("rec_py", rec_py, "rec_py[n_tracks]/F");
513  _qa_tree->Branch("rec_pz", rec_pz, "rec_pz[n_tracks]/F");
514  _qa_tree->Branch("rec_pt", rec_pt, "rec_pt[n_tracks]/F");
515  _qa_tree->Branch("rec_eta", rec_eta, "rec_eta[n_tracks]/F");
516  _qa_tree->Branch("rec_phi", rec_phi, "rec_phi[n_tracks]/F");
517 
518 
520  _qa_tree->Branch("sq_pos_st1", sq_pos_st1, "sq_pos_st1[n_tracks]/F");
521  _qa_tree->Branch("sq_drift_st1", sq_drift_st1, "sq_drift_st1[n_tracks]/F");
522  _qa_tree->Branch("sq_x_st1", sq_x_st1, "sq_x_st1[n_tracks]/F");
523  _qa_tree->Branch("sq_y_st1", sq_y_st1, "sq_y_st1[n_tracks]/F");
524  _qa_tree->Branch("sq_z_st1", sq_z_st1, "sq_z_st1[n_tracks]/F");
525  _qa_tree->Branch("sq_px_st1", sq_px_st1, "sq_px_st1[n_tracks]/F");
526  _qa_tree->Branch("sq_py_st1", sq_py_st1, "sq_py_st1[n_tracks]/F");
527  _qa_tree->Branch("sq_pz_st1", sq_pz_st1, "sq_pz_st1[n_tracks]/F");
528 
529  _qa_tree->Branch("rec_drift_st1", rec_drift_st1, "rec_drift_st1[n_tracks]/F");
530  _qa_tree->Branch("rec_px_st1", rec_px_st1, "rec_px_st1[n_tracks]/F");
531  _qa_tree->Branch("rec_py_st1", rec_py_st1, "rec_py_st1[n_tracks]/F");
532  _qa_tree->Branch("rec_pz_st1", rec_pz_st1, "rec_pz_st1[n_tracks]/F");
533  _qa_tree->Branch("rec_x_st1", rec_x_st1, "rec_x_st1[n_tracks]/F");
534  _qa_tree->Branch("rec_y_st1", rec_y_st1, "rec_y_st1[n_tracks]/F");
535  _qa_tree->Branch("rec_z_st1", rec_z_st1, "rec_z_st1[n_tracks]/F");
536 
537 
539  _qa_tree->Branch("sq_pos_st2", sq_pos_st2, "sq_pos_st2[n_tracks]/F");
540  _qa_tree->Branch("sq_drift_st2", sq_drift_st2, "sq_drift_st2[n_tracks]/F");
541  _qa_tree->Branch("sq_x_st2", sq_x_st2, "sq_x_st2[n_tracks]/F");
542  _qa_tree->Branch("sq_y_st2", sq_y_st2, "sq_y_st2[n_tracks]/F");
543  _qa_tree->Branch("sq_z_st2", sq_z_st2, "sq_z_st2/[n_tracks]F");
544  _qa_tree->Branch("sq_px_st2", sq_px_st2, "sq_px_st2[n_tracks]/F");
545  _qa_tree->Branch("sq_py_st2", sq_py_st2, "sq_py_st2[n_tracks]/F");
546  _qa_tree->Branch("sq_pz_st2", sq_pz_st2, "sq_pz_st2[n_tracks]/F");
547 
548  _qa_tree->Branch("rec_drift_st2", rec_drift_st2, "rec_drift_st2[n_tracks]/F");
549  _qa_tree->Branch("rec_px_st2", rec_px_st2, "rec_px_st2[n_tracks]/F");
550  _qa_tree->Branch("rec_py_st2", rec_py_st2, "rec_py_st2[n_tracks]/F");
551  _qa_tree->Branch("rec_pz_st2", rec_pz_st2, "rec_pz_st2[n_tracks]/F");
552  _qa_tree->Branch("rec_x_st2", rec_x_st2, "rec_x_st2[n_tracks]/F");
553  _qa_tree->Branch("rec_y_st2", rec_y_st2, "rec_y_st2[n_tracks]/F");
554  _qa_tree->Branch("rec_z_st2", rec_z_st2, "rec_z_st2[n_tracks]/F");
555 
556 
558  _qa_tree->Branch("sq_pos_st3", sq_pos_st3, "sq_pos_st3[n_tracks]/F");
559  _qa_tree->Branch("sq_drift_st3", sq_drift_st3, "sq_drift_st3[n_tracks]/F");
560  _qa_tree->Branch("sq_x_st3", sq_x_st3, "sq_x_st3[n_tracks]/F");
561  _qa_tree->Branch("sq_y_st3", sq_y_st3, "sq_y_st3[n_tracks]/F");
562  _qa_tree->Branch("sq_z_st3", sq_z_st3, "sq_z_st3[n_tracks]/F");
563  _qa_tree->Branch("sq_px_st3", sq_px_st3, "sq_px_st3[n_tracks]/F");
564  _qa_tree->Branch("sq_py_st3", sq_py_st3, "sq_py_st3[n_tracks]/F");
565  _qa_tree->Branch("sq_pz_st3", sq_pz_st3, "sq_pz_st3[n_tracks]/F");
566 
567  _qa_tree->Branch("rec_drift_st3", rec_drift_st3, "rec_drift_st3[n_tracks]/F");
568  _qa_tree->Branch("rec_px_st3", rec_px_st3, "rec_px_st3[n_tracks]/F");
569  _qa_tree->Branch("rec_py_st3", rec_py_st3, "rec_py_st3[n_tracks]/F");
570  _qa_tree->Branch("rec_pz_st3", rec_pz_st3, "rec_pz_st3[n_tracks]/F");
571  _qa_tree->Branch("rec_x_st3", rec_x_st3, "rec_x_st3[n_tracks]/F");
572  _qa_tree->Branch("rec_y_st3", rec_y_st3, "rec_y_st3[n_tracks]/F");
573  _qa_tree->Branch("rec_z_st3", rec_z_st3, "rec_z_st3[n_tracks]/F");
574 
575 
577  _qa_tree->Branch("pull_q2p_st1", pull_q2p_st1, "pull_q2p_st1[n_tracks]/F");
578  _qa_tree->Branch("pull_q2p_st2", pull_q2p_st2, "pull_q2p_st2[n_tracks]/F");
579  _qa_tree->Branch("pull_q2p_st3", pull_q2p_st3, "pull_q2p_st3[n_tracks]/F");
580 
581  _qa_tree->Branch("chisq_st1", chisq_st1, "chisq_st1[n_tracks]/F");
582  _qa_tree->Branch("prob_st1", prob_st1, "prob_st1[n_tracks]/F");
583  _qa_tree->Branch("quality", quality, "quality[n_tracks]/F");
584 
585  _qa_tree->Branch("nhits", nhits, "nhits[n_tracks]/I");
586  _qa_tree->Branch("nhits_st1", nhits_st1, "nhits_st1[n_tracks]/I");
587  _qa_tree->Branch("nhits_st2", nhits_st2, "nhits_st2[n_tracks]/I");
588  _qa_tree->Branch("nhits_st3", nhits_st3, "nhits_st3[n_tracks]/I");
589  _qa_tree->Branch("charge", charge, "charge[n_tracks]/I");
590 
591 
592 
593 
594 
595  return 0;
596 }
597 
598 int AnaTrkQA::ResetEvalVars() {
599  run_id = std::numeric_limits<int>::max();
600  spill_id = std::numeric_limits<int>::max();
601  target_pos = std::numeric_limits<float>::max();
602  event_id = std::numeric_limits<int>::max();
603  emu_trigger = 0;
604  krecstat = std::numeric_limits<int>::max();
605 
606  n_hits = 0;
607  for(int i=0; i<100; ++i) {
608  detector_id[i] = std::numeric_limits<short>::max();
609  element_id[i] = std::numeric_limits<short>::max();
610  hodo_mask[i] = std::numeric_limits<short>::max();
611  drift_distance[i] = std::numeric_limits<float>::max();
612  pos[i] = std::numeric_limits<float>::max();
613  detector_z[i] = std::numeric_limits<float>::max();
614 
615  truth_x[i] = std::numeric_limits<float>::max();
616  truth_y[i] = std::numeric_limits<float>::max();
617  truth_z[i] = std::numeric_limits<float>::max();
618  truth_pos[i] = std::numeric_limits<float>::max();
619  }
620 
621  n_tracks = 0;
622 
623  for(int i=0; i<100; ++i) {
624  rec_id[i] = std::numeric_limits<int>::max();
625  par_id[i] = std::numeric_limits<int>::max();
626  pid[i] = std::numeric_limits<int>::max();
627  gvx[i] = std::numeric_limits<float>::max();
628  gvy[i] = std::numeric_limits<float>::max();
629  gvz[i] = std::numeric_limits<float>::max();
630  gpx[i] = std::numeric_limits<float>::max();
631  gpy[i] = std::numeric_limits<float>::max();
632  gpz[i] = std::numeric_limits<float>::max();
633  gpt[i] = std::numeric_limits<float>::max();
634  geta[i] = std::numeric_limits<float>::max();
635  gphi[i] = std::numeric_limits<float>::max();
636  gnhits[i] = std::numeric_limits<int>::max();
637  gx_st1[i] = std::numeric_limits<float>::max();
638  gy_st1[i] = std::numeric_limits<float>::max();
639  gz_st1[i] = std::numeric_limits<float>::max();
640  gpx_st1[i] = std::numeric_limits<float>::max();
641  gpy_st1[i] = std::numeric_limits<float>::max();
642  gpz_st1[i] = std::numeric_limits<float>::max();
643  gndc[i] = std::numeric_limits<int>::max();
644  gnhodo[i] = std::numeric_limits<int>::max();
645  gnprop[i] = std::numeric_limits<int>::max();
646  gndp[i] = std::numeric_limits<int>::max();
647 
648 
649  ac_gpx[i] = std::numeric_limits<float>::max();
650  ac_gpy[i] = std::numeric_limits<float>::max();
651  ac_gpz[i] = std::numeric_limits<float>::max();
652 
653 
654 
655  /*for(int j=0; j<NDET+1; ++j) {
656  gelmid[i][j] = std::numeric_limits<int>::max();
657  }
658 */
659 
660  nhits[i] = std::numeric_limits<int>::max();
661  charge[i] = std::numeric_limits<int>::max();
662  rec_vx[i] = std::numeric_limits<float>::max();
663  rec_vy[i] = std::numeric_limits<float>::max();
664  rec_vz[i] = std::numeric_limits<float>::max();
665  rec_px[i] = std::numeric_limits<float>::max();
666  rec_py[i] = std::numeric_limits<float>::max();
667  rec_pz[i] = std::numeric_limits<float>::max();
668  rec_pt[i] = std::numeric_limits<float>::max();
669  rec_eta[i] = std::numeric_limits<float>::max();
670  rec_phi[i] = std::numeric_limits<float>::max();
671  /* x_st1[i] = std::numeric_limits<float>::max();
672  y_st1[i] = std::numeric_limits<float>::max();
673  px_st1[i] = std::numeric_limits<float>::max();
674  py_st1[i] = std::numeric_limits<float>::max();
675  pz_st1[i] = std::numeric_limits<float>::max();
676 */
677  sq_x_st1[i] = std::numeric_limits<float>::max();
678  sq_y_st1[i] = std::numeric_limits<float>::max();
679  sq_z_st1[i] = std::numeric_limits<float>::max();
680  sq_px_st1[i] = std::numeric_limits<float>::max();
681  sq_py_st1[i] = std::numeric_limits<float>::max();
682  sq_pz_st1[i] = std::numeric_limits<float>::max();
683  sq_pos_st1[i] = std::numeric_limits<float>::max();
684  sq_drift_st1[i] = std::numeric_limits<float>::max();
685 
686  rec_x_st1[i] = std::numeric_limits<float>::max();
687  rec_y_st1[i] = std::numeric_limits<float>::max();
688  rec_z_st1[i] = std::numeric_limits<float>::max();
689  rec_px_st1[i] = std::numeric_limits<float>::max();
690  rec_py_st1[i] = std::numeric_limits<float>::max();
691  rec_pz_st1[i] = std::numeric_limits<float>::max();
692  rec_drift_st1[i] = std::numeric_limits<float>::max();
693 
694 
695  sq_x_st2[i] = std::numeric_limits<float>::max();
696  sq_y_st2[i] = std::numeric_limits<float>::max();
697  sq_z_st2[i] = std::numeric_limits<float>::max();
698  sq_px_st2[i] = std::numeric_limits<float>::max();
699  sq_py_st2[i] = std::numeric_limits<float>::max();
700  sq_pz_st2[i] = std::numeric_limits<float>::max();
701  sq_pos_st2[i] = std::numeric_limits<float>::max();
702  sq_drift_st2[i] = std::numeric_limits<float>::max();
703 
704  rec_x_st2[i] = std::numeric_limits<float>::max();
705  rec_y_st2[i] = std::numeric_limits<float>::max();
706  rec_z_st2[i] = std::numeric_limits<float>::max();
707  rec_px_st2[i] = std::numeric_limits<float>::max();
708  rec_py_st2[i] = std::numeric_limits<float>::max();
709  rec_pz_st2[i] = std::numeric_limits<float>::max();
710  rec_drift_st2[i] = std::numeric_limits<float>::max();
711 
712 
713  sq_x_st3[i] = std::numeric_limits<float>::max();
714  sq_y_st3[i] = std::numeric_limits<float>::max();
715  sq_z_st3[i] = std::numeric_limits<float>::max();
716  sq_px_st3[i] = std::numeric_limits<float>::max();
717  sq_py_st3[i] = std::numeric_limits<float>::max();
718  sq_pz_st3[i] = std::numeric_limits<float>::max();
719  sq_pos_st3[i] = std::numeric_limits<float>::max();
720  sq_drift_st3[i] = std::numeric_limits<float>::max();
721 
722  rec_x_st3[i] = std::numeric_limits<float>::max();
723  rec_y_st3[i] = std::numeric_limits<float>::max();
724  rec_z_st3[i] = std::numeric_limits<float>::max();
725  rec_px_st3[i] = std::numeric_limits<float>::max();
726  rec_py_st3[i] = std::numeric_limits<float>::max();
727  rec_pz_st3[i] = std::numeric_limits<float>::max();
728  rec_drift_st3[i] = std::numeric_limits<float>::max();
729 
730  nhits_st1[i] = std::numeric_limits<float>::max();
731  nhits_st2[i] = std::numeric_limits<float>::max();
732  nhits_st3[i] = std::numeric_limits<float>::max();
733 
734  }
735 
736  return 0;
737 }
738 
739 int AnaTrkQA::GetNodes(PHCompositeNode* topNode) {
740 
741  _run_header = findNode::getClass<SQRun>(topNode, "SQRun");
742  if (!_run_header) {
743  LogError("!_run_header");
744  //return Fun4AllReturnCodes::ABORTEVENT;
745  }
746 
747  _spill_map = findNode::getClass<SQSpillMap>(topNode, "SQSpillMap");
748  if (!_spill_map) {
749  LogError("!_spill_map");
750  //return Fun4AllReturnCodes::ABORTEVENT;
751  }
752 
753  _event_header = findNode::getClass<SQEvent>(topNode, "SQEvent");
754  if (!_event_header) {
755  LogError("!_event_header");
756  //return Fun4AllReturnCodes::ABORTEVENT;
757  }
758 
759  if(_hit_container_type.find("Map") != std::string::npos) {
760  _hit_map = findNode::getClass<SQHitMap>(topNode, "SQHitMap");
761  if (!_hit_map) {
762  LogError("!_hit_map");
763  return Fun4AllReturnCodes::ABORTEVENT;
764  }
765  }
766 
767  if(_hit_container_type.find("Vector") != std::string::npos) {
768  _hit_vector = findNode::getClass<SQHitVector>(topNode, "SQHitVector");
769  if (!_hit_vector) {
770  LogError("!_hit_vector");
771  return Fun4AllReturnCodes::ABORTEVENT;
772  }
773  }
774 
775  _truth = findNode::getClass<PHG4TruthInfoContainer>(topNode, "G4TruthInfo");
776  if (!_truth) {
777  LogError("!_truth");
778  return Fun4AllReturnCodes::ABORTEVENT;
779  }
780 
781  _recEvent = findNode::getClass<SRecEvent>(topNode, "SRecEvent");
782  if (!_recEvent) {
783  LogError("!_recEvent");
784  //return Fun4AllReturnCodes::ABORTEVENT;
785  }
786 
787 
788  g4hc_d1x = findNode::getClass<PHG4HitContainer >(topNode, "G4HIT_D1X");
789  g4hc_d2xp = findNode::getClass<PHG4HitContainer >(topNode, "G4HIT_D2Xp");
790  g4hc_d3px = findNode::getClass<PHG4HitContainer >(topNode, "G4HIT_D3pXp");
791  g4hc_d3mx = findNode::getClass<PHG4HitContainer >(topNode, "G4HIT_D3mXp");
792  if (! g4hc_d1x) g4hc_d1x = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_D0X");
793 
794  if ( !g4hc_d1x || !g4hc_d3px || !g4hc_d3mx) {
795  cout << "Failed at getting nodes: "<< g4hc_d1x << " " << g4hc_d3px << " " << g4hc_d3mx << endl;
796  return Fun4AllReturnCodes::ABORTEVENT;
797  }
798 
799 //hodoscope for the acceptance study
800  g4hc_h1t = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H1T");
801  g4hc_h1b = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H1B");
802  g4hc_h2t = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H2T");
803  g4hc_h2b = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H2B");
804  g4hc_h3t = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H3T");
805  g4hc_h3b = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H3B");
806  g4hc_h4t = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H4T");
807  g4hc_h4b = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_H4B");
808 
809  if (!g4hc_h1t || !g4hc_h1b || !g4hc_h2t || !g4hc_h2b ||
810  !g4hc_h3t || !g4hc_h3b || !g4hc_h4t || !g4hc_h4b ) {
811  return Fun4AllReturnCodes::ABORTEVENT;
812  }
813 
815  g4hc_p1y1 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P1Y1");
816  g4hc_p1y2 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P1Y2");
817  g4hc_p1x1 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P1X1");
818  g4hc_p1x2 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P1X2");
819  g4hc_p2x1 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P2X1");
820  g4hc_p2x2 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P2X2");
821  g4hc_p2y1 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P2Y1");
822  g4hc_p2y2 = findNode::getClass<PHG4HitContainer>(topNode, "G4HIT_P2Y2");
823 
824  if (!g4hc_p1y1 || !g4hc_p1y2 || !g4hc_p1x1 || !g4hc_p1x2 ||
825  !g4hc_p2x1 || !g4hc_p2x2 || !g4hc_p2y1 || !g4hc_p2y2 ) {
826  return Fun4AllReturnCodes::ABORTEVENT;
827  }
828 
829 
830 
831  return Fun4AllReturnCodes::EVENT_OK;
832 }
833 
834 
835 //For finding g4hit information in stations (following Kenichi's truth node maker)
836 bool AnaTrkQA::FindG4HitAtStation(const int trk_id, const PHG4HitContainer* g4hc, TVector3* pos, TLorentzVector* mom)
837 {
838  //const double M_MU = 0.1056583745;
839  PHG4HitContainer::ConstRange range = g4hc->getHits();
840  for (PHG4HitContainer::ConstIterator it = range.first; it != range.second; it++) {
841  PHG4Hit* hit = it->second;
842  if (hit->get_trkid() == trk_id) {
843  pos->SetXYZ (hit->get_x(0) , hit->get_y(0) , hit->get_z(0) );
844  mom->SetXYZM(hit->get_px(0), hit->get_py(0), hit->get_pz(0), M_MU);
845  return true;
846  }
847  }
848  return false;
849 }
850 
851 
852 //Function for finding best reco track
853 SRecTrack* AnaTrkQA::FindBestMomRecTrack(SRecEvent *recEvent, const float true_TargetP)
854 {
855  double dP = 100.;
856  double hold_dP = 99999.;
857 
858  SRecTrack* Best_recTrack = NULL;
859  for(int itrack=0; itrack<recEvent->getNTracks(); ++itrack){
860  if (hold_dP>dP) hold_dP = dP;
861  SRecTrack *recTrack = &recEvent->getTrack(itrack);
862  dP = fabs(true_TargetP - recTrack->getTargetMom().Mag());
863 
864  //Finding out best match track in terms of energy
865  if(dP-hold_dP<0.) Best_recTrack = recTrack;
866  }
867  return Best_recTrack;
868 
869 }
870 
871 
872 //Function to find common hit ids for reco and truth tracks
873 int AnaTrkQA::FindCommonHitIDs(vector<int>& hitidvec1, vector<int>& hitidvec2)
874 {
875  //This function assumes the input vectors have been sorted
876  auto iter = hitidvec1.begin();
877  auto jter = hitidvec2.begin();
878 
879  int nCommon = 0;
880  while(iter != hitidvec1.end() && jter != hitidvec2.end()) {
881  if(*iter < *jter) {
882  ++iter;
883  } else {
884  if(!(*jter < *iter)) {
885  ++nCommon;
886  ++iter;
887  }
888  ++jter;
889  }
890  }
891 
892  return nCommon;
893 }
894 
895 
896 //functions for the acceptance
897 bool AnaTrkQA::FindG4HitAtHodo(const int trk_id, const PHG4HitContainer* g4hc)
898 {
899  //const double M_MU = 0.1056583745;
900  PHG4HitContainer::ConstRange range = g4hc->getHits();
901  for (PHG4HitContainer::ConstIterator it = range.first; it != range.second; it++) {
902  PHG4Hit* hit = it->second;
903  if (hit->get_trkid() == trk_id) {
904  return true;
905  }
906  }
907  return false;
908 }
909 
910 
911 bool AnaTrkQA::FindG4HitAtProp(const int trk_id, const PHG4HitContainer* g4hc)
912 {
913  PHG4HitContainer::ConstRange range = g4hc->getHits();
914  for (PHG4HitContainer::ConstIterator it = range.first; it != range.second; it++) {
915  PHG4Hit* hit = it->second;
916  if (hit->get_trkid() == trk_id) {
917  return true;
918  }
919  }
920  return false;
921 }
922 
LogError
#define LogError(exp)
Definition: AnaTrkQA.cxx:52
nChamberPlanes
#define nChamberPlanes
Definition: GlobalConsts.h:6
M_MU
#define M_MU
Definition: GlobalConsts.h:12
PHTFileServer.h
TFile clean handling.
NULL
#define NULL
Definition: Pdb.h:9
SQEvent_v1.h
SQHitMap_v1.h
SQHitVector_v1.h
SQHit_v1.h
SQMCHit_v1.h
SQRun_v1.h
SQSpillMap_v1.h
SQSpill_v1.h
AnaTrkQA::ResetEvalVars
int ResetEvalVars()
Definition: AnaTrkQA.cxx:598
AnaTrkQA::process_event
int process_event(PHCompositeNode *topNode)
Definition: AnaTrkQA.cxx:88
AnaTrkQA::AnaTrkQA
AnaTrkQA(const std::string &name="AnaTrkQA.root")
Definition: AnaTrkQA.cxx:57
AnaTrkQA::InitEvalTree
int InitEvalTree()
Definition: AnaTrkQA.cxx:472
AnaTrkQA::End
int End(PHCompositeNode *topNode)
===========================
Definition: AnaTrkQA.cxx:462
AnaTrkQA::Init
int Init(PHCompositeNode *topNode)
Definition: AnaTrkQA.cxx:71
AnaTrkQA::InitRun
int InitRun(PHCompositeNode *topNode)
Definition: AnaTrkQA.cxx:75
Fun4AllBase::VERBOSITY_A_LOT
@ VERBOSITY_A_LOT
Output a lot of messages.
Definition: Fun4AllBase.h:48
Fun4AllBase::Verbosity
virtual int Verbosity() const
Gets the verbosity of this module.
Definition: Fun4AllBase.h:64
GeomSvc::instance
static GeomSvc * instance()
singlton instance
Definition: GeomSvc.cxx:212
GeomSvc::getDCA
double getDCA(int detectorID, int elementID, double tx, double ty, double x0, double y0)
Definition: GeomSvc.cxx:865
PHG4HitContainer::ConstIterator
Map::const_iterator ConstIterator
Definition: PHG4HitContainer.h:18
PHG4HitContainer::getHits
ConstRange getHits(const unsigned int detid) const
return all hits matching a given detid
Definition: PHG4HitContainer.cc:117
PHG4HitContainer::ConstRange
std::pair< ConstIterator, ConstIterator > ConstRange
Definition: PHG4HitContainer.h:20
PHG4Hit::get_py
virtual float get_py(const int i) const
Definition: PHG4Hit.h:25
PHG4Hit::get_z
virtual float get_z(const int i) const
Definition: PHG4Hit.h:23
PHG4Hit::get_pz
virtual float get_pz(const int i) const
Definition: PHG4Hit.h:26
PHG4Hit::get_px
virtual float get_px(const int i) const
Definition: PHG4Hit.h:24
PHG4Hit::get_y
virtual float get_y(const int i) const
Definition: PHG4Hit.h:22
PHG4Hit::get_x
virtual float get_x(const int i) const
Definition: PHG4Hit.h:21
PHG4Hit::get_trkid
virtual int get_trkid() const
Definition: PHG4Hit.h:41
PHG4Particle::get_track_id
virtual int get_track_id() const
Definition: PHG4Particle.h:21
PHG4Particle::get_pid
virtual int get_pid() const
Definition: PHG4Particle.h:14
PHG4Particle::get_px
virtual double get_px() const
Definition: PHG4Particle.h:16
PHG4Particle::get_vtx_id
virtual int get_vtx_id() const
Definition: PHG4Particle.h:22
PHG4Particle::get_py
virtual double get_py() const
Definition: PHG4Particle.h:17
PHG4Particle::get_pz
virtual double get_pz() const
Definition: PHG4Particle.h:18
PHG4TruthInfoContainer::GetVtx
PHG4VtxPoint * GetVtx(const int vtxid)
Definition: PHG4TruthInfoContainer.cc:130
PHG4VtxPoint::get_y
virtual double get_y() const
Definition: PHG4VtxPoint.h:21
PHG4VtxPoint::get_x
virtual double get_x() const
Definition: PHG4VtxPoint.h:20
PHG4VtxPoint::get_z
virtual double get_z() const
Definition: PHG4VtxPoint.h:22
PHTFileServer::get
static PHTFileServer & get(void)
return reference to class singleton
Definition: PHTFileServer.h:36
PHTFileServer::open
void open(const std::string &filename, const std::string &type="RECREATE")
open a SafeTFile. If filename is not found in the map, create a new TFile and append to the map; incr...
Definition: PHTFileServer.cxx:29
PHTFileServer::cd
bool cd(const std::string &filename)
change to directory of TFile matching filename
Definition: PHTFileServer.cxx:76
SQHitVector::at
virtual const SQHit * at(const size_t idkey) const =0
SQHitVector::size
virtual size_t size() const =0
SQHit
An SQ interface class to hold one detector hit.
Definition: SQHit.h:20
SQHit::get_truth_z
virtual float get_truth_z() const
Return the true z-position of this hit. Meaningful only if this hit is of MC.
Definition: SQHit.h:78
SQHit::get_drift_distance
virtual float get_drift_distance() const
Return the drift distance of this hit. Probably the value is not properly set at present....
Definition: SQHit.h:57
SQHit::get_truth_pz
virtual float get_truth_pz() const
Return the true z-momentum of this hit. Meaningful only if this hit is of MC.
Definition: SQHit.h:87
SQHit::get_truth_y
virtual float get_truth_y() const
Return the true y-position of this hit. Meaningful only if this hit is of MC.
Definition: SQHit.h:75
SQHit::get_truth_px
virtual float get_truth_px() const
Return the true x-momentum of this hit. Meaningful only if this hit is of MC.
Definition: SQHit.h:81
SQHit::get_pos
virtual float get_pos() const
Return the absolute position of this hit. Probably the value is not properly set at present.
Definition: SQHit.h:60
SQHit::get_element_id
virtual short get_element_id() const
Return the element ID of this hit.
Definition: SQHit.h:45
SQHit::get_hit_id
virtual int get_hit_id() const
Return the ID of this hit.
Definition: SQHit.h:39
SQHit::get_truth_py
virtual float get_truth_py() const
Return the true y-momentum of this hit. Meaningful only if this hit is of MC.
Definition: SQHit.h:84
SQHit::get_truth_x
virtual float get_truth_x() const
Return the true x-position of this hit. Meaningful only if this hit is of MC.
Definition: SQHit.h:72
SQHit::get_detector_id
virtual short get_detector_id() const
Return the detector ID of this hit.
Definition: SQHit.h:42
SQHit::get_track_id
virtual int get_track_id() const
Return the track ID associated with this hit. Probably the value is not properly set at present.
Definition: SQHit.h:66
SRecEvent::getNTracks
Int_t getNTracks()
Get tracks.
Definition: SRecEvent.h:455
SRecEvent::getTrack
SRecTrack & getTrack(Int_t i)
Definition: SRecEvent.h:456
SRecTrack::getCovariance
TMatrixD getCovariance(Int_t i)
Definition: SRecEvent.h:110
SRecTrack::getChisq
Double_t getChisq() const
Definition: SRecEvent.h:104
SRecTrack::getNHits
Int_t getNHits() const
Definition: SRecEvent.h:102
SRecTrack::getTargetPos
TVector3 getTargetPos()
Definition: SRecEvent.h:188
SRecTrack::getCharge
Int_t getCharge() const
Gets.
Definition: SRecEvent.h:101
SRecTrack::getStateVector
TMatrixD getStateVector(Int_t i)
Definition: SRecEvent.h:109
SRecTrack::getProb
Double_t getProb() const
Definition: SRecEvent.cxx:163
SRecTrack::getZ
Double_t getZ(Int_t i)
Definition: SRecEvent.h:111
SRecTrack::getQuality
Double_t getQuality() const
Definition: SRecEvent.h:106
SRecTrack::getHitIndex
Int_t getHitIndex(Int_t i)
Definition: SRecEvent.h:108
SRecTrack::getNHitsInStation
Int_t getNHitsInStation(Int_t stationID)
Definition: SRecEvent.cxx:149
SRecTrack::getNearestNode
Int_t getNearestNode(Double_t z)
Definition: SRecEvent.cxx:249
SRecTrack::getTargetMom
TVector3 getTargetMom()
Definition: SRecEvent.h:193