eventAnalysis  7.0-49-g0ac7482
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Pages
TFgdOnlyModule.cxx
Go to the documentation of this file.
1 #include "TFgdOnlyModule.hxx"
2 #include <TFGDPid.hxx>
3 #include <TTrackState.hxx>
4 #include <cmath>
5 #include "TIntegerDatum.hxx"
6 #include "TRealDatum.hxx"
7 #include "TReconCluster.hxx"
8 #include "TrackTruthInfo.hxx"
9 
10 ClassImp(ND::TFgdOnlyModule::TFgd2DIsoTrack);
11 ND::TFgdOnlyModule::TFgd2DIsoTrack::~TFgd2DIsoTrack() {}
12 ClassImp(ND::TFgdOnlyModule::TFgd3DIsoTrack);
13 ND::TFgdOnlyModule::TFgd3DIsoTrack::~TFgd3DIsoTrack() {}
14 ClassImp(ND::TFgdOnlyModule::TFgd2DCluster);
15 ND::TFgdOnlyModule::TFgd2DCluster::~TFgd2DCluster() {}
16 ClassImp(ND::TFgdOnlyModule::TFgd3DShowerHyp);
17 ND::TFgdOnlyModule::TFgd3DShowerHyp::~TFgd3DShowerHyp() {}
18 ClassImp(ND::TFgdOnlyModule::TFgd3DShowerPID);
19 ND::TFgdOnlyModule::TFgd3DShowerPID::~TFgd3DShowerPID() {}
20 
21 #include "../cvstags/TFgdOnlyModule.cxx"
22 
23 
24 double getTrackLength(ND::THandle<ND::TReconTrack> track) {
25  const ND::TReconNodeContainer &nodes = track->GetNodes();
26  if (nodes.size() < 2) return -1;
27 
28  // horrendous syntax begins here
29  ND::THandle<ND::TTrackState> start = (*(nodes.begin()))->GetState();
30  ND::THandle<ND::TTrackState> stop = (*(nodes.end() - 1))->GetState();
31  // horrendous syntax ends here
32  if (start && stop) {
33  TVector3 beginning = start->GetPosition().Vect();
34  TVector3 end = stop->GetPosition().Vect();
35  return (beginning - end).Mag();
36  } else {
37  return -1;
38  }
39 }
40 
41 ND::TFgdOnlyModule::TFgdOnlyModule(const char *name, const char *title) {
42  fTrackAlgorithms.push_back("_Radon2");
43  fTrackAlgorithms.push_back("_SBCAT");
44  fTrackAlgorithms.push_back("_Radon");
45  fTrackAlgorithms.push_back("_flexRadon");
46  fTrackAlgorithms.push_back("_P0DHough");
47 
48  fPids.push_back("_Proton");
49  fPids.push_back("_Pion");
50  fPids.push_back("_Muon");
51 
52  SetNameTitle(name, title);
53 
54  fIsEnabled = kTRUE;
55  fDescription = "FGD Recon Output";
56  fCVSTagName = CVSTAG;
57  fCVSID = CVSID;
58 
59  fNXZTracks = new int[fTrackAlgorithms.size()];
60  fNYZTracks = new int[fTrackAlgorithms.size()];
61  fNXYZTracks = new int[fTrackAlgorithms.size()];
62  fNXZTracksAllFGD = new int[fTrackAlgorithms.size()];
63  fNYZTracksAllFGD = new int[fTrackAlgorithms.size()];
64  fNXYZTracksAllFGD = new int[fTrackAlgorithms.size()];
65 
66  fXZTracks = new TClonesArray *[fTrackAlgorithms.size()];
67  fYZTracks = new TClonesArray *[fTrackAlgorithms.size()];
68  fXYZTracks = new TClonesArray *[fTrackAlgorithms.size()];
69  fXZTracksAllFGD = new TClonesArray *[fTrackAlgorithms.size()];
70  fYZTracksAllFGD = new TClonesArray *[fTrackAlgorithms.size()];
71  fXYZTracksAllFGD = new TClonesArray *[fTrackAlgorithms.size()];
72 
73  for (unsigned int i = 0; i < fTrackAlgorithms.size(); ++i) {
74  fNXZTracks[i] = 0;
75  fXZTracks[i] = new TClonesArray("ND::TFgdOnlyModule::TFgd2DIsoTrack", 200);
76  fNYZTracks[i] = 0;
77  fYZTracks[i] = new TClonesArray("ND::TFgdOnlyModule::TFgd2DIsoTrack", 200);
78  fNXYZTracks[i] = 0;
79  fXYZTracks[i] = new TClonesArray("ND::TFgdOnlyModule::TFgd3DIsoTrack", 200);
80 
81  fNXZTracksAllFGD[i] = 0;
82  fXZTracksAllFGD[i] =
83  new TClonesArray("ND::TFgdOnlyModule::TFgd2DIsoTrack", 200);
84  fNYZTracksAllFGD[i] = 0;
85  fYZTracksAllFGD[i] =
86  new TClonesArray("ND::TFgdOnlyModule::TFgd2DIsoTrack", 200);
87  fNXYZTracksAllFGD[i] = 0;
88  fXYZTracksAllFGD[i] =
89  new TClonesArray("ND::TFgdOnlyModule::TFgd3DIsoTrack", 200);
90  }
91 
92  fN3DShowers = 0;
93  f3DShowers = new TClonesArray("ND::TFgdOnlyModule::TFgd3DShowerPID", 200);
94 
95  fN2DClustersXZ = 0;
96  f2DClustersXZ = new TClonesArray("ND::TFgdOnlyModule::TFgd2DCluster", 200);
97  f2DClustersYZ = 0;
98  f2DClustersYZ = new TClonesArray("ND::TFgdOnlyModule::TFgd2DCluster", 200);
99 
100  fFGDPid = new TFGDPid();
101 }
102 
103 ND::TFgdOnlyModule::~TFgdOnlyModule() {
104  if (fFGDPid) {
105  delete fFGDPid;
106  fFGDPid = NULL;
107  }
108 }
109 
110 Bool_t ND::TFgdOnlyModule::ProcessFirstEvent(ND::TND280Event &event) {
111  return true;
112 }
113 
114 void ND::TFgdOnlyModule::InitializeBranches() {
115  //char buf[100];
116  //char bufI[100];
117 
118  for (unsigned int i = 0; i < fTrackAlgorithms.size(); ++i) {
119  const char *algoName = fTrackAlgorithms[i];
120 
121  //sprintf(buf, "NXZTracks%s", algoName);
122  //sprintf(bufI, "%s/I", buf);
123  fOutputTree->Branch(Form("NXZTracks%s", algoName), &fNXZTracks[i],
124  Form("NXZTracks%s/I", algoName), fBufferSize);
125 
126  //sprintf(buf, "NYZTracks%s", algoName);
127  //sprintf(bufI, "%s/I", buf);
128  fOutputTree->Branch(Form("NYZTracks%s", algoName), &fNYZTracks[i],
129  Form("NYZTracks%s/I",algoName), fBufferSize);
130 
131  //sprintf(buf, "NXYZTracks%s", algoName);
132  //sprintf(bufI, "%s/I", buf);
133  fOutputTree->Branch(Form("NXYZTracks%s", algoName) ,&fNXYZTracks[i],
134  Form("NXYZTracks%s/I", algoName), fBufferSize);
135 
136  //sprintf(buf, "NXZTracksAllFGD%s", algoName);
137  //sprintf(bufI, "%s/I", buf);
138  fOutputTree->Branch(Form("NXZTracksAllFGD%s", algoName), &fNXZTracksAllFGD[i],
139  Form("NXZTracksAllFGD%s/I", algoName), fBufferSize);
140 
141  //sprintf(buf, "NYZTracksAllFGD%s", algoName);
142  //sprintf(bufI, "%s/I", buf);
143  fOutputTree->Branch(Form("NYZTracksAllFGD%s", algoName), &fNYZTracksAllFGD[i],
144  Form("NYZTracksAllFGD%s/I", algoName), fBufferSize);
145 
146  //sprintf(buf, "NXYZTracksAllFGD%s", algoName);
147  //sprintf(bufI, "%s/I", buf);
148  fOutputTree->Branch(Form("NXYZTracksAllFGD%s", algoName), &fNXYZTracksAllFGD[i],
149  Form("NXYZTracksAllFGD%s/I", algoName), fBufferSize);
150 
151  //sprintf(buf, "XZTracks%s", algoName);
152  fOutputTree->Branch(Form("XZTracks%s",algoName), &fXZTracks[i], fBufferSize, fSplitLevel)
153  ->SetTitle("These tracks use only hits unused by the TPC+FGD fits");
154 
155  //sprintf(buf, "YZTracks%s", algoName);
156  fOutputTree->Branch(Form("YZTracks%s", algoName), &fYZTracks[i], fBufferSize, fSplitLevel)
157  ->SetTitle("These tracks use only hits unused by the TPC+FGD fits");
158 
159  //sprintf(buf, "XYZTracks%s", algoName);
160  fOutputTree->Branch(Form( "XYZTracks%s", algoName), &fXYZTracks[i], fBufferSize, fSplitLevel)
161  ->SetTitle("These tracks use only hits unused by the TPC+FGD fits");
162 
163  //sprintf(buf, "XZTracksAllFGD%s", algoName);
164  fOutputTree->Branch(Form("XZTracksAllFGD%s", algoName), &fXZTracksAllFGD[i], fBufferSize, fSplitLevel)
165  ->SetTitle("All and only FGD hits used for these tracks");
166 
167  //sprintf(buf, "YZTracksAllFGD%s", algoName);
168  fOutputTree->Branch(Form("YZTracksAllFGD%s", algoName), &fYZTracksAllFGD[i], fBufferSize, fSplitLevel)
169  ->SetTitle("All and only FGD hits used for these tracks");
170 
171  //sprintf(buf, "XYZTracksAllFGD%s", algoName);
172  fOutputTree->Branch(Form("XYZTracksAllFGD%s", algoName), &fXYZTracksAllFGD[i], fBufferSize, fSplitLevel)
173  ->SetTitle("All and only FGD hits used for these tracks");
174  }
175 
176  fOutputTree->Branch("N3DShowers", &fN3DShowers, "N3DShowers/I", fBufferSize)
177  ->SetTitle("Number of Showers");
178  fOutputTree->Branch("N2DClustersXZ", &fN2DClustersXZ, "N2DClustersXZ/I",
179  fBufferSize)
180  ->SetTitle("Number of 2D constituents of showers");
181  fOutputTree->Branch("N2DClustersYZ", &fN2DClustersYZ, "N2DClustersYZ/I",
182  fBufferSize)
183  ->SetTitle(" Number of 2D constituents of showers");
184 
185  fOutputTree->Branch("FGD3DShowers", &f3DShowers, fBufferSize, fSplitLevel)
186  ->SetTitle(" Showers");
187 
188  fOutputTree->Branch("FGD2DClustersXZ", &f2DClustersXZ, fBufferSize,
189  fSplitLevel)
190  ->SetTitle(" 2D constituents of showers");
191  fOutputTree->Branch("FGD2DClustersYZ", &f2DClustersYZ, fBufferSize,
192  fSplitLevel)
193  ->SetTitle(" 2D constituents of showers");
194 
195 }
196 
197 bool ND::TFgdOnlyModule::FillTree(ND::TND280Event &event) {
198  for (unsigned int i = 0; i < fTrackAlgorithms.size(); ++i) {
199  fNXZTracks[i] = 0;
200  fXZTracks[i]->Clear();
201 
202  fNYZTracks[i] = 0;
203  fYZTracks[i]->Clear();
204 
205  fNXYZTracks[i] = 0;
206  fXYZTracks[i]->Clear();
207 
208  fNXZTracksAllFGD[i] = 0;
209  fXZTracksAllFGD[i]->Clear();
210 
211  fNYZTracksAllFGD[i] = 0;
212  fYZTracksAllFGD[i]->Clear();
213 
214  fNXYZTracksAllFGD[i] = 0;
215  fXYZTracksAllFGD[i]->Clear();
216  }
217 
218  fN3DShowers = 0;
219  f3DShowers->Clear();
220 
221  fN2DClustersXZ = 0;
222  f2DClustersXZ->Clear();
223  fN2DClustersYZ = 0;
224  f2DClustersYZ->Clear();
225 
226  ND::THandle<ND::TAlgorithmResult> FgdResult = event.GetFit("fgdRecon");
227 
228  // Returning false will lead to this module being disabled - need to decide
229  // if we want this to happen if don't find one "fgdRecon" fit result
230  if (!FgdResult) return true;
231 
232  char buf[100];
233 
234  for (unsigned int i = 0; i < fTrackAlgorithms.size(); ++i) {
235  const char *algoName = fTrackAlgorithms[i];
236 
237  sprintf(buf, "xzFgdReconTracks%s", algoName);
238  ND::THandle<ND::TReconObjectContainer> xzReconTracks =
239  FgdResult->GetResultsContainer(buf);
240  sprintf(buf, "yzFgdReconTracks%s", algoName);
241  ND::THandle<ND::TReconObjectContainer> yzReconTracks =
242  FgdResult->GetResultsContainer(buf);
243  sprintf(buf, "fittedFgdReconTracks%s", algoName);
244  ND::THandle<ND::TReconObjectContainer> xyzReconTracks =
245  FgdResult->GetResultsContainer(buf);
246 
247  sprintf(buf, "xzFgdReconTracks_allFGD%s", algoName);
248  ND::THandle<ND::TReconObjectContainer> xzReconTracksAllFGD =
249  FgdResult->GetResultsContainer(buf);
250  sprintf(buf, "yzFgdReconTracks_allFGD%s", algoName);
251  ND::THandle<ND::TReconObjectContainer> yzReconTracksAllFGD =
252  FgdResult->GetResultsContainer(buf);
253  sprintf(buf, "fittedFgdReconTracks_allFGD%s", algoName);
254  ND::THandle<ND::TReconObjectContainer> xyzReconTracksAllFGD =
255  FgdResult->GetResultsContainer(buf);
256 
257  if (xzReconTracks) {
258  for (ND::TReconObjectContainer::iterator track = xzReconTracks->begin();
259  track != xzReconTracks->end(); track++) {
260  ND::THandle<ND::TReconTrack> tr = *track;
261  if (!tr) continue;
262  ND::THandle<ND::TTrackState> state = tr->GetState();
263  if (!state) continue;
264 
265  TFgd2DIsoTrack *TempTrack =
266  new ((*(fXZTracks[i]))[fNXZTracks[i]++]) TFgd2DIsoTrack;
267  Fill2DIsoTrack(tr, state, TempTrack, 'X');
268  }
269  }
270  if (yzReconTracks) {
271  for (ND::TReconObjectContainer::iterator track = yzReconTracks->begin();
272  track != yzReconTracks->end(); track++) {
273  ND::THandle<ND::TReconTrack> tr = *track;
274  if (!tr) continue;
275  ND::THandle<ND::TTrackState> state = tr->GetState();
276  if (!state) continue;
277 
278  TFgd2DIsoTrack *TempTrack =
279  new ((*(fYZTracks[i]))[fNYZTracks[i]++]) TFgd2DIsoTrack;
280  Fill2DIsoTrack(tr, state, TempTrack, 'Y');
281  }
282  }
283 
284  if (xyzReconTracks) {
285  for (ND::TReconObjectContainer::iterator track = xyzReconTracks->begin();
286  track != xyzReconTracks->end(); track++) {
287  ND::THandle<ND::TReconTrack> tr = *track;
288  if (!tr) continue;
289  ND::THandle<ND::TTrackState> state = tr->GetState();
290  if (!state) continue;
291 
292  TFgd3DIsoTrack *TempTrack =
293  new ((*(fXYZTracks[i]))[fNXYZTracks[i]++]) TFgd3DIsoTrack;
294  Fill3DIsoTrack(tr, state, TempTrack);
295  }
296  }
297 
298  // Tracks using all the FGD hits
299  if (xzReconTracksAllFGD) {
300  for (ND::TReconObjectContainer::iterator track =
301  xzReconTracksAllFGD->begin();
302  track != xzReconTracksAllFGD->end(); track++) {
303  ND::THandle<ND::TReconTrack> tr = *track;
304  if (!tr) continue;
305  ND::THandle<ND::TTrackState> state = tr->GetState();
306  if (!state) continue;
307 
308  TFgd2DIsoTrack *TempTrack =
309  new ((*(fXZTracksAllFGD[i]))[fNXZTracksAllFGD[i]++]) TFgd2DIsoTrack;
310  Fill2DIsoTrack(tr, state, TempTrack, 'X');
311  }
312  }
313  if (yzReconTracksAllFGD) {
314  for (ND::TReconObjectContainer::iterator track =
315  yzReconTracksAllFGD->begin();
316  track != yzReconTracksAllFGD->end(); track++) {
317  ND::THandle<ND::TReconTrack> tr = *track;
318  if (!tr) continue;
319  ND::THandle<ND::TTrackState> state = tr->GetState();
320  if (!state) continue;
321 
322  TFgd2DIsoTrack *TempTrack =
323  new ((*(fYZTracksAllFGD[i]))[fNYZTracksAllFGD[i]++]) TFgd2DIsoTrack;
324  Fill2DIsoTrack(tr, state, TempTrack, 'Y');
325  }
326  }
327 
328  if (xyzReconTracksAllFGD) {
329  for (ND::TReconObjectContainer::iterator track =
330  xyzReconTracksAllFGD->begin();
331  track != xyzReconTracksAllFGD->end(); track++) {
332  ND::THandle<ND::TReconTrack> tr = *track;
333  if (!tr) continue;
334  ND::THandle<ND::TTrackState> state = tr->GetState();
335  if (!state) continue;
336 
337  TFgd3DIsoTrack *TempTrack =
338  new ((*(fXYZTracksAllFGD[i]))[fNXYZTracksAllFGD[i]++])
339  TFgd3DIsoTrack;
340  Fill3DIsoTrack(tr, state, TempTrack);
341  }
342  }
343  } // end loop over track algorithms
344 
345  ND::THandle<ND::TReconObjectContainer> fgd3DShowers =
346  FgdResult->GetResultsContainer("FGDShowerPIDs");
347  std::vector<ND::THandle<ND::TReconObjectContainer> > fgd2DClustersXZ,
348  fgd2DClustersYZ;
349  fgd2DClustersXZ.push_back(
350  FgdResult->GetResultsContainer("combi_basic_fgd1_xz"));
351  fgd2DClustersYZ.push_back(
352  FgdResult->GetResultsContainer("combi_basic_fgd1_yz"));
353  fgd2DClustersXZ.push_back(
354  FgdResult->GetResultsContainer("combi_basic_fgd2_xz"));
355  fgd2DClustersYZ.push_back(
356  FgdResult->GetResultsContainer("combi_basic_fgd2_yz"));
357 
358  // FGD Showers
359  if (fgd3DShowers) {
360  ND280NamedVerbose("TFgdOnlyModule","Have fgd3DShowers");
361  for (ND::TReconObjectContainer::iterator pidIter = fgd3DShowers->begin();
362  pidIter != fgd3DShowers->end(); pidIter++) {
363  ND::THandle<ND::TReconPID> pid = *pidIter;
364 
365  TFgd3DShowerPID *TempObject =
366  new ((*f3DShowers)[fN3DShowers++]) TFgd3DShowerPID;
367  Fill3DShower(TempObject, pid);
368  }
369  }
370 
371  // 2D Constituents of 3D Showers
372  for (std::vector<ND::THandle<ND::TReconObjectContainer> >::iterator it =
373  fgd2DClustersXZ.begin();
374  it != fgd2DClustersXZ.end(); it++) {
375  ND::THandle<ND::TReconObjectContainer> roc = (*it);
376  if (roc) {
377  for (ND::TReconObjectContainer::iterator objIter = roc->begin();
378  objIter != roc->end(); objIter++) {
379  ND::THandle<ND::TReconCluster> cluster = *objIter;
380  TFgd2DCluster *TempObject =
381  new ((*f2DClustersXZ)[fN2DClustersXZ++]) TFgd2DCluster;
382  Fill2DCluster(TempObject, cluster);
383  }
384  }
385  }
386  for (std::vector<ND::THandle<ND::TReconObjectContainer> >::iterator it =
387  fgd2DClustersYZ.begin();
388  it != fgd2DClustersYZ.end(); it++) {
389  ND::THandle<ND::TReconObjectContainer> roc = (*it);
390  if (roc) {
391  for (ND::TReconObjectContainer::iterator objIter = roc->begin();
392  objIter != roc->end(); objIter++) {
393  ND::THandle<ND::TReconCluster> cluster = *objIter;
394  TFgd2DCluster *TempObject =
395  new ((*f2DClustersYZ)[fN2DClustersYZ++]) TFgd2DCluster;
396  Fill2DCluster(TempObject, cluster);
397  }
398  }
399  }
400 
401  return true;
402 }
403 
404 void ND::TFgdOnlyModule::Fill2DIsoTrack(ND::THandle<ND::TReconTrack> tr,
405  ND::THandle<ND::TTrackState> state,
406  TFgd2DIsoTrack *isoTrack, char Axis) {
407 isoTrack->AlgorithmName = tr->GetAlgorithmName();
408 
409 ND::THandle<ND::THitSelection> hits = tr->GetHits();
410 isoTrack->NHits = hits->size();
411 
412 double charge = 0;
413 for (ND::THitSelection::iterator hit = hits->begin(); hit != hits->end();
414  hit++) {
415 charge += (*hit)->GetCharge();
416  }
417  isoTrack->SumCharge = charge;
418 
419  TLorentzVector posn = state->GetPosition();
420  isoTrack->Origin = posn;
421  TLorentzVector dposn = state->GetPositionVariance();
422  isoTrack->OriginVariance = dposn;
423 
424  TVector3 dir = state->GetDirection();
425  isoTrack->Direction = dir;
426 
427  if (Axis == 'X') isoTrack->Angle = atan2(dir.X(), dir.Z());
428  if (Axis == 'Y') isoTrack->Angle = atan2(dir.Y(), dir.Z());
429 
430  isoTrack->Range = getTrackLength(tr);
431 
432  for (ND::THitSelection::iterator hit = hits->begin(); hit != hits->end();
433  hit++) {
434  TVector3 *pos = new TVector3((*hit)->GetPosition());
435  isoTrack->HitPositions.push_back(pos);
436  }
437 
438  isoTrack->TrajId = TrackTruthInfo::GetG4TrajectoryID(
439  tr, isoTrack->Completeness, isoTrack->Cleanliness);
440  }
441 
442  void ND::TFgdOnlyModule::Fill3DIsoTrack(ND::THandle<ND::TReconTrack> tr,
443  ND::THandle<ND::TTrackState> state,
444  TFgd3DIsoTrack *isoTrack) {
445  // TFGDPid fFGDPid;
446 
447  isoTrack->AlgorithmName = tr->GetAlgorithmName();
448 
449  ND::THandle<ND::THitSelection> hits = tr->GetHits();
450  isoTrack->NHits = hits->size();
451 
452  double charge = 0;
453  for (ND::THitSelection::iterator hit = hits->begin(); hit != hits->end();
454  hit++) {
455  charge += (*hit)->GetCharge();
456  }
457  isoTrack->SumCharge = charge;
458 
459  TLorentzVector posn = state->GetPosition();
460  isoTrack->Origin = posn;
461  TLorentzVector dposn = state->GetPositionVariance();
462  isoTrack->OriginVariance = dposn;
463 
464  TVector3 dir = state->GetDirection();
465  isoTrack->Direction = dir;
466 
467  isoTrack->Range = getTrackLength(tr);
468 
469  ND::THandle<ND::TReconPID> pid = fFGDPid->ApplyPID(tr);
470 
471  ND::THandle<ND::TRealDatum> buf;
472  buf = pid->Get<ND::TRealDatum>("fgdPidWgt_EvsXPull_Muon");
473  if (buf) {
474  isoTrack->muonPull = buf->GetValue();
475  } else {
476  isoTrack->muonPull = 1000.;
477  }
478  buf = pid->Get<ND::TRealDatum>("fgdPidWgt_EvsXPull_Pion");
479  if (buf) {
480  isoTrack->pionPull = buf->GetValue();
481  } else {
482  isoTrack->pionPull = 1000.;
483  }
484  buf = pid->Get<ND::TRealDatum>("fgdPidWgt_EvsXPull_Proton");
485  if (buf) {
486  isoTrack->protonPull = buf->GetValue();
487  } else {
488  isoTrack->protonPull = 1000.;
489  }
490  ND280NamedVerbose("TFgdOnlyModule","Muon pull " << isoTrack->muonPull);
491  ND280NamedVerbose("TFgdOnlyModule","Pion pull " << isoTrack->pionPull);
492  ND280NamedVerbose("TFgdOnlyModule","Proton pull " << isoTrack->protonPull);
493 
494  isoTrack->TrajId = TrackTruthInfo::GetG4TrajectoryID(
495  tr, isoTrack->Completeness, isoTrack->Cleanliness);
496  }
497 
498  void ND::TFgdOnlyModule::Fill2DCluster(TFgd2DCluster *TempObject,
499  ND::THandle<ND::TReconCluster> cluster) {
500  TempObject->Status = cluster->GetStatus();
501  TempObject->NDOF = cluster->GetNDOF();
502  TempObject->Quality = cluster->GetQuality();
503  TempObject->Position = cluster->GetPosition();
504  TempObject->EDeposit = cluster->GetEDeposit();
505  TempObject->NumHits = cluster->GetHits()->size();
506 
507  TempObject->Range = cluster->Get<ND::TRealDatum>("range")->GetValue();
508  TempObject->AvgHitTime =
509  cluster->Get<ND::TRealDatum>("avgHitTime")->GetValue();
510 
511  //std::vector<double> startPos =
512  //cluster->Get<ND::TRealDatum>("startPosition")->GetVector();
513 
514  THandle<ND::TRealDatum> V=cluster->Get<ND::TRealDatum>("startPosition");
515  TempObject->StartPosition.SetXYZ((*V)[0],(*V)[1],(*V)[2]);
516 
517 
518  //= TVector3(startPos[0], startPos[1], startPos[2]);
519  //std::vector<double> endPos =
520  //cluster->Get<ND::TRealDatum>("endPosition")->GetVector();
521  //TempObject->EndPosition = *(cluster->Get<TVector3>("endPosition"));
522  V=cluster->Get<ND::TRealDatum>("endPosition");
523  TempObject->EndPosition.SetXYZ((*V)[0],(*V)[1],(*V)[2]);
524 
525  //TVector3(endPos[0], endPos[1], endPos[2]);
526  //std::vector<double> dir =
527  //cluster->Get<ND::TRealDatum>("pcaDirection")->GetVector();
528  V=cluster->Get<ND::TRealDatum>("pcaDirection");
529  TempObject->PCADirection.SetXYZ((*V)[0],(*V)[1],(*V)[2]);
530 
531  //TVector3(dir[0], dir[1], dir[2]);
532 
533  TempObject->Trajectories =
534  TrackTruthInfo::GetG4Trajectories(*(cluster->GetHits()));
535  }
536 
537  void ND::TFgdOnlyModule::Fill3DShower(TFgd3DShowerPID *TempObject,
538  ND::THandle<ND::TReconPID> pid) {
539  ND280NamedVerbose("TFgdOnlyModule","Filling next shower");
540  ND::TReconObjectContainer altCon = pid->GetAlternates();
541  if (altCon.size() != 1) {
542  ND280NamedWarn("TFgdOnlyModule","Expect 1 alternative hypothesis for FGD Shower PID, have "
543  << altCon.size());
544  return;
545  }
546 
547  ND::THandle<ND::TReconPID> alt = altCon.at(0);
548  if (!alt) {
549  ND280NamedWarn("TFgdOnlyModule","Unable to get alternate hypothesis");
550  return;
551  }
552 
553  ND::THandle<ND::TReconObjectContainer> cons = pid->GetConstituents();
554  if (cons->size() != 1) {
555  ND280NamedWarn("TFgdOnlyModule","Expect 1 constituent for FGD Shower PID, have " << cons->size());
556  return;
557  }
558 
559  ND::THandle<ND::TReconShower> shower = cons->at(0);
560  if (!shower) {
561  ND280NamedWarn("TFgdOnlyModule","Couldn't cast constituent to TReconShower");
562  return;
563  }
564 
565  // Ensure that hypothesis 1 corresponds to the forward-going hypothesis.
566  if (pid->GetDirection().Z() > 0) {
567  TempObject->Hyp1 = Fill3DShowerHyp(pid);
568  TempObject->Hyp2 = Fill3DShowerHyp(alt);
569  } else {
570  TempObject->Hyp1 = Fill3DShowerHyp(alt);
571  TempObject->Hyp2 = Fill3DShowerHyp(pid);
572  }
573 
574  TempObject->Status = pid->GetStatus();
575  TempObject->NDOF = pid->GetNDOF();
576  TempObject->Quality = pid->GetQuality();
577  TempObject->NumHits = pid->GetHits()->size();
578  TempObject->MatchingLikelihood3D =
579  shower->Get<ND::TRealDatum>("MatchingLikelihood3D")->GetValue();
580  //std::vector<double> pcaValues =
581 // shower->Get<ND::TRealDatum>("pcaValues")->GetVector();
582  //TempObject->PCAEigenValues = *(shower->Get<TVector3>("pcaValues"));
583  TempObject->PCAEigenValues =TVector3(
584  shower->Get<ND::TRealDatum>("pcaValues")->at(0),
585  shower->Get<ND::TRealDatum>("pcaValues")->at(1),
586  shower->Get<ND::TRealDatum>("pcaValues")->at(2)
587  );
588  // TVector3(pcaValues[0], pcaValues[1], pcaValues[2]);
589  TempObject->Circularity =
590  shower->Get<ND::TRealDatum>("Circularity")->GetValue();
591  TempObject->Trajectories =
592  TrackTruthInfo::GetG4Trajectories(*(pid->GetHits()));
593  }
594 ND::TFgdOnlyModule::TFgd3DShowerHyp ND::TFgdOnlyModule::Fill3DShowerHyp(ND::THandle<ND::TReconPID> hyp)
595 {
596  ND280NamedVerbose("TFgdOnlyModule","Filling next shower hypothesis");
597  TFgd3DShowerHyp output;
598 
599  ND::THandle<ND::TReconObjectContainer> cons = hyp->GetConstituents();
600  if (cons->size() != 1) {
601  ND280NamedWarn("TFgdOnlyModule","Expect 1 constituent for FGD Shower PID, have " << cons->size());
602  return output;
603  }
604 
605  ND::THandle<ND::TReconShower> shower = cons->at(0);
606  if (!shower) {
607  ND280NamedWarn("TFgdOnlyModule","Couldn't cast constituent to TReconShower");
608  return output;
609  }
610 
611  ND::THandle<ND::TShowerState> state = shower->GetState();
612  if (!state) {
613  ND280NamedWarn("TFgdOnlyModule","Couldn't get state for shower");
614  return output;
615  }
616 
617  // PID-related datums
618  //std::vector<double> qAvg =
619  //shower->Get<ND::TRealDatum>("QAvgInThirds")->GetVector();
620  output.QAvgInThirds = TVector3(
621 
622  shower->Get<ND::TRealDatum>("QAvgInThirds")->at(0),
623 
624  shower->Get<ND::TRealDatum>("QAvgInThirds")->at(1),
625 
626  shower->Get<ND::TRealDatum>("QAvgInThirds")->at(2)
627 
628  );
629 
630  //std::vector<double> spread =
631 
632  //shower->Get<ND::TRealDatum>("SpreadInThirds")->GetVector();
633 
634  output.SpreadInThirds = TVector3(
635 
636  shower->Get<ND::TRealDatum>("SpreadInThirds")->at(0),
637 
638  shower->Get<ND::TRealDatum>("SpreadInThirds")->at(1),
639 
640  shower->Get<ND::TRealDatum>("SpreadInThirds")->at(2)
641 
642  );
643 
644 
645  //output.QAvgInThirds = *(shower->Get<TVector3>("QAvgInThirds"));
646  //TVector3(qAvg[0], qAvg[1], qAvg[2]);
647  //std::vector<double> spread =
648  //shower->Get<ND::TRealDatum>("SpreadInThirds")->GetVector();
649  //output.SpreadInThirds = *(shower->Get<TVector3>("SpreadInThirds"));
650 
651  //TVector3(spread[0], spread[1], spread[2]);
652 
653  output.EDeposit = shower->GetEDeposit();
654  output.ConeAngle = state->GetCone();
655  output.ConeAngleVar = state->GetConeVariance();
656  output.Direction = state->GetDirection();
657  output.DirectionVar = state->GetDirectionVariance();
658  output.Position = state->GetPosition();
659  output.PositionVar = state->GetPositionVariance();
660 
661  return output;
662  }
ND::TFgdOnlyModule::fN2DClustersYZ
Int_t fN2DClustersYZ
Number of 2D constituents of showers.
Definition: TFgdOnlyModule.hxx:269
ND::TFgdOnlyModule::TFgd2DCluster::NumHits
int NumHits
The number of hits contributing to this cluster.
Definition: TFgdOnlyModule.hxx:106
ND::TFgdOnlyModule::fXZTracksAllFGD
TClonesArray ** fXZTracksAllFGD
Definition: TFgdOnlyModule.hxx:248
ND::TFgdOnlyModule::TFgd2DIsoTrack::OriginVariance
TLorentzVector OriginVariance
Variance on origin.
Definition: TFgdOnlyModule.hxx:43
ND::TFgdOnlyModule::TFgd3DShowerPID::NumHits
int NumHits
The number of hits contributing to this cluster.
Definition: TFgdOnlyModule.hxx:180
ND::TFgdOnlyModule::TFgd3DShowerHyp::Direction
TVector3 Direction
Identified direction of the shower, found using PCA.
Definition: TFgdOnlyModule.hxx:131
CVSID
#define CVSID
Definition: TGeometrySummaryModule.cxx:20
ND::TFgdOnlyModule::fYZTracks
TClonesArray ** fYZTracks
Definition: TFgdOnlyModule.hxx:240
ND::TFgdOnlyModule::TFgd3DIsoTrack::AlgorithmName
std::string AlgorithmName
Algorithm name.
Definition: TFgdOnlyModule.hxx:60
ND::TFgdOnlyModule::TFgd3DShowerHyp
TFgd3DShowerHyp Information on a specific hypothesis of an FGD shower.
Definition: TFgdOnlyModule.hxx:122
ND::TFgdOnlyModule::TFgd3DShowerHyp::ConeAngle
TVector3 ConeAngle
Opening angle of the cone describing this shower.
Definition: TFgdOnlyModule.hxx:134
getTrackLength
double getTrackLength(ND::THandle< ND::TReconTrack > track)
Definition: TFgdOnlyModule.cxx:24
ND::TFgdOnlyModule::TFgd3DShowerHyp::Position
TLorentzVector Position
Identified start position of the shower.
Definition: TFgdOnlyModule.hxx:126
ND::TFgdOnlyModule::fXYZTracksAllFGD
TClonesArray ** fXYZTracksAllFGD
Definition: TFgdOnlyModule.hxx:256
ClassImp
ClassImp(ND::TBeamSummaryDataModule::TBeamSummaryData)
ND::TFgdOnlyModule::fTrackAlgorithms
std::vector< const char * > fTrackAlgorithms
Definition: TFgdOnlyModule.hxx:274
ND::TFgdOnlyModule::TFgd3DShowerHyp::EDeposit
double EDeposit
Energy deposited in this shower.
Definition: TFgdOnlyModule.hxx:137
ND::TFgdOnlyModule::TFgd3DShowerPID::Trajectories
std::map< int, int > Trajectories
Map of true trajectory IDs to the number of G4 contributors that contributed to this cluster...
Definition: TFgdOnlyModule.hxx:196
ND::TAnalysisModuleBase::fDescription
std::string fDescription
A longish descrition of the analysis.
Definition: TAnalysisModuleBase.hxx:188
ND::TFgdOnlyModule::TFgdOnlyModule
TFgdOnlyModule(const char *name="FGDOnly", const char *title="FGD Only Recon Module")
Definition: TFgdOnlyModule.cxx:41
ND::TFgdOnlyModule::TFgd3DShowerHyp::DirectionVar
TVector3 DirectionVar
Variance on the direction of the shower.
Definition: TFgdOnlyModule.hxx:132
ND::TFgdOnlyModule::f2DClustersYZ
TClonesArray * f2DClustersYZ
2D constituents of showers
Definition: TFgdOnlyModule.hxx:271
ND::TFgdOnlyModule::f2DClustersXZ
TClonesArray * f2DClustersXZ
2D constituents of showers
Definition: TFgdOnlyModule.hxx:266
ND::TFgdOnlyModule::fPids
std::vector< const char * > fPids
Definition: TFgdOnlyModule.hxx:275
ND::TFgdOnlyModule::TFgd3DShowerPID::MatchingLikelihood3D
double MatchingLikelihood3D
The MVA likelihood value returned when matching 2D clusters in the XZ and YZ views into a single 3D c...
Definition: TFgdOnlyModule.hxx:187
ND::TFgdOnlyModule::TFgd2DCluster::Position
TLorentzVector Position
Charge-weighted position of the cluster.
Definition: TFgdOnlyModule.hxx:97
ND::TFgdOnlyModule::TFgd2DIsoTrack::HitPositions
std::vector< TVector3 * > HitPositions
Hit positions.
Definition: TFgdOnlyModule.hxx:46
ND::TFgdOnlyModule::f3DShowers
TClonesArray * f3DShowers
Showers.
Definition: TFgdOnlyModule.hxx:261
ND::TFgdOnlyModule::TFgd3DShowerHyp::PositionVar
TLorentzVector PositionVar
Variance on the start position of the shower.
Definition: TFgdOnlyModule.hxx:128
ND::TFgdOnlyModule::fN2DClustersXZ
Int_t fN2DClustersXZ
Number of 2D constituents of showers.
Definition: TFgdOnlyModule.hxx:264
ND::TAnalysisModuleBase::fBufferSize
Int_t fBufferSize
Buffer Size for TBranch.
Definition: TAnalysisModuleBase.hxx:184
ND::TFgdOnlyModule::fN3DShowers
Int_t fN3DShowers
Number of Showers.
Definition: TFgdOnlyModule.hxx:259
ND::TFgdOnlyModule::Fill3DShowerHyp
TFgd3DShowerHyp Fill3DShowerHyp(ND::THandle< ND::TReconPID > hyp)
Definition: TFgdOnlyModule.cxx:594
ND::TFgdOnlyModule::TFgd3DShowerHyp::QAvgInThirds
TVector3 QAvgInThirds
Hits are split into three groups based on their distance from the start of the shower.
Definition: TFgdOnlyModule.hxx:143
ND::TAnalysisModuleBase::fCVSID
std::string fCVSID
Defined if an official tagged version.
Definition: TAnalysisModuleBase.hxx:192
ND::TFgdOnlyModule::Fill2DIsoTrack
void Fill2DIsoTrack(ND::THandle< ND::TReconTrack > tr, ND::THandle< ND::TTrackState > state, TFgd2DIsoTrack *isoTrack, char Axis)
Definition: TFgdOnlyModule.cxx:404
ND::TFgdOnlyModule::fNXZTracksAllFGD
Int_t * fNXZTracksAllFGD
All and only FGD hits used for these tracks.
Definition: TFgdOnlyModule.hxx:247
ND::TFgdOnlyModule::fXZTracks
TClonesArray ** fXZTracks
Definition: TFgdOnlyModule.hxx:236
ND::TFgdOnlyModule::TFgd2DCluster::NDOF
int NDOF
The number of degrees of freedom in the reconstruction.
Definition: TFgdOnlyModule.hxx:110
ND::TFgdOnlyModule::TFgd3DShowerPID::Circularity
double Circularity
Dan Scully&#39;s Circularity variable, adapted for FGDs.
Definition: TFgdOnlyModule.hxx:194
ND::TFgdOnlyModule::fXYZTracks
TClonesArray ** fXYZTracks
Definition: TFgdOnlyModule.hxx:244
ND::TFgdOnlyModule::Fill3DShower
void Fill3DShower(TFgd3DShowerPID *TempObject, ND::THandle< ND::TReconPID > pid)
Definition: TFgdOnlyModule.cxx:537
ND::TFgdOnlyModule::TFgd2DCluster::EDeposit
double EDeposit
The energy deposited in the cluster.
Definition: TFgdOnlyModule.hxx:105
ND::TFgdOnlyModule::TFgd3DShowerPID::NDOF
int NDOF
The number of degrees of freedom in the reconstruction.
Definition: TFgdOnlyModule.hxx:198
ND::TAnalysisModuleBase::SetNameTitle
void SetNameTitle(char const *name, char const *title)
Definition: TAnalysisModuleBase.cxx:108
ND::TFgdOnlyModule::fNXZTracks
Int_t * fNXZTracks
These tracks use only hits unused by the TPC+FGD fits.
Definition: TFgdOnlyModule.hxx:235
ND::TFgdOnlyModule::TFgd3DShowerHyp::SpreadInThirds
TVector3 SpreadInThirds
Hits are split into three groups based on their distance from the start of the shower.
Definition: TFgdOnlyModule.hxx:153
ND::TFgdOnlyModule::TFgd2DCluster::Range
double Range
Range of shower along PCADirection.
Definition: TFgdOnlyModule.hxx:102
ND::TFgdOnlyModule::TFgd2DCluster
TFgd2DCluster The main object that contains information on clusters of hits after the 2D reconstructi...
Definition: TFgdOnlyModule.hxx:91
ND::TFgdOnlyModule::TFgd3DShowerPID
TFgd3DShowerPID Information on an object reconstructed using the FGD shower-based reconstruction...
Definition: TFgdOnlyModule.hxx:170
ND::TFgdOnlyModule::TFgd3DIsoTrack::OriginVariance
TLorentzVector OriginVariance
Variance on origin.
Definition: TFgdOnlyModule.hxx:68
ND::TFgdOnlyModule::TFgd3DShowerPID::Hyp1
TFgd3DShowerHyp Hyp1
Information assuming the particle is forward-going.
Definition: TFgdOnlyModule.hxx:175
ND::TAnalysisModuleBase::fSplitLevel
Int_t fSplitLevel
Split Level for TBranch.
Definition: TAnalysisModuleBase.hxx:186
ND::TFgdOnlyModule::TFgd2DCluster::Quality
double Quality
The goodness of fit for the reconstruction.
Definition: TFgdOnlyModule.hxx:111
ND::TFgdOnlyModule::TFgd2DCluster::StartPosition
TVector3 StartPosition
Identified &quot;start&quot; position of the cluster, from extrapolating along PCADrection. ...
Definition: TFgdOnlyModule.hxx:100
ND::TFgdOnlyModule::Fill2DCluster
void Fill2DCluster(TFgd2DCluster *TempObject, ND::THandle< ND::TReconCluster > cluster)
Definition: TFgdOnlyModule.cxx:498
ND::TFgdOnlyModule::fYZTracksAllFGD
TClonesArray ** fYZTracksAllFGD
Definition: TFgdOnlyModule.hxx:252
ND::TFgdOnlyModule::ProcessFirstEvent
virtual Bool_t ProcessFirstEvent(ND::TND280Event &event)
Is called after the first event is loaded in.
Definition: TFgdOnlyModule.cxx:110
ND::TFgdOnlyModule::TFgd2DCluster::EndPosition
TVector3 EndPosition
Identified &quot;end&quot; position of the cluster, from extrapolating along PCADirection.
Definition: TFgdOnlyModule.hxx:101
ND::TAnalysisModuleBase::fCVSTagName
std::string fCVSTagName
Defined if an official tagged version.
Definition: TAnalysisModuleBase.hxx:190
CVSTAG
#define CVSTAG
Definition: TGeometrySummaryModule.cxx:17
ND::TFgdOnlyModule::fNYZTracks
Int_t * fNYZTracks
These tracks use only hits unused by the TPC+FGD fits.
Definition: TFgdOnlyModule.hxx:239
ND::TFgdOnlyModule::TFgd3DShowerPID::Quality
double Quality
The goodness of fit for the reconstruction.
Definition: TFgdOnlyModule.hxx:199
ND::TFgdOnlyModule::FillTree
virtual bool FillTree(ND::TND280Event &)
Fill all the stuff that goes in the output tree.
Definition: TFgdOnlyModule.cxx:197
ND::TFgdOnlyModule::Fill3DIsoTrack
void Fill3DIsoTrack(ND::THandle< ND::TReconTrack > tr, ND::THandle< ND::TTrackState > state, TFgd3DIsoTrack *isoTrack)
Definition: TFgdOnlyModule.cxx:442
ND::TFgdOnlyModule::TFgd2DCluster::PCADirection
TVector3 PCADirection
Primary PCA eigenvector, associated with the direction of the cluster.
Definition: TFgdOnlyModule.hxx:99
ND::TFgdOnlyModule::TFgd2DCluster::Trajectories
std::map< int, int > Trajectories
Map of true trajectory IDs to the number of G4 contributors that contributed to this cluster...
Definition: TFgdOnlyModule.hxx:108
ND::TFgdOnlyModule::fNXYZTracks
Int_t * fNXYZTracks
These tracks use only hits unused by the TPC+FGD fits.
Definition: TFgdOnlyModule.hxx:243
ND::TFgdOnlyModule::InitializeBranches
virtual void InitializeBranches()
Initialize Branches. Don&#39;t do anything else in this function.
Definition: TFgdOnlyModule.cxx:114
ND::TFgdOnlyModule::TFgd3DShowerPID::PCAEigenValues
TVector3 PCAEigenValues
The three PCA eigenvalues.
Definition: TFgdOnlyModule.hxx:179
ND::TFgdOnlyModule::TFgd3DShowerPID::Hyp2
TFgd3DShowerHyp Hyp2
Information assuming the particle is backward-going.
Definition: TFgdOnlyModule.hxx:177
ND::TFgdOnlyModule::fNYZTracksAllFGD
Int_t * fNYZTracksAllFGD
All and only FGD hits used for these tracks.
Definition: TFgdOnlyModule.hxx:251
ND::TFgdOnlyModule::TFgd2DCluster::AvgHitTime
double AvgHitTime
Average time of hits in the cluster.
Definition: TFgdOnlyModule.hxx:104
ND::TFgdOnlyModule::TFgd3DShowerHyp::ConeAngleVar
TVector3 ConeAngleVar
Variance on the cone opening angle.
Definition: TFgdOnlyModule.hxx:135
ND::TFgdOnlyModule::fNXYZTracksAllFGD
Int_t * fNXYZTracksAllFGD
All and only FGD hits used for these tracks.
Definition: TFgdOnlyModule.hxx:255
Package Summary
Package Name: eventAnalysis
Package Version: 7.0-49-g0ac7482
Package Manager:
Generated on Mon Mar 25 2024 14:43:58 for eventAnalysis by doxygen 1.8.5