TSFGReconModule.hxx

Go to the documentation of this file.

#ifndef TSFGReconModule_hxx_seen
#define TSFGReconModule_hxx_seen

#include <string>

#include <TClonesArray.h>
#include <TLorentzVector.h>
#include <TNamed.h>
#include <TPRegexp.h>
#include <TTree.h>
#include <TVector3.h>

#include <TND280Event.hxx>
#include <TReconCluster.hxx>
#include <TReconPID.hxx>
#include <TReconShower.hxx>
#include <TReconTrack.hxx>
#include <TReconVertex.hxx>

#include <TG4VHit.hxx>
#include <TMCDigit.hxx>
#include <TMCHit.hxx>

#include <TG4VHit.hxx>
#include <TG4HitSegment.hxx>
#include <retrieveHitTruthInfo.hxx>
#include <TG4Trajectory.hxx>

#include "TAnalysisReconModuleBase.hxx"

namespace ND {
    class TSFGReconModule;
};

/// Used to fill a TTree of summary information for the SFG reconstruction
/// algorithms.  This defines branches for the ReconDir/SFG tree.
class ND::TSFGReconModule : public TAnalysisReconModuleBase {
public:
    TSFGReconModule(const char *name = "SFG",
                    const char *title = "SFG Recon Module");
    virtual ~TSFGReconModule();

    /// Override the parent method to return the type of this tree.  This MUST
    /// be provided.
    virtual EType GetTreeType() const {return kRecon;}

    /// This gets called on the first event to let the main event loop know if
    /// the first event in the file should be processed.  Always return true.
    virtual Bool_t ProcessFirstEvent(ND::TND280Event &) {return true;}

    /// An internal Id and object type for each Reconstruction object.
    struct ObjectId {
        /// The reconstruction object type that this internal Id refers to.
        /// Not explicitly stored in output TTree.  It's used by
        /// FillReconObject to determine which Fill<type>() Method to call.
        enum OType_t {
            kBlank = 0,
            kVertex,
            kParticle,
            kTrack,
            kShower,
            kCluster,
            kHit
        };
        OType_t type;

        /// An internal Id for each Reconstruction object.  These Ids are
        /// sequential from 0 for each object type within each event and
        /// correspond to their position within the respective containers.
        int id;

        /// The default constructor.
        ObjectId(): type(kBlank), id(-1) { }
    };

    /// The representation of the information store in each SFG
    /// TAlgorithmResult object.  This is used to track which vertices,
    /// particles, tracks, showers, clusters and hits are associated with the
    /// particular reconstruction result.  The path in the event for this
    /// result is saved in AlgorithmName.
    class TSFGAlgoRes : public TObject {
    public:
        virtual ~TSFGAlgoRes();

        //###################################################
        // These items are used by templated code, and must be the same
        // for all of: SFGAlgoRes, SFGVertex, SFGParticle, SFGTrack,
        // SFGShower and SFGCluster.
        //###################################################

        std::string AlgorithmName;         ///< The name of the algorithm that generated this object.


        std::vector<int> Vertices; ///< Holds index of the TSFGVertex objects that are pertinent to this algorithm result.
        ///Holds index of the TSFGVertex objects that are pertinent to this algorithm result.
        ///  The associated objects are saved inside the
        /// fVertices field.  The fVertices field is attached to the
        /// "Vertices" branch.


        std::vector<int> Particles;///< Holds index of the TSFGParticle objects that are pertinent to this algorithm result.
        ///Holds index of the TSFGParticle objects that are pertinent to this algorithm result.
        ///  The associated objects are saved inside the
        /// fParticles field which is attached to the "Particles" branch.

        std::vector<int> Tracks; ///< Holds index of the TSFGTrack objects that are pertinent to this  algorithm result.
        /// Holds index of the TSFGTrack objects that are pertinent to this  algorithm result.
        ///  The associated objects are saved inside the
        /// fTracks field which is attached to the "Tracks" branch.

        std::vector<int> Showers;///< Holds index of the TSFGShower objects that are pertinent to this algorithm result.  
        ///Holds index of the TSFGShower objects that are pertinent to this algorithm result.  
        /// The associated objects are saved inside the
        /// fShowers field which is attached to the "Showers" branch.

