TGlobalReconModule.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.
///
/// 21-Dec-2011: Current responsible for this module is,
/// Per Jonsson (per.jonsson@imperial.ac.uk)
/// Previous author:
/// Anselmo Cervera Villanueva (anselmo [*a*t*] cervera@cern.ch)
///
#ifndef TGlobalReconModule_hxx_seen
#define TGlobalReconModule_hxx_seen

#include <string>

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

#include <TND280Event.hxx>

#include <TReconPID.hxx>
#include <TReconVertex.hxx>

#include <TComboHit.hxx>
#include <TDigit.hxx>
#include <TFGDmcDigit.hxx>
#include <TG4HitSegment.hxx>
#include <TG4PrimaryVertex.hxx>
#include <TG4Trajectory.hxx>
#include <TMCDigit.hxx>
#include <TMCHit.hxx>
#include <TMultiHit.hxx>
#include <TTFBmcDigit.hxx>
#include <TTPCmcDigit.hxx>

#include <EeventAnalysis.hxx>
#include "eventAnalysisEnums.hxx"
#include "TAnalysisReconModuleBase.hxx"
#include "TGlobalBaseObjects.hxx"
#include "TTrueVertex.hxx"
#include "recpack/HelixEquation.h"
#include "recpack/Surface.h"
#include "recpack/Trajectory.h"
#include "recpack/Volume.h"

#include "TTrueVertex.hxx"

const int NDETSEXTRAP   = 25;
const int NDETSUSED     = 23;
const int NCONSTITUENTS = 20;
const int NSVERTICES    = 20;
const int NTIMEBINS     = 8;

namespace ND {
class TGlobalReconModule;
OA_EXCEPTION(EeventAnalysisInfiniteLoop2, EeventAnalysis);
};

/// This module summarizes the information from global reconstruction.
class ND::TGlobalReconModule : public TAnalysisReconModuleBase {
 public:
  /// An object to store subdetector-agnostic hit information.
  class TGlobalHit : public TObject {
   public:
    virtual ~TGlobalHit();
    double Charge;     ///< Deposited charge
    double Time;     ///< Hit time [ns]
    TVector3 Position;     ///< Hit position in global ND coordinates [mm]
    TVector3 PositionError;     ///< The variance on ND::TGlobalReconModule::TGlobalHit::Position [mm]
    int Type;     ///< The hit 'type': (0=X,1=Y,2=Z)
    ClassDef(TGlobalReconModule::TGlobalHit, 1);
  };

  /// An object to store hit information for the SMRD subdetector
  class TSMRDHit : public TObject {
   public:
    virtual ~TSMRDHit();
    int Wall;     ///< SMRD wall number, 0=Top, 1=Bottom, 2= Right, 3= Left.
    int Yoke;     ///< Yoke ring number.
    int Layer;     ///< SMRD hit layer number.
    int Tower;     ///< SMRD Tower number.
    int Counter;     ///< SMRD scint number.
    double Charge;     ///< Deposited charge
    double Time;     ///< Hit time [ns]
    TVector3 Position;     ///< Hit position in global ND coordinates [mm]
    TVector3 PositionError;     ///< The variance on ND::TGlobalReconModule::TSMRDHit::Position [mm]
    int Type;     ///< The hit 'type': (0=X,1=Y,2=Z)
    ClassDef(TGlobalReconModule::TSMRDHit, 1);
  };

  /// An object to store the outermost hits in x,y, and z.
  class TOutermostHits : public TObject {
   public:
    virtual ~TOutermostHits();
    TGlobalHit hitMinX;     ///< Hit with lowest X position.
    TGlobalHit hitMaxX;     ///< Hit with highest X position.
    TGlobalHit hitMinY;     ///< Hit with lowest Y position.
    TGlobalHit hitMaxY;     ///< Hit with highest Y position.
    TGlobalHit hitMinZ;     ///< Hit with lowest Z position.
    TGlobalHit hitMaxZ;     ///< Hit with highest Z position.
    ClassDef(TGlobalReconModule::TOutermostHits, 1);
  };

  /// An object to store information about an FGD Time Bin.
  class TFgdTimeBin : public TObject {
   public:
    TFgdTimeBin();
    virtual ~TFgdTimeBin();
    double minTime;     ///< Bin start time.
    double maxTime;     ///< Bin end time.
    int nHits[2];     ///< Number of hits in FGD1 (nHits[0]), and 2 (nHits[1])
    double rawChargeSum[2];     ///< Summed hit charge in FGD1 (rawChargeSum[0]), and 2 (rawChargeSum[1])
    float chargePerLayer[2][30];    ///<\brief Summed hit charge for layer x in FGD1 (chargePerLayer[0][x]),  and 2 (chargePerLayer[1][x])
    TVector3 chargeWeightedPos[2];     ///<\brief Charge weighted average hit position in FGD1 chargeWeightedPos[0]) and 2 (chargeWeightedPos[1])
    TOutermostHits FGD1OutermostHits;     ///< A named collection of the outermost hits in X,Y, and Z from FGD1
    TOutermostHits FGD2OutermostHits;     ///< A named collection of the outermost hits in X,Y, and Z from FGD2
    std::vector<int> FGD1HitLayer;     ///< Vector to store the layer number of each hit in FGD1
    std::vector<float> FGD1HitPosition;     ///< Vector to store the X or Y position of each hit in FGD1
    std::vector<float> FGD1HitQ;     ///< Vector to store the charge of each hit in FGD1
    std::vector<float> FGD1HitTrueE;     ///< Vector to store the true edeposit of each hit in FGD1
    std::vector<float> FGD1HitT;     ///< Vector to store the time of each hit in FGD1
    std::vector<int> FGD1HitTrajID;     ///< Vector to store the ID of the Trajectory that created the hit in FGD1
    std::vector<int> FGD2HitLayer;     ///< Vector to store the layer number of each hit in FGD2
    std::vector<float> FGD2HitPosition;     ///< Vector to store the X or Y position of each hit in FGD2
    std::vector<float> FGD2HitQ;     ///< Vector to store the charge of each hit in FGD2
    std::vector<float> FGD2HitT;     ///< Vector to store the time of each hit in FGD2
    std::vector<int> FGD2HitTrajID;     ///< Vector to store the ID of the Trajectory that created the hit in FGD1
    Int_t NFGD1Unused;     ///<  Number of hits unused in FGD1
    TClonesArray* FGD1Unused;     ///<  The vector unused hits in FGD1
    Int_t NFGD2Unused;     ///<  Number of hits unused in FGD2
    TClonesArray* FGD2Unused;     ///<  The vector unused hits in FGD2
    int g4ID;     ///< The ID for the G4 trajectory that contributed most to this time bin.
    TGlobalHit hackFGDUnused;     ///< This is just here to fool TFile::MakeProject, not a real object.
    ClassDef(TGlobalReconModule::TFgdTimeBin, 1);
  };

