HighLAND
Public Member Functions | Protected Attributes | List of all members
FlatTreeConverter Class Reference
Inheritance diagram for FlatTreeConverter:
RedoTreeConverter InputConverter

Public Member Functions

 FlatTreeConverter (bool readRooTrackerVtx=false)
 
virtual bool Initialize ()
 
virtual void DefineBranches ()
 Define the branches to be read from the input tree. More...
 
Int_t GetSpill (Long64_t &entry, AnaSpillC *&spill)
 
virtual bool AddFileToTChain (const std::string &inputString)
 Add the file specified to fChain, and any friend chains that were set up.
 
virtual AnaSpillB * MakeSpill ()
 
virtual AnaBunchB * MakeBunch ()
 
virtual AnaBeamB * MakeBeam ()
 
virtual AnaDataQualityB * MakeDataQuality ()
 
virtual AnaEventInfoB * MakeEventInfo ()
 
virtual AnaTrigger * MakeTrigger ()
 
virtual AnaVertexB * MakeVertex ()
 
virtual AnaTrueParticleB * MakeTrueParticle ()
 
virtual AnaTrueVertexB * MakeTrueVertex ()
 
virtual AnaTrackB * MakeTrack ()
 
virtual AnaTPCParticleB * MakeTpcTrack ()
 
virtual AnaTrackerTrackB * MakeTrackerTrack ()
 
virtual AnaFGDParticleB * MakeFgdTrack ()
 
virtual AnaP0DParticleB * MakeP0dTrack ()
 
virtual AnaECALParticleB * MakeEcalTrack ()
 
virtual AnaSMRDParticleB * MakeSmrdTrack ()
 
virtual AnaFgdTimeBinB * MakeFgdTimeBin ()
 
virtual AnaBunchB * MakeLocalReconBunch ()
 
virtual AnaTECALReconObject * MakeTECALReconObject ()
 
virtual AnaTECALUnmatchedObject * MakeTECALUnmatchedObject ()
 
virtual AnaPECALReconObject * MakePECALReconObject ()
 
virtual AnaPECALUnmatchedObject * MakePECALUnmatchedObject ()
 
virtual AnaP0DReconObject * MakeP0DReconVertex ()
 
virtual AnaFGDOnlyReconObject * MakeFGDOnlyReconObject ()
 
virtual void FillTECALReconObjectInfo (int iObj, AnaTECALReconObject *anaTECAL, AnaBunch *bunch)
 
virtual void FillInfo (AnaSpillB *spill)
 
virtual void FillBunchInfo (std::vector< AnaTrueParticleB *> &trueParticles, AnaBunchB *bunch)
 
virtual void FillNotInBunchObjWithNullPointers (AnaSpill *spill)
 
virtual void CheckNotInBunchObjWithNullPointers (AnaSpill *spill)
 
virtual void FillNotInBunchObjWithNullPointers (AnaBunch *bunch)
 
virtual void FillFgdTimeBinInfo (std::vector< AnaFgdTimeBinB *> &AnaFgdTimeBins)
 
virtual void FillTrackInfo (std::vector< AnaTrueParticleB *> &trueParticles, int itrk, AnaTrackB *track)
 
virtual void FillTrueParticleInfo (std::vector< AnaTrueVertexB *> &trueVertices, int itrk, AnaTrueParticleB *part)
 
virtual void FillTpcInfo (std::vector< AnaTrueParticleB *> &trueParticles, int itrk, int tpc, AnaTPCParticleB *track)
 
virtual void FillFgdInfo (int itrk, int fgd, AnaFGDParticleB *track)
 
virtual void FillEcalInfo (int itrk, int ecal, AnaECALParticleB *track)
 
virtual void FillSmrdInfo (int itrk, int smrd, AnaSMRDParticleB *track)
 
virtual void FillP0dInfo (int itrk, int p0d, AnaP0DParticleB *track)
 
virtual void FillTrackerInfo (int itrk, int tracker, AnaTrackerTrack *seg)
 
virtual void FillSubdetectorInfo (std::vector< AnaTrueParticleB *> &trueParticles, int itrk, AnaTrackB *trackB)
 
virtual void FillTrueVertexInfo (int ivtx, AnaTrueVertexB *vertex)
 
virtual bool FillTrueVertexRooInfo (AnaTrueVertexB *vertex)
 
virtual void FillNPrimaryParticles (AnaTrueVertex *vertex)
 
virtual void FillDQInfo (AnaDataQualityB *dq)
 
virtual void FillBeamInfo (AnaBeamB *beam)
 
virtual void FillTriggerInfo (AnaTrigger *trigger)
 
virtual void FillVertexInfo (int ivtx, AnaVertexB *vertex, AnaBunchB *bunch)
 
virtual AnaParticleB * FindParticle (int ID, AnaBunchB *bunch)
 
int GetLocalDetEnum (SubDetId::SubDetEnum det, SubDetId::SubDetEnum i)
 Get old local detector enumeration to find array index of Flat tree.
 
- Public Member Functions inherited from RedoTreeConverter
virtual void Reset ()
 Reset the trees in the TChain and the number of entries. Also the header (POT, etc)
 
Int_t GetSpill (Long64_t &entry, AnaSpillC *&spill)
 
Int_t GetEvent (Long64_t &entry, AnaEventC *&event)
 
void IncrementPOTBySpill ()
 
Long64_t GetEntries ()
 Return the total number of entries in the chain.
 
void FillEventInfo (AnaEventB *event)
 
void FillEventSpillInfo (AnaEventB *event)
 
virtual void FillFgdTimeBinInfo (AnaEventB *event)
 
virtual void FillTrackInfo (AnaEventB *event, int itrk, AnaTrackB *track)
 
virtual void FillTrueParticleInfo (AnaEventB *event, int itrk, AnaTrueParticleB *track)
 
virtual void FillTpcInfo (AnaEventB *event, int itrk, int tpc, AnaTPCParticleB *track)
 
void FillSubdetectorInfo (AnaEventB *event, int itrk, AnaTrackB *track)
 
void FindTrueParticle (AnaEventB *event, int ID, AnaTrueObjectC *&trueParticle)
 
void FindTrueParticle (std::vector< AnaTrueParticleB *> &trueParticles, int ID, AnaTrueObjectC *&trueParticle)
 
void FillVertexInfo (int ivtx, AnaVertexB *vertex, AnaEventB *event)
 
AnaParticleB * FindParticle (int ID, AnaEventB *event)
 
- Public Member Functions inherited from InputConverter
 InputConverter (const std::string &name)
 Constrctor provided a name.
 
virtual ~InputConverter ()
 Everyone should have a destructor...
 
const std::string & GetTreeName ()
 returns the name of the tree to convert
 
const std::string & Name () const
 Return the name of this converter.
 
void SetName (const std::string &name)
 Set the name of this converter, which is used internally by the InputManager.
 
virtual Long64_t LoadTree (Long64_t entry)
 Handle loading the correct entry from fChain.
 
virtual Int_t GetNEvents (Int_t entries=-1)
 Return the total number of events for a given number of entries in the tree.
 
virtual bool IsCorrectType (const std::string &inputString)
 Whether the implementation can handle the specified file.
 
virtual void SetCosmicMode (const bool cosmic)
 
bool HasChain (const std::string &name)
 
void AddChain (const std::string &name, const std::string &name_path="")
 
TChain * GetChain (const std::string &name="")
 
Header & header ()
 Returns the Header manager.
 

Protected Attributes

bool _useCorrectedValues
 
bool _readRooTrackerVtx
 
bool _firstFile
 
bool _firstEntry
 
Int_t _RooVtxEntryInCurrentInputFile
 
Long64_t _entry_roo
 
bool _isUsingReconDirFGDOnly
 Store whether AnaLocalReconBunch information is enabled in the parameters file.
 
bool _isUsingReconDirP0D
 
bool _isUsingReconDirPECAL
 
bool _isUsingReconDirTECAL
 
Int_t RunID
 
Int_t SubrunID
 
Int_t EventID
 
Int_t NNVtx
 
TClonesArray * NVtx
 
Int_t NGVtx
 
TClonesArray * GVtx
 
Int_t sIsMC
 
Int_t sRooVtxEntry
 
Int_t sInputFileIndex
 
Int_t sTrueVertexLeptonPDG [NMAXTRUEVERTICES]
 
Int_t sTrueVertexIsPauliBlocked [NMAXTRUEVERTICES]
 
Int_t sTrueVertexIsCohOnH [NMAXTRUEVERTICES]
 
Int_t sTrueVertexNPrimaryParticles [NMAXTRUEVERTICES][Int_t(ParticleId::kLast)+1]
 
Int_t trReconPDG [NMAXPARTICLES]
 
Int_t trNTimeNodes [NMAXPARTICLES]
 
Int_t trTimeNodeDetector [NMAXPARTICLES][NMAXTIMENODES]
 
Int_t trTpcUniqueID [NMAXPARTICLES][NMAXTPCS]
 
Int_t trFgdUniqueID [NMAXPARTICLES][NMAXTPCS]
 
Int_t trECALUniqueID [NMAXPARTICLES][NMAXTPCS]
 
Int_t trSMRDUniqueID [NMAXPARTICLES][NMAXTPCS]
 
Int_t trP0DUniqueID [NMAXPARTICLES][NMAXTPCS]
 
Int_t trNTRACKERs [NMAXPARTICLES]
 
Int_t trTRACKERDetector [NMAXPARTICLES][NMAXTRACKERS]
 
Int_t trTRACKERNHits [NMAXPARTICLES][NMAXTRACKERS]
 
Int_t trTRACKERNNodes [NMAXPARTICLES][NMAXTRACKERS]
 
Int_t trTRACKERUniqueID [NMAXPARTICLES][NMAXTRACKERS]
 
