TTRExReconModule.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.
///
/// 11-07-2014: Current collaborator responsible for this module is
/// Pip Hamilton (p.hamilton11@imperial.ac.uk)
///
#ifndef TTRExReconModule_hxx_seen
#define TTRExReconModule_hxx_seen

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

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

#include "TGeometryDatabase.hxx"
#include "TIntegerDatum.hxx"
#include "TND280Event.hxx"
#include "TP0DVetoForTPC.hxx"
#include "TReconCluster.hxx"
#include "TReconHit.hxx"
#include "TReconPID.hxx"
#include "TReconShower.hxx"
#include "TReconTrack.hxx"
#include "TrackTruthInfo.hxx"

// Headers from TREx modules
// Some of these probably aren't necessary!
#include "TDatum.hxx"
#include "TGeomInfo.hxx"
#include "TIntegerDatum.hxx"

#include "TIntegerDatum.hxx"
#include "TOARuntimeParams.hxx"
#include "TRealDatum.hxx"
#include "TrackingUtils.hxx"

#include "TIntegerDatum.hxx"
#include "TMultiHit.hxx"
#include "TRealDatum.hxx"
#include "TrackingUtils.hxx"

#include "TAnalysisReconModuleBase.hxx"

namespace ND {
class TTRExReconModule;
};

/** TTRExReconModule - Object that contains information related to reconstructed
object from the extended TPC reconstruction package, TREx.

This eventAnalysis module provides information gleaned from the output of the TREx
reconstruction package.

The main objects provided are:

- TPC patterns - connected networks of tracks ("Paths") and vertices
("Junctions")
- TPC junctions - points at which paths meet
- TPC paths - collections of hits resembling a particle track.

Users are encouraged to add information to this module.

Originally documented by Pip Hamilton.

*/

class ND::TTRExReconModule : public TAnalysisReconModuleBase {
  //========================================================================

 public:
  /// TTPCAnaPattern
  /// The master object for any connected system of hits in a TPC.
  class TTPCAnaPattern : public TObject {
   public:
    virtual ~TTPCAnaPattern();
    TTPCAnaPattern() {
      Junctions = new TClonesArray("ND::TTRExReconModule::TTPCAnaJunction", 40);
      Paths = new TClonesArray("ND::TTRExReconModule::TTPCAnaPath", 40);
    };

    Bool_t S1Sflag;   ///< A flag to say whether this pattern would pass the TPC gas Stage 1 Selection
    Int_t PatternID;  ///< The ID of the pattern

    Int_t NJunctions;         ///< The number of junctions in the pattern.
    TClonesArray *Junctions;  ///< The constituent junctions of the pattern

    Int_t NPaths;         ///< The number of paths.
    TClonesArray *Paths;  ///< The constituent paths of the pattern.

    Int_t TPC;  ///< The TPC in which the pattern resides.

    ClassDef(TTRExReconModule::TTPCAnaPattern, 1);
  };

  //======================================================================

 public:
  /// TTPCAnaJunction
  /// An object describing a meeting point of two or more paths, and containing
  /// all associated paths.
  class TTPCAnaJunction : public TObject {
   public:
    virtual ~TTPCAnaJunction();
    TTPCAnaJunction(){};

    Int_t JunctionID;  ///< A unique identifier for the junction within the pattern.

    Int_t JunctionMatchingID;  //< A unique identifier for the junction within the event.

    TLorentzVector Position;  ///< The spatial coordinates of the junction

    Int_t NPaths;    ///< The number of paths connected to the junction.
    Int_t *PathIDs;  //[NPaths]
    ///^ The unique identifiers of the associated paths.

    TVector3 MaximumCoordinates;  ///< The most extreme hit positions in the positive direction
    TVector3 MinimumCoordinates;  ///< The most extreme hit positions in the negative direction

    ClassDef(TTRExReconModule::TTPCAnaJunction, 1);
  };

  //=====================================================================

 public:
  /// TTPCAnaPath
  /// An object describing a track-like grouping of hits in the TPC.
  class TTPCAnaPath : public TObject {
   public:
    virtual ~TTPCAnaPath();
    TTPCAnaPath(){};

    Int_t PathID;  ///< A unique identifier for the path within the pattern.
    Int_t G4ID;  ///< G4 ID of the primary true trajectory associated with this path.
    Int_t
        PathMatchingID;  //< A unique identifier for the path within the event.