  /// An object to store information about an SFG Time Bin.
  class TSfgTimeBin : public TObject {
   public:
    TSfgTimeBin();
    virtual ~TSfgTimeBin();
    double minTime;     ///< Bin start time.
    double maxTime;     ///< Bin end time.
    double rawChargeSum;     ///< Summed hit charge in SFG
 
    TVector3 chargeWeightedPos;       ///<\brief Charge weighted average hit position in SFG
    TOutermostHits SFGOutermostHits;         ///< A named collection of the outermost hits in X,Y, and Z from SFG
 
    int    nHits;         ///< Number of hits in SFG

    std::vector<float> SFGHitPositionX;       ///< Vector to store the Xposition of each hit in SFG
    std::vector<float> SFGHitPositionY;         ///< Vector to store the  Y position of each hit in SFG
    std::vector<float> SFGHitPositionZ;         ///< Vector to store the X or Y position of each hit in SFG
    std::vector<float> SFGHitQ;          ///< Vector to store the charge of each hit in SFG
    std::vector<float> SFGHitT;         ///< Vector to store the time of each hit in SFG
    std::vector<int> SFGHitTrajID;         ///< Vector to store the ID of the Trajectory that created the hit in SFG
    Int_t NSFGUnused;     ///<  Number of hits unused in SFG
    TClonesArray* SFGUnused;     ///<  The vector unused hits in SFG
    TGlobalHit hackSFGUnused;         ///< This is just here to fool TFile::MakeProject, not a real object.
    int g4ID;         ///< The ID for the G4 trajectory that contributed most to this time bin.

    ClassDef(TGlobalReconModule::TSfgTimeBin, 1);
  };


  /// An object to hold a reconstructed vertex constituent track
  class TVertexConstituent : public TObject {
   public:
    virtual ~TVertexConstituent();
    int Charge;     ///< Charge of the constituent track
    double Quality;     ///< Quality (chi2) of the constituent track
    TVector3 Momentum;     ///< 3-momentum of the constituent track
    int PID;     ///< The TGlobalPID of the constituent track
    ClassDef(TGlobalReconModule::TVertexConstituent, 1);
  };

  /// An object to describe a reconstructed primary vertex candidate.
  class TGlobalVertex : public TObject {
   public:
    TGlobalVertex();
    virtual ~TGlobalVertex();
    int Type;             ///< Vertex type (0: Global vertex | 1: SFG vertex)
    int PrimaryIndex;     ///< The index of the corresponding primary vertex
    std::string AlgorithmName;     ///< The name of the algorithm that created this object.
    int Status;           ///< The status for the fit.
    double Quality;       ///<  The quality of the fit.  
/// For Vertices created using -O TGlobalReconModule=UseECalVertices  the quality denotes 
    /// whether all constituents were correctly found  1: for all found  0: for not all found  
    /// Not finding them is an internal TGlobalReconModule error and these vertices should not 
    /// be trusted.
    int NDOF;     ///< The number of degrees of freedom.
    TLorentzVector Position;     ///< The position of the vertex.
    TLorentzVector Variance;     ///< The position variance;
    Int_t         NTrueVertices;     ///< The true vertex
    TClonesArray* TrueVertices;     ///< The true vertex
    Int_t         NConstituents;     ///< Constituent tracks
    TClonesArray* Constituents;     ///< Constituent tracks
    TTrueVertex hackTrueVertexObject;     ///< This is just here to fool TFile::MakeProject, not a real object.
    TVertexConstituent hackVertexConstituentObject;     ///< This is just here to fool TFile::MakeProject, not a real object.
    ClassDef(TGlobalReconModule::TGlobalVertex, 1);
  };

  /// An object to described a P0D shower
  class TP0DObject : public TSubBaseShowerObject {
   public:
    virtual ~TP0DObject();
    double Width;     ///< The width of the shower (perpendicular to the direction).
    double avgtime;     ///< Averaged corrected node time.
    std::vector<int> ParticleId; ///< A vector of potential PIDs, sorted by weight, c.f.  TP0DObject::PIDWeight.
    std::vector<double> PIDWeight;     ///< The weights for the PID hypotheses, c.f. TP0DObject::ParticleId
    ClassDef(TGlobalReconModule::TP0DObject, 1);
  };

  /// Describes a reconstructed ECalObject
  class TECALObject : public TSubBaseShowerObject {
   public:
    virtual ~TECALObject();
     double  Length   ;///< The length of the track or shower, its value depends on if the object is reconstructed as track-like or shower-like.
    ///< If IsTrackLike Length is set by RecPack ND::tman().ComputeObjectLength
    ///< If IsShowerLike length is set by Tracker ECal reconstruction and is the distance between the charge weighted position of 
    ///< hits in the first layer and the charge weighted position of hits in the last layer.
    double  EDeposit ;///<    Deposited energy. Its value depends on if the object is reconstructed as track-like or shower-like If IsTrackLike EDeposit is the total charge in the cluster in MEU. If IsShowerLike it is the result of the Tracker ECal EMEnergyFit in MeV.
    double LLR_Quality; ///<\brief PID quality flag.   A non-zero indicates an bad quality.  If this value is non-zero the PID values are set to -9999.
    double LLR_MIP_EM; ///<\brief Value to separate MIP-like objects (e.g. muons) from EM showers e.g. photons/electrons). -9999 indicates an error.
     double LLR_MIP_Pion;     ///<\brief Value to separate MIP-like objects (e.g. muons) from showering  pions. -9999 indicates an error.
    double LLR_EM_HIP; ///<\brief Value to separate light tracks/MIP-like objects (e.g. muons) from  heavy tracks / Highly-ionising particles (specifically proton).  -9999 indicates an error.
    double LLR_MIP_EM_LowMomentum; ///<  UNSTABLE: 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.  -9999 indicates an error.
    double LLR_MIP_HIP_VACut; ///< UNSTABLE: Only filled for FilledAsType == 2  Recalculates PID variables for a vertex track where the X% (20% by  default) hits nearest to the reconstructed vertex are ignored. 
    double AverageHitTime;     ///< The charged weighted average time for the ECal cluster
    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
    int FilledAsType;     ///<\brief Whether the object was filled as a shower (or a track.). This is      NOT a PID.         This lets you know how some of these variables were filled from the     original ECal cluster. ECal-iso vertex tracks do not fill many of these     variables. Showers and Tracks differ in their definitions of Width and     Length, and EDeposit.     Cone is filled from the alternate Shower hypothesis for Track-like     clusters.     2. ECal-iso vertex track     1. Shower-like     0. Track-like     -1. Default value
    double PID_Circularity; ///< The circularity of the object
    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; ///<    \brief 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 Thrust;  ///< The thrust value
    TVector3 ThrustOrigin; ///< The origin point of the thrust
    TVector3 ThrustAxis;  ///< The thrust axis
    int InnerMostLayerHit;///<\brief Zero-indexed layer number of tracker-closest layer with an ECal  hit belonging to this object.
    int OuterMostLayerHit; ///<\brief Zero-indexed layer number of tracker-farthest layer with an ECal  hit belonging to this object.
    TVector3 Width;     ///< TrackShower width         Filled depending on `FilledAsShower`.     * Track: `ND::TReconTrack::GetWidth`     * Shower: All three components are = `Length*tan(PID_ShowerAngle)`
    ClassDef(TGlobalReconModule::TECALObject, 2);
  };

