TTrackerECALReconModule.hxx

Go to the documentation of this file.

///
/// For questions or suggestions about this module please contact the
/// current responsible and CC in the eventAnalysis package manager.
///
/// 2015-3-25: Currently responsible lp208 [at] ac [dot] ic [dot] uk
///
#ifndef TTrackerECALReconModule_hxx_seen
#define TTrackerECALReconModule_hxx_seen

#include <iostream>
#include <set>
#include <sstream>
#include <string>

#include "TClonesArray.h"
#include "TH2F.h"
#include "TNamed.h"
#include "TTree.h"

#include "TG4Trajectory.hxx"
#include "TIntegerDatum.hxx"
#include "TND280Event.hxx"
#include "TReconCluster.hxx"
#include "TReconHit.hxx"
#include "TReconPID.hxx"
#include "TReconShower.hxx"
#include "TReconTrack.hxx"
#include "TReconVertex.hxx"
#include "vertexReconstruction/TECALVertexing.hxx"

#include "TAnalysisReconModuleBase.hxx"

namespace ND {
    namespace TTrackerECALReconModule {
        
        class OutputManager;
        
        #ifdef TTRACKERECALRECONMODULE_USE_EXP
        class TECALReconHit;
        #endif
        class TECALReconVertexCandidate;
        class TECALReconTrack;
        class TECALReconShower;
        class TECALReconCluster;
        class TECALReconObject;
        class TECALReconUnmatchedObject;
        class TECALReconVertexCluster;
        class TECALReconVertexTrack;
        class TECALReconVertexCrossing;
        
        #ifdef TTRACKERECALRECONMODULE_USE_EXP
        /// Describes a reconstructed ECal Hit.
        /// Contains information about the charge deposited in MEU, the reconstructed
        /// position and associated uncertainty, and the reconstructed objects that
        /// this hit was included in.
        ///\note Associations are kept on the hits rather than the objects to avoid
        /// changing the recon object output format.
        class TECALReconHit : public TObject {
            const static int MaxAssocs = 20;
            
        public:
            ~TECALReconHit();
            TECALReconHit();
            /// Attempts to add a recon object association.
            void AddAssocUID(unsigned int tuid);
            
            Int_t GeomId;   ///< oaEvent TGeometryId of the physical volume associated with this hit.
            
            
            Int_t UsedByNObjs;   ///< Keeps track of the number of recon object associations this hit has.
            
            /// VLA of recon object associations.
            UInt_t *ObjUIDs;  //[UsedByNObjs]
            
            TLorentzVector Position;   ///< Reconstructed position of the hit.
            
            TVector3 PosUncertainty;   ///< Reconstructed position uncertainty of the hit.
            
            double ChargeDeposit;   ///< Reconstructed charge deposition of the hit, scaled to MEU.
            
            short IsXYZ;   ///< IsXYZ Hit
            
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconHit, 1);
        };
        #endif
        
        ///\brief Reconstructed ECal vertex candidate, contains fitted position and
        /// associated track UIDs.
        /// See ND::TECalVertexing for how these are created from vertex clusters
        /// and 3D hough prongs.
        class TECALReconVertexCandidate : public TObject {
        public:
            virtual ~TECALReconVertexCandidate() {}
            TECALReconVertexCandidate();
            
            UInt_t VertexClusterUID;   ///< The UID of the associated TECALReconVertexCluster
            
            TLorentzVector Position;   ///< The fitted position of the vertex candidate.
            
            std::string ECalModule;   ///< The ECalModule that this vertex was reconstructed in.
            
            Int_t NTracks;   ///< The number of tracks that contributed to the fitted position.
            
            Int_t NHits;///< The number of hits that were included in fitted tracks or were  closer to this vertex candidate than any other in the cluster.
            
            Int_t G4IDSingle;   ///< The G4ID of the single biggest contributor to the cluster
            
            Float_t CompletenessSingle;   ///< The Completeness of the single biggest contributor to the cluster
            
            Float_t CleanlinessSingle; ///< The cleanliness (hit purity) of the single biggest contributor   to the cluster
            
            Int_t G4IDPrimary;   ///< The G4ID of the primary contributor to the cluster
            
            Float_t CompletenessPrimary;   ///< The Completeness of the primary contributor to the cluster
            
            Float_t CleanlinessPrimary;   ///< The cleanliness (hit purity) of the primary contributor to the cluster
            
            Int_t G4IDRecursive;   ///< The G4ID of the Recursive contributor to the cluster
            
            Float_t CompletenessRecursive;   ///< The Completeness of the Recursive contributor to the cluster
            
