HighLAND
Public Types | Public Member Functions | Protected Attributes | List of all members
numuCCMultiPiAnalysis Class Reference
Inheritance diagram for numuCCMultiPiAnalysis:
baseTrackerAnalysis baseAnalysis AnalysisAlgorithm

Public Types

enum  enumStandardMicroTrees_numuMultiPiAnalysis {
  HM_pos = numuCCAnalysis::enumStandardMicroTreesLast_numuCCAnalysis + 1, MuonVertexId, MuonIndex, NNegPion,
  NegPionMom, NegPionPidLik, NegPionElPidLik, NegPionTId,
  NegPionIndex, NegPionParentTId, NegPionGParentTId, NegPionVId,
  NegPionDir, NegPionPosStart, NegPionPosEnd, NPosPion,
  PosPionMom, PosPionTheta, PosPionPidLik, PosPionElPidLik,
  PosPionTId, PosPionIndex, PosPionParentTId, PosPionGParentTId,
  PosPionVId, PosPionDir, PosPionPosStart, PosPionPosEnd,
  NPi0El, Pi0ElMom, Pi0ElPull, Pi0ElTId,
  Pi0ElIndex, Pi0ElParentTId, Pi0ElGParentTId, Pi0ElVId,
  Pi0ElDir, Pi0ElPosStart, Pi0ElPosEnd, NPi0Pos,
  Pi0PosMom, Pi0PosPull, Pi0PosTId, Pi0PosIndex,
  Pi0PosParentTId, Pi0PosGParentTId, Pi0PosVId, Pi0PosDir,
  Pi0PosPosStart, Pi0PosPosEnd, NTPCSec, TPCSecMom,
  TPCSecPiPidLik, TPCSecMuPidLik, TPCSecPrPidLik, TPCSecElPidLik,
  TPCSecDetectors, TPCSecQ, TPCSecTId, TPCSecIndex,
  TPCSecParentTId, TPCSecGParentTId, TPCSecDir, TPCSecPosStart,
  TPCSecPosEnd, NFGDPi, FGDPiLength, FGDPiPiPull,
  FGDPiAvgTime, FGDPiDistance, FGDPiMuonangle, FGDPiCosTheta,
  FGDPiTId, FGDPiIndex, FGDPiParentTId, FGDPiGParentTId,
  FGDPiVId, FGDPiDir, FGDPiPosStart, FGDPiPosEnd,
  FGDPiTimeIni, FGDPiTimeEnd, FGDPiDeltaTimeIniSelMu, FGDPiDeltaTimeEndSelMu,
  NFGDEl, FGDElLength, FGDElPiPull, FGDElAvgTime,
  FGDElDistance, FGDElMuonangle, FGDElCosTheta, FGDElTId,
  FGDElIndex, FGDElParentTId, FGDElGParentTId, FGDElVId,
  FGDElDir, FGDElPosStart, FGDElPosEnd, FGDElTimeIni,
  FGDElTimeEnd, FGDElDeltaTimeIniSelMu, FGDElDeltaTimeEndSelMu, NFGDSec,
  FGDSecLength, FGDSecPiPull, FGDSecContained, FGDSecAvgTime,
  FGDSecCosTheta, FGDSecTId, FGDSecIndex, FGDSecParentTId,
  FGDSecGParentTId, FGDSecDir, FGDSecPosStart, FGDSecPosEnd,
  FGDSecTimeIni, FGDSecTimeEnd, FGDSecDeltaTimeIniSelMu, FGDSecDeltaTimeEndSelMu,
  NME, MENHits, MERawCharge, MEMinTime,
  MEMaxTime, NTPC1Track, TPC1TrackMom, TPC1TrackCosTheta,
  TPC1TrackPhi, TPC1TrackVId, TPC1TrackTId, TPC1TrackParentTId,
  TPC1TrackGParentTId, TPC1TrackPosStart, TPC1TrackPosEnd, IntType,
  NInts, PionType, PionMom, NPions,
  truepi_mom, truepi_dir, truepi_costheta, enumStandardMicroTreesLast_numuCCMultiPiAnalysis
}
 
- Public Types inherited from baseTrackerAnalysis
enum  enumStandardMicroTrees_baseTrackerAnalysis {
  ntpctracks = enumStandardMicroTreesLast_baseAnalysis+1, ntpcposQualityFV, ntpcnegQualityFV, nfgdtracks,
  nfgdonlytracks, chargeid_ncorrect, chargeid_nwrong, tpcfgdmatch_ncorrect,
  tpcfgdmatch_nwrong, tpctr_ncorrect, tpctr_nwrong, fgdtr_ncorrect,
  fgdtr_nwrong, fgdhybtr_ncorrect, fgdhybtr_nwrong, meeff_ncorrect,
  meeff_nwrong, mepur_ncorrect, mepur_nwrong, tpc_ecal_match_ncorrect,
  tpc_ecal_match_nwrong, tpc_p0d_match_ncorrect, tpc_p0d_match_nwrong, fgd_ecal_match_ncorrect,
  fgd_ecal_match_nwrong, fgd_ecal_smrd_match_ncorrect, fgd_ecal_smrd_match_nwrong, ecal_pid_ncorrect,
  ecal_pid_nwrong, ecal_tr_ncorrect, ecal_tr_nwrong, ecal_emhippid_ncorrect,
  ecal_emhippid_nwrong, fgd2shower_ncorrect, fgd2shower_nwrong, enumStandardMicroTreesLast_baseTrackerAnalysis
}
 
enum  enumConf_baseTrackerAnalysis {
  bfield_syst =baseAnalysis::enumConfLast_baseAnalysis+1, momscale_syst, momresol_syst, momrange_resol_syst,
  tpcpid_syst, fgdpid_syst, chargeideff_syst, tpctrackeff_syst,
  fgdtrackeff_syst, fgdhybridtrackeff_syst, tpcfgdmatcheff_syst, tpcclustereff_syst,
  michel_syst, oofv_syst, pileup_syst, fgdmass_syst,
  sandmu_syst, ecal_emresol_syst, ecal_emscale_syst, tpc_ecal_matcheff_syst,
  tpc_p0d_matcheff_syst, fgd_ecal_matcheff_syst, fgd_ecal_smrd_matcheff_syst, ecal_trackeff_syst,
  ecal_pid_syst, tof_resol_syst, ecal_emhippid_syst, fgd2shower_syst,
  nuetpcpileup_syst, nuep0dpileup_syst, nueecalpileup_syst, nueoofv_syst,
  p0d_elossscale_syst, p0d_elossresol_syst, p0d_veto_syst, enumConfLast_baseTrackerAnalysis
}
 