  /// An object to hold specific TPC variables
  class TTPCObject : public TSubBaseObject {
   public:
    virtual ~TTPCObject();
    double Charge;  ///< Charge from the TPC pid (+1, or -1)
    double NTrun;       ///< 70% of the number of cluster
    double Craw; // Raw mean charge deposit in PID
    double Ccorr;       ///< Corrected truncated mean charge deposit in PID
    double PullEle;     ///< Pull for TPC pid electron hypothesis
    double PullMuon;    ///< Pull for TPC pid muon hypothesis
    double PullPion;    ///< Pull for TPC pid pion hypothesis
    double PullKaon;    ///< Pull for TPC pid kaon hypothesis
    double PullProton;  ///< Pull for TPC pid proton hypothesis
    double dEdxexpEle;     ///< Estimated dE/dx for electron hypothesis
    double dEdxexpMuon;    ///< Estimated dE/dx for muon hypothesis
    double dEdxexpPion;    ///< Estimated dE/dx for pion hypothesis
    double dEdxexpKaon;    ///< Estimated dE/dx for kaon hypothesis
    double dEdxexpProton;  ///< Estimated dE/dx for proton hypothesis
    double SigmaEle;   ///< Sigma estimated width of TPC pid electron hypothesis
    double SigmaMuon;  ///< Sigma estimated width of TPC pid muon hypothesis
    double SigmaPion;  ///< Sigma estimated width of TPC pid pion hypothesis
    double SigmaKaon;  ///< Sigma estimated width of TPC pid kaon hypothesis
    double SigmaProton;  ///< Sigma estimated width of TPC pid proton hypothesis
    std::vector<int> T0Source;  ///< The T0Source, the values are defined in TTPCFitStatusBranch.hxx, the TTPCT0Source enumeration.
    std::vector<int>
        NHorRows;  ///< The number of horizontal clusters in the track
    std::vector<int>
        NVerRows;  ///< The number of vertical clusters in the track
    int NbFittedVerticalClusters;    ///< The number of vertical clusters contributed to the fit,  TREx
    int NbFittedHorizontalClusters;  ///< The number of horizontal clusters contributed to the fit,  TREx
    double PDist;      ///< Placeholder for momentum of BField refit.
    double PEField;    ///< Placeholder for momentum of EField refit.
    double TPCLength;  ///< TPC track length.
    int TrackType;  ///< Record of why the track was refit with a kalman filter fit instead of the likelihood fit.
    
    // Newly added variables
    double TrueEDeposit; // True energy deposition summing over hit segments
    double TrueEDeposit_sec; // The same, but use function GetSecondaryDeposition()
    double TruedEdx; // True dE/dx computed based on hit segment energy deposition and "length"
    double TruedEdx_sec; // The same, but use function GetSecondaryDeposition()
    
    ClassDef(TGlobalReconModule::TTPCObject, 1);
  };

  /// An object to hold specific TPC variables
  class TTPCOtherObject : public TObject {
   public:
    virtual ~TTPCOtherObject();
    double Charge;    ///< Charge
    int Detector;     ///< Detector
    int NHits;        ///< Number of hits
    double Chi2;      ///< Chi squared
    double EDeposit;  ///< Energy deposit
    TLorentzVector FrontPosition;  ///< The Front position of the object.
    TLorentzVector BackPosition;  ///< The Back position of the object.
    TVector3 FrontDirection;  ///< The Front direction of the object.
    TVector3 BackDirection;  ///< The Back direction of the object.
    double Momentum;  ///< the momentum of the object
    TTrueParticle TrueParticle;  ///< The true particle
    ClassDef(TGlobalReconModule::TTPCOtherObject, 1);
  };

  /// An object to hold specific TRACKER variables
  class TTrackerObject : public TSubBaseObject {
   public:
    virtual ~TTrackerObject();
    double Charge;
    int matchingFailure_flag;
    ClassDef(TGlobalReconModule::TTrackerObject, 1);
  };

  /// An object to hold specific SFG variables
  class TSFGObject : public TSubBaseObject {
   public:
    virtual ~TSFGObject();
   
    int    Type; ///< Object type,  0: Particle, 1: Track, 2: Cluster, 3: Shower, 4: Vertex

    double avgtime;  ///< Average fully corrected SFG hit time.
    double EDeposit;   ///< Energy deposit of the corresponding object.
    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.


    double PIDWeightProt;     ///< PID weights for proton hypothesis
    double PIDWeightPion;    ///< PID weights for pion hypothesis
    double PIDWeightMuon;    ///< PID weights for muon hypothesis
    double PIDWeightElec;    ///< PID weights for electron hypothesis

   
    int ProtonBraggCut;  ///< Bragg peak cut (only used for SFGD contained tracks)
    int PionBraggCut;  ///< Bragg peak cut (only used for SFGD contained tracks)
    int NegPionBraggCut;  ///< Bragg peak cut (only used for SFGD contained tracks)
    //============  SFG hit ===================//
   
    std::vector<TLorentzVector>      HitPosition;   ///< Vector to store the position of each hit
    std::vector<TLorentzVector>      HitPosVariance;   ///< Vector to store the variance of the position of each hit
    std::vector<double>              HitCharge;         ///< Vector to store the charge of each hit

    std::vector<int>                 HitTrajID;      ///< Vector to store the ID of the Trajectory that created the hit

    std::vector<std::vector<int>>    HitUniqueID;      ///< Vector to store the Unique ID of the hit

    //============  SFG node ===================//
    std::vector<TLorentzVector>      NodePosition;      ///< Vector to store the position and time of each node

    std::vector<TLorentzVector>      NodePosVariance;  ///< Vector to store the variance on the  position and time of each node
    std::vector<TVector3>            NodeDirection;      ///< Vector to store the direction of each node

    std::vector<TVector3>            NodeDirVariance;   ///< Vector to store the variance on the direction of each node
    std::vector<double>              NodeEDeposit;      ///< Vector to store the energy deposit of each node