    TVector3 FirstPosition;  ///< The start position of the path.
    TVector3 LastPosition;   ///< The end position of the path.
    Double_t Time;           ///< The T0 for the path.
    Double_t Length;         ///< The length of the path.
    Double_t Momentum;       ///< The momentum of the path.
    Double_t MomentumError;  ///< The momentum error of the path.
    TVector3 Direction;      ///< The direction of the path.
    Bool_t IsContained;      ///< True if the path does not leave the TPC; false otherwise.
    Bool_t LikFit;           ///< True if the likelihood fit was performed
    Bool_t Success;          ///< True if the likelihood fit succeeded
    Double_t FitLikelihood;  ///< Value of log likelihood from fit
    Int_t T0Source;          ///< Enumerator of T0 sources.
    Int_t NClusters;         ///< Number of clusters in the path.
    Double_t Charge;         ///< Charge of the path

    /// Pull-related values
    Double_t ElePull;
    Double_t EleExp;
    Double_t EleSigma;
    Double_t MuonPull;
    Double_t MuonExp;
    Double_t MuonSigma;
    Double_t PionPull;
    Double_t PionExp;
    Double_t PionSigma;
    Double_t ProtonPull;
    Double_t ProtonExp;
    Double_t ProtonSigma;
    Double_t KaonPull;
    Double_t KaonExp;
    Double_t KaonSigma;
    Double_t PDist;
    Double_t PEField;
    Double_t T0Range [2];
    Double_t T0RangeDeltaX [2];

    //ND::TReconPID::ParticleId PID;
    Int_t PID;          ///< The PID of the path.
    Double_t NetCharge; ///< The total charge left by the path on the micromegas

    Int_t NJunctions;  ///< The number of junctions to which the path connects.
    Int_t *JunctionIDs;  //[NJunctions]
    ///^ The unique identifiers of the associated junctions

    Int_t NMatchingPaths;  ///< The number of paths to which this path might be matched.
    Int_t *MatchingPathIDs;  //[NMatchingPaths]
    ///^ The unique identifiers of the paths
    Double_t *PathMatchingLikelihood;  //[NMatchingPaths]
    ///^ The likelihood of matching to that path.

    Int_t NMatchingPatterns;
    Int_t *MatchingPatternIDs;            //[NMatchingPatterns]
    Int_t *MatchingPatternPathIDs;        //[NMatchingPatterns]
    Double_t *PatternMatchingLikelihood;  //[NMatchingPatterns]

    ClassDef(TTRExReconModule::TTPCAnaPath, 1);
  };

  //=====================================================================

  TTRExReconModule(const char *name = "TREx",
                   const char *title = "TPC Recon Extension Module");
  virtual ~TTRExReconModule();

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

  /// Returns true if there is at least one recon object.
  /// If so, and -preselection=TTRExReconModule is specified,
  /// the full oaEvent event will be output for this event
  virtual bool IsFullEventWorthSaving(ND::TND280Event &event);

  /// Returns TPC in which the pattern was found for all 3 possible input types
  int GetTPCFromPattern(ND::THandle<ND::TReconVertex>);
  int GetTPCFromPattern(ND::THandle<ND::TReconPID>);
  int GetTPCFromPattern(ND::THandle<ND::TReconTrack>);

  /// Fills a TTPCAnaPath with information from either a TReconTrack or a
  /// TReconPID
  void FillPathInfo(TTPCAnaPath *outputPath, ND::THandle<ND::TReconPID> path,
                    std::list<ND::THandle<ND::TReconBase> > patternpaths,
                    ND::THandle<ND::TReconObjectContainer> patterns,
                    ND::THandle<ND::TReconBase> parent_pattern);
  void FillPathInfo(TTPCAnaPath *outputPath, ND::THandle<ND::TReconTrack> path,
                    std::list<ND::THandle<ND::TReconBase> > patternpaths,
                    ND::THandle<ND::TReconObjectContainer> patterns,
                    ND::THandle<ND::TReconBase> parent_pattern);

  bool FGDHitVeto(int FGD, int nhits_threshold, ND::TND280Event &event,
                  int mode);
  void FillPathMatchingInfo(
      TTPCAnaPath *outputPath, ND::THandle<ND::TReconBase> path,
      std::list<ND::THandle<ND::TReconBase> > patternpaths,
      ND::THandle<ND::TReconObjectContainer> patterns,
      ND::THandle<ND::TReconBase> parent_pattern);

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

 public:
  /// Tree Entries
  Int_t fNPatterns;

  Bool_t fIsMC;

  TClonesArray *fPatterns;

  TTRExReconModule::TTPCAnaPath hackPath;
  TTRExReconModule::TTPCAnaJunction hackPatten;

 private:
};

// A predicate to sort hits using time
struct timeLessThan : public std::binary_function<ND::THandle<ND::THit>,
                                                  ND::THandle<ND::THit>, bool> {
  bool operator()(ND::THandle<ND::THit> lhs, ND::THandle<ND::THit> rhs) {
    return (lhs->GetTime() < rhs->GetTime());
  }
};

#endif