GHepRecord.h

Go to the documentation of this file.

//____________________________________________________________________________
/*!
 
\class    genie::GHepRecord
 
\brief    GENIE's GHEP MC event record.
 
\author   Costas Andreopoulos <c.andreopoulos \at cern.ch>
          University of Liverpool
 
\created  October 1, 2004
 
\cpright  Copyright (c) 2003-2025, The GENIE Collaboration
          For the full text of the license visit http://copyright.genie-mc.org        
*/
//____________________________________________________________________________
 
#ifndef _GHEP_RECORD_H_
#define _GHEP_RECORD_H_
 
#include <ostream>
#include <vector>
 
#include <TClonesArray.h>
#include <TBits.h>
 
#include "Framework/Conventions/GMode.h"
#include "Framework/Conventions/KinePhaseSpace.h"
#include "Framework/Interaction/Interaction.h"
#include "Framework/GHEP/GHepStatus.h"
 
class TRootIOCtor;
class TLorentzVector;
 
using std::ostream;
using std::vector;
 
namespace genie {
 
class GHepRecord;
class GHepParticle;
 
ostream & operator << (ostream & stream, const GHepRecord & event);
 
class GHepRecord : public TClonesArray {
 
public :
  using TClonesArray::Print; // suppress clang 'hides overloaded virtual function [-Woverloaded-virtual]' warnings
  using TClonesArray::Copy;
 
  GHepRecord();
  GHepRecord(int size);
  GHepRecord(const GHepRecord & record);
  GHepRecord(TRootIOCtor*);
  virtual ~GHepRecord();
 
  // Methods to attach / get summary information
 
  virtual Interaction * Summary       (void) const;
  virtual void          AttachSummary (Interaction * interaction);
 
  // Provide a simplified wrapper of the 'new with placement'
  // TClonesArray object insertion method
  // ALWAYS use these methods to insert new particles as they check
  // for the compactness of the daughter lists.
  // Note that the record might be automatically re-arranged as the
  // result of your GHepParticle insertion
 
  virtual void AddParticle (const GHepParticle & p);
  virtual void AddParticle (int pdg, GHepStatus_t ist,
                     int mom1, int mom2, int dau1, int dau2,
                        const TLorentzVector & p, const TLorentzVector & v);
  virtual void AddParticle (int pdg, GHepStatus_t ist,
                     int mom1, int mom2, int dau1, int dau2,
                           double px, double py, double pz, double E,
                                    double x, double y, double z, double t);
 
  // Methods to search the GHEP record
 
  virtual GHepParticle * Particle     (int position) const;
  virtual GHepParticle * FindParticle (int pdg, GHepStatus_t ist, int start) const;
 
  virtual int ParticlePosition (int pdg, GHepStatus_t i, int start=0) const;
  virtual int ParticlePosition (GHepParticle * particle, int start=0) const;
 
  virtual vector<int> * GetStableDescendants(int position) const;
 
  // Return the mode (lepton+nucleon/nucleus, hadron+nucleon/nucleus, nucleon
  // decay etc...) by looking at the event entries
 
  GEvGenMode_t EventGenerationMode(void) const;
 
  // Easy access methods for the most frequently used GHEP entries
 
  virtual GHepParticle * Probe                            (void) const;
  virtual GHepParticle * TargetNucleus                    (void) const;
  virtual GHepParticle * RemnantNucleus                   (void) const;
  virtual GHepParticle * HitNucleon                       (void) const;
  virtual GHepParticle * HitElectron                      (void) const;
  virtual GHepParticle * FinalStatePrimaryLepton          (void) const;
  virtual GHepParticle * FinalStateHadronicSystem         (void) const;
  virtual int            ProbePosition                    (void) const;
  virtual int            TargetNucleusPosition            (void) const;
  virtual int            RemnantNucleusPosition           (void) const;
  virtual int            HitNucleonPosition               (void) const;
  virtual int            HitElectronPosition              (void) const;
  virtual int            FinalStatePrimaryLeptonPosition  (void) const;
  virtual int            FinalStateHadronicSystemPosition (void) const;
 