    std::vector<double>              NodeEDeposit_fit;     // Fitted node energy deposit

    std::vector<int>                 NodeNHits;      ///< Vector to store the number of hits contributing to each node

    std::vector<std::vector<int>>    NodeHits;    ///< Vector to store the hits contributing to each node
    std::vector<std::vector<int>>    NodeUniqueID;       ///< Vector to store the Unique ID of the node

    ClassDef(TGlobalReconModule::TSFGObject, 1);
  };

  /// An object to hold specific FGD variables
  class TFGDObject : public TSubBaseObject {
   public:
    virtual ~TFGDObject();

    double avgtime;  ///< Average fully corrected FGD hit time.
    float chargePerLayer[30];
    float chargePerLayerAttenCorr[30];

    int fgdContainment;  
    ///< Fully contained PID information. Indicates whether the FGD PID algorithm 
    /// determined the track to be fully contained in FGD1 or FGD2 (=1 or 2), 
    /// stopping in FGD1 or FGD2 (=-1 or -2), or other (0).

    double E;  ///< Measured energy in an FGD.
    double x;  ///< Distance traveled in an FGD.
    double TrueE; ///< True energy in an FGD              

    double E_exp_muon;      ///< Expected energy deposit for a muon.
    double E_exp_pion;      ///< Expected energy deposit for a pion.
    double E_exp_proton;    ///< Expected energy deposit for a proton.
    double E_exp_electron;  ///< Expected energy deposit for an electron.

    double sigmaE_muon;      ///< Expected energy uncertainty for a muon.
    double sigmaE_pion;      ///< Expected energy uncertainty for a pion.
    double sigmaE_proton;    ///< Expected energy uncertainty for a proton.
    double sigmaE_electron;  ///< Expected energy uncertainty for an electron.

    double PullMuon;      ///< The FGD PID pull value for a muon.
    double PullPion;      ///< The FGD PID pull value for a pion.
    double PullProton;    ///< The FGD PID pull value for a proton.
    double PullElectron;  ///< The FGD PID pull value for an electron.
    double PullNotSet;    ///< PullNotSet = 1 if the pull is not set, and 0 otherwise.

    bool isFgdVA;
    bool isFgdVA_flag;
    int globpassVA_flag;      /// FGD vertex activity Vertex (1) or Entrance (2)
    double fgdVA_upMinZ;      ///< FGD vertex activity values.
    double fgdVA_downMaxZ;    ///< FGD vertex activity values.
    double fgdVA_upCosTheta;  ///< FGD vertex activity values.
    double fgdVA_downCosTheta;      ///< FGD vertex activity values.
    double fgdVA_otherUpQ;          ///< FGD vertex activity values.
    double fgdVA_otherDownQ;        ///< FGD vertex activity values.
    double fgdVA_verQ;              ///< FGD vertex activity values.
    double fgdVA_verLayQ;           ///< FGD vertex activity values.
    double fgdVA_verNearQ;          ///< FGD vertex activity values.
    double fgdVA_verNextNearQ;      ///< FGD vertex activity values.
    double fgdVA_verNextNextNearQ;  ///< FGD vertex activity values.

    double fgdVA_verNearQ_rect;          ///< FGD vertex activity 2x3.
    double fgdVA_verNextNearQ_rect;      ///< FGD vertex activity 2x5.
    double fgdVA_verNextNextNearQ_rect;  ///< FGD vertex activity 2x7.

    double fgdVA_totalQ;      ///< FGD vertex activity values.
    double fgdVA_totalCorrE;  ///< FGD vertex activity values.

    bool isFgdEA;           
    bool isFgdEA_flag;
    int globpassEA_flag;            /// FGD end activity End (1) or Exit (2)
    double fgdEA_otherUpQ;          ///< FGD end activity values.
    double fgdEA_otherDownQ;        ///< FGD end activity values.
    double fgdEA_verQ;              ///< FGD end activity values.
    double fgdEA_verLayQ;           ///< FGD end activity values.
    double fgdEA_verNearQ;          ///< FGD end activity values.
    double fgdEA_verNextNearQ;      ///< FGD end activity values.
    double fgdEA_verNextNextNearQ;  ///< FGD end activity values.

    double fgdEA_verNearQ_rect;          ///< FGD end activity values.
    double fgdEA_verNextNearQ_rect;      ///< FGD end activity values.
    double fgdEA_verNextNextNearQ_rect;  ///< FGD end activity values.

    std::vector<int> fgdhits_Layer;     ///< Vector to store the layer number of each hit
    std::vector<TVector3> fgdhits_Position;     ///< Vector to store the X or Y position of each hit
    std::vector<float> fgdhits_Time;     ///< Vector to store the time of each hit
    std::vector<float> fgdhits_Charge;     ///< Vector to store the charge of each hit
    std::vector<int> fgdhits_TrajID;     ///< Vector to store the ID of the Trajectory that created the hit
    
    // Node information
    std::vector<TLorentzVector> NodePosition;  ///< FGD Node positions
    std::vector<double> NodeEDeposit;          /// FGD Node Energy Deposits
    
    ClassDef(TGlobalReconModule::TFGDObject, 1);
  };

  /// An object to hold specific SMRD variables
  class TSMRDObject : public TSubBaseObject {
   public:
    virtual ~TSMRDObject();
    double avgtime;  // Avergaed light-propagation corrected hit time

    ClassDef(TGlobalReconModule::TSMRDObject, 1);
  };

  /// An object to describe a reconstructed PID.
  class TTpcPID : public TObject {
   public:
    //    TTpcPID();
    virtual ~TTpcPID();
    std::string AlgorithmName;  ///< The name of the algorithm that created this object.
    unsigned long Detectors;  ///< Detectors used, defined according to the algorithm in GetDetectorNumber.
    unsigned long Status;  ///< The status for the fit, from: object->CheckStatus(object->kSuccess).
    int NDOF;  ///< The number of degrees of freedom.
    double Chi2;  ///< The chi2 of the fit.
    int NNodes;  ///< The number of nodes
    int NHits;  ///< The number of hits.
    int NConstituents;  ///< The number of constituents.
    bool isForward;  ///< Sense of object.
    double Charge;  ///< The Charge
    double EDeposit;  ///< The deposited charge for the object.
    TVector3 Cone;  ///< The opening angles of the cone (only for showers)
    double Width;  ///< The width of the shower (perpendicular to the direction)
    double Length;  ///< The total length of the object
    std::vector<double> Likelihoods;  /// the PID likelihoods for combined PID
    TLorentzVector FrontPosition;  ///< The position of the object.
    TLorentzVector BackPosition;  ///< The position of the object.
    TLorentzVector FrontPositionVar;  ///< The position variance;
    TLorentzVector BackPositionVar;  ///< The position variance;
    TVector3 FrontDirection;  ///< The direction of the object.
    TVector3 BackDirection;  ///< The direction of the object.
    TVector3 FrontDirectionVar;  ///< The direction variance of the object.
    TVector3 BackDirectionVar;  ///< The direction variance of the object.
    double FrontMomentum;  ///< the momentum of the object
    double BackMomentum;  ///< the momentum of the object
    double FrontMomentumError;  ///< the error on the momentum of the object
    double BackMomentumError;  ///< the error on the momentum of the object