- Public Types inherited from baseAnalysis
enum  enumStandardMicroTrees_baseAnalysis {
  run = enumStandardMicroTreesLast_AnalysisAlgorithm+1, subrun, evt, evt_time,
  bunch, NWEIGHTS, weight, TruthVertexID,
  TruthVertexNB, RooVtxIndex, RooVtxEntry, RooVtxEntry2,
  RooVtxFile, nu_pdg, nu_trueE, nu_truereac,
  nu_truedir, truelepton_mom, truelepton_costheta, truelepton_dir,
  truevtx_pos, selvtx_det, selvtx_pos, selvtx_truepos,
  true_signal, weight_syst_total_noflux, enumStandardMicroTreesLast_baseAnalysis
}
 
enum  enumConf_baseAnalysis {
  sipion_syst =ConfigurationManager::enumConfLast_ConfigurationManager+1, siproton_syst, nuflux_syst, antinuflux_syst,
  all_syst, zero_var, enumConfLast_baseAnalysis
}
 
- Public Types inherited from AnalysisAlgorithm
enum  enumAnalysisPoint {
  kInitialize =0, kDefineProductions, kDefineInputConverters, kDefineSelections,
  kDefineCorrections, kDefineSystematics, kDefineConfigurations, kDefineMicroTrees,
  kDefineTruthTree, kFillConfigTree, kInitializeSpill, kInitializeBunch,
  kInitializeConfiguration, kInitializeToy, kInitializeSelection, kFinalizeSelection,
  kFinalizeToy, kFillToyVarsInMicroTrees, kFinalizeConfiguration, kFillCategories,
  kFillMicroTrees, kFinalizeBunch, kFillTruthTree, kFinalizeSpill,
  kFinalize
}
 
enum  enumStandardMicroTrees_AnalysisAlgorithm {
  firstCategory = OutputManager::enumStandardMicroTreesLast_OutputManager+1, firstCategoryCounter = firstCategory+NMAXCATEG, entry = firstCategoryCounter + NMAXCATEGCOUNTERS, toy_ref,
  toy_index, toy_par_weight, toy_par_var, NWEIGHTSYST,
  weight_syst, weight_syst_total, weight_corr, weight_corr_total,
  redo, accum_level, first_cut, last_cut =first_cut+NMAXSTEPS,
  enumStandardMicroTreesLast_AnalysisAlgorithm
}
 
enum  enumConfigTree_AnalysisAlgorithm {
  SoftwareVersion =0, HOSTNAME, CMTPATH, INPUTFILE,
  OriginalFile, MinAccumLevelToSave, enumConfigTreeLast_AnalysisAlgorithm
}
 

Public Member Functions

 numuCCMultiPiAnalysis (AnalysisAlgorithm *ana=NULL)
 
void DefineSelections ()
 
void DefineCorrections ()
 
void DefineMicroTrees (bool addBase=false)
 
void DefineTruthTree ()
 
void FillCategories ()
 
void FillMicroTrees (bool addBase=false)
 
void FillToyVarsInMicroTrees (bool addBase=false)
 
bool CheckFillTruthTree (const AnaTrueVertex &vtx)
 
void FillTruthTree (const AnaTrueVertex &vtx)
 
bool Initialize ()
 [AnalysisAlgorithm_mandatory]
 
const ToyBoxCCMultiPi & mybox ()
 
Int_t FindTPCTracks (const ToyBoxB &box, SubDetId::SubDetEnum det, AnaTrackB **TPCtracks)
 
- Public Member Functions inherited from baseTrackerAnalysis
 baseTrackerAnalysis (AnalysisAlgorithm *ana=NULL)
 
virtual void DefineSystematics ()
 
virtual void DefineConfigurations ()
 
virtual void FillTruthTreeBase (const AnaTrueVertex &vtx, const SubDetId::SubDetEnum det=SubDetId::kFGD1, bool IsAntinu=false)
 
virtual const ToyBoxTracker & box (Int_t isel=-1) const
 Returns the ToyBoxTracker.
 
virtual AnaVertexB * GetVertex () const
 Returns the vertex for the ToyBoxTracker.
 
virtual AnaTrueVertexB * GetTrueVertex () const
 Returns the true vertex for the ToyBoxTracker.
 
- Public Member Functions inherited from baseAnalysis
 baseAnalysis (AnalysisAlgorithm *ana=NULL)
 
virtual bool InitializeSpill ()
 
virtual bool FinalizeConfiguration ()
 
virtual void DefineProductions ()
 
virtual void DefineInputConverters ()
 
void FillMicroTreesBase (bool addBase=true)
 
void FillToyVarsInMicroTreesBase (bool addBase=true)
 
void FillTruthTree ()
 
void FillTruthTreeBase (const AnaTrueVertex &vtx, const SubDetId::SubDetEnum det=SubDetId::kFGD1, bool IsAntinu=false)
 
AnaSpill & GetSpill ()
 Get a casted AnaSpillC to AnaSpill from the InputManager.
 
AnaBunch & GetBunch ()
 Get a casted AnaBunchBB to AnaBunch from the InputManager (TODO the protection)
 
AnaEvent & GetEvent ()
 Get a casted AnaEventC to AnaEvent.
 
virtual AnaEventC * MakeEvent ()
 Create the appropriate event time from an Spill and a Bunch in that spill.
 
void SetSaveRooTracker (bool save)
 Set whether to save the RooTrackerVtx tree or not.
 
void SetRooVtxManager (RooTrackerVtxManager *man)
 Set the RooTrackerVtxManager.
 
- Public Member Functions inherited from AnalysisAlgorithm
 AnalysisAlgorithm (AnalysisAlgorithm *ana=NULL)
 
virtual void Finalize ()
 [AnalysisAlgorithm_optional]
 
virtual void FinalizeSpill ()
 
virtual void InitializeBunch ()
 
virtual void FinalizeBunch ()
 
virtual void InitializeConfiguration ()
 
virtual void InitializeToy ()
 
virtual void FinalizeToy ()
 
virtual void InitializeSelection (const SelectionBase &)
 
virtual void FinalizeSelection (const SelectionBase &)
 
virtual void FillConfigTree ()
 
void FinalizeToyBase ()
 [AnalysisAlgorithm_mandatory] More...
 
void SetFillSuccessOnly (bool fill)
 Fill trees and process weight systematics only when any of the branches is successful.
 
bool GetFillSuccessOnly ()
 
void SetInitializeTrees (bool ini)
 Initialize trees at the beginning of each configuration.
 