        std::vector<int> Clusters; ///< Holds index of the TSFGCluster objects that are pertinent to this algorithm result.  
        ///Holds index of the TSFGCluster objects that are pertinent to this algorithm result.  
        ///The associated objects are saved inside the
        /// fClusters field which is attached to the "Clusters" branch.

        std::vector<int> Nodes; ///< Holds index of the TSFGNode objects that are pertinent to this algorithm result. 
        ///Holds index of the TSFGNode objects that are pertinent to this algorithm result. 
        /// The associated objects are saved inside the
        /// fNodes field which is attached to the "Nodes" branch.

        std::vector<int> Hits; ///< Holds index of the TSFGHit objects that are pertinent to this algorithm result.
        /// Holds index of the TSFGHit objects that are pertinent to this algorithm result.
        ///  The associated objects are saved inside the
        /// fHits field which is attached to the "Hits" branch.  The hits are
        /// only saved for some of the files that are intended for special
        /// studies.  For full productions, this will probably be empty.

        int NHits;///< A count of the Hits associated with this object.
        ///A count of the Hits associated with this object.
        ///  This is not the
        /// count of entries in the Hits vector (above).  It is filled even
        /// with the Hits vector is not.

        UInt_t UniqueId;///< A unique Id used for reconstruction objects
        /// A unique Id used for reconstruction objects.
        ///  It is not used for
        /// the TSFGAlgoRes object but is used for the other TSFGVertex (&c)
        /// objects.

        //###################################################
        // Objects below here are unique to the TSFGAlgoRes class.
        //###################################################

        std::string FullName; ///< The path to the result inside the event.  This is also the string
        /// The path to the result inside the event.  This is also the string
        /// that would be passed to TND280Event::GetFit() to find the result.
        /// For example, if the result is saved in "~/fit/TSFGRecon", this
        /// string will contain "TSFGRecon".

        std::vector<int> AlgoResults; ///< The index of the daughter algorithms for this algorithm result.

        int Parent; ///< The index of the parent algorithm for this algorithm result.  This will be -1 if this doesn't have a parent.

        int UsedHitCluster; ///< The index of the cluster that contains all of the hits used by this algorithm result.  This is -1 if the hits are not saved.

        int UnusedHitCluster; ///< The index of the cluster that contains all of the hits not used by this algorithm result.  This is -1 if the hits are not saved.

        ClassDef(ND::TSFGReconModule::TSFGAlgoRes, 1);
    };

    /// The representation of the information store in each SFG TReconVertex
    /// object.
    class TSFGVertex : public TObject {
    public:
        virtual ~TSFGVertex();

        /// @{ The indices of the objects contained by the current object.
        /// See the documentation in TSFGAlgoRes for details.
        std::string AlgorithmName; ///< The name of the algorithm which produced this object
        std::vector<int> Vertices;  ///<The indices of the vertices contained by the current object.
        std::vector<int> Particles; ///<The indices of the particles contained by the current object.
        std::vector<int> Tracks;  ///<The indices of the tracks contained by the current object.
        std::vector<int> Showers;///<The indices of the showers contained by the current object.
        std::vector<int> Clusters;///<The indices of the clusters contained by the current object.
        std::vector<int> Nodes;///<The indices of the nodes contained by the current object.
        std::vector<int> Hits;///<The indices of the hits contained by the current object.
        int NHits; ///< Number of hits
        UInt_t UniqueId;  ///<  A unique Id used for reconstruction objects. 
        /// @}

        int Status; ///< The reported status of the corresponding object.  Use ND::TReconBase::StateBits to check the which status flags are set.

        float Quality;        ///< The reported reconstruction 'quality' of the vertex.  Retrieved from ND::TReconBase::GetQuality

        int NDOF;        ///< The Number of Degrees of Freedom in the vertex.  Retrieved from ND::TReconBase::GetNDOF

        TLorentzVector Position; ///< Position of the correspponding object.

        TLorentzVector PosVariance; ///< Variance on the position of the corresponding object.

        // Truth level hit information.  For the MC hits in an object we
        // store: the true trajectory Ids, the number of hits contributed
        // by each and the charge share.

