gar::anatree Class Reference

Inheritance diagram for gar::anatree:

Public Member Functions
	anatree (fhicl::ParameterSet const &p)
	anatree (anatree const &)=delete
	anatree (anatree &&)=delete
anatree &	operator= (anatree const &)=delete
anatree &	operator= (anatree &&)=delete
virtual void	endRun (art::Run const &run) override
virtual void	beginJob () override
void	analyze (art::Event const &e) override
Public Member Functions inherited from art::EDAnalyzer
	EDAnalyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	EDAnalyzer (Table< Config > const &config)
std::string	workerType () const
Public Member Functions inherited from art::detail::Analyzer
virtual	~Analyzer () noexcept
	Analyzer (fhicl::ParameterSet const &pset)
template<typename Config >
	Analyzer (Table< Config > const &config)
void	doBeginJob (SharedResources const &resources)
void	doEndJob ()
void	doRespondToOpenInputFile (FileBlock const &fb)
void	doRespondToCloseInputFile (FileBlock const &fb)
void	doRespondToOpenOutputFiles (FileBlock const &fb)
void	doRespondToCloseOutputFiles (FileBlock const &fb)
bool	doBeginRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doEndRun (RunPrincipal &rp, ModuleContext const &mc)
bool	doBeginSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEndSubRun (SubRunPrincipal &srp, ModuleContext const &mc)
bool	doEvent (EventPrincipal &ep, ModuleContext const &mc, std::atomic< std::size_t > &counts_run, std::atomic< std::size_t > &counts_passed, std::atomic< std::size_t > &counts_failed)
Public Member Functions inherited from art::Observer
	~Observer () noexcept
	Observer (Observer const &)=delete
	Observer (Observer &&)=delete
Observer &	operator= (Observer const &)=delete
Observer &	operator= (Observer &&)=delete
void	registerProducts (ProductDescriptions &, ModuleDescription const &)
void	fillDescriptions (ModuleDescription const &)
fhicl::ParameterSetID	selectorConfig () const
Public Member Functions inherited from art::ModuleBase
virtual	~ModuleBase () noexcept
	ModuleBase ()
ModuleDescription const &	moduleDescription () const
void	setModuleDescription (ModuleDescription const &)
std::array< std::vector< ProductInfo >, NumBranchTypes > const &	getConsumables () const
void	sortConsumables (std::string const &current_process_name)
template<typename T , BranchType BT>
ViewToken< T >	consumesView (InputTag const &tag)
template<typename T , BranchType BT>
ViewToken< T >	mayConsumeView (InputTag const &tag)

Private Types
typedef int	TrkId

Private Member Functions
void	ClearVectors ()
void	FillGeneratorMonteCarloInfo (art::Event const &e)
void	FillRawInfo (art::Event const &e)
void	FillRecoInfo (art::Event const &e)
void	FillHighLevelRecoInfo (art::Event const &e)
void	processIonizationInfo (rec::TrackIoniz &ion, float ionizeTruncate, float &forwardIonVal, float &backwardIonVal)
float	processOneDirection (std::vector< std::pair< float, float >> SigData, float ionizeTruncate)
float	computeT (simb::MCTruth theMCTruth)
std::vector< std::pair< int, float > >	processPIDInfo (float p)

Static Private Member Functions
static bool	lessThan_byE (std::pair< float, float > a, std::pair< float, float > b)

Private Attributes
cheat::BackTrackerCore *	BackTrack
float	ItsInTulsa [3]
float	xTPC
float	rTPC
std::vector< std::string >	fGeneratorLabels
std::vector< std::string >	fGENIEGeneratorLabels
std::string	fPOTtag
std::string	fInstanceLabelCalo
	Instance name for ECAL. More...
std::string	fInstanceLabelMuID
	Instance name for MuID. More...
std::string	fGeantLabel
	module label for geant4 simulated hits More...
std::string	fHitLabel
	module label for reco TPC hits rec::Hit More...
std::string	fTPCClusterLabel
	module label for TPC Clusters rec::TPCCluster More...
std::string	fTrackLabel
	module label for TPC Tracks rec:Track More...
std::string	fTrackTrajectoryLabel
	module label for TPC Track Trajectories rec:TrackTrajectory More...
std::string	fVertexLabel
	module label for vertexes rec:Vertex More...
std::string	fVeeLabel
	module label for conversion/decay vertexes rec:Vee More...
std::string	fRawCaloHitLabel
	module label for digitized calo hits raw::CaloRawDigit More...
std::string	fRawMuIDHitLabel
std::string	fCaloHitLabel
	module label for reco calo hits rec::CaloHit More...
std::string	fMuIDHitLabel
std::string	fClusterLabel
	module label for calo clusters rec::Cluster More...
std::string	fClusterMuIDLabel
	module label for calo clusters rec::Cluster in MuID More...
std::string	fPFLabel
	module label for reco particles rec::PFParticle More...
std::string	fECALAssnLabel
	module label for track-clusters associations More...
bool	fWriteMCinfo
	Info from MCTruth, GTruth Default=true. More...
bool	fWriteMCPTrajectory
	Write MCP Trajectory Default=true. More...
bool	fWriteMCPTrajMomenta
	Write Momenta associated with MCP Trajectory Default=false. More...
bool	fWriteMCCaloInfo
	Write MC info for calorimeter Default=true. More...
float	fMatchMCPtoVertDist
	MCParticle to MC vertex match Default=roundoff. More...
bool	fWriteHits
	Write info about TPC Hits Default=false. More...
bool	fWriteTPCClusters
	Write TPCClusters info Default=true. More...
bool	fWriteTracks
	Start/end X, P for tracks Default=true. More...
bool	fWriteTrackTrajectories
	Point traj of reco tracks Default=false. More...
bool	fWriteVertices
	Reco vertexes & their tracks Default=true. More...
bool	fWriteVees
	Reco vees & their tracks Default=true. More...
bool	fWriteMuID
bool	fWriteCaloDigits
	Raw digits for calorimetry. Default=false. More...
bool	fWriteCaloHits
	Write ECAL hits. Default=true. More...
bool	fWriteCaloClusters
	Write ECAL clusters. Default=true. More...
bool	fWriteMatchedTracks
	Write ECAL-track Assns Default=true. More...
float	fIonizTruncate
	Default=1.00;. More...
bool	fWriteCohInfo
	MC level t for coherent pi+. Default=false. More...
TTree *	fTree
const geo::GeometryCore *	fGeo
	pointer to the geometry More...
std::string	fECALEncoding
std::string	fMuIDEncoding
gar::geo::BitFieldCoder *	fFieldDecoder_ECAL
gar::geo::BitFieldCoder *	fFieldDecoder_MuID
std::unordered_map< TrkId, Int_t >	TrackIdToIndex
Int_t	fEvent
	number of the event being processed More...
Int_t	fRun
	number of the run being processed More...
Int_t	fSubRun
	number of the sub-run being processed More...
Float_t	fTPC_X
	center of TPC stored as per-event & compressed by root More...
Float_t	fTPC_Y
Float_t	fTPC_Z
Int_t	fTotalPOT
Int_t	fNSpills
std::vector< Int_t >	fNeutrinoType
std::vector< Int_t >	fCCNC
std::vector< Int_t >	fMode
std::vector< Int_t >	fInteractionType
std::vector< Float_t >	fQ2
std::vector< Float_t >	fW
std::vector< Float_t >	fX
std::vector< Float_t >	fY
std::vector< Float_t >	fTheta
std::vector< Float_t >	fT
std::vector< Float_t >	fMCVertexX
std::vector< Float_t >	fMCVertexY
std::vector< Float_t >	fMCVertexZ
std::vector< Float_t >	fMCnuPx
std::vector< Float_t >	fMCnuPy
std::vector< Float_t >	fMCnuPz
std::vector< Int_t >	fGint
std::vector< Int_t >	fTgtPDG
std::vector< Float_t >	fWeight
std::vector< Float_t >	fgT
std::vector< Int_t >	fnGPart
std::vector< Int_t >	fGPartIntIdx
std::vector< Int_t >	fGPartIdx
std::vector< Int_t >	fGPartPdg
std::vector< Int_t >	fGPartStatus
std::vector< Int_t >	fGPartFirstMom
std::vector< Int_t >	fGPartLastMom
std::vector< Int_t >	fGPartFirstDaugh
std::vector< Int_t >	fGPartLastDaugh
std::vector< std::string >	fGPartName
std::vector< Float_t >	fGPartPx
std::vector< Float_t >	fGPartPy
std::vector< Float_t >	fGPartPz
std::vector< Float_t >	fGPartE
std::vector< Float_t >	fGPartMass
std::vector< Int_t >	fMCTrkID
std::vector< Int_t >	fMCPDG
std::vector< Int_t >	fMCMotherIndex
std::vector< Int_t >	fMCMotherTrkID
std::vector< Int_t >	fMCPDGMother
std::vector< Float_t >	fMCPStartX
std::vector< Float_t >	fMCPStartY
std::vector< Float_t >	fMCPStartZ
std::vector< Float_t >	fMCPTime
std::vector< Float_t >	fMCPStartPX
std::vector< Float_t >	fMCPStartPY
std::vector< Float_t >	fMCPStartPZ
std::vector< Float_t >	fMCPEndX
std::vector< Float_t >	fMCPEndY
std::vector< Float_t >	fMCPEndZ
std::vector< Float_t >	fMCPEndPX
std::vector< Float_t >	fMCPEndPY
std::vector< Float_t >	fMCPEndPZ
std::vector< std::string >	fMCPProc
std::vector< std::string >	fMCPEndProc
std::vector< Int_t >	fMCPVertIndex
std::vector< Float_t >	fTrajMCPX
std::vector< Float_t >	fTrajMCPY
std::vector< Float_t >	fTrajMCPZ
std::vector< Float_t >	fTrajMCPT
std::vector< Float_t >	fTrajMCPE
std::vector< Int_t >	fTrajMCPIndex
std::vector< Int_t >	fTrajMCPTrackID
std::vector< Float_t >	fTrajMCPPX
std::vector< Float_t >	fTrajMCPPY
std::vector< Float_t >	fTrajMCPPZ
UInt_t	fSimnHits
std::vector< Float_t >	fSimHitX
std::vector< Float_t >	fSimHitY
std::vector< Float_t >	fSimHitZ
std::vector< Float_t >	fSimHitTime
std::vector< Float_t >	fSimHitEnergy
std::vector< Int_t >	fSimHitTrackID
std::vector< ULong64_t >	fSimHitCellID
Float_t	fSimEnergySum
UInt_t	fSimnHits_MuID
std::vector< Float_t >	fSimHitX_MuID
std::vector< Float_t >	fSimHitY_MuID
std::vector< Float_t >	fSimHitZ_MuID
std::vector< Float_t >	fSimHitTime_MuID
std::vector< Float_t >	fSimHitEnergy_MuID
std::vector< Int_t >	fSimHitTrackID_MuID
std::vector< ULong64_t >	fSimHitCellID_MuID
Float_t	fSimEnergySum_MuID
std::vector< Float_t >	fHitX
std::vector< Float_t >	fHitY
std::vector< Float_t >	fHitZ
std::vector< Float_t >	fHitSig
std::vector< Float_t >	fHitRMS
std::vector< UInt_t >	fHitChan
std::vector< Float_t >	fTPCClusterX
std::vector< Float_t >	fTPCClusterY
std::vector< Float_t >	fTPCClusterZ
std::vector< Float_t >	fTPCClusterSig
std::vector< Float_t >	fTPCClusterRMS
std::vector< ULong64_t >	fTPCClusterTrkIDNumber
std::vector< Float_t >	fTPCClusterCovXX
std::vector< Float_t >	fTPCClusterCovXY
std::vector< Float_t >	fTPCClusterCovXZ
std::vector< Float_t >	fTPCClusterCovYY
std::vector< Float_t >	fTPCClusterCovYZ
std::vector< Float_t >	fTPCClusterCovZZ
std::vector< Int_t >	fTPCClusterMCindex
std::vector< Float_t >	fTPCClusterMCfrac
std::vector< ULong64_t >	fTrackIDNumber
std::vector< Float_t >	fTrackStartX
std::vector< Float_t >	fTrackStartY
std::vector< Float_t >	fTrackStartZ
std::vector< Float_t >	fTrackStartPX
std::vector< Float_t >	fTrackStartPY
std::vector< Float_t >	fTrackStartPZ
std::vector< Int_t >	fTrackStartQ
std::vector< Float_t >	fTrackEndX
std::vector< Float_t >	fTrackEndY
std::vector< Float_t >	fTrackEndZ
std::vector< Float_t >	fTrackEndPX
std::vector< Float_t >	fTrackEndPY
std::vector< Float_t >	fTrackEndPZ
std::vector< Int_t >	fTrackEndQ
std::vector< Float_t >	fTrackLenF
std::vector< Float_t >	fTrackLenB
std::vector< Float_t >	fTrackChi2F
std::vector< Float_t >	fTrackChi2B
std::vector< Int_t >	fNTPCClustersOnTrack
std::vector< Float_t >	fTrackAvgIonF
std::vector< Float_t >	fTrackAvgIonB
std::vector< Int_t >	fTrackPIDF
std::vector< Float_t >	fTrackPIDProbF
std::vector< Int_t >	fTrackPIDB
std::vector< Float_t >	fTrackPIDProbB
std::vector< Int_t >	fTrackMCindex
std::vector< Float_t >	fTrackMCfrac
std::vector< Float_t >	fTrackTrajectoryFWDX
std::vector< Float_t >	fTrackTrajectoryFWDY
std::vector< Float_t >	fTrackTrajectoryFWDZ
std::vector< Int_t >	fTrackTrajectoryFWDID
std::vector< Float_t >	fTrackTrajectoryBWDX
std::vector< Float_t >	fTrackTrajectoryBWDY
std::vector< Float_t >	fTrackTrajectoryBWDZ
std::vector< Int_t >	fTrackTrajectoryBWDID
std::vector< ULong64_t >	fVertexIDNumber
std::vector< Float_t >	fVertexX
std::vector< Float_t >	fVertexY
std::vector< Float_t >	fVertexZ
std::vector< ULong64_t >	fVertexT
std::vector< Int_t >	fVertexN
std::vector< Int_t >	fVertexQ
std::vector< ULong64_t >	fVTAssn_VertIDNumber
std::vector< ULong64_t >	fVTAssn_TrackIDNumber
std::vector< gar::rec::TrackEnd >	fVTAssn_TrackEnd
std::vector< ULong64_t >	fVeeIDNumber
std::vector< Float_t >	fVeeX
std::vector< Float_t >	fVeeY
std::vector< Float_t >	fVeeZ
std::vector< ULong64_t >	fVeeT
std::vector< Float_t >	fVeePXKpipi
std::vector< Float_t >	fVeePYKpipi
std::vector< Float_t >	fVeePZKpipi
std::vector< Float_t >	fVeeEKpipi
std::vector< Float_t >	fVeeMKpipi
std::vector< Float_t >	fVeePXLppi
std::vector< Float_t >	fVeePYLppi
std::vector< Float_t >	fVeePZLppi
std::vector< Float_t >	fVeeELppi
std::vector< Float_t >	fVeeMLppi
std::vector< Float_t >	fVeePXLpip
std::vector< Float_t >	fVeePYLpip
std::vector< Float_t >	fVeePZLpip
std::vector< Float_t >	fVeeELpip
std::vector< Float_t >	fVeeMLpip
std::vector< ULong64_t >	fVeeTAssn_VeeIDNumber
std::vector< ULong64_t >	fVeeTAssn_TrackIDNumber
std::vector< gar::rec::TrackEnd >	fVeeTAssn_TrackEnd
UInt_t	fDiginHits
std::vector< Float_t >	fDigiHitX
std::vector< Float_t >	fDigiHitY
std::vector< Float_t >	fDigiHitZ
std::vector< Float_t >	fDigiHitTime
std::vector< UInt_t >	fDigiHitADC
std::vector< ULong64_t >	fDigiHitCellID
UInt_t	fDiginHits_MuID
std::vector< Float_t >	fDigiHitX_MuID
std::vector< Float_t >	fDigiHitY_MuID
std::vector< Float_t >	fDigiHitZ_MuID
std::vector< Float_t >	fDigiHitTime_MuID
std::vector< UInt_t >	fDigiHitADC_MuID
std::vector< ULong64_t >	fDigiHitCellID_MuID
UInt_t	fReconHits
std::vector< ULong64_t >	fReconHitIDNumber
std::vector< Float_t >	fRecoHitX
std::vector< Float_t >	fRecoHitY
std::vector< Float_t >	fRecoHitZ
std::vector< Float_t >	fRecoHitTime
std::vector< Float_t >	fRecoHitEnergy
std::vector< ULong64_t >	fRecoHitCellID
std::vector< Int_t >	fRecoHitLayer
Float_t	fRecoEnergySum
UInt_t	fReconHits_MuID
std::vector< ULong64_t >	fReconHitIDNumber_MuID
std::vector< Float_t >	fRecoHitX_MuID
std::vector< Float_t >	fRecoHitY_MuID
std::vector< Float_t >	fRecoHitZ_MuID
std::vector< Float_t >	fRecoHitTime_MuID
std::vector< Float_t >	fRecoHitEnergy_MuID
std::vector< ULong64_t >	fRecoHitCellID_MuID
std::vector< Int_t >	fRecoHitLayer_MuID
Float_t	fRecoEnergySum_MuID
UInt_t	fnCluster
std::vector< ULong64_t >	fClusterIDNumber
std::vector< UInt_t >	fClusterNhits
std::vector< Float_t >	fClusterEnergy
std::vector< Float_t >	fClusterTime
std::vector< Float_t >	fClusterTimeDiffFirstLast
std::vector< Float_t >	fClusterX
std::vector< Float_t >	fClusterY
std::vector< Float_t >	fClusterZ
std::vector< Float_t >	fClusterTheta
std::vector< Float_t >	fClusterPhi
std::vector< Float_t >	fClusterPID
std::vector< Float_t >	fClusterMainAxisX
std::vector< Float_t >	fClusterMainAxisY
std::vector< Float_t >	fClusterMainAxisZ
std::vector< Int_t >	fClusterMCindex
std::vector< Float_t >	fClusterMCfrac
UInt_t	fnCluster_MuID
std::vector< ULong64_t >	fClusterIDNumber_MuID
std::vector< UInt_t >	fClusterNhits_MuID
std::vector< Float_t >	fClusterEnergy_MuID
std::vector< Float_t >	fClusterTime_MuID
std::vector< Float_t >	fClusterTimeDiffFirstLast_MuID
std::vector< Float_t >	fClusterX_MuID
std::vector< Float_t >	fClusterY_MuID
std::vector< Float_t >	fClusterZ_MuID
std::vector< Float_t >	fClusterTheta_MuID
std::vector< Float_t >	fClusterPhi_MuID
std::vector< Float_t >	fClusterPID_MuID
std::vector< Float_t >	fClusterMainAxisX_MuID
std::vector< Float_t >	fClusterMainAxisY_MuID
std::vector< Float_t >	fClusterMainAxisZ_MuID
std::vector< Int_t >	fClusterMCindex_MuID
std::vector< Float_t >	fClusterMCfrac_MuID
std::vector< std::vector< ULong64_t > >	fClusterAssn_RecoHitIDNumber
std::vector< std::vector< ULong64_t > >	fClusterMuIDAssn_MuIDHitIDNumber
std::vector< ULong64_t >	fCALAssn_ClusIDNumber
std::vector< ULong64_t >	fCALAssn_TrackIDNumber
std::vector< gar::rec::TrackEnd >	fCALAssn_TrackEnd
CLHEP::HepRandomEngine &	fEngine
	random engine More...