    // Kinematics at vertex
    TLorentzVector PositionAtTrueVertex;  ///< Position at true vertex.
    TLorentzVector
        PositionVarAtTrueVertex;  ///< The position variance at the true vertex.
    TVector3 DirectionAtTrueVertex;     ///< Direction at the true vertex.
    TVector3 DirectionVarAtTrueVertex;  ///< The direction variance at the true vertex.
    double MomentumAtTrueVertex;        ///< Momentum at the true vertex.
    double MomentumErrorAtTrueVertex;   ///< The momentum variance at the true vertex.

    std::vector<TLorentzVector*> EntrancePosition;  ///< the position of the object at the entrance of each subdetector
    std::vector<TLorentzVector*> ExitPosition;  ///< the position of the object at the exit of each subdetector
    TTrueParticle TrueParticle;  ///< The true particle
    ClassDef(TGlobalReconModule::TTpcPID, 1);
  };

  /// An object to describe a reconstructed PID.
  class TGlobalPIDAlternate : public TObject {
   public:
    TGlobalPIDAlternate(){};
    virtual ~TGlobalPIDAlternate(){};

    unsigned long Detectors;  ///< Detectors used, defined according to the formula in GetDetectorNumber.
    bool DetectorUsed[NDETSUSED];  ///< Detectors used (NDETSUSED = 23)
    unsigned long Status;  ///< The status for the fit.
    int NDOF;  ///< The number of degrees of freedom.
    double Chi2;  ///< The chi2 of the fit.
    double Charge;  ///< The Charge
    double Length;  ///< The length of the track or shower (RMS)
    int ParticleId;  ///< the PDG code obtained in the recon combined PID
    double PIDWeight;  ///< the PID weight for this hypothesis
    
    TLorentzVector FrontPosition;  ///< The position of the object.
    TLorentzVector BackPosition;  ///< The position of the object.
    TLorentzVector FrontPositionVar;  ///< The position variance;
    TLorentzVector BackPositionVar;  ///< The position variance;
    TVector3 FrontDirection;  ///< The direction of the object.
    TVector3 BackDirection;  ///< The direction of the object.
    TVector3 FrontDirectionVar;  ///< The direction variance of the object.
    TVector3 BackDirectionVar;  ///< The direction variance of the object.
    double FrontMomentum;  ///< the momentum of the object
    double BackMomentum;  ///< the momentum of the object
    double FrontMomentumError;  ///< the error on the momentum of the object
    double BackMomentumError;  ///< the error on the momentum of the object
    
    // Kinematics at vertex
    TLorentzVector PositionAtTrueVertex;  ///< The position at the true vertex.
    TLorentzVector
        PositionVarAtTrueVertex;  ///< The position variance at the true vertex.
    TVector3 DirectionAtTrueVertex;     ///< The direction at the true vertex.
    TVector3 DirectionVarAtTrueVertex;  ///< The direction variance at the true vertex.
    double MomentumAtTrueVertex;        ///< The momentum at the true vertex.
    double MomentumErrorAtTrueVertex;   ///< The error of the momentum at the true vertex.
    ClassDef(TGlobalReconModule::TGlobalPIDAlternate, 1);
  };

  /// An object to describe a reconstructed PID.
  class TGlobalPID : public TObject {
   public:
    TGlobalPID();
    virtual ~TGlobalPID();
    UInt_t UniqueID;  ///< Unique identifier for global recon objects (needed fro broken association)
    std::vector<UInt_t> BrokenUniqueIDs;  ///< the broken partners unique IDs
    std::string
        AlgorithmName;  ///< The name of the algorithm that created this object.
    unsigned long Detectors;  ///<     Detectors used
    bool DetectorUsed[NDETSUSED]; ///< Detectors used. Index order from 0 to 26
    unsigned long Status;  ///< The status for the fit.
    int NDOF;  ///< The number of degrees of freedom.
    double Chi2;  ///< The chi2 of the fit.
    int NNodes;  ///< The number of nodes.
    int NHits;  ///< The number of hits.
    int NConstituents;  ///< The number of constituents.
    bool isForward;  ///< Sense of object.
    bool SenseOK;  ///< Sense of object.
    bool IsCurvBack;  ///< A curving-back object
    bool IsFgdECalIncremental;  ///< A track created by FGD-ECal matching algorithm
    double Charge;  ///< The Charge
    double EDeposit;  ///< The deposited charge for the object.
    TVector3 Cone;  ///< The opening angles of the cone (only for showers)
    double Width;  ///< The width of the shower (perpendicular to the direction)
    double Length;  ///< The length of the track or shower (RMS)

    // Position of each node
    std::vector<TLorentzVector> NodePosition;
    // Position of each hit
    std::vector<TLorentzVector> HitPosition;
    std::vector<int>
        ParticleIds;  ///< the PDG codes obtained in the recon combined PID

    std::vector<double> PIDWeights;  ///< the PID likelihoods for combined PID