        std::vector<int> Truth_PrimaryTrajIds; ///< The vector of primary true trajectory Ids which contribute to the ND::THits which are constituents of this vertex.  
        /// The vector of primary true trajectory Ids which contribute to the ND::THits which are constituents of this vertex.  
        ///These are
        /// 'pseudo-primaries', which may or may not be primaries for a
        /// vertex.  It is the 'interesting' primary that is defined by
        /// nd280Geant4Sim, and can include particles such as photons from
        /// pi0 decay and michel electrons from muon decay.  If you want to
        /// be sure of finding a vertex, use the TSFGVertex::Truth_TrajIds
        /// list and get primary Id from the trajectories.  See
        /// HitTruthPrimaryInfo for how they are
        /// calculated.

        std::vector<int> Truth_TrajIds;///< The vector of true trajectory Ids which contribute to the ND::THits which are constituents of this vertex. 
        /// The vector of true trajectory Ids which contribute to the ND::THits which are constituents of this vertex. 
        /// The index of a
        /// given trajectory id within this vector is used as the index for
        /// the corresponding information held in TSFGVertex::Truth_HitCount
        /// and TSFGVertex::Truth_ChargeShare.  See
        /// HitTruthInfo for how they are calculated.

        std::vector<int> Truth_HitCount; ///< The number of THits that each truth trajectory contributed to.
        /// The number of THits that each truth trajectory contributed to.
        /// This doesn't have to equal the number of hits, hits can be shared
        /// and some hits may not have associated trajectories.  Indexed by
        /// the position of the relevant trajectory Id in
        /// TSFGVertex::Truth_TrajIds.  See HitTruthInfo
        /// for how they are calculated.

        std::vector<float> Truth_ChargeShare; ///< The weighted reconstructed charge deposited by each truth
         /// The weighted reconstructed charge deposited by each truth
        /// trajectory.  For each THit, a trajectory will receive a
        /// proportional share of the charge, based on the total true charge
        /// deposited by all contributing trajectories.  Indexed by the
        /// position of the relevant trajectory Id in
        /// TSFGVertex::Truth_TrajIds.  See HitTruthInfo
        /// for how they are calculated.

        ClassDef(ND::TSFGReconModule::TSFGVertex, 1);
    };

    /// A summary of the reconstruction information in a TReconPID.
    class TSFGParticle : public TObject {
    public:
        virtual ~TSFGParticle();

        /// @{ The indices of the objects contained by the current object.
        /// See the documentation in TSFGAlgoRes for details.
          std::string AlgorithmName; ///< The name of the algorithm which produced this object
        std::vector<int> Vertices;  ///<The indices of the vertices contained by the current object.
        std::vector<int> Particles; ///<The indices of the particles contained by the current object.
        std::vector<int> Tracks;  ///<The indices of the tracks contained by the current object.
        std::vector<int> Showers;///<The indices of the showers contained by the current object.
        std::vector<int> Clusters;///<The indices of the clusters contained by the current object.
        std::vector<int> Nodes;///<The indices of the nodes contained by the current object.
        std::vector<int> Hits;///<The indices of the hits contained by the current object.

       int NHits; ///< Number of hits
        UInt_t UniqueId;  ///<  A unique Id used for reconstruction objects. 
        /// @}

        int Status; ///< The reported Status of the corresponding ND::TReconPID.  Use
        /// ND::TReconBase::StateBits to check the which status flags are set.

        float Quality; ///< The reported reconstruction 'quality' of the corresponding
        /// object.  Uses ND::TReconBase::GetQuality

        int NDOF; ///< The Number of Degrees of Freedom in the reconstruction of the
        /// corresponding object.  Retrieved from
        /// ND::TReconBase::GetNDOF

        TLorentzVector Position; ///< Position of the correspponding object.

        TLorentzVector PosVariance; ///< Variance on the position of the corresponding object.

        TVector3 Direction; ///< Direction of the corresponding object.

        TVector3 DirVariance; ///< Direction variance of the corresponding object.

        float Momentum; ///< The reconstructed momentum of the corresponding TReconPID.

        float Charge; ///< The reconstructed particle charge of the corresponding TReconPID.

        std::vector<int> PID; ///< Potential PIDs (ND::TReconPID::ParticleId) matching with TSFGParticle::PID_Weight values.