            Float_t CleanlinessRecursive;   ///< The cleanliness (hit purity) of the Recursive contributor to the cluster
            
            
            UInt_t *TrackUIDs;  //[NTracks]   ///< The UIDs of the associated TECALReconVertexTracks
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconVertexCandidate, 1);
        };
        
        /// Fills this vertex candidate from a ND::TECALReconVertex.
        TECALReconVertexCandidate *TECALVertexCandidateFactory(
            const ND::TECALReconVertex &, ND::THandle<ND::TReconVertex>, bool,
            void *pos = NULL);
        
        TECALReconVertexCandidate *TECALVertexCandidateFactory(
            ND::THandle<ND::TReconVertex>, UInt_t, bool, void *pos = NULL);
        
        /// The main object that contains ECAL track information
        class TECALReconTrack : public TObject {
        public:
            virtual ~TECALReconTrack();
            TECALReconTrack(){};
            
            TVector3 Direction;   ///< The track direction
            
            
            double EDeposit;   ///< The charge deposited by the track in units of MIPs
            
            
            TLorentzVector Position;   ///< The track starting 4-position.
            
            
            TLorentzVector PositionVar;   ///< The track starting 4-position variance.
            
            
            TLorentzVector BackPosition;   ///< The position of the end of the track
            
            
            ///< Track 'width'
            ///< Used by GlobalRecon, isn't needed here, so generate streamer info.
            TVector3 Width;  //!
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconTrack, 1);
        };
        
        /// The main object that contains ECAL shower information
        class TECALReconShower : public TObject {
        public:
            virtual ~TECALReconShower();
            
            TVector3 ConeAngle;   ///< The shower opening angle.
            
            
            TVector3 Direction;   ///< The shower direction.
            
            
            double EDeposit;   ///< The energy deposited in the shower
            
            
            TLorentzVector Position;   ///< The shower position.
            
            
            TLorentzVector PositionVar;   ///< The shower position variance.
            
            
            TLorentzVector BackPosition;   ///< The charge weighted position of the end of the shower
            
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconShower, 1);
        };
        
        /// The main object that contains ECAL cluster information
        class TECALReconCluster : public TObject {
        public:
            virtual ~TECALReconCluster();
            TECALReconCluster(){};
            TLorentzVector Position;   ///< The cluster position.
            
            
            TLorentzVector PositionVar;   ///< The cluster position variance.
            
            
            int NDOF;   ///< The number of degrees of freedom in the reconstruction.
            
            
            double EDeposit;   ///< The charge deposited by the cluster.
            
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconCluster, 1);
        };
        
        /// The main object that contains ECAL recon information
        class TECALReconObject : public TObject {
        public:
            TECALReconObject();
            virtual ~TECALReconObject();
            
            bool FilledAsTrack;  ///< Was filled by a Track-like TReconPID \note This is an ease of use boolean NOT a PID. For determining PID please  use the PID variables.
            
            bool FilledAsShower; ///< Was filled by a Shower-like TReconPID \note This is an ease of use boolean NOT a PID. For determining PID please  use the PID variables.
            
            TECALReconTrack Track;   ///< Objects to store information for a track.
            
            
            TECALReconShower Shower;   ///< Objects to store information for a shower.
            
            
            TECALReconCluster Cluster;   ///< Objects to store information for a cluster.
            
            
            UInt_t UniqueID;   ///< Unique ID number to allow matching to Global Recon object.
            
            
            Int_t G4ID; ///< G4ID for truth matched objects, using TrackTruthInfo the original truth-matching algorithm).
            
            Int_t G4ID_Primary; ///< G4ID of the primary particle associated with this object.  See TShowerTruthInfo in oaUtility for details.
            
            Double_t Completeness_Primary;   ///< Truth-matching completeness for G4ID_Primary
            
            Double_t Cleanliness_Primary;   ///< Truth-matching cleanliness for G4ID_Primary
            
            
            Int_t G4ID_Recursive;  ///< G4ID of the highest-level parent particle that enters the ECal module,  and which had a daughter that contributed to this object. See TShowerTruthInfo in oaUtility for details.
            
            Int_t G4ID_Recursive2;   ///< G4ID of the highest-level parent particle that enters the ECal module,  and which had a daughter that contributed to this object. See TShowerTruthInfo in oaUtility for details.
            
            Int_t G4ID_Recursive3; ///< G4ID of the highest-level parent particle that enters the ECal module,  and which had a daughter that contributed to this object. See TShowerTruthInfo in oaUtility for details.
            
            Int_t G4ID_Recursive4;   ///< G4ID of the highest-level parent particle that enters the ECal module,  and which had a daughter that contributed to this object. See TShowerTruthInfo in oaUtility for details.
            
            Double_t Completeness_Recursive;   ///< Truth-matching completeness for G4ID_Recursive
            
            
            Double_t Cleanliness_Recursive;   ///< Truth-matching cleanliness for G4ID_Recursive
            
            
            Int_t G4ID_Single; ///< The single true particle that contributed most hits to this object.  Should be the same as G4ID in most cases  (unless two particles contributed the same amount).  See TShowerTruthInfo in oaUtility for details.
            
            Double_t Completeness_Single;   ///< Truth-matching completeness for G4ID_Single
            
            Double_t Cleanliness_Single;   ///< Truth-matching cleanliness for G4ID_Single
            
            
            Int_t NHits;   ///< Number of hits in this object
            
            
            Int_t NIsXHits;   ///< Number of hits with precise X information in the object
            
            
            Int_t NIsYHits;   ///< Number of hits with precise Y information in the object
            
            
            Int_t NIsZHits;   ///< Number of hits with precise Z information in the object
            
            
            Int_t NLayersHit;   ///< Number of layers hit by this object
            
            
            Int_t MaxPerpBarHit; ///<\ The maximum bar number hit in a cluster, for layers perpendicular  to the beam axis
            ///<\details The maximum value is 95 for Barrel ECals, 49 for DsECal
            
            Int_t MaxParaBarHit; ///< The maximum bar number hit in a cluster, for layers parallel to  the beam axis
            ///<\details The maximum value is 56 or 37 for Side and Top/Bottom Barrel
            ///< ECals and 49 for DsECal
            
            
            Int_t MinBarHit; ///< The minimum bar number hit in a cluster  The minimum value of this is 0 for all ECals
            
            Int_t MostUpStreamLayerHit; ///< The layer closest to the tracker that was hit by the object. 0 indexed.
            
            Int_t MostDownStreamLayerHit; ///< The layer furthest from the tracker that was hit by the object.  This is layer number 30 (the 31st layer) for Barrel ECals and layer  number 33 (the 34th layer) for the downstream ECal
            
            Double_t TotalHitCharge;   ///< Sum of charges of the consitituent hits in reconstructed object.
            
            
            Double_t AverageHitTime;   ///< Average time of hits in reconstructed object.
            
            
            std::string Module;   ///< Name of ECAL module in which object was reconstructed.
            
            
            Double_t ObjectLength;   ///< Recon object length in mm
            
            
            ///Pid Variables, For more info on the Pid variable see the documentation
            ///in ecalRecon or the technical note at;
            /// http://www.t2k.org/docs/technotes/002
            
            double PID_Circularity; ///< The combined "circularity" of the object.  (showers) 0.0 <= circularity <= 1.0 (tracks)  This variable is a replacement for AMR.  PID_Circularity = PID_CircularityView0 * PID_CircularityView1
            
            double PID_Angle;   ///< The zenith angle with respect to each detector.
            
            
            double PID_ShowerAngle;   ///< The angle from the start of an object to its width at its charge centre
            
            double PID_Asymmetry;   ///< Ratio of the big width of an object by its small width.
            
            double PID_TruncatedMaxRatio;   ///< A truncated Max Ratio. See ecalRecon docs for the full definition.
            
            
            double PID_TransverseChargeRatio; ///< A variable sensitive to the charge distribution in the plane  transverse to a shower/track direction.  See the ecalRecon documentation for the full definition.
            
            double PID_FrontBackRatio; ///< The ratio of the charge in equal length blocks at each end of the track. \note  Assumes particle is coming from the tracker into the ECal.
            
            double Containment; ///< Containment: contained = 1.0, not-contained = 0.0, default = -1.0.      An object is classed as contained if it has no hits in the outer bars   of the ECal (bar number 0 or the maximum bar in a layer)   and no hits in the outermost layer of the ECal.
            
            double PID_LLR_Quality; ///< A quality flag for the likelihood PID variables.   Good quality = 0, Bad quality != 0.   The quality criteria is defined in ecalRecon.
            
            double PID_LLR_MIP_EM;   ///< A combined discriminator for separating MIPs from EM showers.   Positive values = EM shower-like;   Negative values = MIP-like.    Analysers should check the PID_LLR_Quality flag before using this variable.
            ///< You should not use this variable for physics if the quality is not good.  
            ///< For more details on the Likelihood PID see ecalRecon documentation or
            ///< http://www.t2k.org/docs/technotes/111
            ///< This variable should eventually replace the old TrShval
            ///< See the ecalRecon documentation for more details.
            
            
            double PID_LLR_MIP_Pion;  ///< Discriminator for tagging showering pions in a sample of MIP-like tracks.  Positive values = showering pion-like;  Negative values = MIP-like.
            ///< See the ecalRecon documentation for more details.
            ///< Analysers should check the PID_LLR_Quality flag before using this variable.
            ///< You should not use this variable for physics if the quality is not good.    
            
            double PID_LLR_EM_HIP;   ///< A combined discriminator for separating protons from electrons.  Positive values = stopping track-like;  Negative values = EM shower-like.
            ///< See the ecalRecon documentation for more details.
            ///< Analysers should check the PID_LLR_Quality flag before using this variable.
            ///< You should not use this variable for physics if the quality is not good.    
            
            double PID_LLR_MIP_EM_LowMomentum; ///< A combined discriminator for separating MIPs from EM showers.  This is similar to LLR_MIP_EM but trained specifically on  low-momentum electrons and muon. NB: this variable is still being  developed and should be considered to be unstable.    Positive values = electron-like;   Negative values = muon-like.   See the ecalRecon documentation for more details.
            
            double AverageZPosition;   ///< Unweighted average Z position of object-constituent hits.
            
            
            double EMEnergyFit_Result;   ///< The result from the EM energy fit to the cluster
            
            double EMEnergyFit_Uncertainty;   ///< The uncertainty of the EM energy fit to the cluster
            
            double EMEnergyFit_Likelihood_energyGrad;   ///< Energy fit experts please fill this in
            
            double EMEnergyFit_Likelihood_energy_qsumGrad;   ///< Energy fit experts please fill this in
            
            double EMEnergyFit_Likelihood_qsum_like;   ///< Energy fit experts please fill this in
            
            double EMEnergyFit_Para_QSum;   ///< The summed charge present in the cluster in units of MIPs
            
            double EMEnergyFit_Para_QMean;   ///< The mean charge of hits in the cluster in units of MIPs
            
            double EMEnergyFit_Para_QRMS;   ///< The RMS of the hit charges for the cluster in units of MIPs
            
            double EMEnergyFit_Para_QSkew;   ///< The skew of hit charges for the cluster in units of MIPs
            
            double EMEnergyFit_Para_QMax;   ///< The maximum hit charge in units of MIPs.
            
            
            double Thrust;
            TVector3 ThrustOrigin;
            TVector3 ThrustAxis;
            
            double MatchingLikelihood;   ///< The matching likelihood
            
            
            int NHitsAtLayersWithManyHits;   ///< The number of hits in a layer when there are at least 2 hits.
            
            int NLayersTwoHits;   ///< The number of layers which have at least 2 hits.
            
            int NLayersThreeHits;   ///< The number of layers which have at least 3 hits.
            
            int FirstLayerManyHits;   ///< The number of the first layer in which there are at least 2 hits.
            
            int LastLayerManyHits;   ///< The last layer in which there are at least 2 hits.
            
            int MaxHitsInALayer;   ///< The layer which received the maximum number of hits.
            
            int MaxHitChargeLayer;   ///< The layer which received the highest hit charge.
            
            
            Int_t Clustering_3DSeedType;   ///< The 3D seed type from the 3D clustering algorithm (-1 means was not  created by 3D clustering, 0 means seed was from a pair of crossed bars, 1  means seed was from a double ended bar). Further details can be found in  TECAL3DClusters.cxx in ecalRecon.
            
            TVector3 Pointing;   ///< Pointing vector.
            
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconObject, 1);
        };
        
        /// Handles Filling from a PID's track hypothesis constituent.
        ///
        /// If `pos == NULL`, then a standard new is invoked. If a position is passed
        /// then placement new is used. If `Allocate == false`, then pos is assumed to
        /// point to an already allocated object.
        /// Also used by TGlobalReconModule to jury rig filling.
        TECALReconObject *TECALReconObjectFactory(ND::THandle<ND::TReconTrack>,
            ND::THandle<ND::TReconPID>, bool,
            void *pos = NULL,
            bool Allocate = true);
        /// Handles Filling from a PID's shower hypothesis constituent.
        ///
        /// If `pos == NULL`, then a standard new is invoked. If a position is passed
        /// then placement new is used. If `Allocate == false`, then pos is assumed to
        /// point to an already allocated object.
        /// Also used by TGlobalReconModule to jury rig filling.
        TECALReconObject *TECALReconObjectFactory(ND::THandle<ND::TReconShower>,
            ND::THandle<ND::TReconPID>, bool,
            void *pos = NULL,
            bool Allocate = true);
        ///\brief Method to calculate the position in the last layer reached by
        /// the particle.
        TLorentzVector FindBackPosition(ND::THandle<ND::THitSelection>, int);
        
        /// Calculates the pointing vector.
        TVector3 CalculatePointing(ND::THandle<ND::THitSelection>);
        
        /// Method to fill hit info is seperate to help keep things tidy.
        void FillHitInfo(TECALReconObject *, ND::THandle<ND::THitSelection>);
        
        /// Method to add information in RealDatums stored in the tracks or showers.
        /// Examples of what this information includes,
        ///   - Pid, Parameters for the TMVA Tool used.
        ///   - Energy likelihood fit parametres, uncertainties etc...
        ///   - Michel Electron Tag information on any tagged delayed clusters.
        void FillDatumInfo(TECALReconObject *, ND::THandle<ND::TReconBase>);
        
        /// Method to calculate the FrontBackRatio variable
        double CalculateFrontBackRatio(ND::THandle<ND::THitSelection> hits);
        
        /// Object containing information about 2D unmatched clusters from the ECALs.
        class TECALReconUnmatchedObject : public TObject {
        public:
            TECALReconUnmatchedObject();
            virtual ~TECALReconUnmatchedObject();
            int NHits;   ///< Number of hits in the cluster
            
            int View; ///< View of the cluster.  View 0 - Y measuring (odd) Layers and View 1 - X measuring (even)  layers
            
            double TotalHitCharge;   ///< Summed hit charge in the cluster in units of MIPs
            
            double AverageHitTime;   ///< Average time of the cluster in ns
            
            TVector3 FrontPosition;   ///< Position of the end of the cluster closest to the tracker
            
            TVector3 BackPosition;   ///< Position in end of the cluster furthest from the tracker
            
            int MostUpStreamLayerHit;   ///< The layer closest to the tracker that was hit by the cluster
            
            int MostDownStreamLayerHit;   ///< The layer furthest from the tracker that was hit by the cluster
            
            
            Int_t G4ID;   ///< Truth-matched particle ID.
            
            
            Int_t G4ID_Primary; ///< G4ID of the primary particle associated with this object.
            ///< See TShowerTruthInfo in oaUtility for details.
            
            Int_t G4ID_Recursive;   ///< G4ID of the highest-level parent particle that enters the ECal module,  and which had a daughter that contributed to this object.  See TShowerTruthInfo in oaUtility for details.
            
            Int_t G4ID_Single; ///< The single true particle that contributed most hits to this object.  Should be the same as G4ID in most cases (unless two particles  contributed the same amount).  See TShowerTruthInfo in oaUtility for details.
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconUnmatchedObject, 1);
        };
        
        /// Method that fills the data members from the unmatched cluster hits
        void FillHitInfo(TECALReconUnmatchedObject *, ND::THandle<ND::THitSelection>);
        /// Method that fills the data members from the unmatched cluster hits
        TECALReconUnmatchedObject *TECALReconUnmatchedObjectFactory(
            ND::THandle<ND::TReconCluster>, bool, void *pos = NULL);
        
        class TECALReconVertexCluster : public TObject {
        public:
            TECALReconVertexCluster();
            virtual ~TECALReconVertexCluster(){};
            
            UInt_t UniqueID;   ///< UniqueID of the cluster
            
            Int_t NHits;   ///< Number of hits in cluster
            
            Float_t TotalCharge;   ///< The total charge of the cluster.
            
            TLorentzVector Position;   ///< Position of cluster
            
            std::string Module;   ///< Name of ECal module the cluster is reconstructed in
            
            
            Int_t MinLayerHit;   ///< The minimum layer number hit
            
            Int_t MaxLayerHit;   ///< The maximum layer number hit
            
            Int_t MinParaBarHit;   ///< The minimum bar number hit parallel to the beam axis
            
            Int_t MaxParaBarHit;   ///< The maximum bar number hit parallel to the beam axis
            
            Int_t MinPerpBarHit;   ///< The minimum bar number hit perpendicular to the beam axis
            
            Int_t MaxPerpBarHit;   ///< The maximum bar number hit perpendicular to the beam axis
            
            
            Int_t N2DTracksMax;   ///< The maximum number of 2D tracks found in a view
            
            Int_t N2DTracksMin;   ///< The minimum number of 2D tracks found in a view
            
            Int_t G4IDSingle;   ///< The G4ID of the single biggest contributor to the cluster
            
            Float_t CompletenessSingle;   ///< The Completeness of the single biggest contributor to the cluster
            
            Float_t CleanlinessSingle; ///< The cleanliness (hit purity) of the single biggest contributor  to the cluster
            
            Int_t G4IDPrimary;   ///< The G4ID of the primary contributor to the cluster
            
            Float_t CompletenessPrimary;   ///< The Completeness of the primary contributor to the cluster
            
            Float_t CleanlinessPrimary;   ///< The cleanliness (hit purity) of the primary contributor to the cluster
            
            Int_t G4IDRecursive;   ///< The G4ID of the recursive contributor to the cluster
            
            Float_t CompletenessRecursive;   ///< The Completeness of the recursive contributor to the cluster
            
            Float_t CleanlinessRecursive; ///< The cleanliness (hit purity) of the recursive contributor to the cluster
            
            Int_t NTracks;   ///< Number of reconstructed tracks
            
            TClonesArray *Tracks;   ///< The constituent tracks TClonesArray
            
            Int_t NCrossings;   ///< Number of track crossings
            
            TClonesArray *Crossings;   ///< The constituent crossings TClonesArray
            
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconVertexCluster, 1);
        };
        
        class TECALReconVertexTrack : public TObject {
        public:
            TECALReconVertexTrack();
            // Deep copy contructor
            TECALReconVertexTrack(TECALReconVertexTrack const &other);
            virtual ~TECALReconVertexTrack(){};
            
            Int_t Status;   ///< Vertexing status of the track
            ///< The properties of this track are as calculated by the Hough transform.
            ///< This status flag lets us know if the track was merged or flagged as bad
            ///< during vertex candidate reconstruction (as opposed to the Hough
            ///< transforming of the original cluster.)
            ///< \note N.B. Values 0--3 are all tracks that were used in vertex candidate
            ///< reconstruction.
            ///<
            ///< Flag values:
            ///< * -1 : unset
            ///< * 0 : good track, used in a vertex candidate
            ///< * 1 : good track, result of two or more merged hough prongs
            ///< * 2 : good track, however, was attempted to be merged with another prong
            ///< and failed
            ///< * 3 : good track, was not fit by RECPACK
            ///< * 4 : missing sub-track (2D) constituent
            ///< * 5 : sub-tracks have no shared layers
            ///< * 6 : sub-track traverses only a single layer
            ///< * 7 : sub-track has only 2 hits
            ///< * 8 : track was merged into a super track
            ///< * 9 : intermediate merged track that does exist in the hough transform or
            ///< in the final vertex candidate tracks.
            ///< Failure mode will only be available when using RunVertexing, otherwise
            ///< failed tracks will have been thrown away.
            
            UInt_t UniqueID;   ///< Unique ID of the track
            
            Int_t NHits;   ///< Number of hits on track
            
            Float_t MatchingLikelihood;   ///< The matching likelihood of the track
            
            TLorentzVector FrontPosition;   ///< The front position (closest to the tracker) of the track
            
            TVector3 FrontDirection;   ///< The front direction (closest to the tracker) of the track
            
            
            Int_t FrontLayerNumber;   ///< The front layer number (closest to the tracker) of the track
            
            
            TLorentzVector BackPosition;   ///< The back position (furthest from the tracker) of the track
            
            TVector3 BackDirection;   ///< The back direction (furthest from the tracker) of the track
            
            Int_t BackLayerNumber;   ///< The back layer number (closest to the tracker) of the track
            
            
            Float_t TotalCharge;   ///< The total charge deposited by the track
            
            Float_t StraightTrackLength;   ///< Distance between the two track end positions
            
            Float_t NodeTrackLength;   ///< Distance integrating along the track representation nodes.
            
            
            // Charge weighted hit time along the track.
            Float_t AverageHitTime;
            
            Int_t G4IDSingle;   ///< The G4ID of the single biggest contributor to the track
            
            
            #ifdef USE_FULL_VERTEX_TRACK_INFO
            Float_t CompletenessSingle;   ///< The Completeness of the single biggest contributor to the track
            
            Float_t CleanlinessSingle;///< The cleanliness (hit purity) of the single biggest contributor  to the track
            
            TVector3 Single_FrontPosition; ///< Position of the closest G4 point of the best match single trajectory to the front position
            
            TVector3 Single_FrontDirection; ///< Direction of the closest G4 point of the best match single  trajectory to the front position
            
            double Single_FrontG4PointDist;   ///< Distance of the closest G4 point of the best match single trajectory  to the front position
            
            TVector3 Single_BackPosition;   ///< Position of the closest G4 point of the best match single trajectory  to the back position
            
            TVector3 Single_BackDirection;   ///< Direction of the closest G4 point of the best match single  trajectory to the back position
            
            
            double Single_BackG4PointDist; ///<\brief Distance of the closest G4 point of the best match single trajectory  to the back position
            
            Int_t G4IDPrimary;   ///< The G4ID of the primary contributor to the track
            
            Float_t CompletenessPrimary;   ///< The Completeness of the primary contributor to the track
            
            Float_t CleanlinessPrimary;   ///< The cleanliness (hit purity) of the primary contributor to the track
            
            Int_t G4IDRecursive;   ///< The G4ID of the recursive contributor to the track
            
            Float_t CompletenessRecursive;   ///< The Completeness of the recursive contributor to the track
            
            Float_t CleanlinessRecursive;   ///< The cleanliness (hit purity) of the recursive contributor to the track
            
            Int_t SubTrack_UniqueID[2];   ///< The unique IDs of the 2D constituents of the track
            
            Int_t SubTrack_NHits[2];   ///< The number of hits on the 2D constituents of the track
            
            Int_t SubTrack_Angle[2];   ///< The angle the 2D constituents makes with the local x or y axis
            
            Int_t SubTrack_FrontLayerNumber[2];   ///< The front layer number (closest to the tracker) of the 2D track
            
            Int_t SubTrack_BackLayerNumber[2];   ///< The back layer number (furthest from the tracker) of the 2D track
            
            Int_t SubTrack_DOCA[2];   ///<  The distance of closest approach of the 2D constituents to the  cluster centre
            
            Float_t SubTrack_TotalCharge[2];   ///< The total charge of the 2D constituents
            
            Int_t SubTrack_G4IDSingle[2];   ///< The G4ID of the single biggest contributor to the 2D constituents
            
            Float_t SubTrack_CompletenessSingle[2]; ///< The Completeness of the single biggest contributor to the 2D  constituents
            
            Float_t SubTrack_CleanlinessSingle[2]; ///< The cleanliness (hit purity) of the single biggest contributor  to the 2D constituents
            
            Int_t SubTrack_G4IDPrimary[2];   ///< The G4ID of the primary contributor to the 2D constituents
            
            
            Float_t SubTrack_CompletenessPrimary[2];   ///< The Completeness of the primary contributor to the 2D constituents
            
            Float_t SubTrack_CleanlinessPrimary[2]; ///< The cleanliness (hit purity) of the primary contributor to the  2D constituents
            
            
            Int_t SubTrack_G4IDRecursive[2];   ///< The G4ID of the recursive contributor to the 2D constituents
            
            Float_t SubTrack_CompletenessRecursive[2];   ///< The Completeness of the recursive contributor to the 2D constituents
            
            Float_t SubTrack_CleanlinessRecursive[2];   ///< The cleanliness (hit purity) of the recursive contributor to the   2D constituents
            
            Int_t NCrossings;   ///< The number of crossings associated with the track
            
            UInt_t *CrossingIDs;  //[NCrossings]   ///< The IDs of the crossings associated with the track
            
            #endif
            
            double PID_LLR_MIP_EM;   ///< A combined discriminator for separating MIPs from EM showers.   Positive values = EM shower-like;  Negative values = MIP-like.
            ///< For more details on the Likelihood PID see ecalRecon documentation or
            ///< http://www.t2k.org/docs/technotes/111
            
            ///< This variable should eventually replace the old TrShval
            ///< See the ecalRecon documentation for more details.
            
            double PID_LLR_EM_HIP;   ///< A combined discriminator for separating protons from electrons.  Positive values = stopping track-like;  Negative values = EM shower-like.
            ///< See the ecalRecon documentation for more details.
            
            double PID_LLR_MIP_HIP;   ///< A combined discriminator for separating MIPs from HIPs.    Positive values = HIP-LIKE;  Negative values = MIP-like
            ///< For more details on the Likelihood PID see ecalRecon documentation or
            ///< http://www.t2k.org/docs/technotes/111
            
            double PID_LLR_MIP_HIP_VACut; ///< A combined discriminator for separating MIPs from HIPs where the  hits nearest the vertex have been ignored.  Positive values = HIP-LIKE; Negative values = MIP-like.
            ///<
            ///< For more details on the Likelihood PID see ecalRecon documentation or
            ///< http://www.t2k.org/docs/technotes/111
            
            
            double Containment;   ///< Containment: contained = 1.0, not-contained = 0.0, default = -1.0.
            ///<
            ///< An object is classed as contained if it has no hits in the outer bars
            ///< of the ECal (bar number 0 or the maximum bar in a layer)
            ///< and no hits in the outermost layer of the ECal.
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconVertexTrack, 1);
        };
        
        TECALReconVertexTrack *TECALReconVertexTrackFactory(
            ND::THandle<ND::TReconPID>, bool, void *pos = NULL,
            ND::THandle<ND::TG4TrajectoryContainer> trajectories =
            ND::THandle<ND::TG4TrajectoryContainer>(NULL),
            bool Allocate = true);
        
        class TECALReconVertexCrossing : public TObject {
        public:
            TECALReconVertexCrossing();
            virtual ~TECALReconVertexCrossing(){};
            UInt_t UniqueID;   ///< Unique ID of the crossing
            
            Int_t NHits;   ///< Number of hits directly associated with the crossing
            
            Float_t *HitCharges;  //[NHits]   ///< Charges of associated hits
            
            Float_t *HitPositionsX;  //[NHits]   ///< X coordinates of associated hits
            
            Float_t *HitPositionsY;  //[NHits]   ///< Y coordinates of associated hits
            
            Float_t *HitPositionsZ;  //[NHits]   ///< Z coordinates of associated hits
            
            Float_t *HitTimes;  //[NHits]   ///< Times of associated hits
            
            Int_t *HitLayerNumbers;  //[NHits]   ///< Layer numbers of associated hits
            
            Int_t *HitBarNumbers;  //[NHits]   ///< Bar numbers of associated hits
            
            TLorentzVector Position;   ///< The reconstruction position of the crossing
            
            Float_t DOCA;   ///< The distance of closest approach of the two lines
            
            Int_t NTracks;   ///< The number of tracks which created this crossing
            
            UInt_t *TrackIDs;  //[NTracks]   ///< The track IDs which created this crossing
            
            
            ClassDef(ND::TTrackerECALReconModule::TECALReconVertexCrossing, 1);
        };
        
        ///\brief Responsible for setting up output tree, looping over oaEvent
        /// containers, and filling output objects.
        ///
        ///\details This eventAnalysis module provides information gleaned from the output
        /// of the ecalRecon reconstruction package.
        /// Amongst other quantities, the output of this module provides:
        /// - Variables which quantify the extent to which the reconstructed object
        /// resembles a track or a shower.
        /// - Track and shower specific reconstructed quantities.
        /// - Information concerning the constituent hits of reconstructed objects.
        /// Users are encouraged to add information to this module.
        /// Originally documented by Tom Maryon and others.
        class OutputManager : public TAnalysisReconModuleBase {
        public:
            OutputManager(const char *name = "TrackerECal",
                const char *title = "Tracker ECal Recon Module");
            virtual ~OutputManager();
            
            virtual Bool_t ProcessFirstEvent(ND::TND280Event &event);
            
            /// \brief Returns true if there is at least one Recon object in the Tracker
            /// ECals.
            ///
            /// If -preselection=TTrackerECALReconModule is specified,
            /// the full oaEvent event will be output for this event
            virtual bool IsFullEventWorthSaving(ND::TND280Event &event);
            
            void SayAvailableOpts(std::string indent = "") {
                std::cout << indent << "=SaveVertexCandy: Will Save reconstructed "
                "vertex\n"
                << indent << " candidate info" << std::endl;
                std::cout << indent
                << "=SaveTheHoff: Will save the bare Hough transform results."
                << std::endl;
                std::cout << indent << "=RunVertexing: will run\n"
                <<indent <<" vertexing if the container\n"
                << indent << " is not found" << std::endl;
                #ifdef TTRACKERECALRECONMODULE_USE_EXP
                std::cout << indent << "=SaveHitInfo: Will save hit info\n" << std::endl;
                
                std::cout << indent << "**Experimental functionality enabled**"
                << std::endl;
                #endif
            }
            
        protected:
            virtual void InitializeModule();
            
            virtual void InitializeBranches();
            virtual bool FillTree(ND::TND280Event &);
            
            void FillVertexingInformation(
                ND::THandle<ND::TAlgorithmResult> ecalFinalResult,
                ND::THandle<ND::TG4TrajectoryContainer> trajectories);
            
            /// Handles saving of the results of the ecalRecon Hough transform
            void FillHoughTransformInformation(
                ND::THandle<ND::TAlgorithmResult> ecalFinalResult,
                ND::THandle<ND::TG4TrajectoryContainer> trajectories);
            
            /// Just saves the final ECal-iso vertexing results.
            /// Useful for matching extra ECal info for studies to global vertices
            /// created with ECal vertexing more downstream.
            void FillECalIsoVertexingInformation(
                ND::THandle<ND::TAlgorithmResult> ecalFinalResult,
                ND::THandle<ND::TG4TrajectoryContainer> trajectories);
            
            /// Processes any results in the ecalRecon *other* container
            void ProcessOtherContainer(ND::THandle<ND::TReconObjectContainer> other);
            /// Processes any results in the ecalRecon *final* container
            void ProcessFinalContainer(ND::THandle<ND::TReconObjectContainer> final);
            /// Handles clearing and resetting of event level variables/arrays
            void PerEvReset();
            
            #ifdef TTRACKERECALRECONMODULE_USE_EXP
            /// Saves a THit, with object association UID
            /// Will optionally overwrite a previous hit deemed to be equivalent via
            /// TECALHitHasher---practically if they occur on the same bar at times within
            /// 100 ns of each other.
            void SaveUsedHit(ND::THandle<ND::THit> hit, unsigned int UID,
                bool overwritePrevious = false);
            
            ///\brief Simple hit hashing function, uses the geomID and the hit time to
            /// attempt to uniquely identify a hit.
            ///\details Unlikely to result in collisions between hits that were not
            /// originally the same, the time window for collision is one tenth of a ms.
            /// - lp208 [at] ac [dot] ic [dot] uk
            inline unsigned long TECALHitHasher(ND::THandle<ND::THit> hit) {
                return (hit->GetGeomId().AsInt() * 1000 +
                    (int(hit->GetTime()) / 100) % 1000);
            }
            
            /// Whether to save the individual hit info. [false]
            bool fDoSaveHitInfo;
            
            /// Used to keep track of which ECal hits have been already used.
            /// Maps between a 'Hit hash' and the index of the hit in
            /// ND::OutputManager::fUsedHits.
            std::map<unsigned long, unsigned int> fSavedHitMap;
            #endif
            /// Helper object which performs vertex candidate reconstruction
            TECalVertexing *fVertexRecon;
            ///\brief Whether to re-run the vertexing (N.B. this is reconstruction!) and
            /// save full vertexing track results.
            bool fDoVertexing;
            /// Whether to output the bare Hough transform results
            bool fDoSaveHoughResults;
            /// Whether to calcluate and save the reconstructed vertx candidaties. [false]
            bool fDoSaveVertexCandidates;
            /// Which tracks have already been saved
            std::map<UInt_t, Int_t> fSavedVertexTrackIds;
            
        public:
            /// Provides CLI for enabling fDoSaveHitInfo and fDoSaveVertexCandidates
            Bool_t Configure(std::string &option);
            
            /// Tree Entries
            Int_t fNReconObjects;
            Int_t fNUnmatchedObjects;
            Int_t fNReconTrackLike;
            Int_t fNReconShowerLike;
            Int_t fNReconCluster;
            Int_t fNReconVertexClusters;
            #ifdef TTRACKERECALRECONMODULE_USE_EXP
            Int_t fNUsedHits;
            #endif
            Int_t fNVertexCandidates;
            Int_t fNVertexCandidateTracks;
            
            long fTotal;
            
            TClonesArray *fReconObjects;   ///< The TECALRecon Objects
            
            TClonesArray *fUnmatchedObjects;   ///< The Unmatched Objects
            
            TClonesArray *fReconVertexClusters;   ///< The Reconstructed Vertices
            
            #ifdef TTRACKERECALRECONMODULE_USE_EXP
            TClonesArray *fUsedHits;   ///< The used ECal hits
            
            #endif
            TClonesArray *fVertexCandidates;   ///< The reconstructed vertex candidates.
            
            TClonesArray *fVertexCandidateTracks;   ///< The tracks associated with the reconstructed vertex candidates
            
        };
    }
}
#endif