    TLorentzVector FrontPosition;  ///< The position of the object.
    TLorentzVector BackPosition;  ///< The position of the object
    TVector3 FrontDirection;  ///< The direction of the object.
    TVector3 BackDirection;  ///< The direction of the object.
    double FrontMomentum;  ///< the momentum of the object
    double FrontCharge;    ///< the charge of the object at the first state
    double BackMomentum;  ///< the momentum of the object
    double BackCharge;    ///< the momentum of the object at the back state
    double FrontMomentumError;  ///< the error on the momentum of the object
    double BackMomentumError;  ///< the error on the momentum of the object
    double FrontStateCov[7][7];  ///< full covariance matrix for front state: pos,  dir, qp
    double BackStateCov[7][7];  ///< full covariance matrix for last state: pos, dir, qp
    double RangeMomentumMuon;  ///< the momentum by range for the muon hypothesis
    double RangeMomentumMuonFlip;  ///< the momentum by range for the flipped muon hypothesis
    double RangeMomentumPion;  ///< the momentum by range for the pion hypothesis
    double RangeMomentumPionFlip;  ///< the momentum by range for the flipped pion hypothesis
    double RangeMomentumElectron;  ///< the momentum by range for the electron hypothesis
    double RangeMomentumElectronFlip;  ///< the momentum by range for the flipped electron hypothesis
    double RangeMomentumProton;        ///< the momentum by range for the proton hypothesis
    double RangeMomentumProtonFlip;  ///< the momentum by range for the flipped proton hypothesis
    double RangeMomentumEndToTPCMuon;     ///< the momentum by range for the muon hypothesis (from end to a TPC)
    double RangeMomentumEndToTPCPion;     ///< the momentum by range for the pion hypothesis (from end to a TPC)
    double RangeMomentumEndToTPCElectron; ///< the momentum by range for the electron hypothesis (from end to a TPC)
    double RangeMomentumEndToTPCProton;   ///< the momentum by range for the proton hypothesis (from end to a TPC)
  
    
    std::vector<std::pair<unsigned long, TVector2> > NodeTimes;  ///< vector of pairs, sub-detecor number and time-stamps of edge nodes in this subdetector
    TLorentzVector PositionAtTrueVertex;  ///< Position at the true vertex.
    TVector3 DirectionAtTrueVertex;       ///< Direction at the true vertex.
    double MomentumAtTrueVertex;          ///< Momentum at the true vertex.
    double MomentumErrorAtTrueVertex;     ///< Error of the momentum at the true vertex.
    double ChargeAtTrueVertex;  ///< Charge at the true vertex.
    double StateCovAtTrueVertex[7][7];  ///< Full covariance matrix for the state: pos,  dir, qp at the true vertex.

    // the position, direction and momentum,  of the object at the entrance and
    // exit of each subdetector
    int            EntranceOK          [NDETSEXTRAP];  ///< Status of the subdetector entrance.
    int            ExitOK              [NDETSEXTRAP];      ///< Status of the subdetector exit.
    TLorentzVector EntrancePosition    [NDETSEXTRAP];  ///< The position of the object at the entrance of each subdetector.
    TLorentzVector ExitPosition        [NDETSEXTRAP];  ///< The position of the object at the exit of each subdetector.
    TVector3       EntranceDirection   [NDETSEXTRAP];  ///< The direction of the object at the entrance of each subdetector volume.
    TVector3       ExitDirection       [NDETSEXTRAP];  ///< The direction of the object at the exit of each subdetector.
    double         EntranceMomentum    [NDETSEXTRAP];  ///< The momentum of the object at the entrance of each subdetector.
    double         ExitMomentum        [NDETSEXTRAP];  ///< The momentum of the object at the exit of each subdetector.
    TLorentzVector EntrancePositionErr [NDETSEXTRAP];  ///< The error of the position of the object at the entrance of each subdetector.
    TLorentzVector ExitPositionErr     [NDETSEXTRAP];  ///< The error of the position of the object at the exit of each subdetector.
    TVector3       EntranceDirectionErr[NDETSEXTRAP];  ///< The error of the direction of the object at the entrance of each subdetector.
    TVector3       ExitDirectionErr    [NDETSEXTRAP];  ///< The error of the direction of the object at the exit of each subdetector.
    double         EntranceMomentumErr [NDETSEXTRAP];  ///< The error of the momentum of the object at the entrance of each subdetector.
    double         ExitMomentumErr     [NDETSEXTRAP];  ///< The error of the momentum of the object at the exit of each subdetector.

    Int_t NHitsSaved;         ///< Number of entries in the HitsSaved array.
    TClonesArray* HitsSaved;  ///< the two first and two last hits (TGlobalHit).
    TTrueParticle TrueParticle;  ///< The true particle

    // The subdetector specific variables
    Int_t         NTRACKERs;    ///< Number of Tracker objects.
    TClonesArray* TRACKER;      ///< Tracker specific variables.
    Int_t         NTPCs;        ///< Number of TPC objects.
    TClonesArray* TPC;          ///< TPC specific variables.
    Int_t         NFGDs;        ///< Number of FGD objects.
    TClonesArray* FGD;          ///< FGD specific variables.
    Int_t         NSFGs;        ///< Number of SFG objects.
    TClonesArray* SFG;          ///< SFG specific variables.
    Int_t         NECALs;       ///< Number of ECAL objects.
    Int_t         NDsECALs;     ///< Number of DsECAL objects.
    Int_t         NTrECALs;     ///< Number of TrECAL objects.
    TClonesArray* ECAL;         ///< ECAL specific variables.
    Int_t         NP0DECALs;    ///< Number of P0DECAL objects.
    TClonesArray* P0DECAL;      ///< P0DECAL specific variables.
    Int_t         NP0Ds;        ///< Number of P0D objects.
    TClonesArray* P0D;          ///< P0D specific variables.
    Int_t         NSMRDs;       ///< Number of SMRD objects.
    TClonesArray* SMRD;         ///< SMRD specific variables.
    Int_t         NAlternates;  ///< Number of entries in the alternate hypotheses list.
    TClonesArray* Alternates;   ///< List of alternate hypotheses

    /// Variables to get the association between the global track and the gas
    /// ouptut involved
    /// The vectorS of path, junction,  pattern ids of the underlying TPC gas
    /// output
    // (in principle could store this info for the TPC constituents but it may
    // lead to "doubling" the info,  so keep it here for the moment)
    std::vector<int> TPCGasPatternIDs;  ///< The IDs of the TREx patterns which contributed to the object
    std::vector<int> TPCGasPathIDs;  ///< The IDs of the TREx paths which contributed to the object
    std::vector<int> TPCGasJunctionIDs;  ///< The IDs of the TREx junctions which contributed to the object

    // JIMHACK - Just for now include an instance of TPC, ECAL and FGD objects
    // here as
    // TFile::MakeProject does not seem able to find them when they are hidden
    // inside a
    // TClonesArray. Nothing is done with these - it is just an ugly workaround.
    TTPCObject hackTPCObject;  ///< This is just here to fool TFile::MakeProject, not a real object.
    TFGDObject hackFGDObject;  ///< This is just here to fool TFile::MakeProject, not a real object.
    TSFGObject hackSFGObject;  ///< This is just here to fool TFile::MakeProject, not a real object.
    TECALObject hackECALObject;  ///< This is just here to fool TFile::MakeProject, not a real object.
    TP0DObject hackP0DObject;    ///< This is just here to fool TFile::MakeProject, not a real object.
    TSMRDObject hackSMRDObject;  ///< This is just here to fool TFile::MakeProject, not a real object.
    TTrackerObject hackTrackerObject;  ///< This is just here to fool TFile::MakeProject, not a real object.
    TGlobalPIDAlternate hackGlobalPIDAlternate;  ///< This is just here to fool TFile::MakeProject, not a real object.

    ClassDef(TGlobalReconModule::TGlobalPID, 1);
  };

 public:
  /// Default Constructor
  TGlobalReconModule(const char* name = "Global",
                     const char* title = "Global Recon Module");