        std::vector<float> PID_weight; ///< PID weights for each PID in TSFGParticle::PID.

        int TrueParticleID;  ///< True G4 particle associated to a TSFGParticle
        int TrueParticlePur;  ///<  Purity of the True G4 particle associated to a TSFGParticle
        int TrueParticleEff;  ///<  Efficiency of the True G4 particle associated to a TSFGParticle

        ///@{ Truth level hit information.  For the MC hits in an object we
        /// store: the true trajectory Ids, the number of hits contributed by
        /// each and the charge share.  See the TSFGVertex object for
        /// documentation.
        std::vector<int> Truth_PrimaryTrajIds; ///<  Primary Ids of truth trajectories
        std::vector<int> Truth_TrajIds;  ///< True trajectory Ids
        std::vector<int> Truth_HitCount; ///< Nmber of hits contributed by  each  true trajectory
        std::vector<float> Truth_ChargeShare; ///<   Carge share o true trajectory 
        /// @}

        ClassDef(ND::TSFGReconModule::TSFGParticle, 1);
    };

    /// Contains a summary of the reconstruction information in a TReconTrack.
    class TSFGTrack : public TObject {
    public:
        virtual ~TSFGTrack();

        /// @{ The indices of the objects contained by the current object.
        /// See the documentation in TSFGAlgoRes for details.
        std::string AlgorithmName; ///< The name of the algorithm which produced this object
        std::vector<int> Vertices;  ///<The indices of the vertices contained by the current object.
        std::vector<int> Particles; ///<The indices of the particles contained by the current object.
        std::vector<int> Tracks;  ///<The indices of the tracks contained by the current object.
        std::vector<int> Showers;///<The indices of the showers contained by the current object.
        std::vector<int> Clusters;///<The indices of the clusters contained by the current object.
        std::vector<int> Nodes;///<The indices of the nodes contained by the current object.
        std::vector<int> Hits;///<The indices of the hits contained by the current object.

        int NHits; ///< Number of hits
        UInt_t UniqueId;  ///<  A unique Id used for reconstruction objects.
        /// @}

        int Status; ///< The reported Status of the corresponding object.  Use ND::TReconBase::StateBits to check the which status flags are set.

        float Quality; ///< The reported reconstruction 'quality' of the corresponding object.  Uses ND::TReconBase::GetQuality

        int NDOF; ///< The Number of Degrees of Freedom in the reconstruction of the corresponding object.  Retrieved from ND::TReconBase::GetNDOF

        float EDeposit;///< The total reconstructed energy deposit of the corresponding track. This is usually just the sum of the charge for all of the hits.

        TLorentzVector Position;///< Position of the corresponding object.

        TLorentzVector PosVariance; ///< Variance on the position of the corresponding object.

        TVector3 Direction;///< Direction of the corresponding object.

        TVector3 DirVariance; ///< Direction variance of the corresponding object.

        float Length; ///< The length of the track calculated by summing over the distances between the constituent TReconNodes.

        // True G4 particle associated to a TSFGTrack
        int TrueParticleID; ///< True Geant4 particle associated to a TSFGTrack
        int TrueParticlePur; ///< Purity of Geant4 particle associated to a TSFGTrack
        int TrueParticleEff; ///< Efficiency of Geant4 particle associated to a TSFGTrack

        ///@{ Truth level hit information.  For the MC hits in an object we
        /// store: the true trajectory Ids, the number of hits contributed by
        /// each and the charge share.  See the TSFGVertex object for
        /// documentation.

        std::vector<int> Truth_PrimaryTrajIds; ///<  Primary Ids of truth trajectories
        std::vector<int> Truth_TrajIds;  ///< True trajectory Ids
        std::vector<int> Truth_HitCount; ///< Nmber of hits contributed by  each  true trajectory
        std::vector<float> Truth_ChargeShare; ///<   Carge share o true trajectory 
        /// @}

        ClassDef(ND::TSFGReconModule::TSFGTrack, 1);
    };

    /// Contains a summary of the reconstruction information in a TReconShower.
    class TSFGShower : public TObject {
    public:
        virtual ~TSFGShower();