bool GetInitializeTrees ()
 
void SetMinAccumCutLevelToSave (Int_t level)
 Set the minimum accumulated cut level to save an event into the micro-tree.
 
Int_t GetMinAccumCutLevelToSave ()
 Get the minimum accumulated cut level to save an event into the micro-tree.
 
bool CheckAccumLevelToSave ()
 Check if the condition is fulfilled for at least one branch.
 
void SetEvent (AnaEventC *event)
 Set the current event into the algorithm and all used algorithms.
 
void SetToyBox (const ToyBoxB *box, Int_t isel=0)
 Set the current box into the algorithm and all used algorithms. This is useful when one Analysis uses another.
 
void UseAnalysis (AnalysisAlgorithm *ana)
 Used a given analysis.
 
void SetSelectedSelection (Int_t sel)
 Select one of the selections.
 
void SetVersionCheck (bool check)
 Set version checking.
 
void SetAnalysisPoint (enumAnalysisPoint point)
 Set the point of the analysis at which AnalysisLoop is.
 
HighlandInputManager & input ()
 
SelectionManager & sel ()
 
CorrectionManager & corr ()
 
SystematicManager & syst ()
 
EventWeightManager & eweight ()
 
EventVariationManager & evar ()
 
OutputManager & output ()
 
ConfigurationManager & conf ()
 
CategoryManager & cat ()
 
DocStringManager & doc ()
 
virtual const ToyBoxB & boxB (Int_t isel=-1) const
 

Protected Attributes

numuCCAnalysis * _numuCCAnalysis
 
- Protected Attributes inherited from baseTrackerAnalysis
bool _computeEfficiency
 Compute analysis sample efficiency.
 
ChargeIDEffSystematics * _chargeid
 
TPCFGDMatchEffSystematics * _tpcfgdmatch
 
TPCTrackEffSystematics * _tpctr
 
FGDTrackEffSystematics * _fgdtr
 
FGDHybridTrackEffSystematics * _fgdhybtr
 
MichelElectronEffSystematics * _me
 
TPCECalMatchEffSystematics * _tpc_ecal_matcheff
 
TPCP0DMatchEffSystematics * _tpc_p0d_matcheff
 
FGDECalMatchEffSystematics * _fgd_ecal_matcheff
 
FGDECalSMRDMatchEffSystematics * _fgd_ecal_smrd_matcheff
 
ECalTrackEffSystematics * _ecal_trackeff
 
ECalPIDSystematics * _ecal_pid
 
ECalEmHipPIDSystematics * _ecal_emhippid
 
FGD2ShowerSystematics * _fgd2shower
 
- Protected Attributes inherited from baseAnalysis
RooTrackerVtxManager * _rooVtxManager
 the manager of the RooTrackerVtx
 
bool _saveRooTrackerVtxTree
 Save RooTracker tree in output file.
 
FluxWeighting * _flux
 Access to the flux weighting.
 
bool _applyFluxWeight
 Flag to enable/disable flux weight.
 
std::string _fluxFile
 Flux file and option.
 
std::string _fluxTuning
 
bool _enableSingleVariationSystConf
 
bool _enableSingleWeightSystConf
 
bool _enableAllSystConfig
 
bool _enableZeroVarConfig
 
Int_t _ntoys
 
Int_t _randomSeed
 
- Protected Attributes inherited from AnalysisAlgorithm
HighlandInputManager * _inputManager
 Input Manager: access to the current Event.
 
CorrectionManager * _corrManager
 Correction Manager.
 
SystematicManager * _systManager
 Systematics Manager.
 
EventWeightManager * _weightManager
 EventWeight Manager.
 
EventVariationManager * _variationManager
 EventVariation Manager.
 
OutputManager * _outputManager
 Output Manager.
 
ConfigurationManager * _confManager
 Configuration Manager.
 
SelectionManager * _selManager
 
CategoryManager * _categManager
 
DocStringManager * _docManager
 
const ToyBoxB * _box [NMAXSELECTIONS]
 The analysis box.
 
Int_t _min_accum_cut_level
 the minimum accumulated cut level to save an event into the micro-tree
 
bool _fillSuccessOnly
 Fill trees and process weight systematics only when any of the branches is succesful.
 
bool _initializeTrees
 Initialize trees at the beginning of each configuration.
 
AnaEventC * _event
 The current event.
 
std::vector< AnalysisAlgorithm * > _usedAnalyses
 The Vector of used analysis.
 
Int_t _selectedSelection
 The selected selection.
 
bool _setMethodCalled
 Boolean parameter to know whether nny of the methods that sets things into used analysis has been called.
 
bool _versionCheck
 
enumAnalysisPoint _analysisPoint
 

Additional Inherited Members

- Protected Member Functions inherited from baseAnalysis
void AddZeroVarConfiguration ()
 

Detailed Description

Definition at line 9 of file numuCCMultiPiAnalysis.hxx.

Member Function Documentation

§ FillMicroTrees()

void numuCCMultiPiAnalysis::FillMicroTrees ( bool  addBase = false)
virtual

checking times

checking times

Reimplemented from baseTrackerAnalysis.

Definition at line 256 of file numuCCMultiPiAnalysis.cxx.

