TReconPerformanceEvalModule.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.
///
/// 28-Nov-2012: Current responsible for this module is
/// Ben Smith (b.smith10 [*a*t*] imperial.ac.uk)
///
#ifndef TReconPerformanceEvalModule_hxx_seen
#define TReconPerformanceEvalModule_hxx_seen

#include <TNamed.h>
#include <TTree.h>
#include <TIntegerDatum.hxx>
#include <TND280Event.hxx>
#include <TReconCluster.hxx>
#include <TReconHit.hxx>
#include <TReconPID.hxx>
#include <TReconShower.hxx>
#include <TReconTrack.hxx>
#include <map>
#include <set>
#include <string>

#include "TClonesArray.h"
#include "TLorentzVector.h"
#include "TVector3.h"

#include "TAnalysisReconModuleBase.hxx"

namespace ND {
class TReconPerformanceEvalModule;
};

/** TReconPerformanceEvalModule - Object that contains information related to
 the performance of
 global recon.

 This eventAnalysis module provides information gleaned from the output of the
 global
 and subdetector reconstruction packages.

 Amongst other quantities, the output of this module provides the state and
 kinematics of a
 global recon object and its constituents. For the P0D, ECal and P0DEcal, which
 get refitted
 by the global reconstruction, information is included for both the refitted and
 original
 objects.

 */
class ND::TReconPerformanceEvalModule : public TAnalysisReconModuleBase {
 public:
  /// TTruthInfo
  /// Information relating to a truth trajectory.
  /// At the constituent level, this contains information from a G4 trajectory
  /// point.
  class TTruthInfo : public TObject {
   public:
    TTruthInfo();
    virtual ~TTruthInfo();

    bool SetOK;  /// < Whether this object was filled

    double
        Momentum;  /// < Momentum of the true trajectory at the trajectory point
    TVector3 Direction;       /// < Direction of the true trajectory at the
                              /// trajectory point
    double Charge;            /// < Charge of the trajectory
    TLorentzVector Position;  /// < Position of the trajectory point
    double Efficiency;        /// < Efficiency of this truth matching
    double Purity;            /// < Purity of this truth matching

    ClassDef(TReconPerformanceEvalModule::TTruthInfo, 1);
  };

 public:
  /// TGlobalTruthInfo
  /// Information relating to a truth trajectory.
  /// At the global level, this contains information about the INITIAL state of
  /// the trajectory.
  class TGlobalTruthInfo : public TObject {
   public:
    TGlobalTruthInfo();
    virtual ~TGlobalTruthInfo();

    bool SetOK;

    double Momentum;          /// < Momentum of the true trajectory
    TVector3 Direction;       /// < Direction of the true trajectory
    double Charge;            /// < Charge of the trajectory
    TLorentzVector Position;  /// < Initial position of the trajectory
    double Efficiency;        /// < Efficiency of this truth matching
    double Purity;            /// < Purity of this truth matching

    ClassDef(TReconPerformanceEvalModule::TGlobalTruthInfo, 1);
  };

 public:
  /// TReconStateInfo
  /// Information related to a recon object's state
  class TReconStateInfo : public TObject {
   public:
    TReconStateInfo();
    virtual ~TReconStateInfo();

    bool SetOK;

    TLorentzVector Position;  /// < Easy access to the state's position. All
                              /// state types support this
    TLorentzVector PositionVariance;  /// < Easy access to the state's position
                                      /// variance. All state types support this
    TVector3 Direction;  /// < Easy access to the state's direction, if the
                         /// state type supports it
    double Momentum;     /// < Easy access to the state's momentum, if the state
                         /// type supports it

    ClassDef(TReconPerformanceEvalModule::TReconStateInfo, 1);
  };

 public:
  /// TDownToTrackerInfo
  /// Information related to the constituents of an object that are built up
  /// from a tracker object
  class TDownToTrackerInfo : public TObject {
   public:
    TDownToTrackerInfo();
    virtual ~TDownToTrackerInfo();

    bool SetOK;

    std::string DetectorName;  /// < Subdetector(s) used for this object
    double MatchingChi2;       /// < Matching chi^2 of this object
    TLorentzVector Position;   /// < Easy access to the state's position. All
                               /// state types support this
    TVector3 Direction;  /// < Easy access to the state's direction, if the
                         /// state type supports it
    double Momentum;     /// < Easy access to the state's momentum, if the state
                         /// type supports it