        /// @{ The indices of the objects contained by the current object.
        /// See the documentation in TSFGAlgoRes for details.
           std::string AlgorithmName; ///< The name of the algorithm which produced this object
        std::vector<int> Vertices;  ///<The indices of the vertices contained by the current object.
        std::vector<int> Particles; ///<The indices of the particles contained by the current object.
        std::vector<int> Tracks;  ///<The indices of the tracks contained by the current object.
        std::vector<int> Showers;///<The indices of the showers contained by the current object.
        std::vector<int> Clusters;///<The indices of the clusters contained by the current object.
        std::vector<int> Nodes;///<The indices of the nodes contained by the current object.
        std::vector<int> Hits;///<The indices of the hits contained by the current object.
        int NHits; ///< Number of hits
        UInt_t UniqueId;  ///<  A unique Id used for reconstruction objects.

        /// @}

        int Status; ///< The reported Status of the corresponding object.  Use ND::TReconBase::StateBits to check the which status flags are set.

        float Quality; ///< The reported reconstruction 'quality' of the corresponding object.  Uses ND::TReconBase::GetQuality

        int NDOF; ///< The Number of Degrees of Freedom in the reconstruction of the corresponding object.  Retrieved from ND::TReconBase::GetNDOF

        float EDeposit;///< The total reconstructed energy deposit of the corresponding track. This is usually just the sum of the charge for all of the hits.

        TLorentzVector Position;///< Position of the corresponding object.

        TLorentzVector PosVariance; ///< Variance on the position of the corresponding object.

        TVector3 Direction;///< Direction of the corresponding object.

        TVector3 DirVariance; ///< Direction variance of the corresponding object.


        // True G4 particle associated to a TSFGTrack
        int TrueParticleID; ///< True Geant4 particle associated to a TSFGTrack
        int TrueParticlePur; ///< Purity of Geant4 particle associated to a TSFGTrack
        int TrueParticleEff; ///< Efficiency of Geant4 particle associated to a TSFGTrack

        float Cone; ///< The opening angle of the TShowerState cone of the corresponding TReconShower.

        float Width;///< The 'width' of the shower, the extent perpendicular to the  direction.
        /// The 'width' of the shower, the extent perpendicular to the  direction.
        ///  This is calculated here. Each of the THits, within the
        /// TReconShower, contributes to the width based on it's, charged
        /// weighted, perpendicular distance from the TReconShower's
        /// position. This is done in 2D.

        float Length;///< The RMS length of the shower, the extent parallel to the direction. 
        ///The RMS length of the shower, the extent parallel to the direction. 
        /// This is calculated here. Each of the THits, within the
        /// TReconShower, contributes to the width based on it's, charged
        /// weighted, perpendicular distance from the TReconShower's
        /// position. This is done in 2D.

        ///@{ Truth level hit information.  For the MC hits in an object we
        /// store: the true trajectory Ids, the number of hits contributed by
        /// each and the charge share.  See the TSFGVertex object for
        /// documentation.

         std::vector<int> Truth_PrimaryTrajIds; ///<  Primary Ids of truth trajectories
        std::vector<int> Truth_TrajIds;  ///< True trajectory Ids
        std::vector<int> Truth_HitCount; ///< Nmber of hits contributed by  each  true trajectory
        std::vector<float> Truth_ChargeShare; ///<   Carge share o true trajectory 
        /// @}

        ClassDef(ND::TSFGReconModule::TSFGShower, 1);
    };

    /// Contains a summary of the reconstruction information in a TReconCluster.
    class TSFGCluster : public TObject {
    public:
        virtual ~TSFGCluster();

        /// @{ The indices of the objects contained by the current object.
        /// See the documentation in TSFGAlgoRes for details.

        std::string AlgorithmName; ///< The name of the algorithm which produced this object
        std::vector<int> Vertices;  ///<The indices of the vertices contained by the current object.
        std::vector<int> Particles; ///<The indices of the particles contained by the current object.
        std::vector<int> Tracks;  ///<The indices of the tracks contained by the current object.
        std::vector<int> Showers;///<The indices of the showers contained by the current object.
        std::vector<int> Clusters;///<The indices of the clusters contained by the current object.
        std::vector<int> Nodes;///<The indices of the nodes contained by the current object.
        std::vector<int> Hits;///<The indices of the hits contained by the current object.