256  {
257 //********************************************************************
258 
259  // Variables from the numuCCAnalysis analysis (including the ones in baseTrackerAnalysis by default, otherwise addBase should be false)
260  if (addBase) _numuCCAnalysis->FillMicroTrees(addBase);
261 
262  if (mybox().HMNtrack ) {
263  if( mybox().HMNtrack->TrueObject ){
264  output().FillVar(MuonIndex,mybox().HMNtrack->TrueObject->ID);
265  if( mybox().HMNtrack->GetTrueParticle()->TrueVertex )
266  output().FillVar(MuonVertexId,static_cast<AnaTrueVertex*>(mybox().HMNtrack->GetTrueParticle()->TrueVertex)->RooVtxIndex);
267  }
268  }
269 
270  // --- Fill here more variables for the CCMultiPi analysis -----
271  // Selected negative pions
272  for( Int_t i = 0; i < mybox().nNegativePionTPCtracks; i++ ){
273  AnaTrackB *track = mybox().NegativePionTPCtracks[i];
274  Float_t ellklh = (anaUtils::GetPIDLikelihood(*track,0)+anaUtils::GetPIDLikelihood(*track,3))/(1.-anaUtils::GetPIDLikelihood(*track,2));
275  output().FillVectorVar(NegPionMom, track->Momentum);
276  output().FillVectorVar(NegPionPidLik, anaUtils::GetPIDLikelihood(*track,3));
277  output().FillVectorVar(NegPionPidLik, ellklh);
278  if( track->TrueObject ){
279  output().FillVectorVar(NegPionTId, track->GetTrueParticle()->PDG);
280  output().FillVectorVar(NegPionIndex,track->GetTrueParticle()->ID);
281  output().FillVectorVar(NegPionParentTId, track->GetTrueParticle()->ParentPDG);
282  output().FillVectorVar(NegPionGParentTId,track->GetTrueParticle()->GParentPDG);
283  if( track->GetTrueParticle()->TrueVertex )
284  output().FillVectorVar(NegPionVId,static_cast<AnaTrueVertex*>(track->GetTrueParticle()->TrueVertex)->RooVtxIndex);
285  }
286  output().FillMatrixVarFromArray(NegPionPosStart, track->PositionStart, 3);
287  output().FillMatrixVarFromArray(NegPionPosEnd, track->PositionEnd,3);
288  output().FillMatrixVarFromArray(NegPionDir, track->DirectionStart,3);
289  output().IncrementCounter(NNegPion);
290  }
291 
292  // Selected positive pions
293  for( Int_t i = 0; i <mybox().nPositivePionTPCtracks; i++ ){
294  AnaTrackB *track = mybox().PositivePionTPCtracks[i];
295  Float_t ellklh = (anaUtils::GetPIDLikelihood(*track,0)+anaUtils::GetPIDLikelihood(*track,3))/(1.-anaUtils::GetPIDLikelihood(*track,2));
296  // output().FillVectorVar(PosPionMom, track->Momentum); Filled in FillToyVarsInMicroTree
297  output().FillVectorVar(PosPionPidLik, anaUtils::GetPIDLikelihood(*track,3));
298  output().FillVectorVar(PosPionPidLik, ellklh);
299 
300  if( track->TrueObject ){
301  output().FillVectorVar(PosPionTId, track->GetTrueParticle()->PDG);
302  output().FillVectorVar(PosPionIndex,track->GetTrueParticle()->ID);
303  output().FillVectorVar(PosPionParentTId, track->GetTrueParticle()->ParentPDG);
304  output().FillVectorVar(PosPionGParentTId,track->GetTrueParticle()->GParentPDG);
305  if( track->GetTrueParticle()->TrueVertex ) {
306  AnaTrueVertex *vtx = static_cast<AnaTrueVertex*>(track->GetTrueParticle()->TrueVertex);
307  output().FillVectorVar(PosPionVId,vtx->RooVtxIndex);
308  if (vtx->PionMom > 0) {
309  // variables for primary pion were filled previously by oaAnalysisTreeConverter
310  output().FillVar(truepi_mom, vtx->PionMom);
311  output().FillVar(truepi_costheta, (Float_t)cos(anaUtils::ArrayToTVector3(vtx->PionDir).Angle(anaUtils::ArrayToTVector3(vtx->NuDir))));
312  output().FillVectorVarFromArray(truepi_dir, vtx->PionDir, 3);
313  } else if (vtx->NPrimaryParticles[ParticleId::kPiPos] > 0) {
314  // variables not filled previously, look for pion in AnaTrueVertex
315  AnaTrueParticleB* trk = NULL;
316  for (int it=0; it<vtx->nTrueParticles; it++) {
317  trk = vtx->TrueParticles[it];
318  if (!trk) continue;
319  if (trk->PDG == 211) {
320  output().FillVar(truepi_mom, trk->Momentum);
321  output().FillVar(truepi_costheta, (Float_t)cos(anaUtils::ArrayToTVector3(trk->Direction).Angle(anaUtils::ArrayToTVector3(vtx->NuDir))));
322  output().FillVectorVarFromArray(truepi_dir, trk->Direction, 3);
323  break;
324  }
325  }
326  }
327  }
328 
329  }
330 
331  output().FillMatrixVarFromArray(PosPionPosStart, track->PositionStart, 3);
332  output().FillMatrixVarFromArray(PosPionPosEnd, track->PositionEnd,3);
333  output().FillMatrixVarFromArray(PosPionDir, track->DirectionStart,3); // Use PosPionTheta to access the angle, it is fille in FillToyVarsInMicroTree
334  output().IncrementCounter(NPosPion);
335  }
336 
337  // Selected pi0 electron tracks
338  for( Int_t i = 0; i < mybox().nElPi0TPCtracks; i++ ) {
339  AnaTrackB *track = mybox().ElPi0TPCtracks[i];
340  output().FillVectorVar(Pi0ElMom, track->Momentum);
341  output().FillVectorVar(Pi0ElPull, anaUtils::GetPIDLikelihood(*track,1));
342  if( track->GetTrueParticle() ){
343  output().FillVectorVar(Pi0ElTId, track->GetTrueParticle()->PDG);
344  output().FillVectorVar(Pi0ElIndex, track->GetTrueParticle()->ID);
345  output().FillVectorVar(Pi0ElParentTId, track->GetTrueParticle()->ParentPDG);
346  output().FillVectorVar(Pi0ElGParentTId,track->GetTrueParticle()->GParentPDG);
347  if( track->GetTrueParticle()->TrueVertex )
348  output().FillVectorVar(Pi0ElVId,static_cast<AnaTrueVertex*>(track->GetTrueParticle()->TrueVertex)->RooVtxIndex);
349  }
350 
351  output().FillMatrixVarFromArray(Pi0ElPosStart, track->PositionStart, 3);
352  output().FillMatrixVarFromArray(Pi0ElPosEnd, track->PositionEnd, 3);
353  output().FillMatrixVarFromArray(Pi0ElDir, track->DirectionStart,3);
354  output().IncrementCounter(NPi0El);
355  }
356 
357  // Selected pi0 positron tracks
358  for( Int_t i = 0; i < mybox().nPosPi0TPCtracks; i++ ) {
359  AnaTrackB *track = mybox().PosPi0TPCtracks[i];
360  output().FillVectorVar(Pi0PosMom, track->Momentum);
361  output().FillVectorVar(Pi0PosPull, anaUtils::GetPIDLikelihood(*track,1));
362  if( track->GetTrueParticle() ){
363  output().FillVectorVar(Pi0PosTId, track->GetTrueParticle()->PDG);
364  output().FillVectorVar(Pi0PosIndex, track->GetTrueParticle()->ID);
365  output().FillVectorVar(Pi0PosParentTId, track->GetTrueParticle()->ParentPDG);
366  output().FillVectorVar(Pi0PosGParentTId,track->GetTrueParticle()->GParentPDG);
367  if( track->GetTrueParticle()->TrueVertex )
368  output().FillVectorVar(Pi0PosVId,static_cast<AnaTrueVertex*>(track->GetTrueParticle()->TrueVertex)->RooVtxIndex);
369  }
370 
371  output().FillMatrixVarFromArray(Pi0PosPosStart, track->PositionStart, 3);
372  output().FillMatrixVarFromArray(Pi0PosPosEnd, track->PositionEnd, 3);
373  output().FillMatrixVarFromArray(Pi0PosDir, track->DirectionStart,3);
374  output().IncrementCounter(NPi0Pos);
375  }
376 
377 
378  // All TPC secondary tracks
379  for( Int_t i = 0; i < mybox().nPositiveTPCtracks; i++ ) {
380  AnaTrackB *track = mybox().PositiveTPCtracks[i];
381 
382  if( mybox().HMNtrack == track ) continue; // This is the muon
383 
384  output().FillVectorVar(TPCSecMom, track->Momentum);
385  output().FillVectorVar(TPCSecPiPidLik, anaUtils::GetPIDLikelihood(*track,3));
386  output().FillVectorVar(TPCSecMuPidLik, anaUtils::GetPIDLikelihood(*track,0));
387  output().FillVectorVar(TPCSecElPidLik, anaUtils::GetPIDLikelihood(*track,1));
388  output().FillVectorVar(TPCSecPrPidLik, anaUtils::GetPIDLikelihood(*track,2));
389  output().FillMatrixVarFromArray(TPCSecPosStart, track->PositionStart,3);
390  output().FillMatrixVarFromArray(TPCSecPosEnd, track->PositionEnd,3);
391  output().FillMatrixVarFromArray(TPCSecDir, track->DirectionStart,3);
392  output().FillVectorVar(TPCSecQ,1);
393  if( track->GetTrueParticle() ){
394  output().FillVectorVar(TPCSecTId, track->GetTrueParticle()->PDG);
395  output().FillVectorVar(TPCSecIndex, track->GetTrueParticle()->ID);
396  output().FillVectorVar(TPCSecParentTId, track->GetTrueParticle()->ParentPDG);
397  output().FillVectorVar(TPCSecGParentTId,track->GetTrueParticle()->GParentPDG);
398  }
399 
400  output().IncrementCounter(NTPCSec);
401  }
402 
403 
404  for( Int_t i = 0; i < mybox().nNegativeTPCtracks; i++ ) {
405  AnaTrackB *track = mybox().NegativeTPCtracks[i];
406  if( mybox().HMNtrack == track ) continue; // This is the muon
407 
408  output().FillVectorVar(TPCSecMom, track->Momentum);
409  output().FillVectorVar(TPCSecPiPidLik, anaUtils::GetPIDLikelihood(*track,3));
410  output().FillVectorVar(TPCSecMuPidLik, anaUtils::GetPIDLikelihood(*track,0));
411  output().FillVectorVar(TPCSecElPidLik, anaUtils::GetPIDLikelihood(*track,1));
412  output().FillVectorVar(TPCSecPrPidLik, anaUtils::GetPIDLikelihood(*track,2));
413  output().FillMatrixVarFromArray(TPCSecPosStart, track->PositionStart,3);
414  output().FillMatrixVarFromArray(TPCSecPosEnd, track->PositionEnd,3);
415  output().FillMatrixVarFromArray(TPCSecDir, track->DirectionStart,3);
416  output().FillVectorVar(TPCSecQ,-1);
417  if( track->GetTrueParticle() ){
418  output().FillVectorVar(TPCSecTId, track->GetTrueParticle()->PDG);
419  output().FillVectorVar(TPCSecIndex, track->GetTrueParticle()->ID);
420  output().FillVectorVar(TPCSecParentTId, track->GetTrueParticle()->ParentPDG);
421  output().FillVectorVar(TPCSecGParentTId,track->GetTrueParticle()->GParentPDG);
422  }
423  output().IncrementCounter(NTPCSec);
424  }
425 
426  // isoFGD pion candidates
427  for (Int_t i=0;i < mybox().nIsoFGDPiontracks;i++){
428  AnaTrackB* track = mybox().IsoFGDPiontracks[i];
429  AnaFGDParticle *fgdTrack = static_cast<AnaFGDParticle*>(track->FGDSegments[0]);
430  if( !fgdTrack ) continue;
431  ///checking times
432  Float_t timeinipi = fgdTrack->PositionStart[3];
433  Float_t timeendpi = fgdTrack->PositionEnd[3];
434 
435  output().FillVectorVar(FGDPiPiPull, fgdTrack->Pullpi);
436  output().FillVectorVar(FGDPiAvgTime, fgdTrack->AvgTime);
437  // Direction of the segment
438  output().FillVectorVar(FGDPiCosTheta,(Float_t)(anaUtils::ArrayToTVector3(fgdTrack->DirectionStart).CosTheta()));
439  //output().FillVectorVar(FGDPiLength,fgdTrack->Length);
440  output().FillVectorVar(FGDPiLength, fgdTrack->X);
441  output().FillVectorVar(FGDPiTimeIni, timeinipi);
442  output().FillVectorVar(FGDPiTimeEnd, timeendpi);
443 
444  output().FillMatrixVarFromArray(FGDPiDir, fgdTrack->DirectionStart,3);
445  output().FillMatrixVarFromArray(FGDPiPosStart,fgdTrack->PositionStart, 3);
446  output().FillMatrixVarFromArray(FGDPiPosEnd, fgdTrack->PositionEnd, 3);
447  if( track->GetTrueParticle() ){
448  output().FillVectorVar(FGDPiTId, track->GetTrueParticle()->PDG);
449  output().FillVectorVar(FGDPiIndex, track->GetTrueParticle()->ID);
450  output().FillVectorVar(FGDPiParentTId, track->GetTrueParticle()->ParentPDG);
451  output().FillVectorVar(FGDPiGParentTId,track->GetTrueParticle()->GParentPDG);
452  if( track->GetTrueParticle()->TrueVertex )
453  output().FillVectorVar(FGDPiVId,static_cast<AnaTrueVertex*>(track->GetTrueParticle()->TrueVertex)->RooVtxIndex);
454  }
455  if( mybox().HMNtrack ) {
456  Float_t deltainimuinipi = TMath::Abs(timeinipi-mybox().HMNtrack->PositionStart[3]);
457  Float_t deltaendmuinipi = TMath::Abs(timeendpi-mybox().HMNtrack->PositionStart[3]);
458  output().FillVectorVar(FGDPiDeltaTimeIniSelMu,deltainimuinipi);
459  output().FillVectorVar(FGDPiDeltaTimeEndSelMu,deltaendmuinipi);
460  // Minimum distance to the muon vertex
461  Float_t dist1 = (anaUtils::ArrayToTVector3(fgdTrack->PositionStart) - anaUtils::ArrayToTVector3(mybox().HMNtrack->PositionStart)).Mag();
462  Float_t dist2 = (anaUtils::ArrayToTVector3(fgdTrack->PositionEnd) - anaUtils::ArrayToTVector3(mybox().HMNtrack->PositionStart)).Mag();
463  output().FillVectorVar(FGDPiDistance,TMath::Min(dist1,dist2));
464  }
465  output().IncrementCounter(NFGDPi);
466  }
467 
468  // isoFGD electron and positron candidates
469  for (Int_t i=0;i < mybox().nIsoFGDElPi0tracks;i++){
470  AnaTrackB* track = mybox().IsoFGDElPi0tracks[i];
471  AnaFGDParticle *fgdTrack = static_cast<AnaFGDParticle*>(track->FGDSegments[0]);
472  if( !fgdTrack ) continue;
473  Float_t timeiniEl = fgdTrack->PositionStart[3];
474  Float_t timeendEl = fgdTrack->PositionEnd[3];
475  output().FillVectorVar(FGDElCosTheta,(Float_t)(anaUtils::ArrayToTVector3(fgdTrack->DirectionStart).CosTheta()));
476  output().FillVectorVar(FGDElPiPull,fgdTrack->Pullpi);
477  output().FillVectorVar(FGDElAvgTime,fgdTrack->AvgTime);
478  //output().FillVectorVar(FGDElLength,fgdTrack->Length);
479  output().FillVectorVar(FGDElLength,fgdTrack->X);
480  output().FillVectorVar(FGDElTimeIni,timeiniEl);
481  output().FillVectorVar(FGDElTimeEnd,timeendEl);
482  // Minimum distance to the muon vertex
483  if( mybox().HMNtrack ) {
484  Float_t deltainimuiniEl = TMath::Abs(timeiniEl-mybox().HMNtrack->PositionStart[3]);
485  Float_t deltaendmuiniEl = TMath::Abs(timeendEl-mybox().HMNtrack->PositionStart[3]);
486  Float_t dist1 = (anaUtils::ArrayToTVector3(fgdTrack->PositionStart) - anaUtils::ArrayToTVector3(mybox().HMNtrack->PositionStart)).Mag();
487  Float_t dist2 = (anaUtils::ArrayToTVector3(fgdTrack->PositionEnd) - anaUtils::ArrayToTVector3(mybox().HMNtrack->PositionStart)).Mag();
488  Float_t prodEl1 = anaUtils::ArrayToTVector3(fgdTrack->DirectionStart)*anaUtils::ArrayToTVector3(mybox().HMNtrack->DirectionStart);
489 
490  output().FillVectorVar(FGDElDeltaTimeIniSelMu,deltainimuiniEl);
491  output().FillVectorVar(FGDElDeltaTimeEndSelMu,deltaendmuiniEl);
492  output().FillVectorVar(FGDElDistance,TMath::Min(dist1,dist2));
493  output().FillVectorVar(FGDElMuonangle,prodEl1);
494 
495  }
496  // Direction and position of the segment
497  output().FillMatrixVarFromArray(FGDElDir, fgdTrack->DirectionStart,3);
498  output().FillMatrixVarFromArray(FGDElPosStart,fgdTrack->PositionStart, 3);
499  output().FillMatrixVarFromArray(FGDElPosEnd, fgdTrack->PositionEnd, 3);
500 
501  if( track->GetTrueParticle() ){
502  output().FillVectorVar(FGDElTId,track->GetTrueParticle()->PDG);
503  output().FillVectorVar(FGDElIndex,track->GetTrueParticle()->ID);
504  output().FillVectorVar(FGDElParentTId,track->GetTrueParticle()->ParentPDG);
505  output().FillVectorVar(FGDElGParentTId,track->GetTrueParticle()->GParentPDG);
506  if( track->GetTrueParticle()->TrueVertex )
507  output().FillVectorVar(FGDElVId,static_cast<AnaTrueVertex*>(track->GetTrueParticle()->TrueVertex)->RooVtxIndex);
508  }
509  output().IncrementCounter(NFGDEl);
510  }
511 
512  // All FGD tracks.
513  AnaRecObjectC** allFGDParticles = NULL;
514  int nFGD=0;
515  if (_fgdID == SubDetId::kFGD1){
516  nFGD = _event->EventBoxes[EventBoxId::kEventBoxTracker]->nRecObjectsInGroup[EventBoxTracker::kTracksWithFGD1AndNoTPC];
517  allFGDParticles = _event->EventBoxes[EventBoxId::kEventBoxTracker]->RecObjectsInGroup[EventBoxTracker::kTracksWithFGD1AndNoTPC];
518  }
519  else if (_fgdID == SubDetId::kFGD2){
520  nFGD = _event->EventBoxes[EventBoxId::kEventBoxTracker]->nRecObjectsInGroup[EventBoxTracker::kTracksWithFGD2AndNoTPC];
521  allFGDParticles = _event->EventBoxes[EventBoxId::kEventBoxTracker]->RecObjectsInGroup[EventBoxTracker::kTracksWithFGD2AndNoTPC];
522  }
523  for (Int_t i=0;i<nFGD;i++){
524  AnaTrackB* track = static_cast<AnaTrackB*>(allFGDParticles[i]);
525  AnaFGDParticle *fgdTrack = static_cast<AnaFGDParticle*>(track->FGDSegments[0]);
526  if( !fgdTrack ) continue;
527  ///checking times
528  Float_t timeini = fgdTrack->PositionStart[3];
529  Float_t timeend = fgdTrack->PositionEnd[3];
530  output().FillVectorVar(FGDSecTimeIni,timeini);
531  output().FillVectorVar(FGDSecTimeEnd,timeend);
532 
533  if( track->GetTrueParticle() ){
534  output().FillVectorVar(FGDSecTId,track->GetTrueParticle()->PDG);
535  output().FillVectorVar(FGDSecIndex,track->GetTrueParticle()->ID);
536  output().FillVectorVar(FGDSecParentTId,track->GetTrueParticle()->ParentPDG);
537  output().FillVectorVar(FGDSecGParentTId,track->GetTrueParticle()->GParentPDG);
538  }
539 
540  if( mybox().HMNtrack ) {
541  Float_t deltainimuini = TMath::Abs(timeini-mybox().HMNtrack->PositionStart[3]);
542  Float_t deltaendmuini = TMath::Abs(timeend-mybox().HMNtrack->PositionStart[3]);
543  output().FillVectorVar(FGDSecDeltaTimeIniSelMu,deltainimuini);
544  output().FillVectorVar(FGDSecDeltaTimeEndSelMu,deltaendmuini);
545  }
546 
547  // Direction of the segment
548  output().FillVectorVar(FGDSecCosTheta,(Float_t)(anaUtils::ArrayToTVector3(fgdTrack->DirectionStart).CosTheta()));
549  output().FillMatrixVarFromArray(FGDSecDir, fgdTrack->DirectionStart,3);
550  output().FillMatrixVarFromArray(FGDSecPosStart,fgdTrack->PositionStart, 3);
551  output().FillMatrixVarFromArray(FGDSecPosEnd, fgdTrack->PositionEnd, 3);
552  output().FillVectorVar(FGDSecContained, fgdTrack->Containment);
553  output().FillVectorVar(FGDSecPiPull, fgdTrack->Pullpi);
554  output().FillVectorVar(FGDSecAvgTime, fgdTrack->AvgTime);
555  output().FillVectorVar(FGDSecLength, fgdTrack->X);
556  //output().FillVectorVar(FGDSecLength, fgdTrack->Length);
557  output().IncrementCounter(NFGDSec);
558 
559  }
560 
561  // Retrieve the EventBox such that we can get the number of michel electrons
562  EventBoxTracker* EventBox = static_cast<EventBoxTracker*>(_event->EventBoxes[EventBoxId::kEventBoxTracker]);
563  SubDetId::SubDetEnum det = static_cast<SubDetId::SubDetEnum>(mybox().DetectorFV);
564 
565  // Fill ME variables.
566  for (Int_t i=0;i < EventBox->nFGDMichelElectrons[det] ;i++){
567  AnaFgdTimeBin* me = static_cast<AnaFgdTimeBin*>(EventBox->FGDMichelElectrons[det][i]);
568  if( me->NHits[0] != 0 ) {
569  output().FillVectorVar(MENHits,(Int_t)me->NHits[0]);
570  output().FillVectorVar(MERawCharge,me->RawChargeSum[0]);
571  }
572  else {
573  output().FillVectorVar(MENHits,(Int_t)me->NHits[1]);
574  output().FillVectorVar(MERawCharge,me->RawChargeSum[1]);
575  }
576  output().FillVectorVar(MEMinTime,me->MinTime);
577  output().FillVectorVar(MEMaxTime,me->MaxTime);
578  output().IncrementCounter(NME);
579  }
580 
581  // Fill TPC1 track variables
582  SubDetId::SubDetEnum tpc = SubDetId::kTPC1;
583  if (box().DetectorFV == SubDetId::kFGD1) tpc = SubDetId::kTPC2;
584 
585  AnaTrackB** TPCtracks;
586  anaUtils::CreateArray(TPCtracks, NMAXPARTICLES);
587  Int_t nTPCtracks = FindTPCTracks(mybox(), tpc, TPCtracks);
588 
589  for( Int_t i = 0; i < nTPCtracks; i++ ) {
590  AnaTrackB *track = TPCtracks[i];
591  if( !track ) continue;
592  Float_t phi=TMath::ATan2(track->DirectionStart[1],track->DirectionStart[0]);
593  output().FillVectorVar(TPC1TrackPhi,phi );
594  if( track->GetTrueParticle() ){
595  output().FillVectorVar(TPC1TrackTId,track->GetTrueParticle()->PDG);
596  output().FillVectorVar(TPC1TrackParentTId,track->GetTrueParticle()->ParentPDG);
597  output().FillVectorVar(TPC1TrackGParentTId,track->GetTrueParticle()->GParentPDG);
598  if( track->GetTrueParticle()->TrueVertex )
599  output().FillVectorVar(TPC1TrackVId,static_cast<AnaTrueVertex*>(track->GetTrueParticle()->TrueVertex)->RooVtxIndex);
600  }
601  output().FillMatrixVarFromArray(TPC1TrackPosStart,track->PositionStart,3);
602  output().FillMatrixVarFromArray(TPC1TrackPosEnd, track->PositionEnd, 3);
603  output().FillVectorVar(TPC1TrackMom, track->Momentum);
604  output().IncrementCounter(NTPC1Track);
605  }
606  delete TPCtracks;
607 
608  // --- Info to understand Pion SI -----
609  if (_addPionSIinfo){
610  PionInteractionSystematic* pionSI = _pionSIManager.ComputePionWeightInfo(GetEvent(), *sel().GetSelection("kTrackerNumuCCMultiPi"), 0);
611 
612  for(int ii = 0; ii < pionSI->nInteractions; ii++){
613 
614  int intType = pionSI->typeInteraction[ii];
615  int mech;
616  if (intType%10 == 0) mech = 0;
617  else if (intType%10 == 1) mech = 1;
618  else if (intType%10 == 4) mech = 2;
619  else mech=-1;
620  output().FillVectorVar(IntType,mech);
621  output().IncrementCounter(NInts);
622  }
623  for(int ns = 0; ns < pionSI->nPions; ns++){
624  output().FillVectorVar(PionType,pionSI->pionType[ns]);
625  output().FillVectorVar(PionMom,pionSI->initMom[ns]);
626  output().IncrementCounter(NPions);
627  }
628  }
629 }
AnaTrueParticleB::TrueVertex
AnaTrueVertexB * TrueVertex
Pointer to the AnaTrueVertexB of the interaction that created this AnaTrueParticleB.
Definition: BaseDataClasses.hxx:199
AnaParticleB::PositionStart
Float_t PositionStart[4]
The reconstructed start position of the particle.
Definition: BaseDataClasses.hxx:292
AnaTrueVertexB::nTrueParticles
int nTrueParticles
How many true particles are associated with this vertex.
Definition: BaseDataClasses.hxx:134
AnaTrueVertex::RooVtxIndex
Int_t RooVtxIndex
The index of the associated RooTrackerVtx vertex from its position in the TClonesArray.
Definition: DataClasses.hxx:75
OutputManager::FillVectorVar
void FillVectorVar(Int_t index, Float_t var, Int_t indx=-1)
Fill a vector variable.
Definition: OutputManager.cxx:1391
ToyBoxB::DetectorFV
SubDetId_h DetectorFV
Indicate the FV we are interested in.
Definition: ToyBoxB.hxx:52
AnaTrueParticleB::GParentPDG
Int_t GParentPDG
The PDG code of this particle&#39;s grandparent, or 0 if there is no grandparent.
Definition: BaseDataClasses.hxx:178
AnaFGDParticleB::Pullpi
Float_t Pullpi
Pion pull, according to FGD information.
Definition: BaseDataClasses.hxx:448
AnaRecObjectC::TrueObject
AnaTrueObjectC * TrueObject
The link to the true oject that most likely generated this reconstructed object.
Definition: CoreDataClasses.hxx:82
AnaTrueParticleB::Momentum
Float_t Momentum
The initial momentum of the true particle.
Definition: BaseDataClasses.hxx:190
ToyBoxND280::TrueVertex
AnaTrueVertexB * TrueVertex
For storing the true vertex, for analyses with no reconstructed primary vertex.
Definition: ToyBoxND280.hxx:22
AnaTrueVertexB::TrueParticles
AnaTrueParticleB ** TrueParticles
The true particles associated with this vertex.
Definition: BaseDataClasses.hxx:132
AnaFGDParticle::AvgTime
Float_t AvgTime
Average Time for the iso FGD hits.
Definition: DataClasses.hxx:465
OutputManager::FillMatrixVarFromArray
void FillMatrixVarFromArray(Int_t index, const Double_t var[], Int_t indx1, UInt_t size)
Fill a matrix variable from array.
Definition: OutputManager.hxx:647
AnaTrueObjectC::ID
Int_t ID
The ID of the trueObj, which corresponds to the ID of the TTruthParticle that created it...
Definition: CoreDataClasses.hxx:51
anaUtils::GetPIDLikelihood
Float_t GetPIDLikelihood(const AnaTrackB &track, Int_t hypo, bool prod5Cut=0)
Definition: PIDUtils.cxx:180
EventBoxB::nRecObjectsInGroup
Int_t nRecObjectsInGroup[NMAXRECOBJECTGROUPS]
----—— RecObjects and TrueRecObjects used in the selection and systematics ------------—— ...
Definition: CoreDataClasses.hxx:150
AnaParticleMomE::Momentum
Float_t Momentum
The reconstructed momentum of the particle, at the start position.
Definition: BaseDataClasses.hxx:327
AnaTrueVertex
Representation of a true Monte Carlo vertex.
Definition: DataClasses.hxx:50
baseTrackerAnalysis::box
virtual const ToyBoxTracker & box(Int_t isel=-1) const
Returns the ToyBoxTracker.
Definition: baseTrackerAnalysis.hxx:56
AnalysisAlgorithm::_event
AnaEventC * _event
The current event.
Definition: AnalysisAlgorithm.hxx:207
AnaTrueParticleB
Representation of a true Monte Carlo trajectory/particle.
Definition: BaseDataClasses.hxx:147
SubDetId::SubDetEnum
SubDetEnum
Enumeration of all detector systems and subdetectors.
Definition: SubDetId.hxx:25
AnaTrueParticleB::PDG
Int_t PDG
The PDG code of this particle.
Definition: BaseDataClasses.hxx:169
ToyBoxTracker::HMNtrack
AnaTrackB * HMNtrack
For storing the highest momentum negative track.
Definition: ToyBoxTracker.hxx:30
AnaTrueParticleB::ParentPDG
Int_t ParentPDG
The PDG code of this particle&#39;s immediate parent, or 0 if there is no parent.
Definition: BaseDataClasses.hxx:175
EventBoxTracker::FGDMichelElectrons
AnaFgdTimeBinB ** FGDMichelElectrons[2]
----------— Michel Electron candidates -------------------------------—
Definition: EventBoxTracker.hxx:54
ToyBoxTracker::NegativeTPCtracks
AnaTrackB ** NegativeTPCtracks
For storing all negative tracks in the event with TPC information.
Definition: ToyBoxTracker.hxx:45
baseAnalysis::GetEvent
AnaEvent & GetEvent()
Get a casted AnaEventC to AnaEvent.
Definition: baseAnalysis.hxx:66
AnaTrackB
Representation of a global track.
Definition: BaseDataClasses.hxx:603
PionSIManager::ComputePionWeightInfo
PionInteractionSystematic * ComputePionWeightInfo(const AnaEventB &event, SubDetId_h det) const
Definition: PionInteractionSystematic.cxx:767
OutputManager::FillVar
void FillVar(Int_t index, Float_t var)
Fill a single variable.
Definition: OutputManager.cxx:1321
AnaParticleB::DirectionStart
Float_t DirectionStart[3]
The reconstructed start direction of the particle.
Definition: BaseDataClasses.hxx:286
AnaTrueVertex::PionDir
Float_t PionDir[3]
The direction of the primary outgoing pions listed first (likely the interacted one).
Definition: DataClasses.hxx:118
AnaFGDParticleB::Containment
Int_t Containment
Containment flag required for proper PID analysis.
Definition: BaseDataClasses.hxx:454
ToyBoxTracker::PositiveTPCtracks
AnaTrackB ** PositiveTPCtracks
For storing all positive tracks in the event with TPC information.
Definition: ToyBoxTracker.hxx:48
AnaTrueVertex::NuDir
Float_t NuDir[3]
The true (unit) direction of the incoming neutrino.
Definition: DataClasses.hxx:82
AnaParticleB::GetTrueParticle
AnaTrueParticleB * GetTrueParticle() const
Return a casted version of the AnaTrueObject associated.
Definition: BaseDataClasses.hxx:270
AnaTrueParticleB::Direction
Float_t Direction[3]
The initial direction of the true particle.
Definition: BaseDataClasses.hxx:187
OutputManager::FillVectorVarFromArray
void FillVectorVarFromArray(Int_t index, const Double_t var[], UInt_t size)
Fill a vector variable from array.
Definition: OutputManager.hxx:631
AnaTrackB::FGDSegments
AnaFGDParticleB * FGDSegments[NMAXFGDS]
The FGD segments that contributed to this global track.
Definition: BaseDataClasses.hxx:652
AnaTrueVertex::PionMom
Float_t PionMom
The momentum of the primary outgoing pions listed first (likely the interacted one).
Definition: DataClasses.hxx:115
AnaTrueVertex::NPrimaryParticles
Int_t NPrimaryParticles[Int_t(ParticleId::kLast)+1]
Array to count the outgoing primary particles of each type (.
Definition: DataClasses.hxx:121
AnaParticleB::PositionEnd
Float_t PositionEnd[4]
The reconstructed end position of the particle.
Definition: BaseDataClasses.hxx:295
The documentation for this class was generated from the following files:
Generated by   doxygen 1.8.13