  virtual ~TGlobalReconModule();

  virtual Bool_t ProcessFirstEvent(ND::TND280Event& event);

  void SayAvailableOpts(std::string indent = "") {
    std::cout << indent << "=UseECalVertices: Will assume global vertexing\n"
              << indent << "\t used the results of ECal-iso vertexing."
              << std::endl;
  }

 protected:
  virtual void InitializeModule();
  void FillConfigTree(TTree* configTree);
  Bool_t Configure(std::string& opt);

  int GetNumberOfHits(ND::THandle<ND::TReconBase> object);

  virtual void InitializeBranches();
  virtual bool FillTree(ND::TND280Event&);

  bool FillVertex(ND::TND280Event& event,ND::THandle<ND::TReconVertex> vertex, bool primary);

  void MatchTrueVertex(ND::THandle<ND::TG4PrimaryVertexContainer> g4PrimVert);

  void FillGlobalPIDs(ND::TND280Event& event,
                      ND::THandle<ND::TReconBase> object);

  void FillGlobalPIDAlternates(ND::THandle<ND::TG4Trajectory> G4track,
                               ND::THandle<ND::TReconBase> object,
                               TGlobalPID& globalObject);
  void FillGlobalPIDAlternate(ND::THandle<ND::TG4Trajectory> G4track,
                              ND::THandle<ND::TReconBase> object,
                              TGlobalPIDAlternate& PIDAlternate);

  void FillTPCPID(ND::THandle<ND::TReconBase> object);

  ND::THandle<ND::TG4PrimaryVertex> GetG4Vertex(const ND::TReconBase& object,
                                                double& pur, double& eff);
  bool GetG4Vertex(ND::THandle<ND::TG4Trajectory> G4track,
                   ND::TG4PrimaryVertex& G4vertex);

  void FillTrueParticle(ND::THandle<ND::TG4Trajectory> G4track, double pur,
                        double eff, ND::TTrueParticle& part);
  void FillTrueVertex(bool, const ND::TG4PrimaryVertex& G4vertex, double pur,
                      double eff, ND::TTrueVertex& vertex);

  void FillSubBaseObject(ND::THandle<ND::TReconBase> object,
                         TSubBaseObject& sub, int det);
  void FillTPCObject(ND::THandle<ND::TReconBase> object, TTPCObject& sub,
                     int det);