        int NHits; ///< Number of hits
        UInt_t UniqueId;  ///<  A unique Id used for reconstruction objects.
        /// @}


        float EDeposit;///< The total reconstructed energy deposit of the corresponding track. This is usually just the sum of the charge for all of the hits.

        TLorentzVector Position;///< Position of the corresponding object.

        TLorentzVector PosVariance; ///< Variance on the position of the corresponding object.


        static const int arraySize = 9; ///< Size of the TSFGCluster::Moments array.

        float Moments[arraySize]; ///< Moments of the cluster stored as a flat 3x3 matrix.

        // True G4 particle associated to a TSFGTrack
        int TrueParticleID; ///< True Geant4 particle associated to a TSFGTrack
        int TrueParticlePur; ///< Purity of Geant4 particle associated to a TSFGTrack
        int TrueParticleEff; ///< Efficiency of Geant4 particle associated to a TSFGTrack

        ///@{ Truth level hit information.  For the MC hits in an object we
        /// store: the true trajectory Ids, the number of hits contributed by
        /// each and the charge share.  See the TSFGVertex object for
        /// documentation.

        std::vector<int> Truth_PrimaryTrajIds; ///<  Primary Ids of truth trajectories
        std::vector<int> Truth_TrajIds;  ///< True trajectory Ids
        std::vector<int> Truth_HitCount; ///< Nmber of hits contributed by  each  true trajectory
        std::vector<float> Truth_ChargeShare; ///<   Carge share o true trajectory 

        /// @}

        ClassDef(ND::TSFGReconModule::TSFGCluster, 1);
    };

    /// Contains a summary of the reconstruction information in a TReconNode.
    class TSFGNode : public TObject {
    public:
        virtual ~TSFGNode();

        std::vector<int> Hits; ///< Holds internal Ids of Hits pertinent to this reconstruction node.
        /// Holds internal Ids of Hits pertinent to this reconstruction node.
        /// Holds ObjectId::id of
        /// TSFGHit objects which are equivalent to
        /// indicies of fHits which hold Hits related to
        /// this reconstruction node.

        float EDeposit; ///< The total reconstructed energy deposit of the corresponding track.

        double EDeposit_fit; ///< Fitted energy deposit for each node


        TLorentzVector Position;///< Position of the corresponding object.

        TLorentzVector PosVariance; ///< Variance on the position of the corresponding object.

        TVector3 Direction;///< Direction of the corresponding object.

        TVector3 DirVariance; ///< Direction variance of the corresponding object.



        ///@{ Truth level hit information.  For the MC hits in an object we
        /// store: the true trajectory Ids, the number of hits contributed by
        /// each and the charge share.  See the TSFGVertex object for
        /// documentation.
         std::vector<int> Truth_PrimaryTrajIds; ///<  Primary Ids of truth trajectories   See the TSFGVertex object for documentation
        std::vector<int> Truth_TrajIds;  ///< True trajectory Ids See the TSFGVertex object for documentation
        std::vector<int> Truth_HitCount; ///< Nmber of hits contributed by  each  true trajectory See the TSFGVertex object for documentation
        std::vector<float> Truth_ChargeShare; ///<   Carge share o true trajectory  See the TSFGVertex object for documentation

        /// @}

        ClassDef(ND::TSFGReconModule::TSFGNode, 1);
    };

    /// Contains a summary of the reconstruction information for each cube.
    class TSFGHit : public TObject {
    public:
        virtual ~TSFGHit();

        UInt_t GeomId; ///< Geometry Id of the TSingleHit.

        float Charge; ///< Reconstructed hit charge without attenuation correction from thE corresponding TSingleHit.

        float Time; ///< Reconstructed hit time from the corresponding TSingleHit.

        TVector3 Position; ///< Hit position

        int TrkHitTag; ///< Single/multiple track hit tagging Notation: 1 = multiple track hits, 2 = single track hits, 3 = other (xtalk or ghost)
        
        std::vector<TLorentzVector> HitSegPosition; ///< True hit segments inside the cube position (3D + time)
        std::vector<TVector3> HitSegDirection; ///< True hit segments inside the cube  direction (3D)