std::unordered_map< int, TH2F * >	m_pidinterp

Additional Inherited Members
Public Types inherited from art::EDAnalyzer
using	WorkerType = WorkerT< EDAnalyzer >
using	ModuleType = EDAnalyzer
Protected Member Functions inherited from art::Observer
std::string const &	processName () const
bool	wantAllEvents () const noexcept
bool	wantEvent (ScheduleID id, Event const &e) const
Handle< TriggerResults >	getTriggerResults (Event const &e) const
	Observer (fhicl::ParameterSet const &config)
	Observer (std::vector< std::string > const &select_paths, std::vector< std::string > const &reject_paths, fhicl::ParameterSet const &config)
Protected Member Functions inherited from art::ModuleBase
ConsumesCollector &	consumesCollector ()
template<typename T , BranchType = InEvent>
ProductToken< T >	consumes (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	consumesView (InputTag const &)
template<typename T , BranchType = InEvent>
void	consumesMany ()
template<typename T , BranchType = InEvent>
ProductToken< T >	mayConsume (InputTag const &)
template<typename Element , BranchType = InEvent>
ViewToken< Element >	mayConsumeView (InputTag const &)
template<typename T , BranchType = InEvent>
void	mayConsumeMany ()

Detailed Description

Definition at line 77 of file anatree_module.cc.

Member Typedef Documentation

typedef int gar::anatree::TrkId

private

Definition at line 187 of file anatree_module.cc.

Constructor & Destructor Documentation

gar::anatree::anatree ( fhicl::ParameterSet const &  p )

explicit

Definition at line 517 of file anatree_module.cc.

  : EDAnalyzer(p),
    fEngine(art::ServiceHandle<rndm::NuRandomService>()->createEngine(*this, p, "Seed")) {
  fGeo     = gar::providerFrom<geo::GeometryGAr>();

  fECALEncoding = fGeo->GetECALCellIDEncoding();
  fFieldDecoder_ECAL = new gar::geo::BitFieldCoder( fECALEncoding );

  if(fGeo->HasMuonDetector()) {
    fMuIDEncoding = fGeo->GetMuIDCellIDEncoding();
    fFieldDecoder_MuID = new gar::geo::BitFieldCoder( fMuIDEncoding );
  }

  bool usegenlabels =
    p.get_if_present<std::vector<std::string> >("GeneratorLabels",fGeneratorLabels);
  if (!usegenlabels) fGeneratorLabels.clear();

  bool usegeniegenlabels  =
    p.get_if_present<std::vector<std::string> >("GENIEGeneratorLabels",fGENIEGeneratorLabels);
  if (!usegeniegenlabels) fGENIEGeneratorLabels.clear();

  fPOTtag            = p.get<std::string>("SummaryDataLabel","generator");

  //Sim Hits
  fGeantLabel        = p.get<std::string>("GEANTLabel","geant");
  fInstanceLabelCalo = p.get<std::string>("InstanceLabelCalo","ECAL");
  fInstanceLabelMuID = p.get<std::string>("InstanceLabelMuID","MuID");

  fHitLabel          = p.get<std::string>("HitLabel","hit");
  fTPCClusterLabel   = p.get<std::string>("TPCClusterLabel","tpccluster");
  fTrackLabel        = p.get<std::string>("TrackLabel","track");
  fTrackTrajectoryLabel  = p.get<std::string>("TrackTrajectoryLabel","track");
  fVertexLabel       = p.get<std::string>("VertexLabel","vertex");
  fVeeLabel          = p.get<std::string>("VeeLabel","veefinder1");

  //Calorimetric related ECAL/MuID
  fRawCaloHitLabel   = p.get<std::string>("RawCaloHitLabel","daqsipm");
  fRawMuIDHitLabel   = p.get<std::string>("RawMuIDHitLabel","daqsipmmuid");
  fCaloHitLabel      = p.get<std::string>("CaloHitLabel","sscalohit");
  fMuIDHitLabel      = p.get<std::string>("MuIDHitLabel","sscalohitmuid");

  fClusterLabel      = p.get<std::string>("ClusterLabel","calocluster");
  fClusterMuIDLabel  = p.get<std::string>("MuIDClusterLabel","caloclustermuid");
  fPFLabel           = p.get<std::string>("PFLabel","pandora");
  fECALAssnLabel     = p.get<std::string>("ECALAssnLabel","trkecalassn");

  // What to write
  fWriteMCinfo              = p.get<bool>("WriteMCinfo",        true);
  fWriteMCPTrajectory       = p.get<bool>("WriteMCPTrajectory", true);
  fWriteMCPTrajMomenta      = p.get<bool>("WriteMCPTrajMomenta",false);
  fWriteMCCaloInfo          = p.get<bool>("WriteMCCaloInfo",    true);
  float MCPtoVertDefault    = 10.0*std::numeric_limits<Float_t>::epsilon();
  fMatchMCPtoVertDist       = p.get<float>("MatchMCPtoVertDist",MCPtoVertDefault);

  fWriteHits                = p.get<bool>("WriteHits",         false);
  fWriteTPCClusters         = p.get<bool>("WriteTPCClusters",  true);
  fWriteTracks              = p.get<bool>("WriteTracks",       true);
  fWriteTrackTrajectories   = p.get<bool>("WriteTrackTrajectories", false);
  fWriteVertices            = p.get<bool>("WriteVertices",     true);
  fWriteVees                = p.get<bool>("WriteVees",         true);

  fWriteMuID                = p.get<bool>("WriteMuID",         true);
  fWriteCaloDigits          = p.get<bool>("WriteCaloDigits",   false);
  fWriteCaloHits            = p.get<bool>("WriteCaloHits",     true);
  fWriteCaloClusters        = p.get<bool>("WriteCaloClusters", true);
  fWriteMatchedTracks       = p.get<bool>("WriteMatchedTracks",true);

  fIonizTruncate            = p.get<float>("IonizTruncate",    0.70);
  fWriteCohInfo             = p.get<bool> ("WriteCohInfo",     false);

  if (usegenlabels) {
    for (size_t i=0; i<fGeneratorLabels.size(); ++i) {
      consumes<std::vector<simb::MCTruth> >(fGeneratorLabels.at(i));
    }
  } else {
    consumesMany<std::vector<simb::MCTruth> >();
  }

  if (usegeniegenlabels) {
    for (size_t i=0; i<fGENIEGeneratorLabels.size(); ++i) {
      consumes<std::vector<simb::GTruth> >(fGENIEGeneratorLabels.at(i));
    }
  } else {
    consumesMany<std::vector<simb::GTruth> >();
  }

  consumesMany<std::vector<sdp::GenieParticle> >();
  //consumes<art::Assns<simb::MCTruth, simb::MCParticle> >(fGeantLabel);
  consumes<std::vector<simb::MCParticle> >(fGeantLabel);

  //TPC related
  consumes<std::vector<sdp::EnergyDeposit> >(fGeantLabel);
  consumes<std::vector<rec::TPCCluster> >(fTPCClusterLabel);
  consumes<art::Assns<rec::Track, rec::TPCCluster> >(fTPCClusterLabel);
  consumes<std::vector<rec::Hit> >(fHitLabel);
  consumes<std::vector<rec::Track> >(fTrackLabel);
  consumes<std::vector<rec::TrackTrajectory> >(fTrackTrajectoryLabel);
  consumes<std::vector<rec::Vertex> >(fVertexLabel);
  consumes<art::Assns<rec::Track, rec::Vertex> >(fVertexLabel);
  consumes<std::vector<rec::Vee> >(fVeeLabel);
  consumes<art::Assns<rec::Track, rec::Vee> >(fVeeLabel);
  consumes<std::vector<rec::TrackIoniz>>(fTrackLabel);
  consumes<art::Assns<rec::TrackIoniz, rec::Track>>(fTrackLabel);

  //Calorimetry related
  art::InputTag ecalgeanttag(fGeantLabel, fInstanceLabelCalo);
  consumes<std::vector<gar::sdp::CaloDeposit> >(ecalgeanttag);

  art::InputTag ecalrawtag(fRawCaloHitLabel, fInstanceLabelCalo);
  consumes<std::vector<raw::CaloRawDigit> >(ecalrawtag);

  art::InputTag ecalhittag(fCaloHitLabel, fInstanceLabelCalo);
  consumes<std::vector<rec::CaloHit> >(ecalhittag);

  art::InputTag ecalclustertag(fClusterLabel, fInstanceLabelCalo);
  consumes<std::vector<rec::Cluster> >(ecalclustertag);
  consumes<art::Assns<rec::Cluster, rec::CaloHit>>(ecalclustertag);

  //Muon system related
  if (fGeo->HasMuonDetector() && fWriteMuID) {
    art::InputTag muidgeanttag(fGeantLabel, fInstanceLabelMuID);
    consumes<std::vector<gar::sdp::CaloDeposit> >(muidgeanttag);

    art::InputTag muidrawtag(fRawMuIDHitLabel, fInstanceLabelMuID);
    consumes<std::vector<raw::CaloRawDigit> >(muidrawtag);

    art::InputTag muidhittag(fCaloHitLabel, fInstanceLabelMuID);
    consumes<std::vector<rec::CaloHit> >(muidhittag);

    art::InputTag muidclustertag(fClusterMuIDLabel, fInstanceLabelMuID);
    consumes<std::vector<rec::Cluster> >(muidclustertag);
    consumes<art::Assns<rec::Cluster, rec::CaloHit>>(muidclustertag);
  }

  consumes<art::Assns<rec::Cluster, rec::Track>>(fECALAssnLabel);

  return;
} // end constructor

gar::anatree::anatree ( anatree const &  )

delete

gar::anatree::anatree ( anatree &&  )

delete

Member Function Documentation

void gar::anatree::analyze ( art::Event const &  e )

overridevirtual

Implements art::EDAnalyzer.

Definition at line 1077 of file anatree_module.cc.

                                           {

  ClearVectors();

  fRun    = e.run();
  fSubRun = e.subRun();
  fEvent  = e.id().event();

  // Need a non-constant backtracker instance, for now, in analyze not beginJob
  cheat::BackTrackerCore const* const_bt = gar::providerFrom<cheat::BackTracker>();
  BackTrack = const_cast<cheat::BackTrackerCore*>(const_bt);

  //Fill generator and MC Information
  if (fWriteMCinfo) FillGeneratorMonteCarloInfo(e);

  //Fill raw calorimeter information
  if (fWriteCaloDigits) FillRawInfo(e);

  //Fill reco information
  FillRecoInfo(e);

  //Fill high-leve reco information
  FillHighLevelRecoInfo(e);

  fTree->Fill();
  return;
}

void gar::anatree::beginJob ( )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 661 of file anatree_module.cc.

                          {

  fTPC_X = ItsInTulsa[0] = fGeo->TPCXCent();
  fTPC_Y = ItsInTulsa[1] = fGeo->TPCYCent();
  fTPC_Z = ItsInTulsa[2] = fGeo->TPCZCent();

  xTPC = fGeo->TPCLength() / 2.;
  rTPC = fGeo->TPCRadius();

  art::ServiceHandle<art::TFileService> tfs;
  fTree = tfs->make<TTree>("GArAnaTree","GArAnaTree");

  fTree->Branch("Run",           &fRun,         "Run/I");
  fTree->Branch("SubRun",        &fSubRun,      "SubRun/I");
  fTree->Branch("Event",         &fEvent,       "Event/I");
  fTree->Branch("TPC_X",         &fTPC_X,       "TPC_X/F");
  fTree->Branch("TPC_Y",         &fTPC_Y,       "TPC_Y/F");
  fTree->Branch("TPC_Z",         &fTPC_Z,       "TPC_Z/F");
  fTree->Branch("POT",           &fTotalPOT,    "POT/I");
  fTree->Branch("NSpills",       &fNSpills,     "NSpills/I");

  if (fWriteMCinfo) {
    fTree->Branch("NType",       &fNeutrinoType);
    fTree->Branch("CCNC",        &fCCNC);
    fTree->Branch("Mode",        &fMode);
    fTree->Branch("InterT",      &fInteractionType);
    fTree->Branch("MC_Q2",       &fQ2);
    fTree->Branch("MC_W",        &fW);
    fTree->Branch("MC_X",        &fX);
    fTree->Branch("MC_Y",        &fY);
    fTree->Branch("MC_Theta",    &fTheta);
    if (fWriteCohInfo) fTree->Branch("MC_T", &fT);
    fTree->Branch("MCVertX",     &fMCVertexX);
    fTree->Branch("MCVertY",     &fMCVertexY);
    fTree->Branch("MCVertZ",     &fMCVertexZ);
    fTree->Branch("MCNuPx",      &fMCnuPx);
    fTree->Branch("MCNuPy",      &fMCnuPy);
    fTree->Branch("MCNuPz",      &fMCnuPz);

    fTree->Branch("Gint",        &fGint);
    fTree->Branch("TgtPDG",      &fTgtPDG);
    fTree->Branch("Weight",      &fWeight);
    fTree->Branch("GT_T",        &fgT);

    //GENIE particle list from the event record
    fTree->Branch("nGPart",         &fnGPart);
    fTree->Branch("GPartIntIdx",    &fGPartIntIdx);
    fTree->Branch("GPartIdx",       &fGPartIdx);
    fTree->Branch("GPartName",      &fGPartName);
    fTree->Branch("GPartPdg",       &fGPartPdg);
    fTree->Branch("GPartStatus",    &fGPartStatus);
    fTree->Branch("GPartFirstMom",  &fGPartFirstMom);
    fTree->Branch("GPartLastMom",   &fGPartLastMom);
    fTree->Branch("GPartFirstDaugh",&fGPartFirstDaugh);
    fTree->Branch("GPartLastDaugh", &fGPartLastDaugh);
    fTree->Branch("GPartPx",        &fGPartPx);
    fTree->Branch("GPartPy",        &fGPartPy);
    fTree->Branch("GPartPz",        &fGPartPz);
    fTree->Branch("GPartE",         &fGPartE);
    fTree->Branch("GPartMass",      &fGPartMass);

    fTree->Branch("MCTrkID",     &fMCTrkID);
    fTree->Branch("PDG",         &fMCPDG);
    fTree->Branch("MotherIndex", &fMCMotherIndex);    // Index into these vector branches
    fTree->Branch("MotherTrkID", &fMCMotherTrkID);    // trackid of the mother
    fTree->Branch("PDGMother",   &fMCPDGMother);
    fTree->Branch("MCPStartX",   &fMCPStartX);
    fTree->Branch("MCPStartY",   &fMCPStartY);
    fTree->Branch("MCPStartZ",   &fMCPStartZ);
    fTree->Branch("MCPTime",     &fMCPTime);
    fTree->Branch("MCPStartPX",  &fMCPStartPX);
    fTree->Branch("MCPStartPY",  &fMCPStartPY);
    fTree->Branch("MCPStartPZ",  &fMCPStartPZ);
    fTree->Branch("MCPEndX",     &fMCPEndX);
    fTree->Branch("MCPEndY",     &fMCPEndY);
    fTree->Branch("MCPEndZ",     &fMCPEndZ);
    fTree->Branch("MCPEndPX",    &fMCPEndPX);
    fTree->Branch("MCPEndPY",    &fMCPEndPY);
    fTree->Branch("MCPEndPZ",    &fMCPEndPZ);
    fTree->Branch("MCPProc",     &fMCPProc);
    fTree->Branch("MCPEndProc",  &fMCPEndProc);
    fTree->Branch("MCPVertIndex",&fMCPVertIndex);
  }

  if (fWriteMCPTrajectory) {
    // Checking for parameter file validity only once to simplify
    // later code in anatree::process etc.
    if (!fWriteMCinfo) {
      throw cet::exception("anatree")
        << " fWriteMCPTrajectory, but !fWriteMCinfo."
        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    } else {
      //Write MCP Trajectory
      fTree->Branch("TrajMCPX",          &fTrajMCPX);
      fTree->Branch("TrajMCPY",          &fTrajMCPY);
      fTree->Branch("TrajMCPZ",          &fTrajMCPZ);
      fTree->Branch("TrajMCPT",          &fTrajMCPT);
      if (fWriteMCPTrajMomenta) {
        fTree->Branch("TrajMCPPX",          &fTrajMCPPX);
        fTree->Branch("TrajMCPPY",          &fTrajMCPPY);
        fTree->Branch("TrajMCPPZ",          &fTrajMCPPZ);
      }
      fTree->Branch("TrajMCPE",          &fTrajMCPE);
      fTree->Branch("TrajMCPIndex",      &fTrajMCPIndex);
      fTree->Branch("TrajMCPTrackID",    &fTrajMCPTrackID);
    }
  }

  if (fWriteMCCaloInfo) {
    if (!fWriteMCinfo) {
      throw cet::exception("anatree")
        << " fWriteMCCaloInfo, but !fWriteMCinfo."
        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    } else {
      // Write calorimetry MC information
      fTree->Branch("SimnHits",     &fSimnHits);
      fTree->Branch("SimHitX",      &fSimHitX);
      fTree->Branch("SimHitY",      &fSimHitY);
      fTree->Branch("SimHitZ",      &fSimHitZ);
      fTree->Branch("SimHitTime",   &fSimHitTime);
      fTree->Branch("SimHitEnergy", &fSimHitEnergy);
      fTree->Branch("SimHitTrkID",  &fSimHitTrackID);
      fTree->Branch("SimHitCellID", &fSimHitCellID);
      fTree->Branch("SimEnergySum", &fSimEnergySum);

      if(fGeo->HasMuonDetector() && fWriteMuID) {
        fTree->Branch("SimnHits_MuID",     &fSimnHits_MuID);
        fTree->Branch("SimHitX_MuID",      &fSimHitX_MuID);
        fTree->Branch("SimHitY_MuID",      &fSimHitY_MuID);
        fTree->Branch("SimHitZ_MuID",      &fSimHitZ_MuID);
        fTree->Branch("SimHitTime_MuID",   &fSimHitTime_MuID);
        fTree->Branch("SimHitEnergy_MuID", &fSimHitEnergy_MuID);
        fTree->Branch("SimHitTrkID_MuID",  &fSimHitTrackID_MuID);
        fTree->Branch("SimHitCellID_MuID", &fSimHitCellID_MuID);
        fTree->Branch("SimEnergySum_MuID", &fSimEnergySum_MuID);
      }
    }
  }

  if (fWriteHits) {
    fTree->Branch("HitX",        &fHitX);
    fTree->Branch("HitY",        &fHitY);
    fTree->Branch("HitZ",        &fHitZ);
    fTree->Branch("HitSig",      &fHitSig);
    fTree->Branch("HitRMS",      &fHitRMS);
    fTree->Branch("HitChan",     &fHitChan);
  }

  if (fWriteTPCClusters) {
    fTree->Branch("TPCClusterX",           &fTPCClusterX);
    fTree->Branch("TPCClusterY",           &fTPCClusterY);
    fTree->Branch("TPCClusterZ",           &fTPCClusterZ);
    fTree->Branch("TPCClusterSig",         &fTPCClusterSig);
    fTree->Branch("TPCClusterRMS",         &fTPCClusterRMS);
    fTree->Branch("TPCClusterTrkIDNumber", &fTPCClusterTrkIDNumber);
    fTree->Branch("TPCClusterCovXX",       &fTPCClusterCovXX);
    fTree->Branch("TPCClusterCovXY",       &fTPCClusterCovXY);
    fTree->Branch("TPCClusterCovXZ",       &fTPCClusterCovXZ);
    fTree->Branch("TPCClusterCovYY",       &fTPCClusterCovYY);
    fTree->Branch("TPCClusterCovYZ",       &fTPCClusterCovYZ);
    fTree->Branch("TPCClusterCovZZ",       &fTPCClusterCovZZ);
    fTree->Branch("TPCClusterMCindex",     &fTPCClusterMCindex);
    fTree->Branch("TPCClusterMCfrac",      &fTPCClusterMCfrac);
  }

  // All position, momentum, etc
  if (fWriteTracks) {
    fTree->Branch("TrackIDNumber",      &fTrackIDNumber);

    fTree->Branch("TrackStartX",        &fTrackStartX);
    fTree->Branch("TrackStartY",        &fTrackStartY);
    fTree->Branch("TrackStartZ",        &fTrackStartZ);
    fTree->Branch("TrackStartPX",       &fTrackStartPX);
    fTree->Branch("TrackStartPY",       &fTrackStartPY);
    fTree->Branch("TrackStartPZ",       &fTrackStartPZ);
    fTree->Branch("TrackStartQ",        &fTrackStartQ);

    fTree->Branch("TrackEndX",          &fTrackEndX);
    fTree->Branch("TrackEndY",          &fTrackEndY);
    fTree->Branch("TrackEndZ",          &fTrackEndZ);
    fTree->Branch("TrackEndPX",         &fTrackEndPX);
    fTree->Branch("TrackEndPY",         &fTrackEndPY);
    fTree->Branch("TrackEndPZ",         &fTrackEndPZ);
    fTree->Branch("TrackEndQ",          &fTrackEndQ);

    fTree->Branch("TrackLenF",          &fTrackLenF);
    fTree->Branch("TrackLenB",          &fTrackLenB);
    fTree->Branch("TrackChi2F",         &fTrackChi2F);
    fTree->Branch("TrackChi2B",         &fTrackChi2B);
    fTree->Branch("NTPCClustersOnTrack",&fNTPCClustersOnTrack);
    fTree->Branch("TrackAvgIonF",       &fTrackAvgIonF);
    fTree->Branch("TrackAvgIonB",       &fTrackAvgIonB);

    fTree->Branch("TrackPIDF",          &fTrackPIDF);
    fTree->Branch("TrackPIDProbF",      &fTrackPIDProbF);
    fTree->Branch("TrackPIDB",          &fTrackPIDB);
    fTree->Branch("TrackPIDProbB",      &fTrackPIDProbB);
    fTree->Branch("TrackMCindex",       &fTrackMCindex);
    fTree->Branch("TrackMCfrac",        &fTrackMCfrac);

    //Track Trajectories
    if(fWriteTrackTrajectories) {
      fTree->Branch("TrackTrajectoryFWDX",    &fTrackTrajectoryFWDX);
      fTree->Branch("TrackTrajectoryFWDY",    &fTrackTrajectoryFWDY);
      fTree->Branch("TrackTrajectoryFWDZ",    &fTrackTrajectoryFWDZ);
      fTree->Branch("TrackTrajectoryFWDID",   &fTrackTrajectoryFWDID);

      fTree->Branch("TrackTrajectoryBWDX",    &fTrackTrajectoryBWDX);
      fTree->Branch("TrackTrajectoryBWDY",    &fTrackTrajectoryBWDY);
      fTree->Branch("TrackTrajectoryBWDZ",    &fTrackTrajectoryBWDZ);
      fTree->Branch("TrackTrajectoryBWDID",     &fTrackTrajectoryBWDID);
    }
  }

  // Reco'd verts & their track-ends
  if (fWriteVertices) {
    if (!fWriteTracks) {
      throw cet::exception("anatree")
        << " fWriteVertices, but !fWriteTracks."
        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    } else {
      fTree->Branch("VertIDNumber",    &fVertexIDNumber);
      fTree->Branch("VertX",           &fVertexX);
      fTree->Branch("VertY",           &fVertexY);
      fTree->Branch("VertZ",           &fVertexZ);
      fTree->Branch("VertT",           &fVertexT);
      fTree->Branch("VertN",           &fVertexN);
      fTree->Branch("VertQ",           &fVertexQ);

      fTree->Branch("VT_VertIDNumber", &fVTAssn_VertIDNumber);
      fTree->Branch("VT_TrackIDNumber",&fVTAssn_TrackIDNumber);
      fTree->Branch("VT_TrackEnd",     &fVTAssn_TrackEnd);
    }
  }

  // Reco'd vees & their track-ends
  if (fWriteVees) {
    if (!fWriteTracks) {
      throw cet::exception("anatree")
        << " fWriteVees, but !fWriteTracks."
        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    } else {
      fTree->Branch("VeeIDNumber",     &fVeeIDNumber);
      fTree->Branch("VeeX",            &fVeeX);
      fTree->Branch("VeeY",            &fVeeY);
      fTree->Branch("VeeZ",            &fVeeZ);
      fTree->Branch("VeeT",            &fVeeT);
      fTree->Branch("VeePXKpipi",      &fVeePXKpipi);
      fTree->Branch("VeePYKpipi",      &fVeePYKpipi);
      fTree->Branch("VeePZKpipi",      &fVeePZKpipi);
      fTree->Branch("VeeEKpipi",       &fVeeEKpipi);
      fTree->Branch("VeeMKpipi",       &fVeeMKpipi);
      fTree->Branch("VeePXLppi",       &fVeePXLppi);
      fTree->Branch("VeePYLppi",       &fVeePYLppi);
      fTree->Branch("VeePZLppi",       &fVeePZLppi);
      fTree->Branch("VeeELppi",        &fVeeELppi);
      fTree->Branch("VeeMLppi",        &fVeeMLppi);
      fTree->Branch("VeePXLpip",       &fVeePXLpip);
      fTree->Branch("VeePYLpip",       &fVeePYLpip);
      fTree->Branch("VeePZLpip",       &fVeePZLpip);
      fTree->Branch("VeeELpip",        &fVeeELpip);
      fTree->Branch("VeeMLpip",        &fVeeMLpip);
      fTree->Branch("VeeT_VertIDNumber", &fVeeTAssn_VeeIDNumber);
      fTree->Branch("VeeT_TrackIDNumber",&fVeeTAssn_TrackIDNumber);
      fTree->Branch("VeeT_TrackEnd",     &fVeeTAssn_TrackEnd);
    }
  }

  // Write calorimetry digits
  if (fWriteCaloDigits) {
    fTree->Branch("DiginHits",        &fDiginHits);
    fTree->Branch("DigiHitX",         &fDigiHitX);
    fTree->Branch("DigiHitY",         &fDigiHitY);
    fTree->Branch("DigiHitZ",         &fDigiHitZ);
    fTree->Branch("DigiHitTime",      &fDigiHitTime);
    fTree->Branch("DigiHitADC",       &fDigiHitADC);
    fTree->Branch("DigiHitCellID",    &fDigiHitCellID);

    if(fGeo->HasMuonDetector()) {
      fTree->Branch("DiginHits_MuID",        &fDiginHits_MuID);
      fTree->Branch("DigiHitX_MuID",         &fDigiHitX_MuID);
      fTree->Branch("DigiHitY_MuID",         &fDigiHitY_MuID);
      fTree->Branch("DigiHitZ_MuID",         &fDigiHitZ_MuID);
      fTree->Branch("DigiHitTime_MuID",      &fDigiHitTime_MuID);
      fTree->Branch("DigiHitADC_MuID",       &fDigiHitADC_MuID);
      fTree->Branch("DigiHitCellID_MuID",    &fDigiHitCellID_MuID);
    }
  }

  // Write calorimetry hits
  if (fWriteCaloHits) {
    fTree->Branch("ReconHits",        &fReconHits);
    fTree->Branch("ReconHitIDNumber", &fReconHitIDNumber);
    fTree->Branch("RecoHitX",         &fRecoHitX);
    fTree->Branch("RecoHitY",         &fRecoHitY);
    fTree->Branch("RecoHitZ",         &fRecoHitZ);
    fTree->Branch("RecoHitTime",      &fRecoHitTime);
    fTree->Branch("RecoHitEnergy",    &fRecoHitEnergy);
    fTree->Branch("RecoHitCellID",    &fRecoHitCellID);
    fTree->Branch("RecoHitLayer",     &fRecoHitLayer);
    fTree->Branch("RecoEnergySum",    &fRecoEnergySum);

    if(fGeo->HasMuonDetector() && fWriteMuID) {
      fTree->Branch("ReconHits_MuID",         &fReconHits_MuID);
      fTree->Branch("ReconHitIDNumber_MuID",    &fReconHitIDNumber_MuID);
      fTree->Branch("RecoHitX_MuID",          &fRecoHitX_MuID);
      fTree->Branch("RecoHitY_MuID",          &fRecoHitY_MuID);
      fTree->Branch("RecoHitZ_MuID",          &fRecoHitZ_MuID);
      fTree->Branch("RecoHitTime_MuID",       &fRecoHitTime_MuID);
      fTree->Branch("RecoHitEnergy_MuID",     &fRecoHitEnergy_MuID);
      fTree->Branch("RecoHitCellID_MuID",     &fRecoHitCellID_MuID);
      fTree->Branch("RecoHitLayer_MuID",      &fRecoHitLayer_MuID);
      fTree->Branch("RecoEnergySum_MuID",     &fRecoEnergySum_MuID);
    }
  }

  // Write calorimetry clusters
  if (fWriteCaloClusters) {
    fTree->Branch("nCluster",                   &fnCluster);
    fTree->Branch("ClusterIDNumber",            &fClusterIDNumber);
    fTree->Branch("ClusterNhits",               &fClusterNhits);
    fTree->Branch("ClusterEnergy",              &fClusterEnergy);
    fTree->Branch("ClusterTime",                &fClusterTime);
    fTree->Branch("ClusterTimeDiffFirstLast",   &fClusterTimeDiffFirstLast);
    fTree->Branch("ClusterX",                   &fClusterX);
    fTree->Branch("ClusterY",                   &fClusterY);
    fTree->Branch("ClusterZ",                   &fClusterZ);
    fTree->Branch("ClusterTheta",               &fClusterTheta);
    fTree->Branch("ClusterPhi",                 &fClusterPhi);
    fTree->Branch("ClusterPID",                 &fClusterPID);
    // fTree->Branch("ClusterShape",            &fClusterShape);
    fTree->Branch("ClusterMainAxisX",           &fClusterMainAxisX);
    fTree->Branch("ClusterMainAxisY",           &fClusterMainAxisY);
    fTree->Branch("ClusterMainAxisZ",           &fClusterMainAxisZ);
    fTree->Branch("ClusterMCindex",             &fClusterMCindex);
    fTree->Branch("ClusterMCfrac",              &fClusterMCfrac);

    fTree->Branch("ClusterAssn_RecoHitIDNumber", &fClusterAssn_RecoHitIDNumber);

    if(fGeo->HasMuonDetector() && fWriteMuID) {
      fTree->Branch("nCluster_MuID",                   &fnCluster_MuID);
      fTree->Branch("ClusterIDNumber_MuID",            &fClusterIDNumber_MuID);
      fTree->Branch("ClusterNhits_MuID",               &fClusterNhits_MuID);
      fTree->Branch("ClusterEnergy_MuID",              &fClusterEnergy_MuID);
      fTree->Branch("ClusterTime_MuID",                &fClusterTime_MuID);
      fTree->Branch("ClusterTimeDiffFirstLast_MuID",   &fClusterTimeDiffFirstLast_MuID);
      fTree->Branch("ClusterX_MuID",                   &fClusterX_MuID);
      fTree->Branch("ClusterY_MuID",                   &fClusterY_MuID);
      fTree->Branch("ClusterZ_MuID",                   &fClusterZ_MuID);
      fTree->Branch("ClusterTheta_MuID",               &fClusterTheta_MuID);
      fTree->Branch("ClusterPhi_MuID",                 &fClusterPhi_MuID);
      fTree->Branch("ClusterPID_MuID",                 &fClusterPID_MuID);
      // fTree->Branch("ClusterShape",            &fClusterShape);
      fTree->Branch("ClusterMainAxisX_MuID",           &fClusterMainAxisX_MuID);
      fTree->Branch("ClusterMainAxisY_MuID",           &fClusterMainAxisY_MuID);
      fTree->Branch("ClusterMainAxisZ_MuID",           &fClusterMainAxisZ_MuID);
      fTree->Branch("ClusterMCindex_MuID",             &fClusterMCindex_MuID);
      fTree->Branch("ClusterMCfrac_MuID",              &fClusterMCfrac_MuID);

      fTree->Branch("ClusterMuIDAssn_MuIDHitIDNumber", &fClusterMuIDAssn_MuIDHitIDNumber);
    }
  }

  if (fWriteMatchedTracks) {
    if (!fWriteTracks || !fWriteCaloClusters) {
      throw cet::exception("anatree")
        << " fWriteMatchedTracks, but (!fWriteTracks || !fWriteCaloClusters)."
        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    } else {
      fTree->Branch("ECALAssn_ClusIDNumber",  &fCALAssn_ClusIDNumber);
      fTree->Branch("ECALAssn_TrackIDNumber", &fCALAssn_TrackIDNumber);
      fTree->Branch("ECALAssn_TrackEnd",      &fCALAssn_TrackEnd);
    }
  }

  std::string filename = "${DUNE_PARDATA_DIR}/MPD/dedxPID/dedxpidmatrices8kevcm.root";
  TFile infile(filename.c_str(), "READ");

  m_pidinterp.clear();
  char str[11];
  for (int q = 0; q < 501; ++q) {
    sprintf(str, "%d", q);
    std::string s = "pidmatrix";
    s.append(str);
    // read the 500 histograms one by one; each histogram is a
    // 6 by 6 matrix of probabilities for a given momentum value
    m_pidinterp.insert( std::make_pair(q, (TH2F*) infile.Get(s.c_str())->Clone("pidinterp")) );
  }

  return;
}  // End of :anatree::beginJob

void gar::anatree::ClearVectors ( )

private

Definition at line 1110 of file anatree_module.cc.

                              {

  // clear out all our vectors
  if (fWriteMCinfo) {
    fNeutrinoType.clear();
    fCCNC.clear();
    fMode.clear();
    fInteractionType.clear();
    fQ2.clear();
    fW.clear();
    fX.clear();
    fY.clear();
    fTheta.clear();
    if (fWriteCohInfo) fT.clear();
    fMCVertexX.clear();
    fMCVertexY.clear();
    fMCVertexZ.clear();
    fMCnuPx.clear();
    fMCnuPy.clear();
    fMCnuPz.clear();

    fGint.clear();
    fTgtPDG.clear();
    fWeight.clear();
    fgT.clear();

    fnGPart.clear();
    fGPartIntIdx.clear();
    fGPartIdx.clear();
    fGPartPdg.clear();
    fGPartStatus.clear();
    fGPartName.clear();
    fGPartFirstMom.clear();
    fGPartLastMom.clear();
    fGPartFirstDaugh.clear();
    fGPartLastDaugh.clear();
    fGPartPx.clear();
    fGPartPy.clear();
    fGPartPz.clear();
    fGPartE.clear();
    fGPartMass.clear();

    fMCTrkID.clear();
    fMCPDG.clear();
    fMCMotherIndex.clear();
    fMCMotherTrkID.clear();
    fMCPDGMother.clear();
    fMCPStartX.clear();
    fMCPStartY.clear();
    fMCPStartZ.clear();
    fMCPTime.clear();
    fMCPStartPX.clear();
    fMCPStartPY.clear();
    fMCPStartPZ.clear();
    fMCPEndX.clear();
    fMCPEndY.clear();
    fMCPEndZ.clear();
    fMCPEndPX.clear();
    fMCPEndPY.clear();
    fMCPEndPZ.clear();
    fMCPProc.clear();
    fMCPEndProc.clear();
    fMCPVertIndex.clear();
  }

  if (fWriteMCPTrajectory) {
    fTrajMCPX.clear();
    fTrajMCPY.clear();
    fTrajMCPZ.clear();
    fTrajMCPT.clear();
    if (fWriteMCPTrajMomenta) {
      fTrajMCPPX.clear();
      fTrajMCPPY.clear();
      fTrajMCPPZ.clear();
    }
    fTrajMCPE.clear();
    fTrajMCPIndex.clear();
    fTrajMCPTrackID.clear();
  }

  if (fWriteMCCaloInfo) {
    fSimnHits = 0;
    fSimHitX.clear();
    fSimHitY.clear();
    fSimHitZ.clear();
    fSimHitTime.clear();
    fSimHitEnergy.clear();
    fSimHitTrackID.clear();
    fSimHitCellID.clear();
    fSimEnergySum = 0.;

    if(fGeo->HasMuonDetector() && fWriteMuID) {
      fSimnHits_MuID = 0;
      fSimHitX_MuID.clear();
      fSimHitY_MuID.clear();
      fSimHitZ_MuID.clear();
      fSimHitTime_MuID.clear();
      fSimHitEnergy_MuID.clear();
      fSimHitTrackID_MuID.clear();
      fSimHitCellID_MuID.clear();
      fSimEnergySum_MuID = 0.;
    }
  }

  if (fWriteHits) {
    fHitX.clear();
    fHitY.clear();
    fHitZ.clear();
    fHitSig.clear();
    fHitRMS.clear();
    fHitChan.clear();
  }

  if (fWriteTPCClusters) {
    fTPCClusterX.clear();
    fTPCClusterY.clear();
    fTPCClusterZ.clear();
    fTPCClusterSig.clear();
    fTPCClusterRMS.clear();
    fTPCClusterTrkIDNumber.clear();
    fTPCClusterCovXX.clear();
    fTPCClusterCovXY.clear();
    fTPCClusterCovXZ.clear();
    fTPCClusterCovYY.clear();
    fTPCClusterCovYZ.clear();
    fTPCClusterCovZZ.clear();
    fTPCClusterMCindex.clear();
    fTPCClusterMCfrac.clear();
  }

  if (fWriteTracks) {
    fTrackIDNumber.clear();
    fTrackStartX.clear();
    fTrackStartY.clear();
    fTrackStartZ.clear();
    fTrackStartPX.clear();
    fTrackStartPY.clear();
    fTrackStartPZ.clear();
    fTrackStartQ.clear();
    fTrackEndX.clear();
    fTrackEndY.clear();
    fTrackEndZ.clear();
    fTrackEndPX.clear();
    fTrackEndPY.clear();
    fTrackEndPZ.clear();
    fTrackEndQ.clear();
    fTrackLenF.clear();
    fTrackLenB.clear();
    fTrackChi2F.clear();
    fTrackChi2B.clear();
    fNTPCClustersOnTrack.clear();
    fTrackAvgIonF.clear();
    fTrackAvgIonB.clear();
    fTrackPIDF.clear();
    fTrackPIDProbF.clear();
    fTrackPIDB.clear();
    fTrackPIDProbB.clear();
    fTrackMCindex.clear();
    fTrackMCfrac.clear();

    if(fWriteTrackTrajectories) {
      fTrackTrajectoryFWDX.clear();
      fTrackTrajectoryFWDY.clear();
      fTrackTrajectoryFWDZ.clear();
      fTrackTrajectoryFWDID.clear();

      fTrackTrajectoryBWDX.clear();
      fTrackTrajectoryBWDY.clear();
      fTrackTrajectoryBWDZ.clear();
      fTrackTrajectoryBWDID.clear();
    }
  }

  if (fWriteVertices) {
    fVertexIDNumber.clear();
    fVertexX.clear();
    fVertexY.clear();
    fVertexZ.clear();
    fVertexT.clear();
    fVertexN.clear();
    fVertexQ.clear();

    fVTAssn_VertIDNumber.clear();
    fVTAssn_TrackIDNumber.clear();
    fVTAssn_TrackEnd.clear();
  }

  if (fWriteVees) {
    fVeeIDNumber.clear();
    fVeeX.clear();
    fVeeY.clear();
    fVeeZ.clear();
    fVeeT.clear();
    fVeePXKpipi.clear();
    fVeePYKpipi.clear();
    fVeePZKpipi.clear();
    fVeeEKpipi.clear();
    fVeeMKpipi.clear();
    fVeePXLppi.clear();
    fVeePYLppi.clear();
    fVeePZLppi.clear();
    fVeeELppi.clear();
    fVeeMLppi.clear();
    fVeePXLpip.clear();
    fVeePYLpip.clear();
    fVeePZLpip.clear();
    fVeeELpip.clear();
    fVeeMLpip.clear();
    fVeeTAssn_VeeIDNumber.clear();
    fVeeTAssn_TrackIDNumber.clear();
    fVeeTAssn_TrackEnd.clear();
  }

  if (fWriteCaloDigits) {
    fDiginHits = 0;
    fDigiHitX.clear();
    fDigiHitY.clear();
    fDigiHitZ.clear();
    fDigiHitTime.clear();
    fDigiHitADC.clear();
    fDigiHitCellID.clear();

    if(fGeo->HasMuonDetector() && fWriteMuID) {
      fDiginHits_MuID = 0;
      fDigiHitX_MuID.clear();
      fDigiHitY_MuID.clear();
      fDigiHitZ_MuID.clear();
      fDigiHitTime_MuID.clear();
      fDigiHitADC_MuID.clear();
      fDigiHitCellID_MuID.clear();
    }
  }

  if (fWriteCaloHits) {
    fReconHits = 0;
    fReconHitIDNumber.clear();
    fRecoHitX.clear();
    fRecoHitY.clear();
    fRecoHitZ.clear();
    fRecoHitTime.clear();
    fRecoHitEnergy.clear();
    fRecoHitCellID.clear();
    fRecoHitLayer.clear();
    fRecoEnergySum = 0.;

    if(fGeo->HasMuonDetector() && fWriteMuID) {
      fReconHits_MuID = 0;
      fReconHitIDNumber_MuID.clear();
      fRecoHitX_MuID.clear();
      fRecoHitY_MuID.clear();
      fRecoHitZ_MuID.clear();
      fRecoHitTime_MuID.clear();
      fRecoHitEnergy_MuID.clear();
      fRecoHitCellID_MuID.clear();
      fRecoHitLayer_MuID.clear();
      fRecoEnergySum_MuID = 0.;
    }
  }

  if (fWriteCaloClusters) {
    fnCluster = 0;
    fClusterIDNumber.clear();
    fClusterNhits.clear();
    fClusterEnergy.clear();
    fClusterTime.clear();
    fClusterTimeDiffFirstLast.clear();
    fClusterX.clear();
    fClusterY.clear();
    fClusterZ.clear();
    fClusterTheta.clear();
    fClusterPhi.clear();
    fClusterPID.clear();
    // fClusterShape.clear();
    fClusterMainAxisX.clear();
    fClusterMainAxisY.clear();
    fClusterMainAxisZ.clear();
    fClusterMCindex.clear();
    fClusterMCfrac.clear();

    fClusterAssn_RecoHitIDNumber.clear();

    if(fGeo->HasMuonDetector() && fWriteMuID) {
      fnCluster_MuID = 0;
      fClusterIDNumber_MuID.clear();
      fClusterNhits_MuID.clear();
      fClusterEnergy_MuID.clear();
      fClusterTime_MuID.clear();
      fClusterTimeDiffFirstLast_MuID.clear();
      fClusterX_MuID.clear();
      fClusterY_MuID.clear();
      fClusterZ_MuID.clear();
      fClusterTheta_MuID.clear();
      fClusterPhi_MuID.clear();
      fClusterPID_MuID.clear();
      // fClusterShape.clear();
      fClusterMainAxisX_MuID.clear();
      fClusterMainAxisY_MuID.clear();
      fClusterMainAxisZ_MuID.clear();
      fClusterMCindex_MuID.clear();
      fClusterMCfrac_MuID.clear();

      fClusterMuIDAssn_MuIDHitIDNumber.clear();
    }
  }

  if (fWriteMatchedTracks) {
    fCALAssn_ClusIDNumber.clear();
    fCALAssn_TrackIDNumber.clear();
    fCALAssn_TrackEnd.clear();
  }

  return;
} // end :anatree::ClearVectors

float gar::anatree::computeT ( simb::MCTruth  theMCTruth )

private

Definition at line 2436 of file anatree_module.cc.

                                                   {
  // Warning.  You probably want the absolute value of t, not t.
  int nPart = theMCTruth.NParticles();
  enum { nu, mu, pi};
  float E[3], Px[3], Py[3], Pz[3];
  E[nu] = E[mu] = E[pi] = -1e42;

  for (int i=0; i<3;++i) {
    Px[i] = 0;
    Py[i] = 0;
    Pz[i] = 0;
    E[i]  = 0;
  }
  // Find t from the MCParticles via the
  for (int iPart=0; iPart<nPart; iPart++) {
    simb::MCParticle Part = theMCTruth.GetParticle(iPart);
    int code = Part.PdgCode();
    int mom  = Part.Mother();

    // get the neutrino
    if ( abs(code) == 12 || abs(code) == 14 || abs(code) == 16 ) {
      if (mom == -1) {
        E[nu] = Part.E();   Px[nu] = Part.Px();   Py[nu] = Part.Py();   Pz[nu] = Part.Pz();
      }
    }

    // get the lepton
    if ( abs(code) == 11 || abs(code) == 13 || abs(code) == 15 ) {
      if (mom == 0) {
        E[mu] = Part.E();   Px[mu] = Part.Px();   Py[mu] = Part.Py();   Pz[mu] = Part.Pz();
      }
    }

    // get the pion
    if ( code==111 || abs(code)==211 ) {
      if (mom == 1) {
        E[pi] = Part.E();   Px[pi] = Part.Px();   Py[pi] = Part.Py();   Pz[pi] = Part.Pz();
      }
    }

    // get outa here
    if ( E[nu]!=0 && E[mu]!=0 && E[pi]!=0) break;

  }

  // Compute t; reuse nu 4-vector to get first q, then t.
  E[nu] -= E[mu];   Px[nu] -= Px[mu];   Py[nu] -= Py[mu];   Pz[nu] -= Pz[mu];
  E[nu] -= E[pi];   Px[nu] -= Px[pi];   Py[nu] -= Py[pi];   Pz[nu] -= Pz[pi];
  float t = E[nu]*E[nu] -Px[nu]*Px[nu] -Py[nu]*Py[nu] -Pz[nu]*Pz[nu];
  return t;
}

void gar::anatree::endRun ( art::Run const &  run )

overridevirtual

Reimplemented from art::EDAnalyzer.

Definition at line 1056 of file anatree_module.cc.

                                         {
  auto const& ID = run.id();

  auto summaryHandle = run.getHandle<sumdata::POTSummary>(fPOTtag);
  if (!summaryHandle) {
    MF_LOG_DEBUG("anatree") << " No sumdata::POTSummary branch for run " << ID 
                            <<" Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    return;
  }

  sumdata::POTSummary const& RunPOT = *summaryHandle;
  fTotalPOT = RunPOT.TotalPOT();
  fNSpills = RunPOT.TotalSpills();

  MF_LOG_INFO("anatree") << "POT for this file is " << fTotalPOT
                         << " The number of spills is " << fNSpills;
}

void gar::anatree::FillGeneratorMonteCarloInfo ( art::Event const &  e )

private

Definition at line 1429 of file anatree_module.cc.

                                                               {

  // =============  Get art handles ==========================================
  // Get handles for MCinfo, also good for MCPTrajectory
  std::vector< art::Handle< std::vector<simb::MCTruth> > > mcthandlelist;
  std::vector< art::Handle< std::vector<simb::GTruth> > > gthandlelist;

  if (fGeneratorLabels.size()<1) {
    mcthandlelist = e.getMany<std::vector<simb::MCTruth> >(); // get them all (even if there are none)
  } else {
    mcthandlelist.resize(fGeneratorLabels.size());
    for (size_t i=0; i< fGeneratorLabels.size(); ++i) {
      // complain if we wanted a specific one but didn't find it
      mcthandlelist.at(i) = e.getHandle<std::vector<simb::MCTruth> >(fGeneratorLabels.at(i));
      if (!mcthandlelist.at(i)) {
        throw cet::exception("anatree") << " No simb::MCTruth branch."
                                        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
      }
    }
  }

  if (fGENIEGeneratorLabels.size()<1) {
    gthandlelist = e.getMany< std::vector<simb::GTruth> >();  // get them all (even if there are none)
  } else {
    gthandlelist.resize(fGENIEGeneratorLabels.size());
    for (size_t i=0; i< fGENIEGeneratorLabels.size(); ++i) {
      // complain if we wanted a specific one but didn't find it
      gthandlelist.at(i) = e.getHandle<std::vector<simb::GTruth> >(fGENIEGeneratorLabels.at(i));
      if (!gthandlelist.at(i)) {
        throw cet::exception("anatree") << " No simb::GTruth branch."
                                        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
      }
    }
  }

  // save MCTruth info
  for (size_t imchl = 0; imchl < mcthandlelist.size(); ++imchl) {
    for ( auto const& mct : (*mcthandlelist.at(imchl)) ) {
      if (mct.NeutrinoSet()) {
        simb::MCNeutrino nuw = mct.GetNeutrino();
        fNeutrinoType.push_back(nuw.Nu().PdgCode());
        fCCNC.push_back(nuw.CCNC());
        fMode.push_back(nuw.Mode());
        fInteractionType.push_back(nuw.InteractionType());
        fQ2.push_back(nuw.QSqr());
        fW.push_back(nuw.W());
        fX.push_back(nuw.X());
        fY.push_back(nuw.Y());
        fTheta.push_back(nuw.Theta());
        if (fWriteCohInfo) {
          double getT = computeT(mct);
          fT.push_back( static_cast<Float_t>(getT) );
        }
        fMCVertexX.push_back(nuw.Nu().EndX());
        fMCVertexY.push_back(nuw.Nu().EndY());
        fMCVertexZ.push_back(nuw.Nu().EndZ());
        fMCnuPx.push_back(nuw.Nu().Px());
        fMCnuPy.push_back(nuw.Nu().Py());
        fMCnuPz.push_back(nuw.Nu().Pz());
      }  // end MC info from MCTruth
    }
  }

  // save GTruth info
  for (size_t igthl = 0; igthl < gthandlelist.size(); ++igthl) {
    for ( auto const& gt : (*gthandlelist.at(igthl)) ) {
      fGint.push_back(gt.fGint);
      fTgtPDG.push_back(gt.ftgtPDG);
      fWeight.push_back(gt.fweight);
      fgT.push_back(gt.fgT);
    }
  }

  // Save the particle list from the GENIE event record
  auto gparthandlelist = e.getMany<std::vector<sdp::GenieParticle>>();

  for (size_t igphl = 0; igphl < gparthandlelist.size(); ++igphl) {
    unsigned int nGPart = 0;
    for ( auto const& gpart : (*gparthandlelist.at(igphl)) ) {
      fGPartIntIdx.push_back(gpart.InteractionIndex());
      fGPartIdx.push_back(gpart.Index());
      fGPartPdg.push_back(gpart.Pdg());
      fGPartStatus.push_back(gpart.Status());
      fGPartName.push_back(gpart.Name());
      fGPartFirstMom.push_back(gpart.FirstMother());
      fGPartLastMom.push_back(gpart.LastMother());
      fGPartFirstDaugh.push_back(gpart.FirstDaughter());
      fGPartLastDaugh.push_back(gpart.LastDaughter());
      fGPartPx.push_back(gpart.Px());
      fGPartPy.push_back(gpart.Py());
      fGPartPz.push_back(gpart.Pz());
      fGPartE.push_back(gpart.E());
      fGPartMass.push_back(gpart.Mass());
      nGPart++;
    }
    fnGPart.push_back(nGPart);
  }

  auto MCPHandle = e.getHandle<std::vector<simb::MCParticle> >(fGeantLabel); 
  if (!MCPHandle) {
    throw cet::exception("anatree") << " No simb::MCParticle branch."
                                    << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
  }

  // Save MCParticle info (post-GEANT; for pre-GEANT, maybe try MCTruth?)
  // Helps to have a map from the TrackId from generator to index number
  // into *MCPHandle, which is a vector<MCParticle>.  Not all TrackId value
  // appear in MCPHandle, although I think the missing ones are all from
  // the GEANT rather than the GENIE stage of GENIEGen.  (*MCPHandle).size()
  // is the same as eg fMCPStartX.size() by the time this entry is written.
  // TracIdToIndex isa class variable for accessibility by per-Track and
  // per-Cluster code
  Int_t index = 0;
  for ( auto const& mcp : (*MCPHandle) ) {
    int TrackId = mcp.TrackId();
    TrackIdToIndex[TrackId] = index++;
  }

  for ( auto const& mcp : (*MCPHandle) ) {
    fMCTrkID.push_back(mcp.TrackId());
    fMCPDG.push_back(mcp.PdgCode());

    // If mcp.Mother() == 0, particle is from initial vertex;
    // Set MCMotherIndex to -1 in that case.
    TrkId momTrkId = mcp.Mother();
    Int_t momIndex = -1;
    int momPDG = 0;
    if (momTrkId>0) {
      //Check if it exists!
      if(TrackIdToIndex.find(momTrkId) != TrackIdToIndex.end()){
        momIndex = TrackIdToIndex[momTrkId];
        momPDG   = (*MCPHandle).at(momIndex).PdgCode();
      } else {
        MF_LOG_DEBUG("Anatree_module")
          << " mcp trkid " << mcp.TrackId()
          << " pdg code " << mcp.PdgCode()
          << " could not find mother trk id " << momTrkId
          << " in the TrackIdToIndex map"
          << " creating process is [ " << mcp.Process() << " ]";
      }
    }

    fMCMotherIndex.push_back(momIndex);
    fMCMotherTrkID.push_back(mcp.Mother());//directly trackid not index
    fMCPDGMother.push_back(momPDG);

    const TLorentzVector& position = mcp.Position(0);
    const TLorentzVector& momentum = mcp.Momentum(0);
    fMCPStartX.push_back(position.X());
    fMCPStartY.push_back(position.Y());
    fMCPStartZ.push_back(position.Z());
    fMCPTime.push_back(mcp.T());
    fMCPStartPX.push_back(momentum.Px());
    fMCPStartPY.push_back(momentum.Py());
    fMCPStartPZ.push_back(momentum.Pz());

    const TLorentzVector& positionEnd = mcp.EndPosition();
    const TLorentzVector& momentumEnd = mcp.EndMomentum();
    fMCPEndX.push_back(positionEnd.X());
    fMCPEndY.push_back(positionEnd.Y());
    fMCPEndZ.push_back(positionEnd.Z());
    fMCPEndPX.push_back(momentumEnd.Px());
    fMCPEndPY.push_back(momentumEnd.Py());
    fMCPEndPZ.push_back(momentumEnd.Pz());
    fMCPProc.push_back(mcp.Process());
    fMCPEndProc.push_back(mcp.EndProcess());
  }

  // Get vertex for each MCParticle.  In principle, the mct.GetParticle()
  // method should produce all of them; filter out the ones with a non-stable
  // status code and the GENIE pseudo-particles (Pid>= 2000000000) and you
  // should have the contents of (*MCPHandle).  But you don't.  On the 1st
  // event I (Leo Bellantoni) tested, with 40 vertices and 351 primary
  // particles, particle 143, a proton, evidently decayed or something and is
  // not in (*MCPHandle).  So we use the following primitive earth technology.
  size_t nMCParticles = (*MCPHandle).size();
  size_t iMCParticle  = 0;
  fMCPVertIndex.resize(nMCParticles);
  for (; iMCParticle<nMCParticles; ++iMCParticle) {
    // Assign noprimary to start with
    fMCPVertIndex[iMCParticle] = -1;
    // Do the primaries first
    if (fMCMotherIndex[iMCParticle]!=-1) break;
    Float_t trackX = fMCPStartX[iMCParticle];
    Float_t trackY = fMCPStartY[iMCParticle];
    Float_t trackZ = fMCPStartZ[iMCParticle];
    int vertexIndex = 0;
    for (size_t imchl = 0; imchl < mcthandlelist.size(); ++imchl) {
      for ( auto const& mct : (*mcthandlelist.at(imchl)) ) {
        if (mct.NeutrinoSet()) {
          simb::MCNeutrino nuw = mct.GetNeutrino();
          Float_t vertX = nuw.Nu().EndX();
          Float_t vertY = nuw.Nu().EndY();
          Float_t vertZ = nuw.Nu().EndZ();
          Float_t dist = std::hypot(trackX-vertX,trackY-vertY,trackZ-vertZ);
          if ( dist <= fMatchMCPtoVertDist ) {
            fMCPVertIndex[iMCParticle] = vertexIndex;
            goto foundMCvert; // break out of all inner loops
          }
        }
        ++vertexIndex;
      }
    }
  foundMCvert:
    ;
  }

  // Now the secondaries.  As they are after the primaries, do not re-init iMCParticle
  for (; iMCParticle<nMCParticles; ++iMCParticle) {
    int momIndex = fMCMotherIndex[iMCParticle];
    int lastMCParticle = iMCParticle;
    while (momIndex != -1) {
      lastMCParticle = momIndex;
      momIndex       = fMCMotherIndex[momIndex];
    }
    fMCPVertIndex[iMCParticle] = fMCPVertIndex[lastMCParticle];
  }

  if (fWriteMCPTrajectory) {
    // It's in the MCParticle table
    Int_t mcpIndex = 0;
    for ( auto const& mcp : (*MCPHandle) ) {
      const TDatabasePDG* databasePDG = TDatabasePDG::Instance();
      const TParticlePDG* definition = databasePDG->GetParticle( mcp.PdgCode() );
      //No charge don't store the trajectory
      // this test fails for alpha particles because they aren't in databasePDG
      // so skip it in this case.
      if (mcp.PdgCode() != 1000020040)
        {
          if (definition==nullptr || definition->Charge() == 0) continue;
        }
      //TrackID of the mcp to keep track to which mcp this trajectory is
      int trackId = mcp.TrackId();
      for(uint iTraj=0; iTraj < mcp.Trajectory().size(); iTraj++) {
        float xTraj = mcp.Trajectory().X(iTraj);
        float yTraj = mcp.Trajectory().Y(iTraj);
        float zTraj = mcp.Trajectory().Z(iTraj);
        float rTraj = std::hypot( yTraj - ItsInTulsa[1], zTraj - ItsInTulsa[2]);

        if (abs(xTraj - ItsInTulsa[0]) > xTPC) continue;
        if (rTraj > rTPC) continue;

        fTrajMCPX.push_back(xTraj);
        fTrajMCPY.push_back(yTraj);
        fTrajMCPZ.push_back(zTraj);
        fTrajMCPT.push_back(mcp.Trajectory().T(iTraj));
        if (fWriteMCPTrajMomenta) {
          fTrajMCPPX.push_back(mcp.Trajectory().Px(iTraj));
          fTrajMCPPY.push_back(mcp.Trajectory().Py(iTraj));
          fTrajMCPPZ.push_back(mcp.Trajectory().Pz(iTraj));
        }
        fTrajMCPE.push_back(mcp.Trajectory().E(iTraj));
        fTrajMCPIndex.push_back(mcpIndex);
        fTrajMCPTrackID.push_back(trackId);
      }
      mcpIndex++;
    }
  }

  // Get handles for MCCaloInfo

  if (fWriteMCCaloInfo) {
    art::InputTag ecalgeanttag(fGeantLabel, fInstanceLabelCalo);
    auto SimHitHandle = e.getHandle<std::vector<gar::sdp::CaloDeposit> >(ecalgeanttag);
    if (!SimHitHandle) {
      throw cet::exception("anatree") << " No gar::sdp::CaloDeposit branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }

    // Save simulation ecal hit info
    for ( auto const& SimHit : (*SimHitHandle) ) {
      fSimnHits++;
      fSimHitX.push_back(SimHit.X());
      fSimHitY.push_back(SimHit.Y());
      fSimHitZ.push_back(SimHit.Z());
      fSimHitTime.push_back(SimHit.Time());
      fSimHitEnergy.push_back(SimHit.Energy());
      fSimHitTrackID.push_back(SimHit.TrackID());
      fSimHitCellID.push_back(SimHit.CellID());
      fSimEnergySum += SimHit.Energy();
    }

    if(fWriteMuID) {
      art::InputTag muidgeanttag(fGeantLabel, fInstanceLabelMuID);
      art::Handle< std::vector<gar::sdp::CaloDeposit> > MuIDSimHitHandle;
      if (fGeo->HasMuonDetector())
        {
          MuIDSimHitHandle = e.getHandle< std::vector<gar::sdp::CaloDeposit> >(muidgeanttag);
          if (!MuIDSimHitHandle) {
            throw cet::exception("anatree") << " No gar::sdp::CaloDeposit branch."
                                            << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
          }
        }

      // Save simulation muon system hit info
      for ( auto const& SimHit : (*MuIDSimHitHandle) ) {
        fSimnHits_MuID++;
        fSimHitX_MuID.push_back(SimHit.X());
        fSimHitY_MuID.push_back(SimHit.Y());
        fSimHitZ_MuID.push_back(SimHit.Z());
        fSimHitTime_MuID.push_back(SimHit.Time());
        fSimHitEnergy_MuID.push_back(SimHit.Energy());
        fSimHitTrackID_MuID.push_back(SimHit.TrackID());
        fSimHitCellID_MuID.push_back(SimHit.CellID());
        fSimEnergySum_MuID += SimHit.Energy();
      }
    }
  }
}

void gar::anatree::FillHighLevelRecoInfo ( art::Event const &  e )

private

Definition at line 1863 of file anatree_module.cc.

                                                         {

  // Get handle for TPCClusters
  art::Handle< std::vector<rec::TPCCluster> > TPCClusterHandle;
  art::FindManyP<rec::Hit>* findManyHits = NULL;
  if (fWriteTPCClusters) {
    TPCClusterHandle = e.getHandle< std::vector<rec::TPCCluster> >(fTPCClusterLabel);
    if (!TPCClusterHandle) {
      throw cet::exception("anatree") << " No rec::TPCCluster branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }
    findManyHits = new art::FindManyP<rec::Hit>(TPCClusterHandle,e,fTPCClusterLabel);
  }

  // Get handles for Tracks and their ionizations; also Assn's to TPCClusters, TrackIoniz
  // null handles if we switch off reading in the data products
  art::Handle< std::vector<rec::Track> > TrackHandle;
  art::Handle< std::vector<rec::TrackIoniz> > TrackIonHandle;
  art::Handle< std::vector<rec::TrackTrajectory> > TrackTrajHandle;
  art::FindManyP<rec::TPCCluster>* findManyTPCClusters = NULL;
  art::FindOneP<rec::TrackIoniz>*  findIonization = NULL;
  if(fWriteTracks) {
    TrackHandle = e.getHandle< std::vector<rec::Track> >(fTrackLabel);
    if (!TrackHandle) {
      throw cet::exception("anatree") << " No rec::Track branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }
    TrackIonHandle = e.getHandle< std::vector<rec::TrackIoniz> >(fTrackLabel);
    if (!TrackIonHandle) {
      throw cet::exception("anatree") << " No rec::TrackIoniz branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }

    findManyTPCClusters = new art::FindManyP<rec::TPCCluster>(TrackHandle,e,fTrackLabel);
    findIonization      = new art::FindOneP<rec::TrackIoniz>(TrackHandle,e,fTrackLabel);

    if(fWriteTrackTrajectories) {
      TrackTrajHandle = e.getHandle< std::vector<rec::TrackTrajectory> >(fTrackTrajectoryLabel);
      if (!TrackTrajHandle) {
        throw cet::exception("anatree") << " No rec::TrackTrajectory branch."
                                        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
      }
    }
  }

  // Get handle for Vertices; also Assn's to Tracks
  art::Handle< std::vector<rec::Vertex> > VertexHandle;
  art::FindManyP<rec::Track, rec::TrackEnd>* findManyTrackEnd = NULL;
  if (fWriteVertices) {
    VertexHandle = e.getHandle< std::vector<rec::Vertex> >(fVertexLabel);
    if (!VertexHandle) {
      throw cet::exception("anatree") << " No rec::Vertex branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }
    findManyTrackEnd = new art::FindManyP<rec::Track, rec::TrackEnd>(VertexHandle,e,fVertexLabel);
  }

  // Get handle for Vees; also Assn's to Tracks
  art::Handle< std::vector<rec::Vee> > VeeHandle;
  art::FindManyP<rec::Track, rec::TrackEnd>* findManyVeeTrackEnd = NULL;
  if (fWriteVees) {
    VeeHandle = e.getHandle< std::vector<rec::Vee> >(fVeeLabel);
    if (!VeeHandle) {
      throw cet::exception("anatree") << " No rec::Vee branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }
    findManyVeeTrackEnd = new art::FindManyP<rec::Track, rec::TrackEnd>(VeeHandle,e,fVeeLabel);
  }

  // Get handle for CaloClusters; also Assn for matching tracks
  art::InputTag ecalclustertag(fClusterLabel, fInstanceLabelCalo);
  art::InputTag muidclustertag(fClusterMuIDLabel, fInstanceLabelMuID);
  art::Handle< std::vector<rec::Cluster> > RecoClusterHandle;
  art::Handle< std::vector<rec::Cluster> > RecoClusterMuIDHandle;
  art::FindManyP<rec::Track, rec::TrackEnd>* findManyCALTrackEnd = NULL;
  art::FindManyP<gar::rec::CaloHit>* findManyClusterRecoHit = NULL;
  art::FindManyP<gar::rec::CaloHit>* findManyClusterMuIDHit = NULL;

  if (fWriteCaloClusters) {
    RecoClusterHandle = e.getHandle< std::vector<rec::Cluster> >(ecalclustertag);
    if (!RecoClusterHandle) {
      throw cet::exception("anatree") << " No rec::Cluster branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }

    if(fWriteMuID) {
      if (fGeo->HasMuonDetector()){
        RecoClusterMuIDHandle = e.getHandle< std::vector<rec::Cluster> >(muidclustertag);
        if (!RecoClusterMuIDHandle) {
          throw cet::exception("anatree") << " No rec::Cluster (MuID) branch."
                                          << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
        }
      }
    }

    findManyClusterRecoHit = new art::FindManyP<gar::rec::CaloHit>(RecoClusterHandle,e,ecalclustertag);

    if (fGeo->HasMuonDetector() && fWriteMuID)
      findManyClusterMuIDHit = new art::FindManyP<gar::rec::CaloHit>(RecoClusterMuIDHandle,e,muidclustertag);
        

    if (fWriteTracks)
      findManyCALTrackEnd = new art::FindManyP<rec::Track, rec::TrackEnd>(RecoClusterHandle,e,fECALAssnLabel);

  }

  // save clusters in the TPC. For some reason, can't get FindOneP<rec::Track> or
  // FindManyP<rec::Track> to work; seems the underlying Assn isn't found.  Have
  // to FindManyP<TPCCluster> instead and  iterate if (fWriteTracks).  :(
  if (fWriteTPCClusters) {
    size_t iTPCCluster = 0;
    for ( auto const& TPCCluster : (*TPCClusterHandle) ) {
      fTPCClusterX.push_back(TPCCluster.Position()[0]);
      fTPCClusterY.push_back(TPCCluster.Position()[1]);
      fTPCClusterZ.push_back(TPCCluster.Position()[2]);
      fTPCClusterSig.push_back(TPCCluster.Signal());
      fTPCClusterRMS.push_back(TPCCluster.RMS());
      const float* cov;
      cov = TPCCluster.CovMatPacked();
      fTPCClusterCovXX.push_back(cov[0]);
      fTPCClusterCovXY.push_back(cov[1]);
      fTPCClusterCovXZ.push_back(cov[2]);
      fTPCClusterCovYY.push_back(cov[3]);
      fTPCClusterCovYZ.push_back(cov[4]);
      fTPCClusterCovZZ.push_back(cov[5]);

      // To get MC matching info from TPCClusters, 1st get the associated Hits
      int indexToPush = -1;        float valueToPush = 0;
      if ( findManyHits->isValid() ) {
        std::map<int,float> sumEforTrkID;
        float eTotCluster = 0;
        auto const& hitsInTPCCluster = findManyHits->at(iTPCCluster);
        for (size_t iHits = 0; iHits<hitsInTPCCluster.size(); ++iHits) {
          std::vector<cheat::HitIDE> IDEs = BackTrack->HitToHitIDEs( hitsInTPCCluster[iHits] );
          for (size_t iIDE = 0; iIDE<IDEs.size(); ++iIDE) {
            int  trackID    = IDEs[iIDE].trackID;
            float thisEdepE = IDEs[iIDE].energyTot;
            if ( sumEforTrkID.find(trackID) == sumEforTrkID.end() ) {
              sumEforTrkID[trackID] = 0;
            }
            sumEforTrkID[trackID] += thisEdepE;
            eTotCluster           += thisEdepE;
          }
        }
        if (sumEforTrkID.size()!=0) {
          // Sort the map by value.  Start by declaring the type of the sorting predicate
          typedef std::function<bool(std::pair<int,float>, std::pair<int,float>)> Comparator;
          // Declare a set that will store the pairs using above comparison logic
          std::set<std::pair<int,float>, Comparator> setOfTrkIDs(
                                                                 sumEforTrkID.begin(), sumEforTrkID.end(),
                                                                 [](std::pair<int,float> a ,std::pair<int,float> b) {
                                                                   return a.second > b.second;
                                                                 }
                                                                 );
          auto iReturnSet = setOfTrkIDs.begin();
          indexToPush     = TrackIdToIndex[iReturnSet->first];
          valueToPush     = iReturnSet->second/eTotCluster;
        }
      }
      fTPCClusterMCindex.push_back(indexToPush);
      fTPCClusterMCfrac.push_back(valueToPush);

      Int_t trackForThisTPCluster = -1;
      if (fWriteTracks) {
        size_t iTrack = 0;
        for ( auto const& track : (*TrackHandle) ) {
          for (size_t iCluster=0; iCluster<track.NHits(); iCluster++) {
            auto const& trackedCluster =
              *(findManyTPCClusters->at(iTrack).at(iCluster));
            if (TPCCluster==trackedCluster) {
              trackForThisTPCluster = track.getIDNumber();
              // No cluster is in 2 tracks (don't mess up dE/dx!)
              goto pushit;   // break 2 loops
            }
          }
          iTrack++;
        }
      }
    pushit:
      fTPCClusterTrkIDNumber.push_back(trackForThisTPCluster);
      iTPCCluster++;
    }
  }

  // save per-track info
  if (fWriteTracks) {
    size_t iTrack = 0;
    for ( auto const& track : (*TrackHandle) ) {
      // track is a rec::Track, not a rec::TrackPar
      fTrackIDNumber.push_back(track.getIDNumber());

      fTrackStartX.push_back(track.Vertex()[0]);
      fTrackStartY.push_back(track.Vertex()[1]);
      fTrackStartZ.push_back(track.Vertex()[2]);
      fTrackStartPX.push_back(track.Momentum_beg()*track.VtxDir()[0]);
      fTrackStartPY.push_back(track.Momentum_beg()*track.VtxDir()[1]);
      fTrackStartPZ.push_back(track.Momentum_beg()*track.VtxDir()[2]);
      fTrackStartQ.push_back(track.ChargeBeg());

      fTrackEndX.push_back(track.End()[0]);
      fTrackEndY.push_back(track.End()[1]);
      fTrackEndZ.push_back(track.End()[2]);
      fTrackEndPX.push_back(track.Momentum_end()*track.EndDir()[0]);
      fTrackEndPY.push_back(track.Momentum_end()*track.EndDir()[1]);
      fTrackEndPZ.push_back(track.Momentum_end()*track.EndDir()[2]);
      fTrackEndQ.push_back(track.ChargeEnd());

      fTrackLenF.push_back(track.LengthForward());
      fTrackLenB.push_back(track.LengthBackward());
      fTrackChi2F.push_back(track.ChisqForward());
      fTrackChi2B.push_back(track.ChisqBackward());
      fNTPCClustersOnTrack.push_back(track.NHits());

      //Add the PID information based on Tom's parametrization
      TVector3 momF(track.Momentum_beg()*track.VtxDir()[0], track.Momentum_beg()*track.VtxDir()[1], track.Momentum_beg()*track.VtxDir()[2]);
      TVector3 momB(track.Momentum_end()*track.EndDir()[0], track.Momentum_end()*track.EndDir()[1], track.Momentum_end()*track.EndDir()[2]);

      //Reconstructed momentum forward and backward
      float pF = momF.Mag();
      float pB = momB.Mag();
      std::vector< std::pair<int, float> > pidF = processPIDInfo( pF );
      std::vector< std::pair<int, float> > pidB = processPIDInfo( pB );

      //Fill the pid and its probability
      for(size_t ipid = 0; ipid < pidF.size(); ipid++) {
        fTrackPIDF.push_back( pidF.at(ipid).first );
        fTrackPIDProbF.push_back( pidF.at(ipid).second );
      }
      for(size_t ipid = 0; ipid < pidB.size(); ipid++) {
        fTrackPIDB.push_back( pidB.at(ipid).first );
        fTrackPIDProbB.push_back( pidB.at(ipid).second );
      }

      // Matching MCParticle info
      std::vector<std::pair<simb::MCParticle*,float>> trakt;
      trakt = BackTrack->TrackToMCParticles( const_cast<rec::Track*>(&track) );
      int eileen = -1;
      if (trakt.size()>0 && TrackIdToIndex.size()!=0) {
        eileen = TrackIdToIndex[trakt[0].first->TrackId()];
      }
      fTrackMCindex.push_back(eileen);
      if (eileen > -1) {
        fTrackMCfrac.push_back(trakt[0].second);
      } else {
        fTrackMCfrac.push_back(0.0);
      }

      if (findIonization->isValid()) {
        // No calibration for now.  Someday this should all be in reco
        rec::TrackIoniz ionization = *(findIonization->at(iTrack));
        float avgIonF, avgIonB;
        processIonizationInfo(ionization, fIonizTruncate, avgIonF, avgIonB);
        fTrackAvgIonF.push_back( avgIonF );
        fTrackAvgIonB.push_back( avgIonB );
      } else {
        // must push_back something so that fTrackAvgIonF,B are of correct size.
        fTrackAvgIonF.push_back( 0.0 );
        fTrackAvgIonB.push_back( 0.0 );
      }
      iTrack++;
    } // end loop over TrackHandle
  }

  //TrackTrajectories
  if(fWriteTrackTrajectories) {
    size_t iTrackTraj = 0;
    for ( auto const& tracktraj : (*TrackTrajHandle) ) {
            
      std::vector<TVector3> temp = tracktraj.getFWDTrajectory();
      for(size_t i = 0; i < temp.size(); i++) {
        fTrackTrajectoryFWDX.push_back(temp.at(i).X());
        fTrackTrajectoryFWDY.push_back(temp.at(i).Y());
        fTrackTrajectoryFWDZ.push_back(temp.at(i).Z());
        fTrackTrajectoryFWDID.push_back(iTrackTraj);
      }

      temp = tracktraj.getBAKTrajectory();
      for(size_t i = 0; i < temp.size(); i++) {
        fTrackTrajectoryBWDX.push_back(temp.at(i).X());
        fTrackTrajectoryBWDY.push_back(temp.at(i).Y());
        fTrackTrajectoryBWDZ.push_back(temp.at(i).Z());
        fTrackTrajectoryBWDID.push_back(iTrackTraj);
      }
      iTrackTraj++;
    }
  }

  // save Vertex and Track-Vertex association info
  if (fWriteVertices) {
    size_t iVertex = 0;
    for ( auto const& vertex : (*VertexHandle) ) {
      fVertexIDNumber.push_back(vertex.getIDNumber());
      fVertexX.push_back(vertex.Position()[0]);
      fVertexY.push_back(vertex.Position()[1]);
      fVertexZ.push_back(vertex.Position()[2]);
      fVertexT.push_back(vertex.Time());

      int nVertexedTracks = 0;
      if ( findManyTrackEnd->isValid() ) {
        nVertexedTracks = findManyTrackEnd->at(iVertex).size();
      }
      fVertexN.push_back(nVertexedTracks);

      int vertexCharge = 0;
      for (int iVertexedTrack=0; iVertexedTrack<nVertexedTracks; ++iVertexedTrack) {
        fVTAssn_VertIDNumber.push_back(vertex.getIDNumber());

        // Get this vertexed track.
        rec::Track track = *(findManyTrackEnd->at(iVertex).at(iVertexedTrack));
        fVTAssn_TrackIDNumber.push_back(track.getIDNumber());

        // Get the end of the track in the vertex.  It isn't that odd for the end
        // of the track not used in the vertex to be closer to the vertex than the
        // one actually used; you might have a very short stub track in a 3 track
        // vertex with small opening angles and the other 2 tracks might pull the
        // vertex some distance towards the far end of the stub track
        rec::TrackEnd fee = *(findManyTrackEnd->data(iVertex).at(iVertexedTrack));
        // TrackEnd is defined in Track.h; 1 means use Beg values, 0 means use End
        fVTAssn_TrackEnd.push_back(fee);

        if (fee==rec::TrackEndBeg) {
          vertexCharge += track.ChargeBeg();
        } else {
          vertexCharge += track.ChargeEnd();
        }
      }
      fVertexQ.push_back(vertexCharge);
      ++iVertex;
    } // end loop over VertexHandle
  }

  // save Vee and Track-Vee association info
  if (fWriteVees) {
    size_t iVee = 0;
    for ( auto const& vee : (*VeeHandle) ) {
      fVeeIDNumber.push_back(vee.getIDNumber());
      fVeeX.push_back(vee.Position()[0]);
      fVeeY.push_back(vee.Position()[1]);
      fVeeZ.push_back(vee.Position()[2]);
      fVeeT.push_back(vee.Time());
      fVeePXKpipi.push_back(vee.FourMomentum(0).X());
      fVeePYKpipi.push_back(vee.FourMomentum(0).Y());
      fVeePZKpipi.push_back(vee.FourMomentum(0).Z());
      fVeeEKpipi.push_back(vee.FourMomentum(0).E());
      fVeeMKpipi.push_back(vee.FourMomentum(0).M());
      fVeePXLppi.push_back(vee.FourMomentum(1).X());
      fVeePYLppi.push_back(vee.FourMomentum(1).Y());
      fVeePZLppi.push_back(vee.FourMomentum(1).Z());
      fVeeELppi.push_back(vee.FourMomentum(1).E());
      fVeeMLppi.push_back(vee.FourMomentum(1).M());
      fVeePXLpip.push_back(vee.FourMomentum(2).X());
      fVeePYLpip.push_back(vee.FourMomentum(2).Y());
      fVeePZLpip.push_back(vee.FourMomentum(2).Z());
      fVeeELpip.push_back(vee.FourMomentum(2).E());
      fVeeMLpip.push_back(vee.FourMomentum(2).M());

      int nVeeTracks = 0;
      if ( findManyVeeTrackEnd->isValid() ) {
        nVeeTracks = findManyVeeTrackEnd->at(iVee).size();
      }

      for (int iVeeTrack=0; iVeeTrack<nVeeTracks; ++iVeeTrack) {
        fVeeTAssn_VeeIDNumber.push_back(vee.getIDNumber());

        // Get this vertexed track.
        rec::Track track = *(findManyVeeTrackEnd->at(iVee).at(iVeeTrack));
        fVeeTAssn_TrackIDNumber.push_back(track.getIDNumber());

        rec::TrackEnd fee = *(findManyVeeTrackEnd->data(iVee).at(iVeeTrack));
        // TrackEnd is defined in Track.h; 1 means use Beg values, 0 means use End
        fVeeTAssn_TrackEnd.push_back(fee);
      }
      ++iVee;
    } // end loop over VeeHandle
  }

  // save Cluster info
  if (fWriteCaloClusters) {
    size_t iCluster = 0;
    for ( auto const& cluster : (*RecoClusterHandle) ) {
      fnCluster++;
      fClusterIDNumber.push_back(cluster.getIDNumber());
      fClusterNhits.push_back(cluster.CalorimeterHits().size());
      fClusterEnergy.push_back(cluster.Energy());
      fClusterTime.push_back(cluster.Time());
      fClusterTimeDiffFirstLast.push_back(cluster.TimeDiffFirstLast());
      fClusterX.push_back(cluster.Position()[0]);
      fClusterY.push_back(cluster.Position()[1]);
      fClusterZ.push_back(cluster.Position()[2]);
      fClusterTheta.push_back(cluster.ITheta());
      fClusterPhi.push_back(cluster.IPhi());
      fClusterPID.push_back(cluster.ParticleID());
      // fClusterShape.push_back(cluster.Shape());
      fClusterMainAxisX.push_back(cluster.EigenVectors()[0]);
      fClusterMainAxisY.push_back(cluster.EigenVectors()[1]);
      fClusterMainAxisZ.push_back(cluster.EigenVectors()[2]);

      //Get the associated reco hit
      std::vector<ULong64_t> fVecHitIDs = {};
      if (findManyClusterRecoHit->isValid()) {
        int nClusterHit = findManyClusterRecoHit->at(iCluster).size();
        for (int iClusterHit=0; iClusterHit<nClusterHit; ++iClusterHit) {
          rec::CaloHit hit  = *(findManyClusterRecoHit->at(iCluster).at(iClusterHit));
          fVecHitIDs.push_back(hit.getIDNumber());
        }
      }

      fClusterAssn_RecoHitIDNumber.push_back(fVecHitIDs);

      // Matching MCParticle info
      std::vector<std::pair<simb::MCParticle*,float>> trakt;
      trakt = BackTrack->ClusterToMCParticles( const_cast<rec::Cluster*>(&cluster) );
      int eileen = -1;
      if (trakt.size()>0 && TrackIdToIndex.size()!=0) {
        eileen = TrackIdToIndex[trakt[0].first->TrackId()];
      }
      fClusterMCindex.push_back(eileen);
      if (eileen > -1) {
        fClusterMCfrac.push_back(trakt[0].second);
      } else {
        fClusterMCfrac.push_back(0.0);
      }
      iCluster++;
    }

    if(fGeo->HasMuonDetector() && fWriteMuID) {
      size_t iCluster_local = 0;
      for ( auto const& cluster : (*RecoClusterMuIDHandle) ) {
        fnCluster_MuID++;
        fClusterIDNumber_MuID.push_back(cluster.getIDNumber());
        fClusterNhits_MuID.push_back(cluster.CalorimeterHits().size());
        fClusterEnergy_MuID.push_back(cluster.Energy());
        fClusterTime_MuID.push_back(cluster.Time());
        fClusterTimeDiffFirstLast_MuID.push_back(cluster.TimeDiffFirstLast());
        fClusterX_MuID.push_back(cluster.Position()[0]);
        fClusterY_MuID.push_back(cluster.Position()[1]);
        fClusterZ_MuID.push_back(cluster.Position()[2]);
        fClusterTheta_MuID.push_back(cluster.ITheta());
        fClusterPhi_MuID.push_back(cluster.IPhi());
        fClusterPID_MuID.push_back(cluster.ParticleID());
        // fClusterShape.push_back(cluster.Shape());
        fClusterMainAxisX_MuID.push_back(cluster.EigenVectors()[0]);
        fClusterMainAxisY_MuID.push_back(cluster.EigenVectors()[1]);
        fClusterMainAxisZ_MuID.push_back(cluster.EigenVectors()[2]);

        //Get the associated reco hit
        std::vector<ULong64_t> fVecHitIDs = {};
        if (findManyClusterMuIDHit->isValid()) {
          int nClusterHit = findManyClusterMuIDHit->at(iCluster_local).size();
          for (int iClusterHit=0; iClusterHit<nClusterHit; ++iClusterHit) {
            rec::CaloHit hit  = *(findManyClusterMuIDHit->at(iCluster_local).at(iClusterHit));
            fVecHitIDs.push_back(hit.getIDNumber());
          }
        }

        fClusterMuIDAssn_MuIDHitIDNumber.push_back(fVecHitIDs);

        /*** TO DO ***/
        // Matching MCParticle info
        // std::vector<std::pair<simb::MCParticle*,float>> trakt;
        // trakt = BackTrack->ClusterToMCParticles( const_cast<rec::Cluster*>(&cluster) );
        // int eileen = -1;
        // if (trakt.size()>0 && TrackIdToIndex.size()!=0) {
        //     eileen = TrackIdToIndex[trakt[0].first->TrackId()];
        // }
        // fClusterMCindex_MuID.push_back(eileen);
        // if (eileen > -1) {
        //     fClusterMCfrac_MuID.push_back(trakt[0].second);
        // } else {
        //     fClusterMCfrac_MuID.push_back(0.0);
        // }
        fClusterMCindex_MuID.push_back(0);
        fClusterMCfrac_MuID.push_back(0.0);
        iCluster_local++;
      }
    }
  }

  // Write info for ECAL-matched tracks
  if (fWriteMatchedTracks) {
    size_t iCluster = 0;
    for ( auto const& cluster : (*RecoClusterHandle) ) {
      int nCALedTracks(0);
      if ( findManyCALTrackEnd->isValid() ) {
        nCALedTracks = findManyCALTrackEnd->at(iCluster).size();
      }
      for (int iCALedTrack=0; iCALedTrack<nCALedTracks; ++iCALedTrack) {
        fCALAssn_ClusIDNumber.push_back(cluster.getIDNumber());
        rec::Track track  = *(findManyCALTrackEnd->at(iCluster).at(iCALedTrack));
        fCALAssn_TrackIDNumber.push_back( track.getIDNumber() );

        rec::TrackEnd fee = *(findManyCALTrackEnd->data(iCluster).at(iCALedTrack));
        fCALAssn_TrackEnd.push_back(fee);    // The rec::TrackEnd (see Track.h) that extrapolated to cluster
      }
      iCluster++;
    }
  } // end branch on fWriteCaloInfo

  return;
} // end :anatree::FillVectors

void gar::anatree::FillRawInfo ( art::Event const &  e )

private

Definition at line 1744 of file anatree_module.cc.

                                               {

  // save ecal raw digits info
  art::InputTag ecalrawtag(fRawCaloHitLabel, fInstanceLabelCalo);
  auto RawHitHandle = e.getHandle<std::vector<gar::raw::CaloRawDigit> >(ecalrawtag);
  if (!RawHitHandle) {
    throw cet::exception("anatree") << " No :raw::CaloRawDigit branch."
                                    << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
  }
  for ( auto const& DigiHit : (*RawHitHandle) ) {
    fDiginHits++;
    fDigiHitX.push_back(DigiHit.X());
    fDigiHitY.push_back(DigiHit.Y());
    fDigiHitZ.push_back(DigiHit.Z());
    fDigiHitTime.push_back( (DigiHit.Time().first + DigiHit.Time().second) / 2.0 );
    fDigiHitADC.push_back(DigiHit.ADC().first);
    fDigiHitCellID.push_back(DigiHit.CellID());
  }

  // save muon system raw digits info
  if(fWriteMuID) {
    art::InputTag muidrawtag(fRawMuIDHitLabel, fInstanceLabelMuID);
    art::Handle<std::vector<gar::raw::CaloRawDigit> > MuIDRawHitHandle;
    if (fGeo->HasMuonDetector()) {
      MuIDRawHitHandle = e.getHandle<std::vector<gar::raw::CaloRawDigit> >(muidrawtag);
      if (!MuIDRawHitHandle) {
        throw cet::exception("anatree") << " No :raw::CaloRawDigit branch."
                                        << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
      }
    }

    for ( auto const& DigiHit : (*MuIDRawHitHandle) ) {
      fDiginHits_MuID++;
      fDigiHitX_MuID.push_back(DigiHit.X());
      fDigiHitY_MuID.push_back(DigiHit.Y());
      fDigiHitZ_MuID.push_back(DigiHit.Z());
      fDigiHitTime_MuID.push_back( (DigiHit.Time().first + DigiHit.Time().second) / 2.0 );
      fDigiHitADC_MuID.push_back(DigiHit.ADC().first);
      fDigiHitCellID_MuID.push_back(DigiHit.CellID());
    }
  }
}

void gar::anatree::FillRecoInfo ( art::Event const &  e )

private

Definition at line 1792 of file anatree_module.cc.

                                                {

  // Get handle for TPC hit data
  if (fWriteHits) {
    auto HitHandle = e.getHandle<std::vector<rec::Hit> >(fHitLabel);
    if (!HitHandle) {
      throw cet::exception("anatree") << " No rec::Hit branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }

    // save hits in the TPC
    for ( auto const& Hit : (*HitHandle) ) {
      fHitX.push_back(Hit.Position()[0]);
      fHitY.push_back(Hit.Position()[1]);
      fHitZ.push_back(Hit.Position()[2]);
      fHitSig.push_back(Hit.Signal());
      fHitRMS.push_back(Hit.RMS());
      fHitChan.push_back(Hit.Channel());
    }
  }

  if (fWriteCaloHits) {
    art::InputTag ecalrecotag(fCaloHitLabel, fInstanceLabelCalo);
    auto RecoHitHandle = e.getHandle<std::vector<rec::CaloHit> >(ecalrecotag);
    if (!RecoHitHandle) {
      throw cet::exception("anatree") << " No rec::CaloHit branch."
                                      << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
    }
    // save reco'd Calorimetry hits
    for ( auto const& Hit : (*RecoHitHandle) ) {
      fReconHits++;
      fReconHitIDNumber.push_back(Hit.getIDNumber());
      fRecoHitX.push_back(Hit.Position()[0]);
      fRecoHitY.push_back(Hit.Position()[1]);
      fRecoHitZ.push_back(Hit.Position()[2]);
      fRecoHitTime.push_back(Hit.Time().first);
      fRecoHitEnergy.push_back(Hit.Energy());
      fRecoHitCellID.push_back(Hit.CellID());
      fRecoHitLayer.push_back(fFieldDecoder_ECAL->get(Hit.CellID(), "layer"));
      fRecoEnergySum += Hit.Energy();
    }

    if(fWriteMuID) {
      art::InputTag muirecotag(fMuIDHitLabel, fInstanceLabelMuID);
      art::Handle<std::vector<rec::CaloHit> > MuIDRecoHitHandle;
      if (fGeo->HasMuonDetector()) {
        MuIDRecoHitHandle = e.getHandle<std::vector<rec::CaloHit> >(muirecotag);
        if (!MuIDRecoHitHandle) {
          throw cet::exception("anatree") << " No rec::CaloHit branch."
                                          << " Line " << __LINE__ << " in file " << __FILE__ << std::endl;
        }
      }
      for ( auto const& Hit : (*MuIDRecoHitHandle) ) {
        fReconHits_MuID++;
        fReconHitIDNumber_MuID.push_back(Hit.getIDNumber());
        fRecoHitX_MuID.push_back(Hit.Position()[0]);
        fRecoHitY_MuID.push_back(Hit.Position()[1]);
        fRecoHitZ_MuID.push_back(Hit.Position()[2]);
        fRecoHitTime_MuID.push_back(Hit.Time().first);
        fRecoHitEnergy_MuID.push_back(Hit.Energy());
        fRecoHitCellID_MuID.push_back(Hit.CellID());
        fRecoHitLayer_MuID.push_back(fFieldDecoder_MuID->get(Hit.CellID(), "layer"));
        fRecoEnergySum_MuID += Hit.Energy();
      }
    }
  }
}

static bool gar::anatree::lessThan_byE ( std::pair< float, float >  a, std::pair< float, float >  b  )

inlinestaticprivate

Definition at line 111 of file anatree_module.cc.

    {return a.first < b.first;}

anatree& gar::anatree::operator= ( anatree const &  )

delete

anatree& gar::anatree::operator= ( anatree &&  )

delete

void gar::anatree::processIonizationInfo ( rec::TrackIoniz &  ion, float  ionizeTruncate, float &  forwardIonVal, float &  backwardIonVal  )

private

Definition at line 2370 of file anatree_module.cc.

                                                                                      {

  // NO CALIBRATION SERVICE FOR NOW

  std::vector<std::pair<float,float>> SigData = ion.getFWD_dSigdXs();
  forwardIonVal = processOneDirection(SigData, ionizeTruncate);

  SigData = ion.getBAK_dSigdXs();
  backwardIonVal = processOneDirection(SigData, ionizeTruncate);

  return;
}

float gar::anatree::processOneDirection ( std::vector< std::pair< float, float >>  SigData, float  ionizeTruncate  )

private

Definition at line 2386 of file anatree_module.cc.

                                                                                                   {

  std::vector<std::pair<float,float>> dEvsX;    // Ionization vs distance along track

  // The first hit on the track never had its ionization info stored.  Not a problem
  // really.  Each pair is a hit and the step along the track that ends at the hit
  // For the last hit, just take the step from the n-1 hit; don't guess some distance
  // to (nonexistant!) n+1 hit.  Using pointer arithmetic because you are a real K&R
  // C nerd!  Except that C++ doesn't know you are such a nerd and if
  //  SigData.size()==0, then SigData.end()-1 is 0xFFFFFFFFFFFFFFF8.
  if (SigData.size()==0) return 0.0;
  float distAlongTrack = 0;
  std::vector<std::pair<float,float>>::iterator littlebit = SigData.begin();
  for (; littlebit<(SigData.end()-1); ++littlebit) {
    float dE =   std::get<0>(*littlebit);
    // tpctrackfit2_module.cc fills the TrackIoniz data product so that
    // this quantity is really dL > 0 not dX, a coordinate on the drift axis
    float dX  = std::get<1>(*littlebit);
    distAlongTrack += dX;    // But count full step to get hit position on track
    // Take dX to be 1/2 the previous + last segment
    dX += std::get<1>(*(littlebit+1));
    float dEdX = dE/(0.5*dX);

    std::pair pushme = std::make_pair(dEdX,distAlongTrack);
    dEvsX.push_back( pushme );
  }

  // Get the truncated mean; first sort then take mean
  std::sort(dEvsX.begin(),dEvsX.end(), lessThan_byE);

  // Get the dEdX vs length data, truncated.
  int goUpTo = ionizeTruncate * dEvsX.size() +0.5;
  if (goUpTo > (int)dEvsX.size()) goUpTo = dEvsX.size();
  int i = 1;        float returnvalue = 0;
  littlebit = dEvsX.begin();
  for (; littlebit<dEvsX.end(); ++littlebit) {
    returnvalue += std::get<0>(*littlebit);
    ++i;
    if (i>goUpTo) break;
  }
  returnvalue /= goUpTo;
  return returnvalue;
}

std::vector< std::pair< int, float > > gar::anatree::processPIDInfo ( float  p )

private

Definition at line 2493 of file anatree_module.cc.

                                                                     {

  std::vector<std::string> recopnamelist = {"#pi", "#mu", "p", "K", "d", "e"};
  std::vector<int> pdg_charged = {211, 13, 2212, 321, 1000010020, 11};
  std::vector< std::pair<int, float> > pid;
  pid.resize(6);

  int qclosest = 0;
  float dist = 100000000.;
  CLHEP::RandFlat FlatRand(fEngine);

  for (int q = 0; q < 501; ++q) {
    //Check the title and the reco momentum take only the one that fits
    std::string fulltitle = m_pidinterp[q]->GetTitle();
    unsigned first = fulltitle.find("=");
    unsigned last = fulltitle.find("GeV");
    std::string substr = fulltitle.substr(first+1, last - first-1);
    float pidinterp_mom = std::atof(substr.c_str());
    //calculate the distance between the bin and mom, store the q the closest
    float disttemp = std::abs(pidinterp_mom - p);

    if( disttemp < dist ) {
      dist = disttemp;
      qclosest = q;
    }
  } // closes the "pidmatrix" loop

    //Compute all the probabities for each type of true to reco
    //loop over the columns (true pid)
  for (int pidm = 0; pidm < 6; ++pidm) {

    //loop over the columns (true pid)
    std::vector< std::pair<float, std::string> > v_prob;

    //loop over the rows (reco pid)
    for (int pidr = 0; pidr < 6; ++pidr) {
      std::string recoparticlename = m_pidinterp[qclosest]->GetYaxis()->GetBinLabel(pidr+1);
      float prob = m_pidinterp[qclosest]->GetBinContent(pidm+1, pidr+1);
      //Need to check random number value and prob value then associate the recopdg to the reco prob
      v_prob.push_back( std::make_pair(prob, recoparticlename) );
    }

    //Compute the pid from it
    if (v_prob.size() > 1) {
      //Order the vector of prob
      std::sort(v_prob.begin(), v_prob.end());
      //Throw a random number between 0 and 1
      float random_number = FlatRand.fire();
      //Make cumulative sum to get the range
      std::partial_sum(v_prob.begin(), v_prob.end(), v_prob.begin(), [](const P& _x, const P& _y){return P(_x.first + _y.first, _y.second);});

      for(size_t ivec = 0; ivec < v_prob.size()-1; ivec++) {
        if( random_number < v_prob.at(ivec+1).first && random_number >= v_prob.at(ivec).first ) {
          pid.push_back( std::make_pair(pdg_charged.at( std::distance( recopnamelist.begin(), std::find(recopnamelist.begin(), recopnamelist.end(), v_prob.at(ivec+1).second) ) ), v_prob.at(ivec+1).first) );
        }
      }
    } else {
      pid.push_back( std::make_pair(pdg_charged.at( std::distance( recopnamelist.begin(), std::find(recopnamelist.begin(), recopnamelist.end(), v_prob.at(0).second) ) ), v_prob.at(0).first) );
    }
  }

  //return a vector of pid and prob
  return pid;
}

Member Data Documentation

cheat::BackTrackerCore* gar::anatree::BackTrack

private

Definition at line 99 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fCALAssn_ClusIDNumber

private

Definition at line 501 of file anatree_module.cc.

std::vector<gar::rec::TrackEnd> gar::anatree::fCALAssn_TrackEnd

private

Definition at line 503 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fCALAssn_TrackIDNumber

private

Definition at line 502 of file anatree_module.cc.

std::string gar::anatree::fCaloHitLabel

private

module label for reco calo hits rec::CaloHit

Definition at line 145 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fCCNC

private

Definition at line 210 of file anatree_module.cc.

std::vector<std::vector<ULong64_t> > gar::anatree::fClusterAssn_RecoHitIDNumber

private

Definition at line 495 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterEnergy

private

Definition at line 458 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterEnergy_MuID

private

Definition at line 478 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fClusterIDNumber

private

Definition at line 456 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fClusterIDNumber_MuID

private

Definition at line 476 of file anatree_module.cc.

std::string gar::anatree::fClusterLabel

private

module label for calo clusters rec::Cluster

Definition at line 148 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMainAxisX

private

Definition at line 468 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMainAxisX_MuID

private

Definition at line 488 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMainAxisY

private

Definition at line 469 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMainAxisY_MuID

private

Definition at line 489 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMainAxisZ

private

Definition at line 470 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMainAxisZ_MuID

private

Definition at line 490 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMCfrac

private

Definition at line 472 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterMCfrac_MuID

private

Definition at line 492 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fClusterMCindex

private

Definition at line 471 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fClusterMCindex_MuID

private

Definition at line 491 of file anatree_module.cc.

std::vector<std::vector<ULong64_t> > gar::anatree::fClusterMuIDAssn_MuIDHitIDNumber

private

Definition at line 498 of file anatree_module.cc.

std::string gar::anatree::fClusterMuIDLabel

private

module label for calo clusters rec::Cluster in MuID

Definition at line 149 of file anatree_module.cc.

std::vector<UInt_t> gar::anatree::fClusterNhits

private

Definition at line 457 of file anatree_module.cc.

std::vector<UInt_t> gar::anatree::fClusterNhits_MuID

private

Definition at line 477 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterPhi

private

Definition at line 465 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterPhi_MuID

private

Definition at line 485 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterPID

private

Definition at line 466 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterPID_MuID

private

Definition at line 486 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterTheta

private

Definition at line 464 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterTheta_MuID

private

Definition at line 484 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterTime

private

Definition at line 459 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterTime_MuID

private

Definition at line 479 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterTimeDiffFirstLast

private

Definition at line 460 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterTimeDiffFirstLast_MuID

private

Definition at line 480 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterX

private

Definition at line 461 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterX_MuID

private

Definition at line 481 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterY

private

Definition at line 462 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterY_MuID

private

Definition at line 482 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterZ

private

Definition at line 463 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fClusterZ_MuID

private

Definition at line 483 of file anatree_module.cc.

std::vector<UInt_t> gar::anatree::fDigiHitADC

private

Definition at line 418 of file anatree_module.cc.

std::vector<UInt_t> gar::anatree::fDigiHitADC_MuID

private

Definition at line 427 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fDigiHitCellID

private

Definition at line 419 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fDigiHitCellID_MuID

private

Definition at line 428 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitTime

private

Definition at line 417 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitTime_MuID

private

Definition at line 426 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitX

private

Definition at line 414 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitX_MuID

private

Definition at line 423 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitY

private

Definition at line 415 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitY_MuID

private

Definition at line 424 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitZ

private

Definition at line 416 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fDigiHitZ_MuID

private

Definition at line 425 of file anatree_module.cc.

UInt_t gar::anatree::fDiginHits

private

Definition at line 413 of file anatree_module.cc.

UInt_t gar::anatree::fDiginHits_MuID

private

Definition at line 422 of file anatree_module.cc.

std::string gar::anatree::fECALAssnLabel

private

module label for track-clusters associations

Definition at line 151 of file anatree_module.cc.

std::string gar::anatree::fECALEncoding

private

Definition at line 182 of file anatree_module.cc.

CLHEP::HepRandomEngine& gar::anatree::fEngine

private

random engine

Definition at line 506 of file anatree_module.cc.

Int_t gar::anatree::fEvent

private

number of the event being processed

Definition at line 192 of file anatree_module.cc.

gar::geo::BitFieldCoder* gar::anatree::fFieldDecoder_ECAL

private

Definition at line 184 of file anatree_module.cc.

gar::geo::BitFieldCoder* gar::anatree::fFieldDecoder_MuID

private

Definition at line 185 of file anatree_module.cc.

std::string gar::anatree::fGeantLabel

private

module label for geant4 simulated hits

Definition at line 133 of file anatree_module.cc.

std::vector<std::string> gar::anatree::fGeneratorLabels

private

Definition at line 126 of file anatree_module.cc.

std::vector<std::string> gar::anatree::fGENIEGeneratorLabels

private

Definition at line 127 of file anatree_module.cc.

const geo::GeometryCore* gar::anatree::fGeo

private

pointer to the geometry

Definition at line 181 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGint

private

Definition at line 227 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fGPartE

private

Definition at line 246 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartFirstDaugh

private

Definition at line 240 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartFirstMom

private

Definition at line 238 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartIdx

private

Definition at line 235 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartIntIdx

private

Definition at line 234 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartLastDaugh

private

Definition at line 241 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartLastMom

private

Definition at line 239 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fGPartMass

private

Definition at line 247 of file anatree_module.cc.

std::vector<std::string> gar::anatree::fGPartName

private

Definition at line 242 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartPdg

private

Definition at line 236 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fGPartPx

private

Definition at line 243 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fGPartPy

private

Definition at line 244 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fGPartPz

private

Definition at line 245 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fGPartStatus

private

Definition at line 237 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fgT

private

Definition at line 230 of file anatree_module.cc.

std::vector<UInt_t> gar::anatree::fHitChan

private

Definition at line 312 of file anatree_module.cc.

std::string gar::anatree::fHitLabel

private

module label for reco TPC hits rec::Hit

Definition at line 135 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fHitRMS

private

Definition at line 311 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fHitSig

private

Definition at line 310 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fHitX

private

Definition at line 307 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fHitY

private

Definition at line 308 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fHitZ

private

Definition at line 309 of file anatree_module.cc.

std::string gar::anatree::fInstanceLabelCalo

private

Instance name for ECAL.

Definition at line 130 of file anatree_module.cc.

std::string gar::anatree::fInstanceLabelMuID

private

Instance name for MuID.

Definition at line 131 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fInteractionType

private

Definition at line 212 of file anatree_module.cc.

float gar::anatree::fIonizTruncate

private

Default=1.00;.

Definition at line 174 of file anatree_module.cc.

float gar::anatree::fMatchMCPtoVertDist

private

MCParticle to MC vertex match Default=roundoff.

Definition at line 158 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fMCMotherIndex

private

Definition at line 252 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fMCMotherTrkID

private

Definition at line 253 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCnuPx

private

Definition at line 222 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCnuPy

private

Definition at line 223 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCnuPz

private

Definition at line 224 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fMCPDG

private

Definition at line 251 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fMCPDGMother

private

Definition at line 254 of file anatree_module.cc.

std::vector<std::string> gar::anatree::fMCPEndProc

private

Definition at line 269 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPEndPX

private

Definition at line 265 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPEndPY

private

Definition at line 266 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPEndPZ

private

Definition at line 267 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPEndX

private

Definition at line 262 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPEndY

private

Definition at line 263 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPEndZ

private

Definition at line 264 of file anatree_module.cc.

std::vector<std::string> gar::anatree::fMCPProc

private

Definition at line 268 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPStartPX

private

Definition at line 259 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPStartPY

private

Definition at line 260 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPStartPZ

private

Definition at line 261 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPStartX

private

Definition at line 255 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPStartY

private

Definition at line 256 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPStartZ

private

Definition at line 257 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCPTime

private

Definition at line 258 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fMCPVertIndex

private

Definition at line 270 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fMCTrkID

private

Definition at line 250 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCVertexX

private

Definition at line 219 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCVertexY

private

Definition at line 220 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fMCVertexZ

private

Definition at line 221 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fMode

private

Definition at line 211 of file anatree_module.cc.

std::string gar::anatree::fMuIDEncoding

private

Definition at line 183 of file anatree_module.cc.

std::string gar::anatree::fMuIDHitLabel

private

Definition at line 146 of file anatree_module.cc.

UInt_t gar::anatree::fnCluster

private

Definition at line 455 of file anatree_module.cc.

UInt_t gar::anatree::fnCluster_MuID

private

Definition at line 475 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fNeutrinoType

private

Definition at line 209 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fnGPart

private

Definition at line 233 of file anatree_module.cc.

Int_t gar::anatree::fNSpills

private

Definition at line 199 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fNTPCClustersOnTrack

private

Definition at line 352 of file anatree_module.cc.

std::string gar::anatree::fPFLabel

private

module label for reco particles rec::PFParticle

Definition at line 150 of file anatree_module.cc.

std::string gar::anatree::fPOTtag

private

Definition at line 128 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fQ2

private

Definition at line 213 of file anatree_module.cc.

std::string gar::anatree::fRawCaloHitLabel

private

module label for digitized calo hits raw::CaloRawDigit

Definition at line 142 of file anatree_module.cc.

std::string gar::anatree::fRawMuIDHitLabel

private

Definition at line 143 of file anatree_module.cc.

Float_t gar::anatree::fRecoEnergySum

private

Definition at line 440 of file anatree_module.cc.

Float_t gar::anatree::fRecoEnergySum_MuID

private

Definition at line 452 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fRecoHitCellID

private

Definition at line 438 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fRecoHitCellID_MuID

private

Definition at line 450 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitEnergy

private

Definition at line 437 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitEnergy_MuID

private

Definition at line 449 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fRecoHitLayer

private

Definition at line 439 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fRecoHitLayer_MuID

private

Definition at line 451 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitTime

private

Definition at line 436 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitTime_MuID

private

Definition at line 448 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitX

private

Definition at line 433 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitX_MuID

private

Definition at line 445 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitY

private

Definition at line 434 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitY_MuID

private

Definition at line 446 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitZ

private

Definition at line 435 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fRecoHitZ_MuID

private

Definition at line 447 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fReconHitIDNumber

private

Definition at line 432 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fReconHitIDNumber_MuID

private

Definition at line 444 of file anatree_module.cc.

UInt_t gar::anatree::fReconHits

private

Definition at line 431 of file anatree_module.cc.

UInt_t gar::anatree::fReconHits_MuID

private

Definition at line 443 of file anatree_module.cc.

Int_t gar::anatree::fRun

private

number of the run being processed

Definition at line 193 of file anatree_module.cc.

Float_t gar::anatree::fSimEnergySum

private

Definition at line 293 of file anatree_module.cc.

Float_t gar::anatree::fSimEnergySum_MuID

private

Definition at line 304 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fSimHitCellID

private

Definition at line 292 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fSimHitCellID_MuID

private

Definition at line 303 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitEnergy

private

Definition at line 290 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitEnergy_MuID

private

Definition at line 301 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitTime

private

Definition at line 289 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitTime_MuID

private

Definition at line 300 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fSimHitTrackID

private

Definition at line 291 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fSimHitTrackID_MuID

private

Definition at line 302 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitX

private

Definition at line 286 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitX_MuID

private

Definition at line 297 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitY

private

Definition at line 287 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitY_MuID

private

Definition at line 298 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitZ

private

Definition at line 288 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fSimHitZ_MuID

private

Definition at line 299 of file anatree_module.cc.

UInt_t gar::anatree::fSimnHits

private

Definition at line 285 of file anatree_module.cc.

UInt_t gar::anatree::fSimnHits_MuID

private

Definition at line 296 of file anatree_module.cc.

Int_t gar::anatree::fSubRun

private

number of the sub-run being processed

Definition at line 194 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fT

private

Definition at line 218 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTgtPDG

private

Definition at line 228 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTheta

private

Definition at line 217 of file anatree_module.cc.

Int_t gar::anatree::fTotalPOT

private

Definition at line 198 of file anatree_module.cc.

Float_t gar::anatree::fTPC_X

private

center of TPC stored as per-event & compressed by root

Definition at line 195 of file anatree_module.cc.

Float_t gar::anatree::fTPC_Y

private

Definition at line 196 of file anatree_module.cc.

Float_t gar::anatree::fTPC_Z

private

Definition at line 197 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterCovXX

private

Definition at line 321 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterCovXY

private

Definition at line 322 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterCovXZ

private

Definition at line 323 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterCovYY

private

Definition at line 324 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterCovYZ

private

Definition at line 325 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterCovZZ

private

Definition at line 326 of file anatree_module.cc.

std::string gar::anatree::fTPCClusterLabel

private

module label for TPC Clusters rec::TPCCluster

Definition at line 136 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterMCfrac

private

Definition at line 328 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTPCClusterMCindex

private

Definition at line 327 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterRMS

private

Definition at line 319 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterSig

private

Definition at line 318 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fTPCClusterTrkIDNumber

private

Definition at line 320 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterX

private

Definition at line 315 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterY

private

Definition at line 316 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTPCClusterZ

private

Definition at line 317 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackAvgIonB

private

Definition at line 354 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackAvgIonF

private

Definition at line 353 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackChi2B

private

Definition at line 351 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackChi2F

private

Definition at line 350 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackEndPX

private

Definition at line 343 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackEndPY

private

Definition at line 344 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackEndPZ

private

Definition at line 345 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrackEndQ

private

Definition at line 346 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackEndX

private

Definition at line 340 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackEndY

private

Definition at line 341 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackEndZ

private

Definition at line 342 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fTrackIDNumber

private

Definition at line 331 of file anatree_module.cc.

std::string gar::anatree::fTrackLabel

private

module label for TPC Tracks rec:Track

Definition at line 137 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackLenB

private

Definition at line 349 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackLenF

private

Definition at line 348 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackMCfrac

private

Definition at line 361 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrackMCindex

private

Definition at line 360 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrackPIDB

private

Definition at line 358 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrackPIDF

private

Definition at line 356 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackPIDProbB

private

Definition at line 359 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackPIDProbF

private

Definition at line 357 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackStartPX

private

Definition at line 335 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackStartPY

private

Definition at line 336 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackStartPZ

private

Definition at line 337 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrackStartQ

private

Definition at line 338 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackStartX

private

Definition at line 332 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackStartY

private

Definition at line 333 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackStartZ

private

Definition at line 334 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrackTrajectoryBWDID

private

Definition at line 372 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackTrajectoryBWDX

private

Definition at line 369 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackTrajectoryBWDY

private

Definition at line 370 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackTrajectoryBWDZ

private

Definition at line 371 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrackTrajectoryFWDID

private

Definition at line 367 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackTrajectoryFWDX

private

Definition at line 364 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackTrajectoryFWDY

private

Definition at line 365 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrackTrajectoryFWDZ

private

Definition at line 366 of file anatree_module.cc.

std::string gar::anatree::fTrackTrajectoryLabel

private

module label for TPC Track Trajectories rec:TrackTrajectory

Definition at line 138 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPE

private

Definition at line 277 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrajMCPIndex

private

Definition at line 278 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPPX

private

Definition at line 280 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPPY

private

Definition at line 281 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPPZ

private

Definition at line 282 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPT

private

Definition at line 276 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fTrajMCPTrackID

private

Definition at line 279 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPX

private

Definition at line 273 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPY

private

Definition at line 274 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fTrajMCPZ

private

Definition at line 275 of file anatree_module.cc.

TTree* gar::anatree::fTree

private

Definition at line 178 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeEKpipi

private

Definition at line 396 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeELpip

private

Definition at line 406 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeELppi

private

Definition at line 401 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVeeIDNumber

private

Definition at line 388 of file anatree_module.cc.

std::string gar::anatree::fVeeLabel

private

module label for conversion/decay vertexes rec:Vee

Definition at line 140 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeMKpipi

private

Definition at line 397 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeMLpip

private

Definition at line 407 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeMLppi

private

Definition at line 402 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePXKpipi

private

Definition at line 393 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePXLpip

private

Definition at line 403 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePXLppi

private

Definition at line 398 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePYKpipi

private

Definition at line 394 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePYLpip

private

Definition at line 404 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePYLppi

private

Definition at line 399 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePZKpipi

private

Definition at line 395 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePZLpip

private

Definition at line 405 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeePZLppi

private

Definition at line 400 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVeeT

private

Definition at line 392 of file anatree_module.cc.

std::vector<gar::rec::TrackEnd> gar::anatree::fVeeTAssn_TrackEnd

private

Definition at line 410 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVeeTAssn_TrackIDNumber

private

Definition at line 409 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVeeTAssn_VeeIDNumber

private

Definition at line 408 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeX

private

Definition at line 389 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeY

private

Definition at line 390 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVeeZ

private

Definition at line 391 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVertexIDNumber

private

Definition at line 375 of file anatree_module.cc.

std::string gar::anatree::fVertexLabel

private

module label for vertexes rec:Vertex

Definition at line 139 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fVertexN

private

Definition at line 380 of file anatree_module.cc.

std::vector<Int_t> gar::anatree::fVertexQ

private

Definition at line 381 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVertexT

private

Definition at line 379 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVertexX

private

Definition at line 376 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVertexY

private

Definition at line 377 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fVertexZ

private

Definition at line 378 of file anatree_module.cc.

std::vector<gar::rec::TrackEnd> gar::anatree::fVTAssn_TrackEnd

private

Definition at line 385 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVTAssn_TrackIDNumber

private

Definition at line 384 of file anatree_module.cc.

std::vector<ULong64_t> gar::anatree::fVTAssn_VertIDNumber

private

Definition at line 383 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fW

private

Definition at line 214 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fWeight

private

Definition at line 229 of file anatree_module.cc.

bool gar::anatree::fWriteCaloClusters

private

Write ECAL clusters. Default=true.

Definition at line 170 of file anatree_module.cc.

bool gar::anatree::fWriteCaloDigits

private

Raw digits for calorimetry. Default=false.

Definition at line 168 of file anatree_module.cc.

bool gar::anatree::fWriteCaloHits

private

Write ECAL hits. Default=true.

Definition at line 169 of file anatree_module.cc.

bool gar::anatree::fWriteCohInfo

private

MC level t for coherent pi+. Default=false.

Definition at line 175 of file anatree_module.cc.

bool gar::anatree::fWriteHits

private

Write info about TPC Hits Default=false.

Definition at line 160 of file anatree_module.cc.

bool gar::anatree::fWriteMatchedTracks

private

Write ECAL-track Assns Default=true.

Definition at line 171 of file anatree_module.cc.

bool gar::anatree::fWriteMCCaloInfo

private

Write MC info for calorimeter Default=true.

Definition at line 157 of file anatree_module.cc.

bool gar::anatree::fWriteMCinfo

private

Info from MCTruth, GTruth Default=true.

Definition at line 154 of file anatree_module.cc.

bool gar::anatree::fWriteMCPTrajectory

private

Write MCP Trajectory Default=true.

Definition at line 155 of file anatree_module.cc.

bool gar::anatree::fWriteMCPTrajMomenta

private

Write Momenta associated with MCP Trajectory Default=false.

Definition at line 156 of file anatree_module.cc.

bool gar::anatree::fWriteMuID

private

Definition at line 167 of file anatree_module.cc.

bool gar::anatree::fWriteTPCClusters

private

Write TPCClusters info Default=true.

Definition at line 161 of file anatree_module.cc.

bool gar::anatree::fWriteTracks

private

Start/end X, P for tracks Default=true.

Definition at line 162 of file anatree_module.cc.

bool gar::anatree::fWriteTrackTrajectories

private

Point traj of reco tracks Default=false.

Definition at line 163 of file anatree_module.cc.

bool gar::anatree::fWriteVees

private

Reco vees & their tracks Default=true.

Definition at line 165 of file anatree_module.cc.

bool gar::anatree::fWriteVertices

private

Reco vertexes & their tracks Default=true.

Definition at line 164 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fX

private

Definition at line 215 of file anatree_module.cc.

std::vector<Float_t> gar::anatree::fY

private

Definition at line 216 of file anatree_module.cc.

float gar::anatree::ItsInTulsa[3]

private

Definition at line 121 of file anatree_module.cc.

std::unordered_map<int, TH2F*> gar::anatree::m_pidinterp

private

Definition at line 507 of file anatree_module.cc.

float gar::anatree::rTPC

private

Definition at line 123 of file anatree_module.cc.

std::unordered_map<TrkId, Int_t> gar::anatree::TrackIdToIndex

private

Definition at line 188 of file anatree_module.cc.

float gar::anatree::xTPC

private

Definition at line 122 of file anatree_module.cc.

---

The documentation for this class was generated from the following file:

• garsoft/Ana/anatree_module.cc