TFgdOnlyModule.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.
///
/// 16-Feb-2016: Current responsible for this module is,
/// Mark Scott (mscott [*a*t*] triumf.ca)
///
#ifndef _TFgdOnlyModule_hxx_seen
#define _TFgdOnlyModule_hxx_seen

#include <TClonesArray.h>
#include <TVector3.h>
#include <TG4Trajectory.hxx>
#include <TReconCluster.hxx>
#include <TReconPID.hxx>
#include <TReconTrack.hxx>
#include <map>
#include <string>
#include <vector>
#include "TAnalysisReconModuleBase.hxx"
#include "TFGDPid.hxx"

namespace ND {
class TFgdOnlyModule;
}

class ND::TFgdOnlyModule : public TAnalysisReconModuleBase {
 public:
  class TFgd2DIsoTrack : public TObject {
   public:
    virtual ~TFgd2DIsoTrack();

    // info on isorecon tracks
    std::string AlgorithmName;

    int NHits;

    double Angle; ///< Angle
    double SumCharge; ///< Charge Sum
    double Range;  ///< Range

    TLorentzVector Origin; ///< Origin
    TLorentzVector OriginVariance; ///< Variance on origin 
    TVector3 Direction;  ///< Direection

    std::vector<TVector3*> HitPositions; ///< Hit positions

    int TrajId;  ///< Trajectory id`
    double Completeness;  ///< Completeness
    double Cleanliness;  ///< Cleanlikness

    ClassDef(TFgdOnlyModule::TFgd2DIsoTrack, 2);
  };

  class TFgd3DIsoTrack : public TObject {
   public:
    virtual ~TFgd3DIsoTrack();

    // info on isorecon tracks
    std::string AlgorithmName; ///< Algorithm name 

    int NHits;   ///< Number of hits

    double SumCharge; ///< Sum of charge
    double Range;  ///< Range

    TLorentzVector Origin; ///< Origin
    TLorentzVector OriginVariance; ///< Variance on origin 
    TVector3 Direction; ///< Direection

    double muonPull; ///< Muon pull
    double pionPull;   ///< Pion pull
    double protonPull;   ///< Proton pull 

    std::vector<TVector3 *> XZHitPositions; ///< XZ Hit Positions

     std::vector<TVector3 *> YZHitPositions; ///< YZ Hit Positions

    int TrajId; ///< Trajectory id` 
    double Completeness;  ///< Completeness 
    double Cleanliness;  ///< Cleanlikness

    ClassDef(TFgdOnlyModule::TFgd3DIsoTrack, 2);
  };

 public:
  /// TFgd2DCluster
  /// The main object that contains information on clusters of hits after the 2D
  /// reconstruction
  /// stage of the FGD shower-based reconstruciton.
  class TFgd2DCluster : public TObject {
   public:
    virtual ~TFgd2DCluster();

    std::string AlgorithmName;  ///< The name of the algorithm..

    TLorentzVector Position;  ///< Charge-weighted position of the cluster.

    TVector3 PCADirection;   ///< Primary PCA eigenvector, associated with the direction of the cluster.
    TVector3 StartPosition;  ///< Identified "start" position of the cluster, from extrapolating along PCADrection.
    TVector3 EndPosition;    ///< Identified "end" position of the cluster, from extrapolating along PCADirection.
    double Range;            ///< Range of shower along PCADirection

    double AvgHitTime;  ///< Average time of hits in the cluster
    double EDeposit;    ///< The energy deposited in the cluster.
    int NumHits;        ///< The number of hits contributing to this cluster.

    std::map<int, int> Trajectories;  ///< Map of true trajectory IDs to the number of G4 contributors that contributed to this cluster.

    int NDOF;  ///< The number of degrees of freedom in the reconstruction.
    double Quality;  ///< The goodness of fit for the reconstruction.
    int Status;      ///< The fit status.

    ClassDef(TFgdOnlyModule::TFgd2DCluster, 1);
  };

 public:
  /// TFgd3DShowerHyp
  /// Information on a specific hypothesis of an FGD shower. There are two
  /// hypotheses - one for a
  /// forward-going particle, one for a backward-going particle.
  class TFgd3DShowerHyp : public TObject {
   public:
    virtual ~TFgd3DShowerHyp();

    TLorentzVector Position;  ///< Identified start position of the shower.
    TLorentzVector
        PositionVar;  ///< Variance on the start position of the shower.

    TVector3
        Direction;  ///< Identified direction of the shower, found using PCA.
    TVector3 DirectionVar;  ///< Variance on the direction of the shower.

    TVector3 ConeAngle;  ///< Opening angle of the cone describing this shower.
    TVector3 ConeAngleVar;  ///< Variance on the cone opening angle.

    double EDeposit;  ///< Energy deposited in this shower.
    /// Hits are split into three groups based on their distance from the start
    /// of the shower.
    /// The X, Y and Z components of this variable contain the average charge of
    /// hits in the
    /// 1st, 2nd and 3rd groups, respectively.
    TVector3 QAvgInThirds;  // Charge of hits in 1st, 2nd and 3rd groups, based
                            // on distance from the start of the shower.