        std::vector<int> HitSegTruePDG;///< True particle PDG of the track contributing to the hit segment
        std::vector<float> HitSegTrueP; ///< True momentum of the track contributing to the hit segment
        std::vector<float> HitSegTrueEdepo; ///< True energy loss of the current hit segment

        ClassDef(ND::TSFGReconModule::TSFGHit, 1);
    };

    typedef TClonesArray TSFGAlgoResContainer;
    typedef TClonesArray TSFGVertexContainer;
    typedef TClonesArray TSFGPartContainer;
    typedef TClonesArray TSFGTrackContainer;
    typedef TClonesArray TSFGShowerContainer;
    typedef TClonesArray TSFGClusterContainer;
    typedef TClonesArray TSFGNodeContainer;
    typedef TClonesArray TSFGHitContainer;

    /// The TSFGAlgoRes vector of results.  These are attached to the
    /// NAlgoResults, and the AlgoResults branches.
    int fNAlgoResults;
     /// The TSFGAlgoRes vector of results.  These are attached to the
    /// NAlgoResults, and the AlgoResults branches.
    TSFGAlgoResContainer* fAlgoResults;

    /// The TSFGVertex vector of results.  These are attached to the
    /// NVertices, and the Vertices branches.
    int fNVertices;
     /// The TSFGVertex vector of results.  These are attached to the
    /// NVertices, and the Vertices branches.
    TSFGVertexContainer* fVertices;

    /// The TSFGParticle vector of results.  These are attached to the
    /// NParticles, and the Particles branches.
    int fNParticles;
      /// The TSFGParticle vector of results.  These are attached to the
    /// NParticles, and the Particles branches.
    TSFGPartContainer* fParticles;

    /// The TSFGTrack vector of results.  These are attached to the
    /// NTracks, and the Tracks branches.
    int fNTracks;
      /// The TSFGTrack vector of results.  These are attached to the
    /// NTracks, and the Tracks branches.
    TSFGTrackContainer* fTracks;

    /// The TSFGShower vector of results.  These are attached to the
    /// NShowers, and the Showers branches.
    int fNShowers;
     /// The TSFGShower vector of results.  These are attached to the
    /// NShowers, and the Showers branches.
    TSFGShowerContainer* fShowers;

    /// The TSFGCluster vector of results.  These are attached to the
    /// NClusters, and the Clusters branches.
    int fNClusters;
      /// The TSFGCluster vector of results.  These are attached to the
    /// NClusters, and the Clusters branches.
    TSFGClusterContainer* fClusters;

    /// The TSFGNode vector of results.  These are attached to the
    /// NNodes, and the Nodes branches.
    int fNNodes;
      /// The TSFGNode vector of results.  These are attached to the
    /// NNodes, and the Nodes branches.
    TSFGNodeContainer* fNodes;

    /// The TSFGHit vector of hits.  These are attached to the
    /// NHits, and the Hits branches.
    int fNHits;
    /// The TSFGHit vector of hits.  These are attached to the
    /// NHits, and the Hits branches.
    TSFGHitContainer* fHits;

    /// The TSFGHit vector of hits for each fiber.  These are attached to the
    /// NFibers, and the Fibers branches.  This is usually only filled for
    /// debugging.
    int fNFibers;
     /// The TSFGHit vector of hits for each fiber.  These are attached to the
    /// NFibers, and the Fibers branches.  This is usually only filled for
    /// debugging.
    TSFGHitContainer* fFibers;

    /// The TSFGHit vector of hits based on the number of photons generated in
    /// each cube.  These are attached to the NTrueHits, and the TrueHits
    /// branches.  This is usually only filled for debugging (and only for
    /// MC).
    int fNTrueHits;
    TSFGHitContainer* fTrueHits;

protected:
    /// Called before anything else to allow the module to initialize.
    /// Nothing to do here.
    virtual void InitializeModule() {}

    /// Called to let the module setup the appropriate branches.
    virtual void InitializeBranches();

    /// Called by the main loop to fill an event.
    virtual bool FillTree(ND::TND280Event &);

private:
    /// Fill an algorithm result and all of it's subsidiary reconstruction
    /// objects.
    virtual int FillAlgorithmResult(const ND::THandle<ND::TAlgorithmResult>,
                                    int);