    ClassDef(TReconPerformanceEvalModule::TDownToTrackerInfo, 1);
  };

 public:
  /// THelixModelInfo
  /// Information from a state extrapolated using the tpcRecon HelixModel
  class THelixModelInfo : public TObject {
   public:
    THelixModelInfo();
    virtual ~THelixModelInfo();

    bool SetOK;

    TVector3 Position;  /// < Extrapolated positions
    double CosTheta;    /// < Extrapolated cosTheta

    ClassDef(TReconPerformanceEvalModule::THelixModelInfo, 1);
  };

 public:
  /// TMatchingChi2Info
  /// Information for storing global recon matching chi2 info
  class TMatchingChi2Info : public TObject {
   public:
    TMatchingChi2Info();
    virtual ~TMatchingChi2Info();

    bool SetOK;

    std::string Det1;     /// < First object's detector string
    bool IsShower1;       /// < Whether the first object was a shower
    std::string Det2;     /// < Second object's detector string
    bool IsShower2;       /// < Whether the second object was a shower
    double MatchingChi2;  /// < The matching chi^2 value

    ClassDef(TReconPerformanceEvalModule::TMatchingChi2Info, 1);
  };

 public:
  /// TGlobalReconStateInfo
  /// Information related to a recon object's state
  class TGlobalReconStateInfo : public TObject {
   public:
    TGlobalReconStateInfo();
    virtual ~TGlobalReconStateInfo();

    bool SetOK;

    TLorentzVector Position;  /// < Easy access to the state's position. All
                              /// state types support this
    TLorentzVector PositionVariance;  /// < Easy access to the state's position
                                      /// variance. All state types support this
    TVector3 Direction;  /// < Easy access to the state's direction, if the
                         /// state type supports it
    double Momentum;     /// < Easy access to the state's momentum, if the state
                         /// type supports it

    ClassDef(TReconPerformanceEvalModule::TGlobalReconStateInfo, 1);
  };

 public:
  /// TGlobalReconNodeInfo
  /// Information related to a recon object's node
  class TGlobalReconNodeInfo : public TObject {
   public:
    TGlobalReconNodeInfo();
    virtual ~TGlobalReconNodeInfo();

    bool SetOK;

    TGlobalReconStateInfo NodeState;
    TGlobalReconStateInfo ObjectState;

    ClassDef(TReconPerformanceEvalModule::TGlobalReconNodeInfo, 1);
  };

 public:
  /// TGlobalReconConstituent
  /// The main object that contains constituent recon information
  /// Feel free to add to.
  class TGlobalReconConstituent : public TObject {
   public:
    TGlobalReconConstituent();
    virtual ~TGlobalReconConstituent();

    bool SetOK;

    std::string ReconAlgorithm;  /// < Name of Subdetector recon algorithm
    std::string DetectorName;    /// < Subdetector(s) used for this object
    std::string ClassName;       /// < ClassName of this recon object
    std::string StatusString;  /// < String containing the status of the object
                               /// (success, ran etc)
    std::string ParticleID;  /// < ParticleID, if the constituent is a TReconPID
    double PIDWeight;        /// < PID weight, if the constituent is a TReconPID
    UInt_t UniqueID;         /// < UniqueID identifying this constituent

    /// Global recon constituent's overall object state
    TReconStateInfo GlobalReconConsState;

    /// State of first node of global recon constituent
    TReconStateInfo GlobalReconConsFirstNodeState;

    /// Object of first node of global recon constituent
    TReconStateInfo GlobalReconConsFirstNodeObject;

    /// State of last node of global recon constituent
    TReconStateInfo GlobalReconConsLastNodeState;

    /// Object of last node of global recon constituent
    TReconStateInfo GlobalReconConsLastNodeObject;

    /// State information of subdetector recon object. Only filled for P0D,
    /// P0DECal and
    /// TrackerECal constituents, as these are the only ones refitted by global
    /// recon
    TReconStateInfo OriginalObjectState;

    /// State information of subdetector recon object. Only filled for P0D,
    /// P0DECal and
    /// TrackerECal constituents, as these are the only ones refitted by global
    /// recon
    TReconStateInfo OriginalObjectFirstNodeState;