    /// Hits are split into three groups based on their distance from the start
    /// of the shower.
    /// The X, Y and Z components of this variable contain the average
    /// transverse spread of hits
    /// in the 1st, 2nd and 3rd groups, respectively. Transverse spread is
    /// defined as the distance
    /// from a hit to the closest position on the PCA major axis.
    TVector3 SpreadInThirds;  // Average transverse spread of hits  in the 1st,
                              // 2nd and 3rd groups, defined as the distance
                              // from a hit to the closest position on the PCA
                              // major axis.

    ClassDef(TFgdOnlyModule::TFgd3DShowerHyp, 1);
  };

 public:
  /// TFgd3DShowerPID
  /// Information on an object reconstructed using the FGD shower-based
  /// reconstruction.
  /// There is currently no particle identification, although variables that can
  /// be used
  /// for a PID are stored. There are two hypotheses saved for each
  /// reconstructed object -
  /// one for a forward-going particle, one for a backward-going particle.
  class TFgd3DShowerPID : public TObject {
   public:
    virtual ~TFgd3DShowerPID();

    TFgd3DShowerHyp
        Hyp1;  ///< Information assuming the particle is forward-going.
    TFgd3DShowerHyp
        Hyp2;  ///< Information assuming the particle is backward-going.

    TVector3 PCAEigenValues;  ///< The three PCA eigenvalues.
    int NumHits;  ///< The number of hits contributing to this cluster.

    /// The MVA likelihood value returned when matching 2D clusters in the XZ
    /// and YZ
    /// views into a single 3D cluster. Values range from 0 -> 1, with higher
    /// values
    /// indicating better matches.
    double MatchingLikelihood3D;  // MVA likelihood value when matching 2D
                                  // clusters in the XZ and YZ views into a
                                  // single 3D cluster.

    /// Dan Scully's Circularity variable, adapted for FGDs. Value goes from 0
    /// (spherical)
    /// -> 1 (track).
    double Circularity;  // Dan Scully's Circularity variable, adapted for FGDs.

    std::map<int, int> Trajectories;  ///< Map of true trajectory IDs to the number of G4 contributors that contributed to this cluster

    int NDOF;  ///< The number of degrees of freedom in the reconstruction.
    double Quality;  ///< The goodness of fit for the reconstruction.
    int Status;      ///< The fit status.

    ClassDef(TFgdOnlyModule::TFgd3DShowerPID, 1);
  };

 public:
  TFgdOnlyModule(const char* name = "FGDOnly",
                 const char* title = "FGD Only Recon Module");

  virtual ~TFgdOnlyModule();

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

 protected:
  // virtual void InitializeModule();

  virtual void InitializeBranches();

  virtual bool FillTree(ND::TND280Event&);

 private:
  void Fill2DIsoTrack(ND::THandle<ND::TReconTrack> tr,
                      ND::THandle<ND::TTrackState> state,
                      TFgd2DIsoTrack* isoTrack, char Axis);
  void Fill3DIsoTrack(ND::THandle<ND::TReconTrack> tr,
                      ND::THandle<ND::TTrackState> state,
                      TFgd3DIsoTrack* isoTrack);
  void Fill2DCluster(TFgd2DCluster* TempObject,
                     ND::THandle<ND::TReconCluster> cluster);
  void Fill3DShower(TFgd3DShowerPID* TempObject,
                    ND::THandle<ND::TReconPID> pid);
  TFgd3DShowerHyp Fill3DShowerHyp(ND::THandle<ND::TReconPID> hyp);

 public:
  /// These tracks use only hits unused by the TPC+FGD fits
  Int_t* fNXZTracks;
  TClonesArray** fXZTracks;

  /// These tracks use only hits unused by the TPC+FGD fits
  Int_t* fNYZTracks;
  TClonesArray** fYZTracks;

  /// These tracks use only hits unused by the TPC+FGD fits
  Int_t* fNXYZTracks;
  TClonesArray** fXYZTracks;

  /// All and only FGD hits used for these tracks
  Int_t* fNXZTracksAllFGD;
  TClonesArray** fXZTracksAllFGD;

  /// All and only FGD hits used for these tracks
  Int_t* fNYZTracksAllFGD;
  TClonesArray** fYZTracksAllFGD;

  /// All and only FGD hits used for these tracks
  Int_t* fNXYZTracksAllFGD;
  TClonesArray** fXYZTracksAllFGD;

  /// Number of  Showers
  Int_t fN3DShowers;
  /// Showers
  TClonesArray* f3DShowers;

  /// Number of 2D constituents of showers
  Int_t fN2DClustersXZ;
  /// 2D constituents of showers
  TClonesArray* f2DClustersXZ;

  /// Number of 2D constituents of showers
  Int_t fN2DClustersYZ;
  /// 2D constituents of showers
  TClonesArray* f2DClustersYZ;

 private:
  std::vector<const char*> fTrackAlgorithms;
  std::vector<const char*> fPids;
  TFGDPid* fFGDPid;

};

#endif