    /// Fill the header for TSFGAlgoRes, TSFGVertex, TSFGParticle, TSFGTrack,
    /// TSFGVertex, and TSFGCluster.  All of these classes have the same
    /// "header" information layout, so they are handled by the same template
    /// code.
    template <class T>
    void FillBaseObject(T basePtr, ND::THandle<ND::TReconBase> baseObject,
                        bool saveHits);

    /// This is a switch yard to take any sort of reconstruction object, and
    /// farm it out to the right specific filling method.  This fills the next
    /// entry from the reconstruction object.
    virtual ObjectId FillReconObject(const ND::THandle<ND::TReconBase>,
                                     bool saveHits);

    /// Fill the next TSFGVertex entry from a TReconVertex.
    virtual ObjectId FillVertexObject(const ND::THandle<ND::TReconVertex>,
                                      bool saveHits);

    /// Fill the next TSFGParticle entry from a TReconPID.
    virtual ObjectId FillParticleObject(const ND::THandle<ND::TReconPID>,
                                        bool saveHits);

    /// Fill the next TSFGTrack entry from a TReconTrack.
    virtual ObjectId FillTrackObject(const ND::THandle<ND::TReconTrack>,
                                     bool saveHits);

    /// Fill the next TSFGShower entry from a TReconShower
    virtual ObjectId FillShowerObject(const ND::THandle<ND::TReconShower>,
                                      bool saveHits);

    /// Fill the next TSFGCluster entry from a TReconCluster
    virtual ObjectId FillClusterObject(const ND::THandle<ND::TReconCluster>,
                                       bool saveHits);

    /// Fill the next node for any type of object.  The saved node has fields
    /// for position and direction, but the direction isn't filled for a
    /// cluster.
    virtual int FillNode(const ND::THandle<ND::TReconNode>, bool saveHits);

    /// Fill the Hits container and return the index of the new hit.  These are
    /// the hits that are used in the reconstruction.
    int FillHit(const ND::THandle<ND::THit>);

    /// Add a hit to the destination container and return the index.  This is
    /// used to fill both the hits in the reconstruction, and the true hits
    /// that were saved by the detector response simulation.
    int AddHit(const ND::THandle<ND::THit>,
               int& nDest,
               ND::TSFGReconModule::TSFGHitContainer* dest);

    /// For each hit, go through and find the energy generated for each
    /// trajectory.
    virtual std::map<int, std::pair<int, float> >
    HitTruthInfo(const ND::THandle<ND::THitSelection>);

    /// For each hit, go through and find the primary particles that are
    /// depositing energy.
    virtual std::vector<int>
    HitTruthPrimaryInfo(const ND::THandle<ND::THitSelection>);

    /// If an incoming TAlgorithmResult's name matches a pattern within this
    /// vector it will not be summarised and stored.
    std::vector<TPRegexp> fRejectAlgoResultList;

    /// Scratch space to keep track of already summarised THits.
    typedef std::map<ND::THandle<ND::THit>, int> HitMap;
    HitMap fTempHitMap;

    // ---- To get the true G4 particle ----
    
    // Get the G4 trajectory associated with the recon object
    template <class T>
    ND::THandle<ND::TG4Trajectory> GetG4Trajectory(const T& object, 
                                                   double& pur, double& eff);

    // ---- For neural network study ----
    
    // True trajectories container
    ND::THandle<ND::TG4TrajectoryContainer> fTrueTraj;   
    
    // Check whether the hit segment is inside the cube
    bool checkHitSegInCube(ND::THandle<ND::THit> hit, ND::TG4HitSegment* HitSeg);

    // Check the nearby cubes to see if the center cube is multiple track hit
    bool checkNearbyMultiTrk(ND::THandle<ND::THit> hit, std::vector<ND::TG4HitSegment*> HitSegAllPlanes, ND::THandle<ND::TG4TrajectoryContainer> true_traj);    
    
    // Fill true trajectory information for the hit
    void FillTrueTrajInfoForHit(ND::TG4HitSegment*, TSFGHit*);
    
    // The main function that adds information to each hit
    void FillHitInfoNeededForNN(const ND::THandle<ND::THit>, TSFGHit*); 

};

#endif