    /// State information of subdetector recon object. Only filled for P0D,
    /// P0DECal and
    /// TrackerECal constituents, as these are the only ones refitted by global
    /// recon
    TReconStateInfo OriginalObjectLastNodeState;

    /// State information of closest global recon node to subdetector state
    /// position,
    /// projected to the position of the subdetector state.
    /// Extrapolation is done to the surface with normal (0,0,1) in the LOCAL
    /// geometry
    /// of the module we're in. So, for the Barrel ECals, that means we
    /// extrapolate to
    /// the surface with normal (1,0,0) or (0,1,0).
    TReconStateInfo ClosestGlobalNodeState;

    /// Truth information at MC trajectory point closest to refitted state
    /// position
    TTruthInfo ConsTruth;

    /// Extrapolation of object to upstream face of DsECal, using tpcRecon
    /// HelixModel.
    /// Only set for TPC constituents.
    THelixModelInfo StateAtDSECal;

    /// Extrapolation of object to inner face of LTECal, using tpcRecon
    /// HelixModel.
    /// Only set for TPC constituents.
    THelixModelInfo StateAtLTECal;

    /// Extrapolation of object to inner face of RTECal, using tpcRecon
    /// HelixModel.
    /// Only set for TPC constituents.
    THelixModelInfo StateAtRTECal;

    /// Extrapolation of object to inner face of TTECal, using tpcRecon
    /// HelixModel.
    /// Only set for TPC constituents.
    THelixModelInfo StateAtTTECal;

    /// Extrapolation of object to inner face of BTECal, using tpcRecon
    /// HelixModel.
    /// Only set for TPC constituents.
    THelixModelInfo StateAtBTECal;

    /// Extrapolation of object to downstream face of P0D, using tpcRecon
    /// HelixModel.
    /// Only set for TPC constituents.
    THelixModelInfo StateAtP0D;

    /// Extrapolation of TPC1(TPC3) object to downstream(upstream) face of TPC2,
    /// using tpcRecon HelixModel.
    THelixModelInfo StateAtTPC2;

    /// Value of averageHitTime TDatum, if set.
    double AverageHitTime;

    /// Number of hits for this constituent, or -1 if the THitSelection is
    /// invalid
    int NumHits;

    /// EDeposit of the constituent
    double EDeposit;

    /// Goodness of fit
    double Quality;

    /// NDOF
    int NDOF;

    /// Whether the constituent is a TReconShower (or a TReconPID with a single
    /// constituent
    /// that is a TReconShower)
    bool IsShower;

    ClassDef(TReconPerformanceEvalModule::TGlobalReconConstituent, 1);
  };

 public:
  /// TGlobalReconObject
  /// Object for containing global recon information
  class TGlobalReconObject : public TObject {
   public:
    TGlobalReconObject();
    virtual ~TGlobalReconObject();

    bool SetOK;

    /// Number of constituents of the global track
    Int_t NConstituents;

    /// Number of constituents in each module
    std::map<std::string, int>* NModuleConstituents;

    /// String containing subdetectors used by this object
    std::string SubdetectorString;

    /// String containing the status of the object (success, ran etc)
    std::string StatusString;

    /// Information about the nodes of the global track, in the same order as
    /// they are stored
    /// in the global track
    TClonesArray* GlobalNodes;

    /// The number of states the global track contains
    Int_t NGlobalNodes;

    /// The number of states of the global track that we saved information about
    Int_t NGlobalNodesSaved;

    /// Momentum of global track
    double Momentum;

    /// Momentum of global track, from the MomentumByRange algorithm
    double MomentumByRange;
    double MomentumByRangeMuon;
    double MomentumByRangeMuonFlip;
    double MomentumByRangeElectron;
    double MomentumByRangeElectronFlip;
    double MomentumByRangeProton;
    double MomentumByRangeProtonFlip;

    /// Position/time of the global track
    TLorentzVector Position;

    /// Direction of global track
    TVector3 Direction;

    /// Charge of global track
    double Charge;

    /// Goodness of fit
    double Quality;

    /// NDOF
    int NDOF;

    /// PID
    std::string ParticleID;

    /// PID weight
    double PIDWeight;

    /// Matching chi^2s, if global recon merged two objects together. Recurse
    /// down all
    /// constituents.
    TClonesArray* MatchingChi2Info;

    /// Number of entries in the MatchingChi2s array.
    int NMatchingChi2Info;