  void FillP0DECALInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);
  void FillECALInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);
  void FillTPCInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);
  void FillFGDInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);
  void FillSFGInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);
  void FillP0DInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);
  void FillSMRDInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);
  void FillTrackerInfo(ND::THandle<ND::TReconBase> object, TGlobalPID& pid);

  void FillTPCOther(ND::TND280Event& event);
  void FillSFGOther(ND::TND280Event& event);
  void FillUnusedHits(ND::TND280Event& event);
  void FillGlobalHit(ND::THandle<ND::THit> hit, TGlobalHit& gHit);
  void FillGlobalHit(ND::THandle<ND::THit> hit, TSMRDHit& smrdHit);

  // a function to fill info related to smrd hit
  void FillSmrdHit(ND::THandle<ND::THit> hit, TSMRDHit& smrdHit);

  void FillDetectorUsed(ND::THandle<ND::TReconBase> object, bool dets[]);
  void FillOutermostHits(ND::THitSelection& hits, double charge_cut,
                         TOutermostHits& outer);
  void FillFirstLastHits(ND::THitSelection& hits, TGlobalPID& globalObject);
  void FillAllHits(ND::THitSelection& hits, TGlobalPID& globalObject);

  double MedianObjectTime(ND::THandle<ND::TReconBase> object);

  void GetFGDSimpleVA(ND::TND280Event& event,
                      ND::THandle<ND::TReconBase>& object,
                      TLorentzVector& vertexPos, int globpass, int vaea);

  void CheckFGDdist(TLorentzVector& FGDPos, TVector3 fFGDActiveMin,
                    TVector3 fFGDActiveMax);

  void FillFgdTimeBins(ND::TND280Event& event);
  void FillSfgTimeBins(ND::TND280Event& event);
  void FillVertexInfo(ND::TND280Event& event,
                      ND::THandle<ND::TReconObjectContainer> globalObjects);

  int GetTrackerDetectorNumber(ND::THandle<ND::TReconBase> object);
  unsigned long GetDetectorNumber(ND::THandle<ND::TReconBase> object);
  int           CountDetector    (ND::THandle<ND::TReconBase> object);

  std::string GetObjectType(ND::THandle<ND::TReconBase> object);
  bool IsTrackLike(ND::THandle<ND::TReconBase> object);

  ND::THandle<ND::TG4Trajectory> GetParent(
      ND::THandle<ND::TG4Trajectory> G4track);

  bool GetIncomingParticle(const ND::TG4PrimaryVertex& G4vertex,
                           ND::TG4PrimaryParticle& incoming);

  void InitializeExtrapolationToDetectors();
  void FillExtrapolationToDetectors(ND::THandle<ND::TReconBase> object,
                                    TGlobalPID& globalObject);
  void FillExtrapolationToDetectors(ND::THandle<ND::TReconBase> object,
                                    TGlobalPID& globalObject, Trajectory& traj,
                                    int sense);

  void FillKinematicsAtTrueVertex(ND::THandle<ND::TG4Trajectory> G4track,
                                  ND::THandle<ND::TReconBase> object,
                                  TLorentzVector& pos, TVector3& dir,
                                  double& mom, double& momErr, double& charge,
                                  double (&cov)[7][7]);

  void FillKinematicsAtTrueVertex(ND::THandle<ND::TG4Trajectory> G4track,
                                  ND::THandle<ND::TReconBase> object,
                                  TLorentzVector& pos, TLorentzVector& posVar,
                                  TVector3& dir, TVector3& dirVar, double& mom,
                                  double& momErr);

  void FillKinematics(ND::THandle<ND::TReconState> state, TLorentzVector& pos,
                      TVector3& dir, double& mom, double& momErr,
                      double& charge, double (&cov)[7][7]);

  void FillKinematics(ND::THandle<ND::TReconState> state, TLorentzVector& pos,
                      TLorentzVector& posVar, TVector3& dir, TVector3& dirVar,
                      double& mom, double& momErr);

  double ComputeTrackLength(ND::THandle<ND::TReconBase> object);

  int ComputeParticleId(ND::THandle<ND::TReconPID> PID);

  void GetConstituentsInTracker(ND::THandle<ND::TReconBase> t1,
                                ND::TReconObjectContainer& trackerObjects);
  bool IsTrackerOnly(ND::THandle<ND::TReconBase> t1);
  void DoAssociationBetweenTrackerAndGlobalObjects(
      const ND::TReconObjectContainer& globalObjects,
      const ND::TReconObjectContainer& trackerObjects);

  ND::THandle<ND::TG4Trajectory> GetG4Trajectory(const ND::TReconBase& object,
                                                 double& pur, double& eff);
  void GetHitsAssociatedToG4Trajectory(const ND::THitSelection& hits,
                                       ND::THandle<ND::TG4Trajectory> traj,
                                       ND::THitSelection& traj_hits);
  void UpdateCoincidences(ND::THandle<ND::TMCHit> mch, ND::TMCDigit* mcdigit,
                          std::vector<int>& coinc, int& nhits);
  ND::THandle<ND::TG4Trajectory> GetMainContributor(
      ND::THandle<ND::TMCHit> mch,
      ND::THandle<ND::TG4TrajectoryContainer> trajectories);

  void FillBrokenTracksMap(const ND::TReconObjectContainer& globalObjects);
  bool GetBrokenIDs(ND::THandle<ND::TReconBase> object,
                    std::vector<UInt_t>& brokenIDs1,
                    std::vector<UInt_t>& brokenIDs2);

  // Keep track if recpack is initialized.
  bool fRecPackInitialized;

  std::vector<std::string> fALLMODULES;
  HelixEquation fEquation;                   //!
  dict::dictionary<int> fDetIndex;           //!
  surface_vector fDetSurfaces[NDETSEXTRAP];  //!
  bool fPassedDetector[NDETSEXTRAP];

  bool fUseECalVertices;

  std::map<ND::THandle<ND::TReconBase>, int> fGlobalIndexMap;         //!
  std::map<ND::THandle<ND::TReconBase>, int> fTrackerGlobalIndexMap;  //!

  std::map<ND::THandle<ND::TReconBase>, std::vector<UInt_t> >
      fBrokenIndexMap;  //!

  ND::THandle<ND::TReconBase> GetTrackerReconVersionOfFGDIsoTrack(
      ND::THandle<ND::TReconBase> object);

  /// Method to find FGD constituent track from a matching object and fill
  /// matchingFailure_flag
  void CheckMatchingFailure(TTrackerObject* result,
                            ND::THandle<ND::TReconBase> reco);

  /// A getter for TPC Datums to work both with TREx and TPC info
  template <class T, typename I>
  bool GetTPCDatum(ND::THandle<ND::TReconBase> object, const std::string& datum,
                   std::vector<I>& vector) const;

 public:
  // this is just for tests
  bool          fTestTPCInfo;  ///< For tests only.
  Int_t         fNTPCPIDs;     ///< For tests only.
  TClonesArray* fTPCPIDs;      ///< For tests only (TTpcPID).

  //---- Actual information saved in the tree -----------------------------

  Int_t         fNVertices;  ///< The number of added primary vertices.
  TClonesArray* fVertices;   ///< The TGlobalVertex vector of vertices.
  Int_t         fNPIDs;  ///< The number of global objects.
  TClonesArray* fPIDs;   ///< The vector of TGlobalPID.
  Int_t         fNTPCOthers;  ///< The number of TPC other objects.
  TClonesArray* fTPCOthers;   ///< The vector of TPC other objects (TTPCOtherObject).
  Int_t         fNSFGClusters;  ///< The number of SFG cluster objects.
  TClonesArray* fSFGClusters;   ///<  The vector of SFG cluster objects.
  Int_t         fNP0DUnused;  ///<  Number of hits unused in the P0D.
  TClonesArray* fP0DUnused;   ///<  The vector unused hits in the P0D (TGlobalHit).
  Int_t         fNSMRDTopUnused;    ///<  Number of hits unused in the SMRDTop.
  Int_t         fNSMRDBottomUnused; ///<  Number of hits unused in the SMRDBottom.
  Int_t         fNSMRDLeftUnused;   ///<  Number of hits unused in the SMRDLeft.
  Int_t         fNSMRDRightUnused;  ///<  Number of hits unused in the SMRDRight.
  Int_t         fNSMRDUnused;       ///<  Number of all hits unused in the SMRD
  TClonesArray* fSMRDUnused;        ///<  The vector unused hits in the SMRD (TSMRDHit).
  Int_t         fPVInd;  ///< The last primary vertex index.
  Int_t         fNSVertices;  ///< Number of added secondary vertices.
  Int_t         fNTPCUnused;  ///<  Number of hits unused in the TPC.
  Int_t         fNFGD1Unused;  ///<  Number of hits unused in the FGD1.
  Int_t         fNFGD2Unused;  ///<  Number of hits unused in the FGD2.
  Int_t         fNSFGUnused;   ///<  Number of hits unused in the SFG.

  //  Int_t fNECALUnused;         //!   Number of hits unused in ECAL

  TOutermostHits fP0DOutermostHits;  ///< Outermost hits in the P0D.
  double
      fEarliestTrackMedianHitTime;  ///<  Median hit time of the earliest track.

  // Information about unused FGD hits and outermost FGD hits is saved for each
  // time bin
  
  Int_t         fNFgdTimeBins;   ///<  Number of hit time bins in the FGD as determined by fgdRecon.
  TClonesArray* fFgdTimeBins;  ///<  Information for each hit time bin (TFgdTimeBins).
  
  // Information about unused SFG hits is saved for each time bin
 
  Int_t         fNSfgTimeBins;   ///<  Number of hit time bins in the SFG as determined by sfgRecon.
  TClonesArray* fSfgTimeBins;  ///<  Information for each hit time bin (TSfgTimeBins).

  Int_t fNP0DECAL;  ///<  Number of objects containing the P0DECAL.
  Int_t fNDsECAL;  ///<  Number of objects containing the DsECAL.
  Int_t fNTrECAL;  ///<  Number of objects containing the TrECAL.
  Int_t fNTPC;  ///<  Number of objects containing the TPC.
  Int_t fNFGD;  ///<  Number of objects containing the FGD.
  Int_t fNSFG;  ///<  Number of objects containing the SFG.
  Int_t fNP0D;  ///<  Number of objects containing the P0D.
  Int_t fNSMRD;  ///<  Number of objects containing the SMRD.
  Int_t fNP0DECALIso;  ///<  Number of objects in the P0DECAL only.
  Int_t fNTrECALIso;  ///<  Number of objects in the TrECAL only.
  Int_t fNDsECALIso;  ///<  Number of objects in the DsECAL only.
  Int_t fNTPCIso;  ///<  Number of objects in the TPC only.
  Int_t fNFGDIso;  ///<  Number of objects in the FGD only.
  Int_t fNSFGIso;  ///<  Number of objects in the SFG only.
  Int_t fNP0DIso;  ///<  Number of objects in the P0D only.
  Int_t fNSMRDIso;  ///<  Number on objects in the SMRD only.

};
#endif