HighLAND
oaAnalysisTreeConverter.hxx
1 /*
2  converter for oaAnalysis input format
3 
4  A. Cervera September 2012
5 */
6 
7 
8 #ifndef oaAnalysisTreeConverter_h
9 #define oaAnalysisTreeConverter_h
10 
11 #include <TROOT.h>
12 #include <TChain.h>
13 #include <TFile.h>
14 #include <TClonesArray.h>
15 #include <TRefArray.h>
16 #include <TRef.h>
17 #include <sstream>
18 #include <fstream>
19 #include <stdio.h>
20 #include <iostream>
21 #include <set>
22 #include "InputConverter.hxx"
23 #include "DataClasses.hxx"
24 #include <AnalysisTools/TTruthUtils.hxx>
25 #include "AnalysisTools/libReadoaAnalysis/libReadoaAnalysisProjectHeaders.h"
26 #include <AnalysisTools/TECALPidLikelihood.hxx>
27 #include "GeometryManager.hxx"
28 #include "ND280AnalysisUtils.hxx"
29 #include <ND280BeamBunching.hxx>
30 
31 // ---- TEST HIGHLAND2-P0D ----
32 #include <P0DDataClasses.hxx>
33 
34 const UInt_t NMAXP0DALGORES=50;
35 // ----------------------------
36 
37 const double _trueBunchShift = 2690.;
38 
39 class oaAnalysisTreeConverter: public InputConverter{
40 
41  public:
42 
43  oaAnalysisTreeConverter();
44  virtual ~oaAnalysisTreeConverter();
45 
46  virtual bool Initialize();
47  virtual void SetCosmicMode(const bool cosmic) {cosmic_mode = cosmic;}
48  virtual Int_t GetSpill(Long64_t& entry, AnaSpillC*& spill);
49  Int_t GetEvent(Long64_t& entry, AnaEventC*& event){(void)entry;(void)event; return 0;}
50 
51  /// Record the POT for the current spill, based on information in the AnaBeam
52  /// member of the current AnaSpill.
53  void IncrementPOTBySpill();
54 
55  virtual Int_t ReadEntries(Long64_t& entry);
56  virtual bool AddFileToTChain(const std::string& inputString);
57 
58  //---------------------------
59 
60  //----------------
61  virtual AnaSpillB* MakeSpill() { return new AnaSpill(); }
62  virtual AnaBunchB* MakeBunch() { return new AnaBunch(); }
63  virtual AnaBeamB* MakeBeam() { return new AnaBeam(); }
64  virtual AnaDataQualityB* MakeDataQuality() { return new AnaDataQuality(); }
65  virtual AnaEventInfoB* MakeEventInfo() { return new AnaEventInfo(); }
66  virtual AnaTrigger* MakeTrigger() { return new AnaTrigger(); }
67  virtual AnaVertexB* MakeVertex() { return new AnaVertex(); }
68  virtual AnaTrueParticleB* MakeTrueParticle() { return new AnaTrueParticle(); }
69  virtual AnaTrueVertexB* MakeTrueVertex() { return new AnaTrueVertex(); }
70  virtual AnaTrackB* MakeTrack() { return new AnaTrack(); }
71  virtual AnaTPCParticleB* MakeTpcTrack() { return new AnaTPCParticle(); }
72  virtual AnaTrackerTrackB* MakeTrackerTrack() { return new AnaTrackerTrack(); }
73  virtual AnaFGDParticleB* MakeFgdTrack() { return new AnaFGDParticle(); }
74  virtual AnaP0DParticleB* MakeP0dTrack() { return new AnaP0DParticle(); }
75  virtual AnaECALParticleB* MakeEcalTrack() { return new AnaECALParticle(); }
76  virtual AnaSMRDParticleB* MakeSmrdTrack() { return new AnaSMRDParticle(); }
77  virtual AnaFgdTimeBinB* MakeFgdTimeBin() { return new AnaFgdTimeBin(); }
78  virtual AnaTECALReconObject* MakeTECALReconObject() { return new AnaTECALReconObject(); }
79  virtual AnaTECALUnmatchedObject* MakeTECALUnmatchedObject() { return new AnaTECALUnmatchedObject(); }
80  virtual AnaP0DReconVertex* MakeP0DReconVertex() { return new AnaP0DReconVertex(); }
81  virtual AnaP0DReconParticle* MakeP0DReconParticle() { return new AnaP0DReconParticle(); }
82  virtual AnaP0DReconCluster* MakeP0DReconCluster() { return new AnaP0DReconCluster(); }
83  virtual AnaBunch* MakeLocalReconBunch() { return new AnaLocalReconBunch(); }
84 
85 
86  // ---- TEST HIGHLAND2-P0D ----
87  virtual void GetBunchLocalP0DObjects();
88  virtual void GetBunchLocalP0DObjectsInAlgoResult(Int_t iAlgoRes);
89 
90  virtual void FillP0DBunch( AnaBunchB* bunch, int ibunch, Int_t iAlgoRes);
91  virtual void FillP0DVertices( const std::vector<Int_t>& indices, AnaP0DBunch* bunch);
92  virtual void FillP0DParticles( const std::vector<Int_t>& indices, AnaP0DBunch* bunch);
93  virtual void FillP0DParticlesFromTracks( const std::vector<Int_t>& indices, AnaP0DBunch* bunch);
94  virtual void FillP0DParticlesFromShowers(const std::vector<Int_t>& indices, AnaP0DBunch* bunch);
95  virtual void FillP0DClusters( const std::vector<Int_t>& indices, AnaP0DBunch* bunch);
96 
97  ND::TP0DReconModule::TP0DParticle* GetP0DReconParticleWithUniqueID(UInt_t uniqueID);
98  void AddReconVertexToReconParticle(AnaVertexB* vertex, AnaTrack* part);
99  void FillDelayedClustersInfo(AnaSpill& spill);
100 
101  AnaP0DVertex* GetAnaP0DVertex(Int_t index);
102  AnaP0DCluster* GetAnaP0DCluster(Int_t index);
103  AnaP0DParticle* GetAnaP0DParticle(Int_t index);
104  AnaP0DParticle* GetAnaP0DParticleFromTrack(Int_t index);
105  AnaP0DParticle* GetAnaP0DParticleFromShower(Int_t index);
106 
107  virtual AnaP0DVertex* MakeP0DVertex() { return new AnaP0DVertex(); }
108  virtual AnaP0DParticle* MakeP0DParticle() { return new AnaP0DParticle(); }
109  virtual AnaP0DCluster* MakeP0DCluster() { return new AnaP0DCluster(); }
110  virtual AnaP0DHit* MakeP0DHit() { return new AnaP0DHit(); }
111  virtual AnaP0DBunch* MakeP0DBunch() { return new AnaP0DBunch(); }
112  // ----------------------------
113 
114  virtual void FillInfo(AnaSpill* spill);
115  virtual void FillBunchInfo(AnaSpill* spill);
116  virtual void FillPIDs(AnaBunch* bunch, int ibunch);
117  virtual void FillTECALReconObjects(AnaBunch* bunch, int ibunch);
118  virtual void FillTECALReconUnmatchedObjects(AnaBunch* bunch, int ibunch);
119  virtual void FillP0DReconVertices(AnaBunch* bunch, int ibunch);
120  virtual void FillP0DReconParticles(AnaBunch* bunch, int ibunch);
121  virtual void FillP0DReconClusters(AnaBunch* bunch, int ibunch);
122  virtual void FillGlobalVertices(AnaSpill* spill);
123  virtual void DeleteBadObjects(AnaSpill* spill);
124  virtual void DeleteTrueParticle(AnaSpill* spill, AnaTrueParticleB* trackToDelete);
125  virtual void DeleteRecoParticle(AnaSpill* spill, AnaParticleB* particleToDelete);
126  virtual void DeleteRecoVertex(AnaSpill* spill, AnaVertexB* vertexToDelete);
127  virtual void FillTrackInfo(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
128  virtual void FillVertexInfo(ND::TGlobalReconModule::TGlobalVertex& global_vertex, AnaVertex* vertex, AnaBunch* bunch, AnaSpill* spill);
129  virtual AnaTrack* FindTrack(const int UniqueID, AnaBunch* bunch, AnaSpill* spill);
130  virtual void FillTrueVerticesMatchInfo(ND::TTrueVertex* matchedTrueVertex, AnaVertex* vertex, AnaBunch* bunch);
131  virtual AnaRecTrueMatch* FillCompletenessCleanliness(AnaVertex* vertex, AnaBunch* bunch, AnaTrueVertexB* truevertex);
132  virtual void FillTrueParticleRecoInfo(ND::TTrueParticle& trueParticle, AnaTrueObjectC*& trueObj, bool setpurity);
133  virtual void FillTrueParticleInfo(ND::TTruthTrajectoriesModule::TTruthTrajectory* truthTraj, AnaTrueParticle* truePart, AnaSpill* spill);
134 
135  virtual void FillTrackHits(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
136 
137  virtual void FillTpcInfo(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
138  virtual void FillTrackerInfo(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
139  virtual void FillFgdInfo(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
140  virtual void FillEcalInfo(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
141  virtual void FillSmrdInfo(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
142  virtual void FillP0dInfo(ND::TGlobalReconModule::TGlobalPID& PID, AnaTrack* track);
143 
144  virtual void FillTpcTrackInfo( ND::TGlobalReconModule::TTPCObject& tpcTrack, AnaTPCParticle* seg);
145  virtual void FillTrackerTrackInfo( ND::TGlobalReconModule::TTrackerObject& trTrack, AnaTrackerTrack* seg);
146  virtual void FillFgdTrackInfo( ND::TGlobalReconModule::TFGDObject& fgdTrack, AnaFGDParticle* seg);
147  virtual void FillEcalTrackInfo(ND::TGlobalReconModule::TECALObject& ecalTrack, AnaECALParticle* seg);
148  virtual void FillSmrdTrackInfo(ND::TGlobalReconModule::TSMRDObject& smrdTrack, AnaSMRDParticle* seg);
149  virtual void FillP0dTrackInfo( ND::TGlobalReconModule::TP0DObject& p0dTrack, AnaP0DParticle* seg);
150  virtual void FillSubdetectorTrackInfo(ND::TSubBaseObject& subTrack, AnaParticleB* seg);
151 
152  virtual void FillTrueInfo(AnaSpill* spill);
153  virtual bool FillTrueVertexInfo(ND::TTruthVerticesModule::TTruthVertex* true_vertex, AnaTrueVertex* vertex, int v, AnaSpill* spill);
154  virtual void FillFgdTimeBinInfo(std::vector<AnaFgdTimeBinB*>* AnaFgdTimeBins);
155 
156  virtual void FillBeamInfo(bool isMC, AnaBeam* beam);
157  virtual void FillTriggerInfo(AnaTrigger* trigger);
158  virtual void FillDQInfo(AnaDataQuality* dq);
159 
160  virtual void FillTECALReconObjectInfo(ND::TTrackerECALReconModule::TECALReconObject& tecalReconObject, AnaTECALReconObject* anaTECALReconObject, AnaLocalReconBunch* anaLocalBunch);
161  virtual void FillTECALUnmatchedObjectInfo(ND::TTrackerECALReconModule::TECALReconUnmatchedObject& tecalUnmatchedObject, AnaTECALUnmatchedObject* anaTECALUnmatchedObject, AnaLocalReconBunch* anaLocalBunch);
162 
163  // --- Methods to create local P0DRecon objects -------
164  virtual void FillP0DReconVertexInfo(ND::TP0DReconModule::TP0DVertex& p0dVertex, AnaP0DReconVertex* anaP0DReconVertex, AnaLocalReconBunch* anaLocalBunch);
165  virtual void FillP0DReconParticleInfo(ND::TP0DReconModule::TP0DParticle& p0dParticle, AnaP0DReconParticle* anaP0DReconParticle, AnaLocalReconBunch* anaLocalBunch);
166  virtual void FillP0DReconClusterInfo(ND::TP0DReconModule::TP0DCluster& p0dCluster, AnaP0DReconCluster* anaP0DReconCluster, AnaLocalReconBunch* anaLocalBunch);
167 
168  virtual void FillP0DReconVertexLinks( ND::TP0DReconModule::TP0DVertex& p0dVertex, AnaP0DReconVertex* anaP0DReconVertex);
169  virtual void FillP0DReconParticleLinks(ND::TP0DReconModule::TP0DParticle& p0dParticle, AnaP0DReconParticle* anaP0DReconParticle);
170  virtual void FillP0DReconClusterLinks( ND::TP0DReconModule::TP0DCluster& p0dCluster, AnaP0DReconCluster* anaP0DReconCluster);
171 
172  // --- New Methods to create native psyche P0D objects -------
173  // ---- TEST HIGHLAND2-P0D ----
174  virtual void FillP0DVertexInfo( ND::TP0DReconModule::TP0DVertex& p0dVertex, AnaP0DVertex* anaP0DVertex, AnaBunchB* bunch);
175  virtual void FillP0DParticleInfo(ND::TP0DReconModule::TP0DParticle& p0dParticle, AnaP0DParticle* anaP0DParticle);
176  virtual void FillP0DParticleInfo(ND::TP0DReconModule::TP0DTrack& p0dTrack, AnaP0DParticle* anaP0DParticle);
177  virtual void FillP0DParticleInfo(ND::TP0DReconModule::TP0DShower& p0dShower, AnaP0DParticle* anaP0DParticle);
178  virtual void FillP0DClusterInfo( ND::TP0DReconModule::TP0DCluster& p0dCluster, AnaP0DCluster* anaP0DCluster);
179  virtual void FillP0DClusterInfo( ND::TP0DReconModule::TP0DNode& p0dNode, AnaP0DCluster* anaP0DCluster);
180  virtual void FillP0DHitInfo( ND::TP0DReconModule::TP0DHit& p0dHit, AnaP0DHit* anaP0DHit);
181  // ----------------------------
182 
183  //----------------
184 
185  virtual void GetBunchPIDs();
186  virtual void GetBunchVertices();
187  virtual void GetBunchLocalObjects();
188  virtual double GetVertexTime(ND::TGlobalReconModule::TGlobalPID& globalTrack);
189 
190  virtual int GetGenieReactionCode(const std::string& reactionCode);
191 
192  Double_t GetPOTFromRooTrackerVtx();
193 
194  bool HasNonContainedReconParticles(AnaTrueParticleB* trueTrack);
195  bool IsFullyContained(const AnaTrueVertexB& trueVertex);
196 
197  Int_t GetNVtx(){if (NVtx) return NNVtx; else if (GVtx) return NGVtx; else return 0;}
198  TClonesArray * GetVtx() {if (NVtx) return NVtx; else if (GVtx) return GVtx; else return NULL;}
199 
200 
201 protected:
202 
203  std::vector<ND::TGlobalReconModule::TGlobalPID*> _bunchPIDs[NBUNCHES+1];
204  std::vector<ND::TGlobalReconModule::TGlobalVertex*> _bunchVertices[NBUNCHES+1];
205 
206 
207  std::vector<ND::TP0DReconModule::TP0DVertex*> _bunchP0DVertices[NBUNCHES+1];
208  std::vector<ND::TP0DReconModule::TP0DParticle*> _bunchP0DParticles[NBUNCHES+1];
209  std::vector<ND::TP0DReconModule::TP0DCluster*> _bunchP0DClusters[NBUNCHES+1];
210  std::vector<ND::TTrackerECALReconModule::TECALReconObject*> _bunchTECALObjects[NBUNCHES+1];
211  std::vector<ND::TTrackerECALReconModule::TECALReconUnmatchedObject*> _bunchTECALUnmatchedObjects[NBUNCHES+1];
212 
213  //---- These objects are used to keep the proper links between P0DRecon objects, converting the indices in pointers
214  std::map<ND::TP0DReconModule::TP0DVertex*, AnaP0DReconVertex*> _P0DReconVerticesMap;
215  std::map<ND::TP0DReconModule::TP0DParticle*, AnaP0DReconParticle*> _P0DReconParticlesMap;
216  std::map<ND::TP0DReconModule::TP0DCluster*, AnaP0DReconCluster*> _P0DReconClustersMap;
217 
218 
219  // ---- TEST HIGHLAND2-P0D ----
220  std::vector<Int_t> _bunchP0DVerticesInAlgoRes [NBUNCHES+1][NMAXP0DALGORES];
221  std::vector<Int_t> _bunchP0DClustersInAlgoRes [NBUNCHES+1][NMAXP0DALGORES];
222  std::vector<Int_t> _bunchP0DParticlesInAlgoRes[NBUNCHES+1][NMAXP0DALGORES];
223  std::vector<Int_t> _bunchP0DTracksInAlgoRes [NBUNCHES+1][NMAXP0DALGORES];
224  std::vector<Int_t> _bunchP0DShowersInAlgoRes [NBUNCHES+1][NMAXP0DALGORES];
225 
226  std::vector<AnaP0DVertex*> _AnaP0DVertices;
227  std::vector<AnaP0DParticle*> _AnaP0DParticles;
228  std::vector<AnaP0DParticle*> _AnaP0DTracks;
229  std::vector<AnaP0DParticle*> _AnaP0DShowers;
230  std::vector<AnaP0DCluster*> _AnaP0DClusters;
231  // ----------------------------
232 
233  //------------------------------------------------------------------------------------------------------------------
234 
235  bool _firstFile;
236  bool _firstEntry;
237 
238  Int_t _RooVtxEntryInCurrentInputFile;
239 
240  TTruthUtils _truthUtils;
241 
242  AnaSpill* _spill;
243 
244  ND280BeamBunching _bunching;
245 
246  std::string _previousFile;
247  Int_t _previousRunID;
248  Int_t _previousSubrunID;
249  Int_t _previousRefEventID;
250 
251  protected:
252 
253  // TChains
254  TChain *reconGlobal;
255  TChain *trackerECAL;
256  TChain *p0d;
257  TChain *fgdOnly;
258  TChain *mcTruthVertices;
259  TChain *mcTruthTrajectories;
260  TChain *GRooTrackerVTX;
261  TChain *NRooTrackerVTX;
262  TChain *beamInfo;
263  TChain *accPOTInfo;
264  TChain *BasicHeader;
265  TChain *DQInfo;
266 
267  Int_t Entries;
268  Int_t Counter;
269 
270  // MC information
271  bool Genie;
272  bool Neut;
273  bool GenieFirstFile;
274  bool NeutFirstFile;
275 
276  // Skimmed information
277  bool AccPOTflg;
278 
279  // Header's
280  Int_t EventID;
281  Int_t RunID;
282  Int_t SubrunID;
283  Bool_t IsMC;
284  Int_t Preselected;
285  Int_t EventTime;
286  Int_t TriggerWord;
287  Bool_t FGDCosmicEvent;
288  Bool_t TripTCosmicEvent;
289  Bool_t P0DWaterStatus;
290  Char_t SoftwareVersion[50];
291  Float_t POTPerSpill;
292 
293  // Tracker ECAL
294  Int_t NTrECalObjects;
295  TClonesArray *TrECalObjects;
296  Int_t NTrECalUnmatched;
297  TClonesArray *TrECalUnmatched;
298 
299  // P0D
300  // ---- TEST HIGHLAND2-P0D ----
301  Short_t NP0DAlgoResults;
302  TClonesArray *P0DAlgoResults;
303  Short_t NP0DReconVertices;
304  TClonesArray *P0DReconVertices;
305  Short_t NP0DReconParticles;
306  TClonesArray *P0DReconParticles;
307  Short_t NP0DReconTracks;
308  TClonesArray *P0DReconTracks;
309  Short_t NP0DReconShowers;
310  TClonesArray *P0DReconShowers;
311  Short_t NP0DReconClusters;
312  TClonesArray *P0DReconClusters;
313  Short_t NP0DReconNodes;
314  TClonesArray *P0DReconNodes;
315  Short_t NP0DReconHits;
316  TClonesArray *P0DReconHits;
317 
318  // ----------------------------
319 
320  // PID's
321  Int_t NPIDs;
322  TClonesArray *PIDs;
323  Int_t NVertices;
324  TClonesArray *Vertices;
325  Int_t NFGD1Unused,NFGD2Unused,NP0DUnused,NTPCUnused;
326  Int_t NDelayedClusters;
327  TClonesArray *DelayedClusters;
328  Int_t NTPCOthers;
329  TClonesArray *TPCOthers;
330 
331  Int_t NFgdTimeBins;
332  TClonesArray *FgdTimeBins;
333 
334  // Set the branches for the truth information.
335  Int_t NTruthVertices;
336  Int_t NVtxFGD1;
337  Int_t NVtxFGD2;
338 
339  TClonesArray *TruthVertices;
340  std::string TruthVerticesName[9];
341 
342  Int_t NTruthTrajs;
343  TClonesArray *TruthTrajs;
344  std::string TruthTrajsName[7];
345 
346 
347  // Genie and Neut Tracker Vertex
348  Int_t NGVtx;
349  TClonesArray *GVtx;
350  Int_t NNVtx;
351  TClonesArray *NVtx;
352 
353  // FGD's
354  Int_t NXZTracks_Radon2,NYZTracks_Radon2,NXYZTracks_Radon2,NXZTracksAllFGD_Radon2,NYZTracksAllFGD_Radon2,NXYZTracksAllFGD_Radon2;
355  TClonesArray *XZTracks_Radon2;
356  TClonesArray *YZTracks_Radon2;
357  TClonesArray *XYZTracks_Radon2;
358  TClonesArray *XZTracksAllFGD_Radon2;
359  TClonesArray *YZTracksAllFGD_Radon2;
360  TClonesArray *XYZTracksAllFGD_Radon2;
361 
362  // beam information
363  TClonesArray *VtxP0DECal;
364  TClonesArray *beamSummary;
365  int beamSummaryDataStatus;
366  Int_t ND280Spill;
367 
368  // DQ information
369  Int_t fBarECALFlag,fDSECALFlag,fECALFlag,fFGD1Flag,fFGD2Flag,fFGDFlag,fINGRIDFlag,fMAGNETFlag,fND280OffFlag;
370  Int_t fP0DECALFlag,fP0DFlag,fSMRDFlag,fTPC1Flag,fTPC2Flag,fTPC3Flag,fTPCFlag;
371 
372  /// Whether we're running in "cosmic" mode, where there is only one bunch
373  bool cosmic_mode;
374 
375  /// To calculate the ECal PID likelihood variables
376  ecalPid::TECALPidLikelihood* _ecalPidCalc;
377 
378  /// Use local reconstruction information?
379  bool _isUsingReconDirFGDOnly;
380  bool _isUsingReconDirP0D;
381  bool _isUsingReconDirPECAL;
382  bool _isUsingReconDirTECAL;
383 
384  // ---- TEST HIGHLAND2-P0D ----
385  bool _isUsingReconDirP0DNew;
386  std::string _p0dAlgoResName;
387  Int_t _topP0DAlgoRes;
388  bool _addGlobalTracksToP0DVertices;
389  // ----------------------------
390 
391  /// ignore some true objects when there are fully contained in the specified subdetectors
392  bool _ignoreSMRDContainedTrueObjects;
393  bool _ignoreP0DECalContainedTrueObjects;
394  bool _ignoreBrECalContainedTrueObjects;
395  bool _ignoreDsECalContainedTrueObjects;
396  bool _ignoreINGRIDContainedTrueObjects;
397 
398  /// Remove uninteresting vertices
399  bool _removeTrueVerticesWithNoTrueParticles;
400 
401  // Vector of Fully contained TrueParticles
402  std::vector<AnaTrueParticleB*> _containedTrueParticles;
403 
404 protected:
405  bool _foundPauliBlocked;
406  bool _foundCohOnH;
407  bool _alreadyWarned;
408 };
409 
410 
411 
412 // function to sort tracks in decreasing Cleanliness order
413 // class needed for passing the global vertex position as argument
414 class CompareCleanliness{
415 
416  AnaVertex* vertex;
417 
418 public:
419 
420  CompareCleanliness(AnaVertex* param) : vertex(param) {}
421 
422  bool operator()(std::pair<AnaTrueVertexB*, AnaRecTrueMatchB> t1, std::pair<AnaTrueVertexB*, AnaRecTrueMatchB> t2) {
423 
424  // set null pointer to be -1 so they are sorted last.
425  double m1 = -1;
426  double m2 = -1;
427  if (t1.first != NULL) m1 = t1.second.Cleanliness;
428  if (t2.first != NULL) m2 = t2.second.Cleanliness;
429 
430  // Set nan to be -1 so they are sorted last.
431  if (m1 != m1) m1 = -1;
432  if (m2 != m2) m2 = -1;
433 
434  if (m1 != m2) return m1 > m2;
435 
436  // if same cleanliness, take the nearest one (
437  // (in general the nearest could not have any common tracks,
438  // then better sort by Cleanliness first)
439 
440  // sort first those in-bunch
441  if (vertex->Bunch == t1.first->Bunch && vertex->Bunch != t2.first->Bunch) return true;
442  if (vertex->Bunch == t2.first->Bunch && vertex->Bunch != t1.first->Bunch) return false;
443 
444  double t1dist = anaUtils::GetSeparationSquared(t1.first->Position, vertex->Position);
445  double t2dist = anaUtils::GetSeparationSquared(t2.first->Position, vertex->Position);
446  return t1dist < t2dist;
447  }
448 };
449 
450 
451 
452 #endif
453 
oaAnalysisTreeConverter::cosmic_mode
bool cosmic_mode
Whether we&#39;re running in "cosmic" mode, where there is only one bunch.
Definition: oaAnalysisTreeConverter.hxx:373
AnaBeamB
Representation of the beam quality and perhaps other beam information as needed.
Definition: BaseDataClasses.hxx:758
AnaTrack
Representation of a global track.
Definition: DataClasses.hxx:571
AnaDataQualityB
Representation of the ND280 data quality flags.
Definition: BaseDataClasses.hxx:789
AnaP0DReconVertex
P0DRecon Vertex.
Definition: DataClasses.hxx:1148
oaAnalysisTreeConverter::_removeTrueVerticesWithNoTrueParticles
bool _removeTrueVerticesWithNoTrueParticles
Remove uninteresting vertices.
Definition: oaAnalysisTreeConverter.hxx:399
AnaTrigger
Representation of the ND280 trigger bits.
Definition: DataClasses.hxx:760
AnaTrueVertexB
Representation of a true Monte Carlo vertex.
Definition: BaseDataClasses.hxx:97
AnaVertexB::Position
Float_t Position[4]
The identified position of the global vertex.
Definition: BaseDataClasses.hxx:711
oaAnalysisTreeConverter::GetSpill
virtual Int_t GetSpill(Long64_t &entry, AnaSpillC *&spill)
Definition: oaAnalysisTreeConverter.cxx:720
AnaECALParticleB
Representation of an ECAL segment of a global track.
Definition: BaseDataClasses.hxx:459
AnaDataQuality
Representation of the ND280 data quality flags.
Definition: DataClasses.hxx:690
AnaP0DReconParticle
P0DRecon Particle.
Definition: DataClasses.hxx:1175
oaAnalysisTreeConverter::AddFileToTChain
virtual bool AddFileToTChain(const std::string &inputString)
Add the file specified to fChain, and any friend chains that were set up.
Definition: oaAnalysisTreeConverter.cxx:473
AnaTECALReconObject
This Ana* object is used to flatten TECALReconObjects from ReconDir/TrackerECal.
Definition: DataClasses.hxx:942
AnaVertexB::Bunch
Int_t Bunch
The bunch of the global vertex, based on the Position.T()
Definition: BaseDataClasses.hxx:705
anaUtils::GetSeparationSquared
float GetSeparationSquared(const Float_t *pos1, const Float_t *pos2)
Calculate the distance between two points.
Definition: AnalysisUtils.cxx:5
AnaTrueVertex
Representation of a true Monte Carlo vertex.
Definition: DataClasses.hxx:50
AnaTrueParticleB
Representation of a true Monte Carlo trajectory/particle.
Definition: BaseDataClasses.hxx:147
AnaSMRDParticleB
Representation of an SMRD segment of a global track.
Definition: BaseDataClasses.hxx:514
AnaTrackerTrackB
Representation of a Tracker segment of a global track.
Definition: BaseDataClasses.hxx:562
AnaTrackB
Representation of a global track.
Definition: BaseDataClasses.hxx:603
AnaTPCParticleB
Representation of a TPC segment of a global track.
Definition: BaseDataClasses.hxx:360
AnaVertexB
Representation of a global vertex.
Definition: BaseDataClasses.hxx:680
oaAnalysisTreeConverter::_ecalPidCalc
ecalPid::TECALPidLikelihood * _ecalPidCalc
To calculate the ECal PID likelihood variables.
Definition: oaAnalysisTreeConverter.hxx:376
AnaFGDParticleB
Representation of a FGD segment of a global track.
Definition: BaseDataClasses.hxx:419
oaAnalysisTreeConverter::GetEvent
Int_t GetEvent(Long64_t &entry, AnaEventC *&event)
Definition: oaAnalysisTreeConverter.hxx:49
AnaTECALUnmatchedObject
This Ana* object is used to flatten TECALUnmatchedObjects from ReconDir/TrackerECal.
Definition: DataClasses.hxx:1015
oaAnalysisTreeConverter::_ignoreSMRDContainedTrueObjects
bool _ignoreSMRDContainedTrueObjects
ignore some true objects when there are fully contained in the specified subdetectors ...
Definition: oaAnalysisTreeConverter.hxx:392
AnaTPCParticle
Representation of a TPC segment of a global track.
Definition: DataClasses.hxx:377
oaAnalysisTreeConverter::SetCosmicMode
virtual void SetCosmicMode(const bool cosmic)
Definition: oaAnalysisTreeConverter.hxx:47
AnaP0DParticleB
Representation of a P0D segment of a global track.
Definition: BaseDataClasses.hxx:538
AnaParticleB
Representation of a reconstructed particle (track or shower).
Definition: BaseDataClasses.hxx:252
AnaTrueParticle
Representation of a true Monte Carlo trajectory/particle.
Definition: DataClasses.hxx:156
AnaBeam
Representation of the beam information, including POT and quality.
Definition: DataClasses.hxx:652
oaAnalysisTreeConverter::_isUsingReconDirFGDOnly
bool _isUsingReconDirFGDOnly
Use local reconstruction information?
Definition: oaAnalysisTreeConverter.hxx:379
Generated by   doxygen 1.8.13