    /// True momentum, angle and charge at closest approach to global state
    /// position
    TGlobalTruthInfo Truth;

    /// TClonesArray of (lowest-level) constituent TGlobalReconConstituent
    TClonesArray* Constituents;

    /// TClonesArray of intermediate constituent states, working down to
    /// tracker-only constituent.
    /// Only set for objects that contain tracker constituents.
    TClonesArray* DownToTrackerConstituents;

    /// Number of objects we saved in the DownToTrackerConstituents
    /// TClonesArray.
    Int_t NDownToTrackerConstituents;

    /// UniqueID identifying this object
    UInt_t UniqueID;

    ClassDef(TReconPerformanceEvalModule::TGlobalReconObject, 1);
  };

 public:
  TReconPerformanceEvalModule(
      const char* name = "ReconPerfEval",
      const char* title = "Recon Performance Evaluation Module");
  virtual ~TReconPerformanceEvalModule();

  virtual Bool_t IsEnabledByDefault() const { return kFALSE; }

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

  virtual bool IsFullEventWorthSaving(ND::TND280Event& event);

 protected:
  virtual void InitializeModule();

  virtual void InitializeBranches();
  void FillConfigTree(TTree* configTree);
  virtual bool FillTree(ND::TND280Event&);

  void FillGlobalInfo(ND::TND280Event& event,
                      ND::THandle<ND::TReconBase> reconObject,
                      TGlobalReconObject* output);
  void FillConstituentInfo(ND::TND280Event& event,
                           ND::THandle<ND::TReconBase> reconObject,
                           ND::THandle<ND::TReconBase> globalObject,
                           TGlobalReconConstituent* output);
  void FillStateInfo(ND::THandle<ND::TReconState> state,
                     TReconStateInfo& output);
  void FillDownToTrackerInfo(ND::THandle<ND::TReconBase> base,
                             TDownToTrackerInfo* output);
  void FillGlobalStateInfo(ND::THandle<ND::TReconState> state,
                           TGlobalReconStateInfo& output);
  void FillConsTruthInfo(ND::TND280Event& event,
                         ND::THandle<ND::TReconBase> reconObject,
                         TTruthInfo& output);
  void FillGlobalTruthInfo(ND::TND280Event& event,
                           ND::THandle<ND::TReconBase> reconObject,
                           TGlobalTruthInfo& output);
  TLorentzVector GetStatePosition(ND::THandle<ND::TReconState> state);
  TLorentzVector GetStatePositionVariance(ND::THandle<ND::TReconState> state);
  double GetStateMomentum(ND::THandle<ND::TReconState> state);
  TVector3 GetStateDirection(ND::THandle<ND::TReconState> state);
  ND::THandle<ND::TReconState> GetLastState(ND::THandle<ND::TReconBase> object);
  ND::THandle<ND::TReconState> GetFirstState(
      ND::THandle<ND::TReconBase> object);
  double GetEDeposit(ND::THandle<ND::TReconBase> object);
  ND::TReconObjectContainer GetConstituentsOfInterest(
      ND::THandle<ND::TReconBase> input);
  ND::TReconObjectContainer GetDownToTracker(ND::THandle<ND::TReconBase> input);
  bool IsOnlyTracker(ND::THandle<ND::TReconBase> input);
  bool ContainsTracker(ND::THandle<ND::TReconBase> input);
  bool ConstituentsAreEqual(ND::THandle<ND::TReconBase> obj1,
                            ND::THandle<ND::TReconBase> obj2);
  void GetObjectsFromVertices(ND::THandle<ND::TReconObjectContainer> input,
                              ND::THandle<ND::TReconObjectContainer> output);
  void ExtrapolateToModuleAndFill(ND::THandle<ND::TReconBase> base,
                                  THelixModelInfo& output, std::string module);
  void GetModuleBox(ND::TGeometryId id, TVector3& minpos, TVector3& maxpos);

 public:
  /// Tree Entries
  Int_t fNGlobalReconObjects;

  /// TClonesArray of TGlobalReconObject
  TClonesArray* fGlobalReconObjects;

  /// Number of hits in each subdetector.
  std::map<std::string, int> fHitInfo;

 private:
  /// Flag for whether to save all global nodes or just the first and last nodes
  bool fSaveAllGlobalNodes;

};
#endif