Int_t trFgdHasFgdVA [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdHasFgdVA_fmode [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdTypeVA [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdHasFgdEA [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdHasFgdEA_fmode [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdTypeEA [NMAXPARTICLES][NMAXFGDS]
 
Float_t sTrueVertexTargetMom [NMAXTRUEVERTICES]
 
Float_t sTrueVertexTargetDir [NMAXTRUEVERTICES][3]
 
Float_t trTimeNodeTimeStart [NMAXPARTICLES][NMAXTIMENODES]
 
Float_t trTimeNodeTimeEnd [NMAXPARTICLES][NMAXTIMENODES]
 
Float_t sTrueVertexLeptonDir [NMAXTRUEVERTICES][3]
 
Float_t sTrueVertexProtonDir [NMAXTRUEVERTICES][3]
 
Float_t sTrueVertexPionDir [NMAXTRUEVERTICES][3]
 
Float_t sTrueVertexLeptonMom [NMAXTRUEVERTICES]
 
Float_t sTrueVertexProtonMom [NMAXTRUEVERTICES]
 
Float_t sTrueVertexPionMom [NMAXTRUEVERTICES]
 
Float_t trTpcPullmu [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcPullele [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcPullp [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcPullpi [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcPullk [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRawdEdxMeas [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRawdEdxExpMu [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRawdEdxExpEle [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRawdEdxExpP [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRawdEdxExpPi [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRawdEdxExpK [NMAXPARTICLES][NMAXTPCS]
 
Float_t trFgdEnd0x0 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdEnd1x1 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdEnd3x3 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdEnd5x5 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdEnd7x7 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trECALPIDMipPion [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trECALContainment [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trSMRDEDeposit [NMAXPARTICLES][NSMRDSUBDETS]
 
Float_t trP0DAvgTime [NMAXPARTICLES][NMAXP0DS]
 
Float_t trTRACKERLength [NMAXPARTICLES][NMAXTRACKERS]
 
Float_t trTRACKERDirectionStart [NMAXPARTICLES][NMAXTRACKERS][3]
 
Float_t trTRACKERDirectionEnd [NMAXPARTICLES][NMAXTRACKERS][3]
 
Float_t trTRACKERPositionStart [NMAXPARTICLES][NMAXTRACKERS][4]
 
Float_t trTRACKERPositionEnd [NMAXPARTICLES][NMAXTRACKERS][4]
 
Float_t trTRACKERCharge [NMAXPARTICLES][NMAXTRACKERS]
 
Float_t trTRACKERMomentum [NMAXPARTICLES][NMAXTRACKERS]
 
Float_t trTRACKERMomentumEnd [NMAXPARTICLES][NMAXTRACKERS]
 
Float_t trDirectionStartFlip [NMAXPARTICLES][3]
 
Float_t trDirectionEndFlip [NMAXPARTICLES][3]
 
Float_t trRangeMomentumMuonFlip [NMAXPARTICLES]
 
Float_t trRangeMomentumProtonFlip [NMAXPARTICLES]
 
Float_t trMomentumAtVertex [NMAXPARTICLES]
 
Float_t trDirectionAtVertex [NMAXPARTICLES][3]
 
Float_t trLength [NMAXPARTICLES]
 
Int_t tecalReconCounter
 AnaLocalReconBunch information.
 
Float_t tecalReconAverageHitTime [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconAverageZPosition [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconContainment [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconEFitResult [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconEFitUncertainty [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconFirstLayer [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconIsShowerLike [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconIsTrackLike [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconLastLayer [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconLikeMIPEM [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconLikeMIPPion [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconLikeEMHIP [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconLikeMIPEMLow [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconMatchingLike [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconMichelTagNDelayedCluster [NMAXTECALRECONOBJECTS]
 
Char_t tecalReconModule [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconMostDownStreamLayerHit [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconMostUpStreamLayerHit [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconNHits [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconNLayersHit [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconObjectLength [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDAMR [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDAngle [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDAsymmetry [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDCircularity [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDFBR [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDMaxRatio [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDMeanPos [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDShowerAngle [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDShowerWidth [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDTransverseChargeRatio [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPIDTruncatedMaxRatio [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconPointing [NMAXTECALRECONOBJECTS][3]
 
Float_t tecalReconThrust [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconThrustAxis [NMAXTECALRECONOBJECTS][3]
 
Float_t tecalReconThrustOrigin [NMAXTECALRECONOBJECTS][3]
 
Int_t tecalReconTimeBunch [NMAXTECALRECONOBJECTS]
 
Float_t tecalReconTotalHitCharge [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconTrueID [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconTrueIDPrimary [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconTrueIDRecursive [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconTrueIDSingle [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconUniqueID [NMAXTECALRECONOBJECTS]
 
Int_t tecalReconBunch [NMAXTECALRECONOBJECTS]
 
TBranch * b_sIsMC
 
TBranch * b_sInputFileIndex
 
TBranch * b_sRooVtxEntry
 
TBranch * b_sBeamPOT
 
TBranch * b_sBeamPOTCT4
 
TBranch * b_sBeamSpill
 
TBranch * b_sBeamSpillNumber
 
TBranch * b_sBeamBeamRunNumber
 
TBranch * b_sDQND280Flag
 
TBranch * b_sDQDetFlag
 
TBranch * b_sTrueVertexLeptonPDG
 
TBranch * b_sTrueVertexLeptonDir
 
TBranch * b_sTrueVertexProtonDir
 
TBranch * b_sTrueVertexPionDir
 
TBranch * b_sTrueVertexLeptonMom
 
TBranch * b_sTrueVertexProtonMom
 
TBranch * b_sTrueVertexPionMom
 
TBranch * b_sTrueVertexTargetDir
 
TBranch * b_sTrueVertexTargetMom
 
TBranch * b_sTrueVertexIsPauliBlocked
 
TBranch * b_sTrueVertexIsCohOnH
 
TBranch * b_sTrueVertexNPrimaryParticles
 
TBranch * b_trReconPDG
 
TBranch * b_trDirectionAtVertex
 
TBranch * b_trNTRACKERs
 
TBranch * b_trTpcPullmu
 
TBranch * b_trTpcPullele
 
TBranch * b_trTpcPullp
 
TBranch * b_trTpcPullpi
 
TBranch * b_trTpcPullk
 
TBranch * b_trNTimeNodes
 
TBranch * b_trTimeNodeDetector
 
TBranch * b_trTimeNodeTimeStart
 
TBranch * b_trTimeNodeTimeEnd
 
TBranch * b_trTpcUniqueID
 
TBranch * b_trFgdUniqueID
 
TBranch * b_trECALUniqueID
 
TBranch * b_trSMRDUniqueID
 
TBranch * b_trP0DUniqueID
 
TBranch * b_trTpcRawdEdxMeas
 
TBranch * b_trTpcRawdEdxExpMu
 
TBranch * b_trTpcRawdEdxExpEle
 
TBranch * b_trTpcRawdEdxExpP
 
TBranch * b_trTpcRawdEdxExpPi
 
TBranch * b_trTpcRawdEdxExpK
 
TBranch * b_trFgdHasFgdVA
 
TBranch * b_trFgdHasFgdVA_fmode
 
TBranch * b_trFgdTypeVA
 
TBranch * b_trFgdHasFgdEA
 
TBranch * b_trFgdHasFgdEA_fmode
 
TBranch * b_trFgdTypeEA
 
TBranch * b_trFgdEnd0x0
 
TBranch * b_trFgdEnd1x1
 
TBranch * b_trFgdEnd3x3
 
TBranch * b_trFgdEnd5x5
 
TBranch * b_trFgdEnd7x7
 
TBranch * b_trP0DAvgTime
 
TBranch * b_trTRACKERDetector
 
TBranch * b_trTRACKERNHits
 
TBranch * b_trTRACKERNNodes
 
TBranch * b_trTRACKERUniqueID
 
TBranch * b_trTRACKERLength
 
TBranch * b_trTRACKERDirectionStart
 
TBranch * b_trTRACKERDirectionEnd
 
TBranch * b_trTRACKERPositionStart
 
TBranch * b_trTRACKERPositionEnd
 
TBranch * b_trTRACKERCharge
 
TBranch * b_trTRACKERMomentum
 
TBranch * b_trTRACKERMomentumEnd
 
TBranch * b_trDirectionStartFlip
 
TBranch * b_trDirectionEndFlip
 
TBranch * b_trRangeMomentumMuonFlip
 
TBranch * b_trRangeMomentumProtonFlip
 
TBranch * b_trMomentumAtVertex
 
TBranch * b_trECALPIDMipPion
 
TBranch * b_trECALContainment
 
TBranch * b_trLength
 
TBranch * b_trSMRDEDeposit
 
TBranch * b_tecalReconCounter
 
TBranch * b_tecalReconAverageHitTime
 
TBranch * b_tecalReconAverageZPosition
 
TBranch * b_tecalReconContainment
 
TBranch * b_tecalReconEFitResult
 
TBranch * b_tecalReconEFitUncertainty
 
TBranch * b_tecalReconFirstLayer
 
TBranch * b_tecalReconIsShowerLike
 
TBranch * b_tecalReconIsTrackLike
 
TBranch * b_tecalReconLastLayer
 
TBranch * b_tecalReconLikeMIPEM
 
TBranch * b_tecalReconLikeMIPPion
 
TBranch * b_tecalReconLikeEMHIP
 
TBranch * b_tecalReconLikeMIPEMLow
 
TBranch * b_tecalReconMatchingLike
 
TBranch * b_tecalReconMichelTagNDelayedCluster
 
TBranch * b_tecalReconModule
 
TBranch * b_tecalReconMostDownStreamLayerHit
 
TBranch * b_tecalReconMostUpStreamLayerHit
 
TBranch * b_tecalReconNHits
 
TBranch * b_tecalReconNLayersHit
 
TBranch * b_tecalReconObjectLength
 
TBranch * b_tecalReconPIDAMR
 
TBranch * b_tecalReconPIDAngle
 
TBranch * b_tecalReconPIDAsymmetry
 
TBranch * b_tecalReconPIDCircularity
 
TBranch * b_tecalReconPIDFBR
 
TBranch * b_tecalReconPIDMaxRatio
 
TBranch * b_tecalReconPIDMeanPos
 
TBranch * b_tecalReconPIDShowerAngle
 
TBranch * b_tecalReconPIDShowerWidth
 
TBranch * b_tecalReconPIDTransverseChargeRatio
 
TBranch * b_tecalReconPIDTruncatedMaxRatio
 
TBranch * b_tecalReconPointing
 
TBranch * b_tecalReconThrust
 
TBranch * b_tecalReconThrustAxis
 
TBranch * b_tecalReconThrustOrigin
 
TBranch * b_tecalReconTimeBunch
 
TBranch * b_tecalReconTotalHitCharge
 
TBranch * b_tecalReconTrueID
 
TBranch * b_tecalReconTrueIDPrimary
 
TBranch * b_tecalReconTrueIDRecursive
 
TBranch * b_tecalReconTrueIDSingle
 
TBranch * b_tecalReconUniqueID
 
TBranch * b_tecalReconBunch
 
- Protected Attributes inherited from RedoTreeConverter
bool _firstFile
 
Int_t _entry_roo
 
TString _currentfilename
 
AnaSpillB * _spill
 
AnaEventB * _prevEvent
 
TChain * flattree
 
TChain * GRooTrackerVTX
 
TChain * NRooTrackerVTX
 
bool fGenie
 
bool fNeut
 
Int_t sRun
 
Int_t sSubrun
 
Int_t sEvt
 
Int_t sEventTime
 
Int_t sNTotalTrueParticles
 
Int_t sNTotalTrueVertices
 
Int_t sBeamSpill
 
Int_t sBeamSpillNumber
 
Int_t sBeamGoodSpill
 
Int_t sBeamBeamRunNumber
 
Int_t sDQGoodDaq
 
Int_t sDQND280Flag
 
Int_t sDQDetFlag [7]
 
Int_t sTriggerFGDCosmic
 
Int_t sTriggerTripTCosmic
 
Int_t sNTrueVertices
 
Int_t sTrueVertexID [NMAXTRUEVERTICES]
 
Int_t sTrueVertexRooVtxIndex [NMAXTRUEVERTICES]
 
Int_t sTrueVertexRooVtxEntry [NMAXTRUEVERTICES]
 
Int_t sTrueVertexReacCode [NMAXTRUEVERTICES]
 
Int_t sTrueVertexNTrueParticles [NMAXTRUEVERTICES]
 
Int_t sTrueVertexNReconTracks [NMAXTRUEVERTICES]
 
Int_t sTrueVertexNReconVertices [NMAXTRUEVERTICES]
 
Int_t sTrueVertexNBaryons [NMAXTRUEVERTICES]
 
Int_t sTrueVertexBunch [NMAXTRUEVERTICES]
 
Int_t sTrueVertexDetector [NMAXTRUEVERTICES]
 
Int_t sTrueVertexNuPDG [NMAXTRUEVERTICES]
 
Int_t sTrueVertexTargetPDG [NMAXTRUEVERTICES]
 
Int_t sNTrueParticles
 
Int_t sTrueVertexNuParentPDG [NMAXTRUEVERTICES]
 
Int_t sTrueParticleID [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleBunch [NMAXTRUEPARTICLES]
 
Int_t sTrueParticlePDG [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleParentPDG [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleGParentPDG [NMAXTRUEPARTICLES]
 
Int_t sTrueParticlePrimaryID [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleParentID [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleVertexIndex [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleTruthVertexID [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleNReconTracks [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleNDetCrossings [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleDetector [NMAXTRUEPARTICLES][NMAXCROSSEDDET]
 
Int_t sTrueParticleInActive [NMAXTRUEPARTICLES][NMAXCROSSEDDET]
 
Int_t sTrueParticleIsTruePrimaryPi0DecayPhoton [NMAXTRUEPARTICLES]
 
Int_t sTrueParticleIsTruePrimaryPi0DecayPhotonChild [NMAXTRUEPARTICLES]
 
Int_t sNFgdTimeBins
 
Int_t sFgdTimeBinNHits1 [NMAXFGDTIMEBINS]
 
Int_t sFgdTimeBinNHits2 [NMAXFGDTIMEBINS]
 
Int_t sFgdTimeBinG4ID [NMAXFGDTIMEBINS]
 
Int_t Bunch
 
Int_t NVertices
 
Int_t vPrimaryIndex [NMAXVERTICES]
 
Int_t vBunch [NMAXVERTICES]
 
Int_t vNDOF [NMAXVERTICES]
 
Int_t vNReconParticles [NMAXVERTICES]
 
Int_t vNTrueVerticesMatch [NMAXVERTICES]
 
Int_t vParticlesUniqueID [NMAXVERTICES][NMAXPARTICLESINVERTEX]
 
Int_t vTrueVertexIndex [NMAXVERTICES][NMAXTRUEVERTICESMATCH]
 
Int_t NParticles
 
Int_t trUniqueID [NMAXPARTICLES]
 
Int_t trStatus [NMAXPARTICLES]
 
Int_t trBunch [NMAXPARTICLES]
 
Int_t trNReconVertices [NMAXPARTICLES]
 
Int_t trDetectors [NMAXPARTICLES]
 
Int_t trDetUsed [NMAXPARTICLES][NDETECTORS]
 
Int_t trNTPCs [NMAXPARTICLES]
 
Int_t trNFGDs [NMAXPARTICLES]
 
Int_t trNECALs [NMAXPARTICLES]
 
Int_t trNSMRDs [NMAXPARTICLES]
 
Int_t trNP0Ds [NMAXPARTICLES]
 
Int_t trNHits [NMAXPARTICLES]
 
Int_t trNNodes [NMAXPARTICLES]
 
Int_t trNDOF [NMAXPARTICLES]
 
Int_t trTpcDetector [NMAXPARTICLES][NMAXTPCS]
 
Int_t trTpcNHits [NMAXPARTICLES][NMAXTPCS]
 
Int_t trTpcNNodes [NMAXPARTICLES][NMAXTPCS]
 
Int_t trFgdDetector [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdNHits [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdNNodes [NMAXPARTICLES][NMAXFGDS]
 
Int_t trFgdContainment [NMAXPARTICLES][NMAXFGDS]
 
Int_t trECALDetector [NMAXPARTICLES][NECALSUBDETS]
 
Int_t trECALNHits [NMAXPARTICLES][NECALSUBDETS]
 
Int_t trECALNNodes [NMAXPARTICLES][NECALSUBDETS]
 
Int_t trECALMostUpStreamLayerHit [NMAXPARTICLES][NECALSUBDETS]
 
Int_t trECALIsShowerLike [NMAXPARTICLES][NECALSUBDETS]
 
Int_t trSMRDDetector [NMAXPARTICLES][NSMRDSUBDETS]
 
Int_t trSMRDNHits [NMAXPARTICLES][NSMRDSUBDETS]
 
Int_t trSMRDNNodes [NMAXPARTICLES][NSMRDSUBDETS]
 
Int_t trP0DDetector [NMAXPARTICLES][1]
 
Int_t trP0DNHits [NMAXPARTICLES][1]
 
Int_t trP0DNNodes [NMAXPARTICLES][1]
 
Int_t trTrueParticleID [NMAXPARTICLES]
 
Int_t trTpcTrueParticleID [NMAXPARTICLES][NMAXTPCS]
 
Float_t Weight
 
Float_t sTrueVertexNuEnergy [NMAXTRUEVERTICES]
 
Float_t sTrueVertexQ2 [NMAXTRUEVERTICES]
 
Float_t sTrueVertexPosition [NMAXTRUEVERTICES][4]
 
Float_t sBeamPOT
 
Float_t sBeamPOTCT4
 
Float_t sPOTSincePreviousSpill
 
Float_t sTrueVertexNuParentDecPoint [NMAXTRUEVERTICES][4]
 
Float_t sTrueVertexNuDir [NMAXTRUEVERTICES][3]
 
Float_t sTrueParticlePurity [NMAXTRUEPARTICLES]
 
Float_t sTrueParticleMomentum [NMAXTRUEPARTICLES]
 
Float_t sTrueParticleCharge [NMAXTRUEPARTICLES]
 
Float_t sTrueParticlePosition [NMAXTRUEPARTICLES][4]
 
Float_t sTrueParticlePositionEnd [NMAXTRUEPARTICLES][4]
 
Float_t sTrueParticleDirection [NMAXTRUEPARTICLES][3]
 
Float_t sTrueParticleEntrancePosition [NMAXTRUEPARTICLES][NMAXCROSSEDDET][4]
 
Float_t sTrueParticleExitPosition [NMAXTRUEPARTICLES][NMAXCROSSEDDET][4]
 
Float_t sTrueParticleEntranceMomentum [NMAXTRUEPARTICLES][NMAXCROSSEDDET][3]
 
Float_t sTrueParticleExitMomentum [NMAXTRUEPARTICLES][NMAXCROSSEDDET][3]
 
Float_t sFgdTimeBinMinTime [NMAXFGDTIMEBINS]
 
Float_t sFgdTimeBinMaxTime [NMAXFGDTIMEBINS]
 
Float_t sFgdTimeBinRawChargeSum1 [NMAXFGDTIMEBINS]
 
Float_t sFgdTimeBinRawChargeSum2 [NMAXFGDTIMEBINS]
 
Float_t vPosition [NMAXVERTICES][4]
 
Float_t vVariance [NMAXVERTICES][4]
 
Float_t vChi2 [NMAXVERTICES]
 
Float_t vTrueVerticesClean [NMAXVERTICES][NMAXTRUEVERTICESMATCH]
 
Float_t vTrueVerticesCompl [NMAXVERTICES][NMAXTRUEVERTICESMATCH]
 
Float_t trChi2 [NMAXPARTICLES]
 
Float_t trCharge [NMAXPARTICLES]
 
Float_t trToFFGD1_FGD2 [NMAXPARTICLES]
 
Float_t trToFP0D_FGD1 [NMAXPARTICLES]
 
Float_t trToFECal_FGD1 [NMAXPARTICLES]
 
Float_t trToFECal_FGD2 [NMAXPARTICLES]
 
Float_t trToFFlag_FGD1_FGD2 [NMAXPARTICLES]
 
Float_t trToFFlag_P0D_FGD1 [NMAXPARTICLES]
 
Float_t trToFFlag_ECal_FGD1 [NMAXPARTICLES]
 
Float_t trToFFlag_ECal_FGD2 [NMAXPARTICLES]
 
Float_t trMomentum [NMAXPARTICLES]
 
Float_t trMomentumError [NMAXPARTICLES]
 
Float_t trMomentumMuon [NMAXPARTICLES]
 
Float_t trMomentumErrorMuon [NMAXPARTICLES]
 
Float_t trMomentumProton [NMAXPARTICLES]
 
Float_t trMomentumErrorProton [NMAXPARTICLES]
 
Float_t trMomentumEle [NMAXPARTICLES]
 
Float_t trMomentumErrorEle [NMAXPARTICLES]
 
Float_t trRangeMomentumEle [NMAXPARTICLES]
 
Float_t trRangeMomentumMuon [NMAXPARTICLES]
 
Float_t trRangeMomentumProton [NMAXPARTICLES]
 
Float_t trDirectionStart [NMAXPARTICLES][3]
 
Float_t trDirectionEnd [NMAXPARTICLES][3]
 
Float_t trPositionStart [NMAXPARTICLES][4]
 
Float_t trPositionEnd [NMAXPARTICLES][4]
 
Float_t trMomentumFlip [NMAXPARTICLES]
 
Float_t trTpcLength [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcDirectionStart [NMAXPARTICLES][NMAXTPCS][3]
 
Float_t trTpcDirectionEnd [NMAXPARTICLES][NMAXTPCS][3]
 
Float_t trTpcPositionStart [NMAXPARTICLES][NMAXTPCS][4]
 
Float_t trTpcPositionEnd [NMAXPARTICLES][NMAXTPCS][4]
 
Float_t trTpcCharge [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcMomentum [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcMomentumError [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcBackMomentum [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRefitCharge [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRefitMomentum [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcRefitPosition [NMAXPARTICLES][NMAXTPCS][4]
 
Float_t trTpcRefitDirection [NMAXPARTICLES][NMAXTPCS][3]
 
Float_t trTpcEFieldRefitMomentum [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxMeas [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxExpMu [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxExpEle [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxExpP [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxExpPi [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxExpK [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxSigmaMu [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxSigmaEle [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxSigmaP [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxSigmaPi [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcdEdxSigmaK [NMAXPARTICLES][NMAXTPCS]
 
Float_t trTpcPurity [NMAXPARTICLES][NMAXTPCS]
 
Float_t trFgdLength [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdDirectionStart [NMAXPARTICLES][NMAXFGDS][3]
 
Float_t trFgdDirectionEnd [NMAXPARTICLES][NMAXFGDS][3]
 
Float_t trFgdPositionStart [NMAXPARTICLES][NMAXFGDS][4]
 
Float_t trFgdPositionEnd [NMAXPARTICLES][NMAXFGDS][4]
 
Float_t trFgdX [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdE [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdPullmu [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdPullp [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdPullpi [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdPullno [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdAvgTime [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdVertex1x1 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdVertex3x3 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdVertex5x5 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdVertex7x7 [NMAXPARTICLES][NMAXFGDS]
 
Float_t trFgdVertexLayer [NMAXPARTICLES][NMAXFGDS]
 
Float_t trECALLength [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trECALDirectionStart [NMAXPARTICLES][NECALSUBDETS][3]
 
Float_t trECALDirectionEnd [NMAXPARTICLES][NECALSUBDETS][3]
 
Float_t trECALPositionStart [NMAXPARTICLES][NECALSUBDETS][4]
 
Float_t trECALPositionEnd [NMAXPARTICLES][NECALSUBDETS][4]
 
Float_t trECALEMEnergy [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trECALEDeposit [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trECALAvgTime [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trECALPIDMipEm [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trECALPIDEmHip [NMAXPARTICLES][NECALSUBDETS]
 
Float_t trECALShowerPosition [NMAXPARTICLES][NECALSUBDETS][3]
 
Float_t trSMRDLength [NMAXPARTICLES][NSMRDSUBDETS]
 
Float_t trSMRDDirectionStart [NMAXPARTICLES][NSMRDSUBDETS][3]
 
Float_t trSMRDDirectionEnd [NMAXPARTICLES][NSMRDSUBDETS][3]
 
Float_t trSMRDPositionStart [NMAXPARTICLES][NSMRDSUBDETS][4]
 
Float_t trSMRDPositionEnd [NMAXPARTICLES][NSMRDSUBDETS][4]
 
Float_t trSMRDAvgTime [NMAXPARTICLES][NSMRDSUBDETS]
 
Float_t trP0DLength [NMAXPARTICLES][1]
 
Float_t trP0DELoss [NMAXPARTICLES][1]
 
Float_t trP0DDirectionStart [NMAXPARTICLES][1][3]
 
Float_t trP0DDirectionEnd [NMAXPARTICLES][1][3]
 
Float_t trP0DPositionStart [NMAXPARTICLES][1][4]
 
Float_t trP0DPositionEnd [NMAXPARTICLES][1][4]
 
TBranch * b_sPOTSincePreviousSpill
 
TBranch * b_sRun
 
TBranch * b_sSubrun
 
TBranch * b_sEvt
 
TBranch * b_sEventTime
 
TBranch * b_sNTotalTrueParticles
 
TBranch * b_sNTotalTrueVertices
 
TBranch * b_sBeamGoodSpill
 
TBranch * b_sDQGoodDaq
 
TBranch * b_sTriggerFGDCosmic
 
TBranch * b_sTriggerTripTCosmic
 
TBranch * b_sNTrueVertices
 
TBranch * b_sTrueVertexID
 
TBranch * b_sTrueVertexRooVtxIndex
 
TBranch * b_sTrueVertexRooVtxEntry
 
TBranch * b_sTrueVertexReacCode
 
TBranch * b_sTrueVertexNTrueParticles
 
TBranch * b_sTrueVertexNReconTracks
 
TBranch * b_sTrueVertexNReconVertices
 
TBranch * b_sTrueVertexNBaryons
 
TBranch * b_sTrueVertexBunch
 
TBranch * b_sTrueVertexDetector
 
TBranch * b_sTrueVertexNuPDG
 
TBranch * b_sTrueVertexTargetPDG
 
TBranch * b_sTrueVertexNuEnergy
 
TBranch * b_sTrueVertexQ2
 
TBranch * b_sTrueVertexPosition
 
TBranch * b_sTrueVertexNuParentPDG
 
TBranch * b_sTrueVertexNuParentDecPoint
 
TBranch * b_sTrueVertexNuDir
 
TBranch * b_sNTrueParticles
 
TBranch * b_sTrueParticleID
 
TBranch * b_sTrueParticleBunch
 
TBranch * b_sTrueParticlePDG
 
TBranch * b_sTrueParticleParentPDG
 
TBranch * b_sTrueParticleGParentPDG
 
TBranch * b_sTrueParticlePrimaryID
 
TBranch * b_sTrueParticleParentID
 
TBranch * b_sTrueParticlePurity
 
TBranch * b_sTrueParticleMomentum
 
TBranch * b_sTrueParticleCharge
 
TBranch * b_sTrueParticleVertexIndex
 
TBranch * b_sTrueParticleTruthVertexID
 
TBranch * b_sTrueParticleNReconTracks
 
TBranch * b_sTrueParticlePosition
 
TBranch * b_sTrueParticlePositionEnd
 
TBranch * b_sTrueParticleDirection
 
TBranch * b_sTrueParticleNDetCrossings
 
TBranch * b_sTrueParticleEntrancePosition
 
TBranch * b_sTrueParticleExitPosition
 
TBranch * b_sTrueParticleEntranceMomentum
 
TBranch * b_sTrueParticleExitMomentum
 
TBranch * b_sTrueParticleDetector
 
TBranch * b_sTrueParticleInActive
 
TBranch * b_sTrueParticleIsTruePrimaryPi0DecayPhoton
 
TBranch * b_sTrueParticleIsTruePrimaryPi0DecayPhotonChild
 
TBranch * b_sNFgdTimeBins
 
TBranch * b_sFgdTimeBinMinTime
 
TBranch * b_sFgdTimeBinMaxTime
 
TBranch * b_sFgdTimeBinNHits1
 
TBranch * b_sFgdTimeBinNHits2
 
TBranch * b_sFgdTimeBinRawChargeSum1
 
TBranch * b_sFgdTimeBinRawChargeSum2
 
TBranch * b_sFgdTimeBinG4ID
 
TBranch * b_Bunch
 
TBranch * b_Weight
 
TBranch * b_NVertices
 
TBranch * b_vPrimaryIndex
 
TBranch * b_vBunch
 
TBranch * b_vPosition
 
TBranch * b_vVariance
 
TBranch * b_vChi2
 
TBranch * b_vNDOF
 
TBranch * b_vNReconParticles
 
TBranch * b_vNTrueVerticesMatch
 
TBranch * b_vParticlesUniqueID
 
TBranch * b_vTrueVertexIndex
 
TBranch * b_vTrueVerticesClean
 
TBranch * b_vTrueVerticesCompl
 
TBranch * b_NParticles
 
TBranch * b_trUniqueID
 
TBranch * b_trStatus
 
TBranch * b_trBunch
 
TBranch * b_trNReconVertices
 
TBranch * b_trDetectors
 
TBranch * b_trDetUsed
 
TBranch * b_trNTPCs
 
TBranch * b_trNFGDs
 
TBranch * b_trNECALs
 
TBranch * b_trNSMRDs
 
TBranch * b_trNP0Ds
 
TBranch * b_trNHits
 
TBranch * b_trNNodes
 
TBranch * b_trNDOF
 
TBranch * b_trChi2
 
TBranch * b_trCharge
 
TBranch * b_trMomentum
 
TBranch * b_trToFFGD1_FGD2
 
TBranch * b_trToFP0D_FGD1
 
TBranch * b_trToFECal_FGD1
 
TBranch * b_trToFECal_FGD2
 
TBranch * b_trToFFlag_FGD1_FGD2
 
TBranch * b_trToFFlag_P0D_FGD1
 
TBranch * b_trToFFlag_ECal_FGD1
 
TBranch * b_trToFFlag_ECal_FGD2
 
TBranch * b_trMomentumError
 
TBranch * b_trMomentumMuon
 
TBranch * b_trMomentumErrorMuon
 
TBranch * b_trMomentumProton
 
TBranch * b_trMomentumErrorProton
 
TBranch * b_trMomentumEle
 
TBranch * b_trMomentumErrorEle
 
TBranch * b_trRangeMomentumEle
 
TBranch * b_trRangeMomentumMuon
 
TBranch * b_trRangeMomentumProton
 
TBranch * b_trDirectionStart
 
TBranch * b_trDirectionEnd
 
TBranch * b_trPositionStart
 
TBranch * b_trPositionEnd
 
TBranch * b_trMomentumFlip
 
TBranch * b_trTpcDetector
 
TBranch * b_trTpcNHits
 
TBranch * b_trTpcNNodes
 
TBranch * b_trTpcLength
 
TBranch * b_trTpcDirectionStart
 
TBranch * b_trTpcDirectionEnd
 
TBranch * b_trTpcPositionStart
 
TBranch * b_trTpcPositionEnd
 
TBranch * b_trTpcCharge
 
TBranch * b_trTpcMomentum
 
TBranch * b_trTpcMomentumError
 
TBranch * b_trTpcBackMomentum
 
TBranch * b_trTpcRefitCharge
 
TBranch * b_trTpcRefitMomentum
 
TBranch * b_trTpcRefitPosition
 
TBranch * b_trTpcRefitDirection
 
TBranch * b_trTpcEFieldRefitMomentum
 
TBranch * b_trTpcdEdxMeas
 
TBranch * b_trTpcdEdxExpMu
 
TBranch * b_trTpcdEdxExpEle
 
TBranch * b_trTpcdEdxExpP
 
TBranch * b_trTpcdEdxExpPi
 
TBranch * b_trTpcdEdxExpK
 
TBranch * b_trTpcdEdxSigmaMu
 
TBranch * b_trTpcdEdxSigmaEle
 
TBranch * b_trTpcdEdxSigmaP
 
TBranch * b_trTpcdEdxSigmaPi
 
TBranch * b_trTpcdEdxSigmaK
 
TBranch * b_trTpcPurity
 
TBranch * b_trFgdDetector
 
TBranch * b_trFgdNHits
 
TBranch * b_trFgdNNodes
 
TBranch * b_trFgdLength
 
TBranch * b_trFgdDirectionStart
 
TBranch * b_trFgdDirectionEnd
 
TBranch * b_trFgdPositionStart
 
TBranch * b_trFgdPositionEnd
 
TBranch * b_trFgdX
 
TBranch * b_trFgdE
 
TBranch * b_trFgdPullmu
 
TBranch * b_trFgdPullp
 
TBranch * b_trFgdPullpi
 
TBranch * b_trFgdPullno
 
TBranch * b_trFgdContainment
 
TBranch * b_trFgdAvgTime
 
TBranch * b_trFgdVertex1x1
 
TBranch * b_trFgdVertex3x3
 
TBranch * b_trFgdVertex5x5
 
TBranch * b_trFgdVertex7x7
 
TBranch * b_trFgdVertexLayer
 
TBranch * b_trECALDetector
 
TBranch * b_trECALNHits
 
TBranch * b_trECALNNodes
 
TBranch * b_trECALLength
 
TBranch * b_trECALDirectionStart
 
TBranch * b_trECALDirectionEnd
 
TBranch * b_trECALPositionStart
 
TBranch * b_trECALPositionEnd
 
TBranch * b_trECALEMEnergy
 
TBranch * b_trECALEDeposit
 
TBranch * b_trECALIsShowerLike
 
TBranch * b_trECALAvgTime
 
TBranch * b_trECALPIDMipEm
 
TBranch * b_trECALPIDEmHip
 
TBranch * b_trECALMostUpStreamLayerHit
 
TBranch * b_trECALShowerPosition
 
TBranch * b_trSMRDDetector
 
TBranch * b_trSMRDNHits
 
TBranch * b_trSMRDNNodes
 
TBranch * b_trSMRDLength
 
TBranch * b_trSMRDDirectionStart
 
TBranch * b_trSMRDDirectionEnd
 
TBranch * b_trSMRDPositionStart
 
TBranch * b_trSMRDPositionEnd
 
TBranch * b_trSMRDAvgTime
 
TBranch * b_trP0DDetector
 
TBranch * b_trP0DNHits
 
TBranch * b_trP0DNNodes
 
TBranch * b_trP0DLength
 
TBranch * b_trP0DELoss
 
TBranch * b_trP0DDirectionStart
 
TBranch * b_trP0DDirectionEnd
 
TBranch * b_trP0DPositionStart
 
TBranch * b_trP0DPositionEnd
 
TBranch * b_trTrueParticleID
 
TBranch * b_trTpcTrueParticleID
 
- Protected Attributes inherited from InputConverter
std::string _name
 The name of the converter.
 
std::string _treeName
 The name of the tree to convert.
 
int _nentries
 The number of entries in the chain. To be set by the implementation.
 
TChain * fChain
 The main TChain used to read events from the input file.
 
Int_t fCurrent
 current Tree number in a TChain
 
Int_t _currentFileIndex
 
std::string _currentFileName
 
std::map< std::string, TChain * > _chain_map
 
Header _header
 The header manager.
 

Detailed Description

Definition at line 19 of file FlatTreeConverter.hxx.

Constructor & Destructor Documentation

§ FlatTreeConverter()

FlatTreeConverter::FlatTreeConverter ( bool  readRooTrackerVtx = false)

AnaLocalReconBunch information

Definition at line 12 of file FlatTreeConverter.cxx.

12  :RedoTreeConverter(){
13 //********************************************************************
14 
15  // If true the RooTrackerVtx tree will be read
16  _readRooTrackerVtx = readRooTrackerVtx;
17 
18  _currentFileIndex=-1;
19  _RooVtxEntryInCurrentInputFile=0;
20  _entry_roo=0;
21 
22  _firstFile=true;
23  _firstEntry=true;
24 
25  // Initialise all the variables. This is particularly important as some
26  // branches many not exist in the flat tree.
27  sBeamPOT = 0;
28  sBeamPOTCT4 = 0;
29  sBeamSpill = 0;
30  sBeamSpillNumber = 0;
31  sBeamBeamRunNumber = 0;
32 
33  sDQND280Flag = 0;
34  for(int i = 0; i < 7; i++) sDQDetFlag[i] = 0;
35 
36  sNTrueVertices = 0;
37  for (unsigned int i = 0; i < NMAXTRUEVERTICES; i++) {
38  sTrueVertexNReconTracks[i] = 0;
39  sTrueVertexNReconVertices[i] = 0;
40  sTrueVertexBunch[i] = 0;
41  sTrueVertexLeptonPDG[i] = 0;
42  sTrueVertexQ2[i] = 0;
43  sTrueVertexTargetMom[i] = 0;
44  sTrueVertexLeptonMom[i] = 0;
45  sTrueVertexProtonMom[i] = 0;
46  sTrueVertexPionMom[i] = 0;
47  sTrueVertexIsPauliBlocked[i] = 0;
48  sTrueVertexIsCohOnH[i] = 0;
49 
50  for (unsigned int j = 0; j < 3; j++) {
51  sTrueVertexTargetDir[i][j] = 0;
52  sTrueVertexLeptonDir[i][j] = 0;
53  sTrueVertexProtonDir[i][j] = 0;
54  sTrueVertexPionDir[i][j] = 0;
55  }
56 
57  for (int j = 0; j < Int_t(ParticleId::kLast)+1; j++) {
58  sTrueVertexNPrimaryParticles[i][j]=0;
59  }
60 
61  }
62 
63  for (unsigned int i = 0; i < NMAXPARTICLES; i++) {
64  trReconPDG[i] = 0;
65  trNTRACKERs[i] = 0;
66  trLength[i] = 0;
67  trRangeMomentumMuonFlip[i] = 0;
68  trRangeMomentumProtonFlip[i] = 0;
69  trTrueParticleID[i] = 0;
70 
71  trNTimeNodes[i] = 0;
72  for (unsigned int j = 0; j < NMAXTIMENODES; j++) {
73  trTimeNodeDetector[i][j] = 0;
74  trTimeNodeTimeStart[i][j] = 0;
75  trTimeNodeTimeEnd[i][j] = 0;
76  }
77 
78  for (int j = 0; j < 3; j++) {
79  trDirectionAtVertex[i][j] = 0;
80  trDirectionStartFlip[i][j] = 0; //!
81  trDirectionEndFlip[i][j] = 0; //!
82  }
83 
84  for (int j = 0; j < 3; j++) {
85  trTpcUniqueID[i][j] = 0;
86  trTpcLength[i][j] = 0;
87  trTpcPullmu[i][j] = 0;
88  trTpcPullele[i][j] = 0;
89  trTpcPullp[i][j] = 0;
90  trTpcPullpi[i][j] = 0;
91  trTpcPullk[i][j] = 0;
92  trTpcRawdEdxMeas[i][j] = 0;
93  trTpcRawdEdxExpMu[i][j] = 0;
94  trTpcRawdEdxExpEle[i][j] = 0;
95  trTpcRawdEdxExpP[i][j] = 0;
96  trTpcRawdEdxExpPi[i][j] = 0;
97  trTpcRawdEdxExpK[i][j] = 0;
98  }
99 
100  for (int j = 0; j < 2; j++) {
101  trFgdUniqueID[i][j] = 0;
102 
103  trFgdHasFgdVA[i][j] = 0;
104  trFgdHasFgdVA_fmode[i][j] = 0;
105  trFgdTypeVA[i][j] = 0;
106 
107  trFgdHasFgdEA[i][j] = 0;
108  trFgdHasFgdEA_fmode[i][j] = 0;
109  trFgdTypeEA[i][j] = 0;
110  trFgdEnd0x0[i][j] = 0;
111  trFgdEnd1x1[i][j] = 0;
112  trFgdEnd3x3[i][j] = 0;
113  trFgdEnd5x5[i][j] = 0;
114  trFgdEnd7x7[i][j] = 0;
115  }
116 
117  for (int j = 0; j < (int)NECALSUBDETS; j++) {
118  trECALUniqueID[i][j] = 0;
119  trECALPIDMipPion[i][j] = 0;
120  trECALContainment[i][j] = 0;
121  }
122 
123  for (int j = 0; j < (int)NSMRDSUBDETS; j++) {
124  trSMRDUniqueID[i][j] = 0;
125  trSMRDEDeposit[i][j] = 0;
126  }
127 
128  for (int j = 0; j < 1; j++) {
129  trP0DUniqueID[i][j] = 0;
130  }
131 
132  for (int j = 0; j < (int)NMAXTRACKERS; j++) {
133  trTRACKERDetector[i][j] = 0;
134  trTRACKERNHits[i][j] = 0;
135  trTRACKERNNodes[i][j] = 0;
136  trTRACKERUniqueID[i][j] = 0;
137  trTRACKERLength[i][j] = 0;
138  trTRACKERCharge[i][j] = 0;
139  trTRACKERMomentum[i][j] = 0;
140  trTRACKERMomentumEnd[i][j] = 0;
141 
142  for (int k = 0; k < 3; k++) {
143  trTRACKERDirectionStart[i][j][k] = 0;
144  trTRACKERDirectionEnd[i][j][k] = 0;
145  }
146 
147  for (int k = 0; k < 4; k++) {
148  trTRACKERPositionStart[i][j][k] = 0;
149  trTRACKERPositionEnd[i][j][k] = 0;
150  }
151  }
152  }
153 
154  /// AnaLocalReconBunch information
155  tecalReconCounter = 0;
156  for (unsigned int i=0; i<NMAXTECALRECONOBJECTS; i++){
157  tecalReconAverageHitTime [i] = 0;
158  tecalReconAverageZPosition [i] = 0;
159  tecalReconContainment [i] = 0;
160  tecalReconEFitResult [i] = 0;
161  tecalReconEFitUncertainty [i] = 0;
162  tecalReconFirstLayer [i] = 0;
163  tecalReconIsShowerLike [i] = 0;
164  tecalReconIsTrackLike [i] = 0;
165  tecalReconLastLayer [i] = 0;
166  tecalReconLikeMIPEM [i] = 0;
167  tecalReconLikeMIPPion [i] = 0;
168  tecalReconLikeEMHIP [i] = 0;
169  tecalReconLikeMIPEMLow [i] = 0;
170  tecalReconMatchingLike [i] = 0;
171  tecalReconMichelTagNDelayedCluster[i] = 0;
172  tecalReconModule [i] = 0;
173  tecalReconMostDownStreamLayerHit [i] = 0;
174  tecalReconMostUpStreamLayerHit [i] = 0;
175  tecalReconNHits [i] = 0;
176  tecalReconNLayersHit [i] = 0;
177  tecalReconObjectLength [i] = 0;
178  tecalReconPIDAMR [i] = 0;
179  tecalReconPIDAngle [i] = 0;
180  tecalReconPIDAsymmetry [i] = 0;
181  tecalReconPIDCircularity [i] = 0;
182  tecalReconPIDFBR [i] = 0;
183  tecalReconPIDMaxRatio [i] = 0;
184  tecalReconPIDMeanPos [i] = 0;
185  tecalReconPIDShowerAngle [i] = 0;
186  tecalReconPIDShowerWidth [i] = 0;
187  tecalReconPIDTransverseChargeRatio[i] = 0;
188  tecalReconPIDTruncatedMaxRatio [i] = 0;
189  tecalReconThrust [i] = 0;
190  tecalReconTimeBunch [i] = 0;
191  tecalReconTotalHitCharge [i] = 0;
192  tecalReconTrueID [i] = 0;
193  tecalReconTrueIDPrimary [i] = 0;
194  tecalReconTrueIDRecursive [i] = 0;
195  tecalReconTrueIDSingle [i] = 0;
196  tecalReconUniqueID [i] = 0;
197  tecalReconBunch [i] = 0;
198 
199  for (int j=0; j<3; j++){
200  tecalReconPointing [i][j] = 0;
201  tecalReconThrustAxis [i][j] = 0;
202  tecalReconThrustOrigin [i][j] = 0;
203 
204  }
205  }
206 
207 
208  // Initialise all the branches. This is particularly important as some
209  // branches many not exist in the flat tree.
210  b_sIsMC = NULL;
211  b_sBeamPOT = NULL;
212  b_sBeamPOTCT4 = NULL;
213  b_sBeamSpill = NULL;
214  b_sBeamSpillNumber = NULL;
215  b_sBeamBeamRunNumber = NULL;
216  b_sDQND280Flag = NULL;
217  b_sDQDetFlag = NULL;
218 
219 
220  b_sTrueVertexLeptonPDG = NULL;
221  b_sTrueVertexLeptonDir = NULL;
222  b_sTrueVertexProtonDir = NULL;
223  b_sTrueVertexPionDir = NULL;
224  b_sTrueVertexLeptonMom = NULL;
225  b_sTrueVertexProtonMom = NULL;
226  b_sTrueVertexPionMom = NULL;
227  b_sTrueVertexIsPauliBlocked = NULL;
228  b_sTrueVertexIsCohOnH = NULL;
229  b_sTrueVertexNPrimaryParticles = NULL;
230  b_sTrueVertexPionMom = NULL;
231  b_sTrueVertexTargetDir = NULL;
232  b_sTrueVertexTargetMom = NULL;
233 
234  b_trReconPDG = NULL;
235  b_trDirectionAtVertex = NULL;
236 
237  b_trNTRACKERs = NULL;
238 
239  b_trTpcPullmu = NULL;
240  b_trTpcPullele = NULL;
241  b_trTpcPullp = NULL;
242  b_trTpcPullpi = NULL;
243  b_trTpcPullk = NULL;
244  b_trNTimeNodes = NULL;
245  b_trTimeNodeDetector = NULL;
246  b_trTimeNodeTimeStart = NULL;
247  b_trTimeNodeTimeEnd = NULL;
248 
249  b_trTpcUniqueID = NULL;
250  b_trFgdUniqueID = NULL;
251  b_trECALUniqueID = NULL;
252  b_trSMRDUniqueID = NULL;
253  b_trP0DUniqueID = NULL;
254 
255  b_trTpcRawdEdxMeas = NULL;
256  b_trTpcRawdEdxExpMu = NULL;
257  b_trTpcRawdEdxExpEle = NULL;
258  b_trTpcRawdEdxExpP = NULL;
259  b_trTpcRawdEdxExpPi = NULL;
260  b_trTpcRawdEdxExpK = NULL;
261 
262  b_trFgdHasFgdVA = NULL;
263  b_trFgdHasFgdVA_fmode = NULL;
264  b_trFgdTypeVA = NULL;
265  b_trFgdHasFgdEA = NULL;
266  b_trFgdHasFgdEA_fmode = NULL;
267  b_trFgdTypeEA = NULL;
268  b_trFgdEnd0x0 = NULL;
269  b_trFgdEnd1x1 = NULL;
270  b_trFgdEnd3x3 = NULL;
271  b_trFgdEnd5x5 = NULL;
272  b_trFgdEnd7x7 = NULL;
273 
274  b_trP0DAvgTime = NULL;
275 
276  b_trTRACKERDetector = NULL;
277  b_trTRACKERNHits = NULL;
278  b_trTRACKERNNodes = NULL;
279  b_trTRACKERUniqueID = NULL;
280  b_trTRACKERLength = NULL;
281  b_trTRACKERDirectionStart = NULL;
282  b_trTRACKERDirectionEnd = NULL;
283  b_trTRACKERPositionStart = NULL;
284  b_trTRACKERPositionEnd = NULL;
285  b_trTRACKERCharge = NULL;
286  b_trTRACKERMomentum = NULL;
287  b_trTRACKERMomentumEnd = NULL;
288 
289  b_trDirectionStartFlip = NULL;
290  b_trDirectionEndFlip = NULL;
291  b_trRangeMomentumMuonFlip = NULL;
292  b_trRangeMomentumProtonFlip = NULL;
293  b_trMomentumAtVertex = NULL;
294  b_trLength = NULL;
295 
296  b_trECALPIDMipPion = NULL;
297  b_trECALContainment = NULL;
298 
299  // SMRD
300  b_trSMRDEDeposit = NULL;
301 
302  b_tecalReconCounter = NULL;
303  b_tecalReconAverageHitTime = NULL;
304  b_tecalReconAverageZPosition = NULL;
305  b_tecalReconContainment = NULL;
306  b_tecalReconEFitResult = NULL;
307  b_tecalReconEFitUncertainty = NULL;
308  b_tecalReconFirstLayer = NULL;
309  b_tecalReconIsShowerLike = NULL;
310  b_tecalReconIsTrackLike = NULL;
311  b_tecalReconLastLayer = NULL;
312  b_tecalReconLikeMIPEM = NULL;
313  b_tecalReconLikeMIPPion = NULL;
314  b_tecalReconLikeEMHIP = NULL;
315  b_tecalReconLikeMIPEMLow = NULL;
316  b_tecalReconMatchingLike = NULL;
317  b_tecalReconMichelTagNDelayedCluster = NULL;
318  b_tecalReconModule = NULL;
319  b_tecalReconMostDownStreamLayerHit = NULL;
320  b_tecalReconMostUpStreamLayerHit = NULL;
321  b_tecalReconNHits = NULL;
322  b_tecalReconNLayersHit = NULL;
323  b_tecalReconObjectLength = NULL;
324  b_tecalReconPIDAMR = NULL;
325  b_tecalReconPIDAngle = NULL;
326  b_tecalReconPIDAsymmetry = NULL;
327  b_tecalReconPIDCircularity = NULL;
328  b_tecalReconPIDFBR = NULL;
329  b_tecalReconPIDMaxRatio = NULL;
330  b_tecalReconPIDMeanPos = NULL;
331  b_tecalReconPIDShowerAngle = NULL;
332  b_tecalReconPIDShowerWidth = NULL;
333  b_tecalReconPIDTransverseChargeRatio = NULL;
334  b_tecalReconPIDTruncatedMaxRatio = NULL;
335  b_tecalReconPointing = NULL;
336  b_tecalReconThrust = NULL;
337  b_tecalReconThrustAxis = NULL;
338  b_tecalReconThrustOrigin = NULL;
339  b_tecalReconTimeBunch = NULL;
340  b_tecalReconTotalHitCharge = NULL;
341  b_tecalReconTrueID = NULL;
342  b_tecalReconTrueIDPrimary = NULL;
343  b_tecalReconTrueIDRecursive = NULL;
344  b_tecalReconTrueIDSingle = NULL;
345  b_tecalReconUniqueID = NULL;
346  b_tecalReconBunch = NULL;
347 
348  RunID=-1;
349  SubrunID=-1;
350  EventID=-1;
351 
352 }
FlatTreeConverter::tecalReconCounter
Int_t tecalReconCounter
AnaLocalReconBunch information.
Definition: FlatTreeConverter.hxx:226

Member Function Documentation

§ DefineBranches()

void FlatTreeConverter::DefineBranches ( )
virtual

Define the branches to be read from the input tree.

AnaLocalReconBunch information

Reimplemented from RedoTreeConverter.

Definition at line 372 of file FlatTreeConverter.cxx.

372  {
373 //********************************************************************
374 
375  RedoTreeConverter::DefineBranches();
376 
377  // The branches commented below are not read becouse they are not currently needed by any analysis.
378  // This is equivalent to setting their status to 0, as it was done in the previous version
379 
380 
381  anaUtils::ConfigureTreeBranch(fChain, "sIsMC", &sIsMC, &b_sIsMC);
382  anaUtils::ConfigureTreeBranch(fChain, "sEventTime", &sEventTime, &b_sEventTime);
383  anaUtils::ConfigureTreeBranch(fChain, "sNTotalTrueTracks", &sNTotalTrueParticles, &b_sNTotalTrueParticles);
384  anaUtils::ConfigureTreeBranch(fChain, "sNTotalTrueVertices", &sNTotalTrueVertices, &b_sNTotalTrueVertices);
385 
386  anaUtils::ConfigureTreeBranch(fChain, "sInputFileIndex", &sInputFileIndex, &b_sInputFileIndex);
387  anaUtils::ConfigureTreeBranch(fChain, "sRooVtxEntry", &sRooVtxEntry, &b_sRooVtxEntry);
388 
389  // anaUtils::ConfigureTreeBranch(fChain, "sPOTSincePreviousSpill", &sPOTSincePreviousSpill, &b_sPOTSincePreviousSpill);
390  anaUtils::ConfigureTreeBranch(fChain, "sBeamPOT", &sBeamPOT, &b_sBeamPOT);
391 #if !VERSION_HAS_OFFICIAL_POT
392  anaUtils::ConfigureTreeBranch(fChain, "sBeamPOTCT4", &sBeamPOTCT4, &b_sBeamPOTCT4);
393 #endif
394  anaUtils::ConfigureTreeBranch(fChain, "sBeamSpill", &sBeamSpill, &b_sBeamSpill);
395  anaUtils::ConfigureTreeBranch(fChain, "sBeamSpillNumber", &sBeamSpillNumber, &b_sBeamSpillNumber);
396  anaUtils::ConfigureTreeBranch(fChain, "sBeamGoodSpill", &sBeamGoodSpill, &b_sBeamGoodSpill);
397  anaUtils::ConfigureTreeBranch(fChain, "sBeamBeamRunNumber", &sBeamBeamRunNumber, &b_sBeamBeamRunNumber);
398  anaUtils::ConfigureTreeBranch(fChain, "sDQGoodDaq", &sDQGoodDaq, &b_sDQGoodDaq);
399  anaUtils::ConfigureTreeBranch(fChain, "sDQND280Flag", &sDQND280Flag, &b_sDQND280Flag);
400  anaUtils::ConfigureTreeBranch(fChain, "sDQDetFlag", sDQDetFlag, &b_sDQDetFlag);
401  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexRooVtxIndex", sTrueVertexRooVtxIndex, &b_sTrueVertexRooVtxIndex);
402  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexRooVtxEntry", sTrueVertexRooVtxEntry, &b_sTrueVertexRooVtxEntry);
403  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexReacCode", sTrueVertexReacCode, &b_sTrueVertexReacCode);
404  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNTrueTracks", sTrueVertexNTrueParticles, &b_sTrueVertexNTrueParticles);
405  // anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNReconTracks", sTrueVertexNReconTracks, &b_sTrueVertexNReconTracks);
406  // anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNReconVertices", sTrueVertexNReconVertices, &b_sTrueVertexNReconVertices);
407  // anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNBaryons", sTrueVertexNBaryons, &b_sTrueVertexNBaryons);
408  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexDetector", sTrueVertexDetector, &b_sTrueVertexDetector);
409  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexLeptonPDG", sTrueVertexLeptonPDG, &b_sTrueVertexLeptonPDG);
410  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexTargetPDG", sTrueVertexTargetPDG, &b_sTrueVertexTargetPDG);
411  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNuEnergy", sTrueVertexNuEnergy, &b_sTrueVertexNuEnergy);
412  // anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexQ2", sTrueVertexQ2, &b_sTrueVertexQ2);
413  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexPosition", sTrueVertexPosition, &b_sTrueVertexPosition);
414  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNuParentPDG", sTrueVertexNuParentPDG, &b_sTrueVertexNuParentPDG);
415  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNuParentDecPoint", sTrueVertexNuParentDecPoint, &b_sTrueVertexNuParentDecPoint);
416  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNuDir", sTrueVertexNuDir, &b_sTrueVertexNuDir);
417  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexTargetDir", sTrueVertexTargetDir, &b_sTrueVertexTargetDir);
418  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexLeptonDir", sTrueVertexLeptonDir, &b_sTrueVertexLeptonDir);
419  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexProtonDir", sTrueVertexProtonDir, &b_sTrueVertexProtonDir);
420  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexPionDir", sTrueVertexPionDir, &b_sTrueVertexPionDir);
421  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexTargetMom", sTrueVertexTargetMom, &b_sTrueVertexTargetMom);
422  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexLeptonMom", sTrueVertexLeptonMom, &b_sTrueVertexLeptonMom);
423  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexProtonMom", sTrueVertexProtonMom, &b_sTrueVertexProtonMom);
424  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexPionMom", sTrueVertexPionMom, &b_sTrueVertexPionMom);
425  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexIsPauliBlocked", sTrueVertexIsPauliBlocked, &b_sTrueVertexIsPauliBlocked);
426  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexIsCohOnH", sTrueVertexIsCohOnH, &b_sTrueVertexIsCohOnH);
427  anaUtils::ConfigureTreeBranch(fChain, "sTrueVertexNPrimaryParticles", sTrueVertexNPrimaryParticles, &b_sTrueVertexNPrimaryParticles);
428  // anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackBunch", sTrueParticleBunch, &b_sTrueParticleBunch);
429  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackPDG", sTrueParticlePDG, &b_sTrueParticlePDG);
430  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackParentPDG", sTrueParticleParentPDG, &b_sTrueParticleParentPDG);
431  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackGParentPDG", sTrueParticleGParentPDG, &b_sTrueParticleGParentPDG);
432  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackPrimaryID", sTrueParticlePrimaryID, &b_sTrueParticlePrimaryID);
433  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackParentID", sTrueParticleParentID, &b_sTrueParticleParentID);
434  // anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackPurity", sTrueParticlePurity, &b_sTrueParticlePurity);
435  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackMomentum", sTrueParticleMomentum, &b_sTrueParticleMomentum);
436  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackCharge", sTrueParticleCharge, &b_sTrueParticleCharge);
437  // anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackNReconTracks", sTrueParticleNReconTracks, &b_sTrueParticleNReconTracks);
438  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackPosition", sTrueParticlePosition, &b_sTrueParticlePosition);
439  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackPositionEnd", sTrueParticlePositionEnd, &b_sTrueParticlePositionEnd);
440  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackDirection", sTrueParticleDirection, &b_sTrueParticleDirection);
441  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackNDetCrossings", sTrueParticleNDetCrossings, &b_sTrueParticleNDetCrossings);
442  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackEntrancePosition", sTrueParticleEntrancePosition, &b_sTrueParticleEntrancePosition);
443  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackEntranceMomentum", sTrueParticleEntranceMomentum, &b_sTrueParticleEntranceMomentum);
444  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackExitPosition", sTrueParticleExitPosition, &b_sTrueParticleExitPosition);
445  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackExitMomentum", sTrueParticleExitMomentum, &b_sTrueParticleExitMomentum);
446  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackInActive", sTrueParticleInActive, &b_sTrueParticleInActive);
447  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackDetector", sTrueParticleDetector, &b_sTrueParticleDetector);
448  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackIsTruePrimaryPi0DecayPhoton", sTrueParticleIsTruePrimaryPi0DecayPhoton, &b_sTrueParticleIsTruePrimaryPi0DecayPhoton);
449  anaUtils::ConfigureTreeBranch(fChain, "sTrueTrackIsTruePrimaryPi0DecayPhotonChild", sTrueParticleIsTruePrimaryPi0DecayPhotonChild, &b_sTrueParticleIsTruePrimaryPi0DecayPhotonChild);
450  anaUtils::ConfigureTreeBranch(fChain, "sFgdTimeBinMinTime", sFgdTimeBinMinTime, &b_sFgdTimeBinMinTime);
451  anaUtils::ConfigureTreeBranch(fChain, "sFgdTimeBinMaxTime", sFgdTimeBinMaxTime, &b_sFgdTimeBinMaxTime);
452  anaUtils::ConfigureTreeBranch(fChain, "sFgdTimeBinRawChargeSum1", sFgdTimeBinRawChargeSum1, &b_sFgdTimeBinRawChargeSum1);
453  anaUtils::ConfigureTreeBranch(fChain, "sFgdTimeBinRawChargeSum2", sFgdTimeBinRawChargeSum2, &b_sFgdTimeBinRawChargeSum2);
454  // anaUtils::ConfigureTreeBranch(fChain, "sFgdTimeBinG4ID", sFgdTimeBinG4ID, &b_sFgdTimeBinG4ID);
455 
456  // anaUtils::ConfigureTreeBranch(fChain, "NVertices", &NVertices, &b_NVertices);
457  // anaUtils::ConfigureTreeBranch(fChain, "vPrimaryIndex", &vPrimaryIndex, &b_vPrimaryIndex);
458  // anaUtils::ConfigureTreeBranch(fChain, "vBunch", &vBunch, &b_vBunch);
459  // anaUtils::ConfigureTreeBranch(fChain, "vPosition", &vPosition, &b_vPosition);
460  // anaUtils::ConfigureTreeBranch(fChain, "vVariance", &vVariance, &b_vVariance);
461  // anaUtils::ConfigureTreeBranch(fChain, "vChi2", &vChi2, &b_vChi2);
462  // anaUtils::ConfigureTreeBranch(fChain, "vNDOF", &vNDOF, &b_vNDOF);
463  anaUtils::ConfigureTreeBranch(fChain, "vNReconTracks", &vNReconParticles, &b_vNReconParticles);
464  anaUtils::ConfigureTreeBranch(fChain, "vNTrueVerticesMatch", &vNTrueVerticesMatch, &b_vNTrueVerticesMatch);
465  anaUtils::ConfigureTreeBranch(fChain, "vTracksUniqueID", &vParticlesUniqueID, &b_vParticlesUniqueID);
466  anaUtils::ConfigureTreeBranch(fChain, "vTrueVertexIndex", &vTrueVertexIndex, &b_vTrueVertexIndex);
467  anaUtils::ConfigureTreeBranch(fChain, "vTrueVerticesClean", &vTrueVerticesClean, &b_vTrueVerticesClean);
468  anaUtils::ConfigureTreeBranch(fChain, "vTrueVerticesCompl", &vTrueVerticesCompl, &b_vTrueVerticesCompl);
469 
470  // anaUtils::ConfigureTreeBranch(fChain, "trStatus", trStatus, &b_trStatus);
471  anaUtils::ConfigureTreeBranch(fChain, "trReconPDG", trReconPDG, &b_trReconPDG);
472  // anaUtils::ConfigureTreeBranch(fChain, "trBunch", trBunch, &b_trBunch);
473  // anaUtils::ConfigureTreeBranch(fChain, "trNReconVertices", &trNReconVertices, &b_trNReconVertices);
474  anaUtils::ConfigureTreeBranch(fChain, "trDetectors", trDetectors, &b_trDetectors);
475  // anaUtils::ConfigureTreeBranch(fChain, "trNTPCs", trNTPCs, &b_trNTPCs);
476  // anaUtils::ConfigureTreeBranch(fChain, "trNFGDs", trNFGDs, &b_trNFGDs);
477  // anaUtils::ConfigureTreeBranch(fChain, "trNECALs", trNECALs, &b_trNECALs);
478  // anaUtils::ConfigureTreeBranch(fChain, "trNSMRDs", trNSMRDs, &b_trNSMRDs);
479  // anaUtils::ConfigureTreeBranch(fChain, "trNP0Ds", trNP0Ds, &b_trNP0Ds);
480  anaUtils::ConfigureTreeBranch(fChain, "trNTRACKERs", trNTRACKERs, &b_trNTRACKERs);
481  anaUtils::ConfigureTreeBranch(fChain, "trNHits", trNHits, &b_trNHits);
482  anaUtils::ConfigureTreeBranch(fChain, "trNNodes", trNNodes, &b_trNNodes);
483  anaUtils::ConfigureTreeBranch(fChain, "trNDOF", trNDOF, &b_trNDOF);
484  anaUtils::ConfigureTreeBranch(fChain, "trChi2", trChi2, &b_trChi2);
485  anaUtils::ConfigureTreeBranch(fChain, "trCharge", trCharge, &b_trCharge);
486  anaUtils::ConfigureTreeBranch(fChain, "trMomentum", trMomentum, &b_trMomentum);
487  // anaUtils::ConfigureTreeBranch(fChain, "trMomentumError", trMomentumError, &b_trMomentumError);
488  anaUtils::ConfigureTreeBranch(fChain, "trMomentumMuon", trMomentumMuon, &b_trMomentumMuon);
489  // anaUtils::ConfigureTreeBranch(fChain, "trMomentumErrorMuon", trMomentumErrorMuon, &b_trMomentumErrorMuon);
490  anaUtils::ConfigureTreeBranch(fChain, "trMomentumProton", trMomentumProton, &b_trMomentumProton);
491  // anaUtils::ConfigureTreeBranch(fChain, "trMomentumErrorProton", trMomentumErrorProton, &b_trMomentumErrorProton);
492  anaUtils::ConfigureTreeBranch(fChain, "trMomentumEle", trMomentumEle, &b_trMomentumEle);
493  // anaUtils::ConfigureTreeBranch(fChain, "trMomentumErrorEle", trMomentumErrorEle, &b_trMomentumErrorEle);
494 
495 
496  anaUtils::ConfigureTreeBranch(fChain, "trLength", trLength, &b_trLength);
497 
498 #if VERSION_HAS_REVERSED_REFITS
499  anaUtils::ConfigureTreeBranch(fChain, "trDirectionStartFlip", trDirectionStartFlip, &b_trDirectionStartFlip);
500  anaUtils::ConfigureTreeBranch(fChain, "trDirectionEndFlip", trDirectionEndFlip, &b_trDirectionEndFlip);
501 #endif
502 
503 
504 #if VERSION_HAS_PRANGE_ESTIMATES
505  // anaUtils::ConfigureTreeBranch(fChain, "trRangeMomentumEle", trRangeMomentumEle, &b_trRangeMomentumEle);
506  anaUtils::ConfigureTreeBranch(fChain, "trRangeMomentumProton", trRangeMomentumProton, &b_trRangeMomentumProton);
507  // anaUtils::ConfigureTreeBranch(fChain, "trRangeMomentumMuonFlip", trRangeMomentumMuonFlip, &b_trRangeMomentumMuonFlip);
508 // anaUtils::ConfigureTreeBranch(fChain, "trRangeMomentumProtonFlip", trRangeMomentumProtonFlip, &b_trRangeMomentumProtonFlip);
509 #endif
510 
511  anaUtils::ConfigureTreeBranch(fChain, "trMomentumAtVertex", trMomentumAtVertex, &b_trMomentumAtVertex);
512  anaUtils::ConfigureTreeBranch(fChain, "trDirectionAtVertex", trDirectionAtVertex, &b_trDirectionAtVertex);
513  anaUtils::ConfigureTreeBranch(fChain, "trDirectionStart", trDirectionStart, &b_trDirectionStart);
514  anaUtils::ConfigureTreeBranch(fChain, "trDirectionEnd", trDirectionEnd, &b_trDirectionEnd);
515  anaUtils::ConfigureTreeBranch(fChain, "trPositionStart", trPositionStart, &b_trPositionStart);
516  anaUtils::ConfigureTreeBranch(fChain, "trPositionEnd", trPositionEnd, &b_trPositionEnd);
517  anaUtils::ConfigureTreeBranch(fChain, "trTrueTrackID", trTrueParticleID, &b_trTrueParticleID);
518 
519 #if VERSION_HAS_TIME_FITS
520  // anaUtils::ConfigureTreeBranch(fChain, "trNTimeNodes", trNTimeNodes, &b_trNTimeNodes);
521  // anaUtils::ConfigureTreeBranch(fChain, "trTimeNodeDetector", trTimeNodeDetector, &b_trTimeNodeDetector);
522  // anaUtils::ConfigureTreeBranch(fChain, "trTimeNodeTimeStart", trTimeNodeTimeStart, &b_trTimeNodeTimeStart);
523  // anaUtils::ConfigureTreeBranch(fChain, "trTimeNodeTimeEnd", trTimeNodeTimeEnd, &b_trTimeNodeTimeEnd);
524 
525  anaUtils::ConfigureTreeBranch(fChain, "trToFFGD1_FGD2", trToFFGD1_FGD2, &b_trToFFGD1_FGD2);
526  anaUtils::ConfigureTreeBranch(fChain, "trToFP0D_FGD1", trToFP0D_FGD1, &b_trToFP0D_FGD1);
527  anaUtils::ConfigureTreeBranch(fChain, "trToFECal_FGD1", trToFECal_FGD1, &b_trToFECal_FGD1);
528  anaUtils::ConfigureTreeBranch(fChain, "trToFECal_FGD2", trToFECal_FGD2, &b_trToFECal_FGD2);
529  anaUtils::ConfigureTreeBranch(fChain, "trToFFlag_FGD1_FGD2", trToFFlag_FGD1_FGD2, &b_trToFFlag_FGD1_FGD2);
530  anaUtils::ConfigureTreeBranch(fChain, "trToFFlag_P0D_FGD1", trToFFlag_P0D_FGD1, &b_trToFFlag_P0D_FGD1);
531  anaUtils::ConfigureTreeBranch(fChain, "trToFFlag_ECal_FGD1", trToFFlag_ECal_FGD1, &b_trToFFlag_ECal_FGD1);
532  anaUtils::ConfigureTreeBranch(fChain, "trToFFlag_ECal_FGD2", trToFFlag_ECal_FGD2, &b_trToFFlag_ECal_FGD2);
533 
534 #endif
535 
536  anaUtils::ConfigureTreeBranch(fChain, "trTpcNHits", trTpcNHits, &b_trTpcNHits);
537  anaUtils::ConfigureTreeBranch(fChain, "trTpcUniqueID", trTpcUniqueID, &b_trTpcUniqueID);
538  anaUtils::ConfigureTreeBranch(fChain, "trTpcLength", trTpcLength, &b_trTpcLength);
539  anaUtils::ConfigureTreeBranch(fChain, "trTpcDirectionStart", trTpcDirectionStart, &b_trTpcDirectionStart);
540  anaUtils::ConfigureTreeBranch(fChain, "trTpcDirectionEnd", trTpcDirectionEnd, &b_trTpcDirectionEnd);
541  anaUtils::ConfigureTreeBranch(fChain, "trTpcPositionStart", trTpcPositionStart, &b_trTpcPositionStart);
542  anaUtils::ConfigureTreeBranch(fChain, "trTpcPositionEnd", trTpcPositionEnd, &b_trTpcPositionEnd);
543  anaUtils::ConfigureTreeBranch(fChain, "trTpcCharge", trTpcCharge, &b_trTpcCharge);
544  anaUtils::ConfigureTreeBranch(fChain, "trTpcMomentum", trTpcMomentum, &b_trTpcMomentum);
545  anaUtils::ConfigureTreeBranch(fChain, "trTpcMomentumError", trTpcMomentumError, &b_trTpcMomentumError);
546  anaUtils::ConfigureTreeBranch(fChain, "trTpcBackMomentum", trTpcBackMomentum, &b_trTpcBackMomentum);
547 #if VERSION_HAS_BFIELD_REFIT
548  anaUtils::ConfigureTreeBranch(fChain, "trTpcRefitMomentum", trTpcRefitMomentum, &b_trTpcRefitMomentum);
549 #endif
550 #if VERSION_HAS_BFIELD_REFIT_FULL
551  anaUtils::ConfigureTreeBranch(fChain, "trTpcRefitCharge", trTpcRefitCharge, &b_trTpcRefitCharge);
552  anaUtils::ConfigureTreeBranch(fChain, "trTpcRefitDirection",trTpcRefitDirection, &b_trTpcRefitDirection);
553  anaUtils::ConfigureTreeBranch(fChain, "trTpcRefitPosition", trTpcRefitPosition, &b_trTpcRefitPosition);
554 #endif
555 #if VERSION_HAS_EFIELD_REFIT
556  anaUtils::ConfigureTreeBranch(fChain, "trTpcEFieldRefitMomentum", trTpcEFieldRefitMomentum, &b_trTpcEFieldRefitMomentum);
557 #endif
558  anaUtils::ConfigureTreeBranch(fChain, "trTpcPullmu", trTpcPullmu, &b_trTpcPullmu);
559  anaUtils::ConfigureTreeBranch(fChain, "trTpcPullele", trTpcPullele, &b_trTpcPullele);
560  anaUtils::ConfigureTreeBranch(fChain, "trTpcPullp", trTpcPullp, &b_trTpcPullp);
561  anaUtils::ConfigureTreeBranch(fChain, "trTpcPullpi", trTpcPullpi, &b_trTpcPullpi);
562  anaUtils::ConfigureTreeBranch(fChain, "trTpcPullk", trTpcPullk, &b_trTpcPullk);
563  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxMeas", trTpcdEdxMeas, &b_trTpcdEdxMeas);
564  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxExpMu", trTpcdEdxExpMu, &b_trTpcdEdxExpMu);
565  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxExpEle", trTpcdEdxExpEle, &b_trTpcdEdxExpEle);
566  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxExpP", trTpcdEdxExpP, &b_trTpcdEdxExpP);
567  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxExpPi", trTpcdEdxExpPi, &b_trTpcdEdxExpPi);
568  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxExpK", trTpcdEdxExpK, &b_trTpcdEdxExpK);
569  anaUtils::ConfigureTreeBranch(fChain, "trTpcRawdEdxMeas", trTpcRawdEdxMeas, &b_trTpcRawdEdxMeas);
570  anaUtils::ConfigureTreeBranch(fChain, "trTpcRawdEdxExpMu", trTpcRawdEdxExpMu, &b_trTpcRawdEdxExpMu);
571  anaUtils::ConfigureTreeBranch(fChain, "trTpcRawdEdxExpEle", trTpcRawdEdxExpEle, &b_trTpcRawdEdxExpEle);
572  anaUtils::ConfigureTreeBranch(fChain, "trTpcRawdEdxExpP", trTpcRawdEdxExpP, &b_trTpcRawdEdxExpP);
573  anaUtils::ConfigureTreeBranch(fChain, "trTpcRawdEdxExpPi", trTpcRawdEdxExpPi, &b_trTpcRawdEdxExpPi);
574  anaUtils::ConfigureTreeBranch(fChain, "trTpcRawdEdxExpK", trTpcRawdEdxExpK, &b_trTpcRawdEdxExpK);
575  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxSigmaMu", trTpcdEdxSigmaMu, &b_trTpcdEdxSigmaMu);
576  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxSigmaEle", trTpcdEdxSigmaEle, &b_trTpcdEdxSigmaEle);
577  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxSigmaP", trTpcdEdxSigmaP, &b_trTpcdEdxSigmaP);
578  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxSigmaPi", trTpcdEdxSigmaPi, &b_trTpcdEdxSigmaPi);
579  anaUtils::ConfigureTreeBranch(fChain, "trTpcdEdxSigmaK", trTpcdEdxSigmaK, &b_trTpcdEdxSigmaK);
580  // anaUtils::ConfigureTreeBranch(fChain, "trTpcPurity", trTpcPurity, &b_trTpcPurity);
581  anaUtils::ConfigureTreeBranch(fChain, "trTpcTrueTrackID", trTpcTrueParticleID, &b_trTpcTrueParticleID);
582  anaUtils::ConfigureTreeBranch(fChain, "trFgdDetector", trFgdDetector, &b_trFgdDetector);
583  anaUtils::ConfigureTreeBranch(fChain, "trFgdNHits", trFgdNHits, &b_trFgdNHits);
584  anaUtils::ConfigureTreeBranch(fChain, "trFgdNNodes", trFgdNNodes, &b_trFgdNNodes);
585  anaUtils::ConfigureTreeBranch(fChain, "trFgdUniqueID", trFgdUniqueID, &b_trFgdUniqueID);
586  anaUtils::ConfigureTreeBranch(fChain, "trFgdLength", trFgdLength, &b_trFgdLength);
587  anaUtils::ConfigureTreeBranch(fChain, "trFgdDirectionStart", trFgdDirectionStart, &b_trFgdDirectionStart);
588  anaUtils::ConfigureTreeBranch(fChain, "trFgdDirectionEnd", trFgdDirectionEnd, &b_trFgdDirectionEnd);
589  anaUtils::ConfigureTreeBranch(fChain, "trFgdPositionStart", trFgdPositionStart, &b_trFgdPositionStart);
590  anaUtils::ConfigureTreeBranch(fChain, "trFgdPositionEnd", trFgdPositionEnd, &b_trFgdPositionEnd);
591  anaUtils::ConfigureTreeBranch(fChain, "trFgdX", trFgdX, &b_trFgdX);
592  anaUtils::ConfigureTreeBranch(fChain, "trFgdE", trFgdE, &b_trFgdE);
593  anaUtils::ConfigureTreeBranch(fChain, "trFgdPullmu", trFgdPullmu, &b_trFgdPullmu);
594  anaUtils::ConfigureTreeBranch(fChain, "trFgdPullp", trFgdPullp, &b_trFgdPullp);
595  anaUtils::ConfigureTreeBranch(fChain, "trFgdPullpi", trFgdPullpi, &b_trFgdPullpi);
596  anaUtils::ConfigureTreeBranch(fChain, "trFgdPullno", trFgdPullno, &b_trFgdPullno);
597  anaUtils::ConfigureTreeBranch(fChain, "trFgdContainment", trFgdContainment, &b_trFgdContainment);
598  // anaUtils::ConfigureTreeBranch(fChain, "trFgdAvgTime", trFgdAvgTime, &b_trFgdAvgTime);
599 
600 #if VERSION_HAS_FGD_VERTEX_AND_END_ACTIVITY
601  anaUtils::ConfigureTreeBranch(fChain, "trFgdHasFgdVA", trFgdHasFgdVA, &b_trFgdHasFgdVA);
602  anaUtils::ConfigureTreeBranch(fChain, "trFgdHasFgdVA_fmode", trFgdHasFgdVA_fmode, &b_trFgdHasFgdVA_fmode);
603  anaUtils::ConfigureTreeBranch(fChain, "trFgdTypeVA", trFgdTypeVA, &b_trFgdTypeVA);
604 #endif
605  anaUtils::ConfigureTreeBranch(fChain, "trFgdVertex1x1", trFgdVertex1x1, &b_trFgdVertex1x1);
606  anaUtils::ConfigureTreeBranch(fChain, "trFgdVertex3x3", trFgdVertex3x3, &b_trFgdVertex3x3);
607  anaUtils::ConfigureTreeBranch(fChain, "trFgdVertex5x5", trFgdVertex5x5, &b_trFgdVertex5x5);
608  anaUtils::ConfigureTreeBranch(fChain, "trFgdVertex7x7", trFgdVertex7x7, &b_trFgdVertex7x7);
609  anaUtils::ConfigureTreeBranch(fChain, "trFgdVertexLayer", trFgdVertexLayer, &b_trFgdVertexLayer);
610 
611 #if VERSION_HAS_FGD_VERTEX_AND_END_ACTIVITY
612  anaUtils::ConfigureTreeBranch(fChain, "trFgdHasFgdEA", trFgdHasFgdEA, &b_trFgdHasFgdEA);
613  anaUtils::ConfigureTreeBranch(fChain, "trFgdHasFgdEA_fmode", trFgdHasFgdEA_fmode, &b_trFgdHasFgdEA_fmode);
614  anaUtils::ConfigureTreeBranch(fChain, "trFgdTypeEA", trFgdTypeEA, &b_trFgdTypeEA);
615  anaUtils::ConfigureTreeBranch(fChain, "trFgdEnd0x0", trFgdEnd0x0, &b_trFgdEnd0x0);
616  anaUtils::ConfigureTreeBranch(fChain, "trFgdEnd0x0", trFgdEnd0x0, &b_trFgdEnd0x0);
617  anaUtils::ConfigureTreeBranch(fChain, "trFgdEnd1x1", trFgdEnd1x1, &b_trFgdEnd1x1);
618  anaUtils::ConfigureTreeBranch(fChain, "trFgdEnd3x3", trFgdEnd3x3, &b_trFgdEnd3x3);
619  anaUtils::ConfigureTreeBranch(fChain, "trFgdEnd5x5", trFgdEnd5x5, &b_trFgdEnd5x5);
620  anaUtils::ConfigureTreeBranch(fChain, "trFgdEnd7x7", trFgdEnd7x7, &b_trFgdEnd7x7);
621 #endif
622 
623  // anaUtils::ConfigureTreeBranch(fChain, "trECALDetector", trECALDetector, &b_trECALDetector);
624  anaUtils::ConfigureTreeBranch(fChain, "trECALNHits", trECALNHits, &b_trECALNHits);
625  // anaUtils::ConfigureTreeBranch(fChain, "trECALNNodes", trECALNNodes, &b_trECALNNodes);
626  anaUtils::ConfigureTreeBranch(fChain, "trECALUniqueID", trECALUniqueID, &b_trECALUniqueID);
627  // anaUtils::ConfigureTreeBranch(fChain, "trECALLength", trECALLength, &b_trECALLength);
628  anaUtils::ConfigureTreeBranch(fChain, "trECALDirectionStart", trECALDirectionStart, &b_trECALDirectionStart);
629  anaUtils::ConfigureTreeBranch(fChain, "trECALDirectionEnd", trECALDirectionEnd, &b_trECALDirectionEnd);
630  anaUtils::ConfigureTreeBranch(fChain, "trECALPositionStart", trECALPositionStart, &b_trECALPositionStart);
631  anaUtils::ConfigureTreeBranch(fChain, "trECALPositionEnd", trECALPositionEnd, &b_trECALPositionEnd);
632  // anaUtils::ConfigureTreeBranch(fChain, "trECALEMEnergy", trECALEMEnergy, &b_trECALEMEnergy);
633  anaUtils::ConfigureTreeBranch(fChain, "trECALEDeposit", trECALEDeposit, &b_trECALEDeposit);
634  anaUtils::ConfigureTreeBranch(fChain, "trECALIsShowerLike", trECALIsShowerLike, &b_trECALIsShowerLike);
635  anaUtils::ConfigureTreeBranch(fChain, "trECALAvgTime", trECALAvgTime, &b_trECALAvgTime);
636  //ECal PID
637  anaUtils::ConfigureTreeBranch(fChain, "trECALPIDMipPion", trECALPIDMipPion, &b_trECALPIDMipPion);
638  // anaUtils::ConfigureTreeBranch(fChain, "trECALPIDMipEm", trECALPIDMipEm, &b_trECALPIDMipEm);
639  // anaUtils::ConfigureTreeBranch(fChain, "trECALPIDEmHip", trECALPIDEmHip, &b_trECALPIDEmHip);
640  anaUtils::ConfigureTreeBranch(fChain, "trECALContainment", trECALContainment, &b_trECALContainment);
641  // anaUtils::ConfigureTreeBranch(fChain, "trECALMostUpStreamLayerHit", trECALMostUpStreamLayerHit, &b_trECALMostUpStreamLayerHit);
642 
643  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDDetector", trSMRDDetector, &b_trSMRDDetector);
644  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDNHits", trSMRDNHits, &b_trSMRDNHits);
645  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDNNodes", trSMRDNNodes, &b_trSMRDNNodes);
646  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDUniqueID", trSMRDUniqueID, &b_trSMRDUniqueID);
647  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDLength", trSMRDLength, &b_trSMRDLength);
648  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDDirectionStart", trSMRDDirectionStart, &b_trSMRDDirectionStart);
649  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDDirectionEnd", trSMRDDirectionEnd, &b_trSMRDDirectionEnd);
650  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDPositionStart", trSMRDPositionStart, &b_trSMRDPositionStart);
651  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDPositionEnd", trSMRDPositionEnd, &b_trSMRDPositionEnd);
652  // anaUtils::ConfigureTreeBranch(fChain, "trSMRDAvgTime", trSMRDAvgTime, &b_trSMRDAvgTime);
653  anaUtils::ConfigureTreeBranch(fChain, "trSMRDEDeposit", trSMRDEDeposit, &b_trSMRDEDeposit);
654 
655 
656 
657  // anaUtils::ConfigureTreeBranch(fChain, "trP0DDetector", trP0DDetector, &b_trP0DDetector);
658  // anaUtils::ConfigureTreeBranch(fChain, "trP0DNHits", trP0DNHits, &b_trP0DNHits);
659  anaUtils::ConfigureTreeBranch(fChain, "trP0DNNodes", trP0DNNodes, &b_trP0DNNodes);
660  // anaUtils::ConfigureTreeBranch(fChain, "trP0DUniqueID", trP0DUniqueID, &b_trP0DUniqueID);
661  // anaUtils::ConfigureTreeBranch(fChain, "trP0DLength", trP0DLength, &b_trP0DLength);
662  // anaUtils::ConfigureTreeBranch(fChain, "trP0DDirectionStart", trP0DDirectionStart, &b_trP0DDirectionStart);
663  // anaUtils::ConfigureTreeBranch(fChain, "trP0DDirectionEnd", trP0DDirectionEnd, &b_trP0DDirectionEnd);
664  // anaUtils::ConfigureTreeBranch(fChain, "trP0DPositionStart", trP0DPositionStart, &b_trP0DPositionStart);
665  // anaUtils::ConfigureTreeBranch(fChain, "trP0DPositionEnd", trP0DPositionEnd, &b_trP0DPositionEnd);
666 
667 #if VERSION_HAS_P0D_AVERAGED_TIME
668  anaUtils::ConfigureTreeBranch(fChain, "trP0DAvgTime", trP0DAvgTime, &b_trP0DAvgTime);
669 #endif
670 
671  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERDetector", trTRACKERDetector, &b_trTRACKERDetector);
672  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERNHits", trTRACKERNHits, &b_trTRACKERNHits);
673  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERNNodes", trTRACKERNNodes, &b_trTRACKERNNodes);
674  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERUniqueID", trTRACKERUniqueID, &b_trTRACKERUniqueID);
675  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERLength", trTRACKERLength, &b_trTRACKERLength);
676  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERDirectionStart", trTRACKERDirectionStart, &b_trTRACKERDirectionStart);
677  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERDirectionEnd", trTRACKERDirectionEnd, &b_trTRACKERDirectionEnd);
678  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERPositionStart", trTRACKERPositionStart, &b_trTRACKERPositionStart);
679  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERPositionEnd", trTRACKERPositionEnd, &b_trTRACKERPositionEnd);
680  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERCharge", trTRACKERCharge, &b_trTRACKERCharge);
681  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERMomentum", trTRACKERMomentum, &b_trTRACKERMomentum);
682  anaUtils::ConfigureTreeBranch(fChain, "trTRACKERMomentumEnd", trTRACKERMomentumEnd, &b_trTRACKERMomentumEnd);
683 
684  /// AnaLocalReconBunch information
685  if(_isUsingReconDirTECAL){
686  anaUtils::ConfigureTreeBranch(fChain, "tecalReconCounter", &tecalReconCounter, &b_tecalReconCounter );
687  anaUtils::ConfigureTreeBranch(fChain, "tecalReconAverageHitTime", tecalReconAverageHitTime, &b_tecalReconAverageHitTime );
688  anaUtils::ConfigureTreeBranch(fChain, "tecalReconAverageZPosition", tecalReconAverageZPosition, &b_tecalReconAverageZPosition );
689  anaUtils::ConfigureTreeBranch(fChain, "tecalReconContainment", tecalReconContainment, &b_tecalReconContainment );
690  anaUtils::ConfigureTreeBranch(fChain, "tecalReconEFitResult", tecalReconEFitResult, &b_tecalReconEFitResult );
691  anaUtils::ConfigureTreeBranch(fChain, "tecalReconEFitUncertainty", tecalReconEFitUncertainty, &b_tecalReconEFitUncertainty );
692  anaUtils::ConfigureTreeBranch(fChain, "tecalReconFirstLayer", tecalReconFirstLayer, &b_tecalReconFirstLayer );
693  anaUtils::ConfigureTreeBranch(fChain, "tecalReconIsShowerLike", tecalReconIsShowerLike, &b_tecalReconIsShowerLike );
694  anaUtils::ConfigureTreeBranch(fChain, "tecalReconIsTrackLike", tecalReconIsTrackLike, &b_tecalReconIsTrackLike );
695  anaUtils::ConfigureTreeBranch(fChain, "tecalReconLastLayer", tecalReconLastLayer, &b_tecalReconLastLayer );
696 #if VERSION_HAS_ECAL_LLR
697  anaUtils::ConfigureTreeBranch(fChain, "tecalReconLikeMIPEM", tecalReconLikeMIPEM, &b_tecalReconLikeMIPEM );
698  anaUtils::ConfigureTreeBranch(fChain, "tecalReconLikeMIPPion", tecalReconLikeMIPPion, &b_tecalReconLikeMIPPion );
699  anaUtils::ConfigureTreeBranch(fChain, "tecalReconLikeEMHIP", tecalReconLikeEMHIP, &b_tecalReconLikeEMHIP );
700  anaUtils::ConfigureTreeBranch(fChain, "tecalReconLikeMIPEMLow", tecalReconLikeMIPEMLow, &b_tecalReconLikeMIPEMLow );
701 #endif
702  anaUtils::ConfigureTreeBranch(fChain, "tecalReconMatchingLike", tecalReconMatchingLike, &b_tecalReconMatchingLike );
703  anaUtils::ConfigureTreeBranch(fChain, "tecalReconMichelTagNDelayedCluster",tecalReconMichelTagNDelayedCluster, &b_tecalReconMichelTagNDelayedCluster);
704  anaUtils::ConfigureTreeBranch(fChain, "tecalReconModule", tecalReconModule, &b_tecalReconModule );
705  anaUtils::ConfigureTreeBranch(fChain, "tecalReconMostDownStreamLayerHit", tecalReconMostDownStreamLayerHit, &b_tecalReconMostDownStreamLayerHit );
706  anaUtils::ConfigureTreeBranch(fChain, "tecalReconMostUpStreamLayerHit", tecalReconMostUpStreamLayerHit, &b_tecalReconMostUpStreamLayerHit );
707  anaUtils::ConfigureTreeBranch(fChain, "tecalReconNHits", tecalReconNHits, &b_tecalReconNHits );
708  anaUtils::ConfigureTreeBranch(fChain, "tecalReconNLayersHit", tecalReconNLayersHit, &b_tecalReconNLayersHit );
709  anaUtils::ConfigureTreeBranch(fChain, "tecalReconObjectLength", tecalReconObjectLength, &b_tecalReconObjectLength );
710  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDAMR", tecalReconPIDAMR, &b_tecalReconPIDAMR );
711  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDAngle", tecalReconPIDAngle, &b_tecalReconPIDAngle );
712  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDAsymmetry", tecalReconPIDAsymmetry, &b_tecalReconPIDAsymmetry );
713  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDCircularity", tecalReconPIDCircularity, &b_tecalReconPIDCircularity );
714  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDFBR", tecalReconPIDFBR, &b_tecalReconPIDFBR );
715  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDMaxRatio", tecalReconPIDMaxRatio, &b_tecalReconPIDMaxRatio );
716  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDMeanPos", tecalReconPIDMeanPos, &b_tecalReconPIDMeanPos );
717  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDShowerAngle", tecalReconPIDShowerAngle, &b_tecalReconPIDShowerAngle );
718  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDShowerWidth", tecalReconPIDShowerWidth, &b_tecalReconPIDShowerWidth );
719  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDTransverseChargeRatio",tecalReconPIDTransverseChargeRatio, &b_tecalReconPIDTransverseChargeRatio);
720  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPIDTruncatedMaxRatio", tecalReconPIDTruncatedMaxRatio, &b_tecalReconPIDTruncatedMaxRatio );
721  anaUtils::ConfigureTreeBranch(fChain, "tecalReconPointing", tecalReconPointing, &b_tecalReconPointing );
722  anaUtils::ConfigureTreeBranch(fChain, "tecalReconThrust", tecalReconThrust, &b_tecalReconThrust );
723  anaUtils::ConfigureTreeBranch(fChain, "tecalReconThrustAxis", tecalReconThrustAxis, &b_tecalReconThrustAxis );
724  anaUtils::ConfigureTreeBranch(fChain, "tecalReconThrustOrigin", tecalReconThrustOrigin, &b_tecalReconThrustOrigin );
725  anaUtils::ConfigureTreeBranch(fChain, "tecalReconTimeBunch", tecalReconTimeBunch, &b_tecalReconTimeBunch );
726  anaUtils::ConfigureTreeBranch(fChain, "tecalReconTotalHitCharge", tecalReconTotalHitCharge, &b_tecalReconTotalHitCharge );
727  anaUtils::ConfigureTreeBranch(fChain, "tecalReconTrueID", tecalReconTrueID, &b_tecalReconTrueID );
728  anaUtils::ConfigureTreeBranch(fChain, "tecalReconTrueIDPrimary", tecalReconTrueIDPrimary, &b_tecalReconTrueIDPrimary );
729  anaUtils::ConfigureTreeBranch(fChain, "tecalReconTrueIDRecursive", tecalReconTrueIDRecursive, &b_tecalReconTrueIDRecursive );
730  anaUtils::ConfigureTreeBranch(fChain, "tecalReconTrueIDSingle", tecalReconTrueIDSingle, &b_tecalReconTrueIDSingle );
731  anaUtils::ConfigureTreeBranch(fChain, "tecalReconUniqueID", tecalReconUniqueID, &b_tecalReconUniqueID );
732  anaUtils::ConfigureTreeBranch(fChain, "tecalReconBunch", tecalReconBunch, &b_tecalReconBunch );
733  }
734 }
RedoTreeConverter::DefineBranches
virtual void DefineBranches()
Define the branches to be read from the input tree.
Definition: RedoTreeConverter.cxx:587
FlatTreeConverter::tecalReconCounter
Int_t tecalReconCounter
AnaLocalReconBunch information.
Definition: FlatTreeConverter.hxx:226
InputConverter::fChain
TChain * fChain
The main TChain used to read events from the input file.
Definition: InputConverter.hxx:139

§ FillBunchInfo()

void FlatTreeConverter::FillBunchInfo ( std::vector< AnaTrueParticleB *> &  trueParticles,
AnaBunchB *  bunch 
)
virtual

Is there AnaLocalReconBunch information to be filled?

Reimplemented from RedoTreeConverter.

Definition at line 981 of file FlatTreeConverter.cxx.

981  {
982 //*****************************************************************************
983 
984  RedoTreeConverter::FillBunchInfo(trueParticles, bunchB);
985 
986  AnaBunch* bunch = static_cast<AnaBunch*>(bunchB);
987 
988  /// Is there AnaLocalReconBunch information to be filled?
989  if(_isUsingReconDirTECAL){
990  for (int i=0; i<tecalReconCounter; i++){
991  AnaTECALReconObject* anaTECAL = static_cast<AnaTECALReconObject*>(MakeTECALReconObject());
992  FillTECALReconObjectInfo(i,anaTECAL,bunch);
993  static_cast<AnaLocalReconBunch*>(bunchB)->TECALReconObjects.push_back(anaTECAL);
994  }
995  }
996 }
AnaTECALReconObject
This Ana* object is used to flatten TECALReconObjects from ReconDir/TrackerECal.
Definition: DataClasses.hxx:942
FlatTreeConverter::tecalReconCounter
Int_t tecalReconCounter
AnaLocalReconBunch information.
Definition: FlatTreeConverter.hxx:226

§ GetSpill()

Int_t FlatTreeConverter::GetSpill ( Long64_t &  entry,
AnaSpillC *&  spill 
)
virtual

Read the specified entry from the file, and fill the spill. The entry number must be incremented as part of this function, and the new entry number returned. 0 should be returned on error.

Implements InputConverter.

Definition at line 801 of file FlatTreeConverter.cxx.

801  {
802 //*****************************************************************************
803 
804  // Read contents of entry.
805  if (!fChain) return 0;
806 
807  // Create an instance of AnaSpill
808  spill = MakeSpill();
809 
810  // get a new entry from the flat tree. entry_temp >0 when succesfull
811  Int_t entry_temp = flattree->GetEntry(entry);
812 
813  // If this is not one of the events to skim just go to the next entry (and don't process that event --> return <=0)
814  if (!anaUtils::CheckSkimmedEvent(sRun,sSubrun,sEvt)){
815  entry++;
816  return 0;
817  }
818 
819  if (_readRooTrackerVtx){
820  // sEvt should be positive since sEvt=-999 is used for the last flatree entry
821  if (entry_temp>0 && sIsMC && (fGenie || fNeut) && sEvt>=0) {
822  // Loop over RooTrackerVtx entries until we get the same run, subrun and event numbers
823  // In general we will get the right entry in the first iteration, but just in case
824  do{
825  if (NRooTrackerVTX) NRooTrackerVTX->GetEntry(_entry_roo);
826  else if (GRooTrackerVTX) GRooTrackerVTX->GetEntry(_entry_roo);
827  if ((RunID> sRun ) ||
828  (RunID==sRun && SubrunID> sSubrun ) ||
829  (RunID==sRun && SubrunID==sSubrun && EventID>sEvt )){
830  _entry_roo--;
831  _RooVtxEntryInCurrentInputFile--;
832  }
833  else{
834  _entry_roo++;
835  _RooVtxEntryInCurrentInputFile++;
836  }
837  }while(EventID!=sEvt || RunID!=sRun || SubrunID!=sSubrun);
838  }
839  }
840 
841 
842 
843  // Print the current file
844  TString filename(flattree->GetFile()->GetName());
845  if( filename != _currentFileName ) {
846  _RooVtxEntryInCurrentInputFile=0;
847  _currentFileIndex++;
848  std::cout << " Running on file (" << _currentFileIndex << " ): " << filename << std::endl;
849  _currentFileName = filename;
850  }
851 
852  // Caset the spill
853  _spill = static_cast<AnaSpillB*>(spill);
854  // _spill = spill;
855 
856  int evt_prev=sEvt;
857 
858  // This is needed to make sure that we read the first bunch of the spill when skiping entries
859  if (_firstEntry){
860  _firstEntry=false;
861  Long64_t requested_first_entry = entry;
862  while (sEvt==evt_prev && entry>0){
863  entry--;
864  entry_temp = flattree->GetEntry(entry);
865  }
866  if (sEvt!=evt_prev){
867  entry++;
868  entry_temp = flattree->GetEntry(entry);
869  }
870 
871  // Fill the general spill info
872  FillInfo(_spill);
873 
874  entry = requested_first_entry;
875  entry_temp = flattree->GetEntry(entry);
876  }
877  else{
878  // Fill the general spill info
879  FillInfo(_spill);
880  }
881 
882  // Fill tracks->vertices and vertices->tracks with null pointers for tracks and vertices that are not in this bunch
883  // FillNotInBunchObjWithNullPointers(_spill);
884 
885  // Always make the out of bunch
886  if (_isUsingReconDirTECAL || _isUsingReconDirPECAL || _isUsingReconDirFGDOnly || _isUsingReconDirP0D)
887  _spill->OutOfBunch = MakeLocalReconBunch();
888  else
889  _spill->OutOfBunch = MakeBunch();
890 
891  evt_prev = sEvt;
892 
893  while (sEvt==evt_prev && entry < _nentries){
894  // Create and fill a new bunch
895 
896  // First the Out of bunch stuff
897  if (Bunch==-1) {
898  FillBunchInfo(_spill->TrueParticles, _spill->OutOfBunch);
899  // Fill tracks->vertices and vertices->tracks with null pointers for tracks and vertices that are not in this bunch
900  // FillNotInBunchObjWithNullPointers(spill->OutOfBunch);
901  } else if (Bunch>-1){ // Bunch=-999 when the entry in the FlatTree is just for the Spill info,
902  // because there are no reconstructed tracks. We should skip this. Actual bunches are numbered: 0-7
903 
904  AnaBunch* bunch = NULL;
905  if (_isUsingReconDirTECAL || _isUsingReconDirPECAL || _isUsingReconDirFGDOnly || _isUsingReconDirP0D)
906  bunch = static_cast<AnaLocalReconBunch*>(MakeLocalReconBunch());
907  else
908  bunch = static_cast<AnaBunch*> (MakeBunch ());
909 
910  _spill->Bunches.push_back(bunch);
911  FillBunchInfo(_spill->TrueParticles, bunch);
912 
913  // Fill tracks->vertices and vertices->tracks with null pointers for tracks and vertices that are not in this bunch
914  // FillNotInBunchObjWithNullPointers(bunch);
915  }
916 
917  // Check that null pointers are still filled properly
918  // CheckNotInBunchObjWithNullPointers(_spill);
919 
920  // increment the entry number
921  entry++;
922 
923  // break if we have reach the maximum entry number
924  if (entry>=_nentries) break;
925 
926  // save the previous event number
927  evt_prev=sEvt;
928 
929  // get a new entry from the input tree
930  entry_temp = flattree->GetEntry(entry);
931  }
932 
933  return entry_temp;
934 }
InputConverter::_nentries
int _nentries
The number of entries in the chain. To be set by the implementation.
Definition: InputConverter.hxx:136
AnaSpillC::Bunches
std::vector< AnaBunchC * > Bunches
The reconstructed objects, split into timing bunches.
Definition: CoreDataClasses.hxx:222
FlatTreeConverter::_isUsingReconDirFGDOnly
bool _isUsingReconDirFGDOnly
Store whether AnaLocalReconBunch information is enabled in the parameters file.
Definition: FlatTreeConverter.hxx:128
AnaSpillB::OutOfBunch
AnaBunchB * OutOfBunch
Reconstructed objects that didn&#39;t fit into one of the timing bunches.
Definition: BaseDataClasses.hxx:1045
AnaSpillB::TrueParticles
std::vector< AnaTrueParticleB * > TrueParticles
The true MC particles used in this spill.
Definition: BaseDataClasses.hxx:1042
InputConverter::fChain
TChain * fChain
The main TChain used to read events from the input file.
Definition: InputConverter.hxx:139
FlatTreeConverter::FillBunchInfo
virtual void FillBunchInfo(std::vector< AnaTrueParticleB *> &trueParticles, AnaBunchB *bunch)
Definition: FlatTreeConverter.cxx:981

§ Initialize()

bool FlatTreeConverter::Initialize ( )
virtual

Any initialization that must be done. Called before the input file is read.

Is AnaLocalReconBunch information enabled in the parameters file?

Reimplemented from RedoTreeConverter.

Definition at line 355 of file FlatTreeConverter.cxx.

355  {
356 //********************************************************************
357 
358  // Use corrected values or raw values
359  _useCorrectedValues = ND::params().GetParameterI("highlandIO.ReadFlatTree.UseCorrectedValues");
360 
361  /// Is AnaLocalReconBunch information enabled in the parameters file?
362  _isUsingReconDirFGDOnly = ND::params().GetParameterI("highlandIO.FlatTree.UseReconDirFGDOnly" );
363  _isUsingReconDirP0D = ND::params().GetParameterI("highlandIO.FlatTree.UseReconDirP0D" );
364  _isUsingReconDirPECAL = ND::params().GetParameterI("highlandIO.FlatTree.UseReconDirP0DECal" );
365  _isUsingReconDirTECAL = ND::params().GetParameterI("highlandIO.FlatTree.UseReconDirTrackerECal");
366 
367 
368  return RedoTreeConverter::Initialize();
369 }
Parameters::GetParameterI
int GetParameterI(std::string)
Get parameter. Value is returned as integer.
Definition: Parameters.cxx:217
RedoTreeConverter::Initialize
virtual bool Initialize()
Definition: RedoTreeConverter.cxx:571
FlatTreeConverter::_isUsingReconDirFGDOnly
bool _isUsingReconDirFGDOnly
Store whether AnaLocalReconBunch information is enabled in the parameters file.
Definition: FlatTreeConverter.hxx:128
The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.13