  // Number of GHepParticle occurences in GHEP
 
  virtual unsigned int NEntries (int pdg, GHepStatus_t ist, int start=0) const;
  virtual unsigned int NEntries (int pdg, int start=0) const;
 
  // Methods to switch on/off and ask for event record flags
 
  virtual TBits * EventFlags   (void) const { return fEventFlags; }
  virtual TBits * EventMask    (void) const { return fEventMask; }
  virtual bool    IsUnphysical (void) const { return (fEventFlags->CountBits()>0); }
  virtual bool    Accept       (void) const;
 
  // Methods to set/get the event weight and cross sections
 
  virtual double Weight         (void) const  { return fWeight;   }
  virtual double Probability    (void) const  { return fProb;     }
  virtual double XSec           (void) const  { return fXSec;     }
  virtual double DiffXSec       (void) const  { return fDiffXSec; }
  virtual KinePhaseSpace_t DiffXSecVars  (void) const  { return fDiffXSecPhSp; }
 
  virtual void   SetWeight      (double wght) { fWeight   = (wght>0) ? wght : 0.; }
  virtual void   SetProbability (double prob) { fProb     = (prob>0) ? prob : 0.; }
  virtual void   SetXSec        (double xsec) { fXSec     = (xsec>0) ? xsec : 0.; }
  virtual void   SetDiffXSec    (double xsec, KinePhaseSpace_t ps)
  { fDiffXSecPhSp = ps;
    fDiffXSec = (xsec>0) ? xsec : 0.;
  }
 
  // Set/get event vertex in detector coordinate system
 
  virtual TLorentzVector * Vertex (void) const { return fVtx; }
 
  virtual void SetVertex (double x, double y, double z, double t);
  virtual void SetVertex (const TLorentzVector & vtx);
 
  // Common event record operations
 
  virtual void Copy        (const GHepRecord & record);
  virtual void Clear       (Option_t * opt="");
  virtual void ResetRecord (void);
  virtual void CompactifyDaughterLists     (void);
  virtual void RemoveIntermediateParticles (void);
 
  // Set mask
  void SetUnphysEventMask(const TBits & mask);
 
  // Set/Get print level
  static void SetPrintLevel(int print_level);
  static int  GetPrintLevel();
 
  // Methods & operators to print the record
 
  void Print (ostream & stream) const;
  friend ostream & operator << (ostream & stream, const GHepRecord & event);
 
protected:
 
  // Attached interaction
  Interaction * fInteraction; ///< attached summary information
 
  // Vertex position
  TLorentzVector * fVtx;  ///< vertex in the detector coordinate system
 
  // Flags (and user-specified mask) for the generated event
  TBits * fEventFlags;    ///< event flags indicating various pathologies or an unphysical event
  TBits * fEventMask;     ///< an input bit-field mask allowing one to ignore bits set in fEventFlags
 
  // Event weight, probability and cross-sections
  double           fWeight;         ///< event weight
  double           fProb;           ///< event probability (for given flux neutrino and density-weighted path-length for target element)
  double           fXSec;           ///< cross section for selected event
  double           fDiffXSec;       ///< differential cross section for selected event kinematics
  KinePhaseSpace_t fDiffXSecPhSp;   ///< specifies which differential cross-section (dsig/dQ2, dsig/dQ2dW, dsig/dxdy,...)
 
  // Utility methods
  void InitRecord  (void);
  void CleanRecord (void);
 
  // Methods used by the daughter list compactifier
  virtual void UpdateDaughterLists    (void);
  virtual bool HasCompactDaughterList (int pos);
  virtual void SwapParticles          (int i, int j);
  virtual void FinalizeDaughterLists  (void);
  virtual int  FirstNonInitStateEntry (void);
 
  //
  static int fPrintLevel; //! print-level flag, see GHepRecord::Print()
 
private:
 
ClassDef(GHepRecord, 2)
 
};
 
}      // genie namespace
 
#endif // _GHEP_RECORD_H_