StMcTrack.hh

#ifndef StMcTrack_hh
#define StMcTrack_hh 
#include "Stiostream.h"
#include "StLorentzVectorF.hh"
#include "StMcContainers.hh"
#include "StObject.h"
#include "StEnumerations.h"
class StParticleDefinition;
class g2t_track_st;
class particle_st;
class StMcTrack;
ostream&  operator<<(ostream& os, const StMcTrack&);

class StMcTrack : public StObject {
public:
    StMcTrack();
    virtual ~StMcTrack();
    StMcTrack(g2t_track_st* trk);
    StMcTrack(particle_st* trk);
    
    // StMcTrack(const StMcTrack&);                     use default
    // const StMcTrack & operator=(const StMcTrack&);   use default
    
    int operator==(const StMcTrack&) const;
    int operator!=(const StMcTrack&) const;

    void initToZero();
  // "Get" Methods
  const StLorentzVectorF& fourMomentum() const { return mFourMomentum; }
  const StThreeVectorF& momentum() const { return mFourMomentum.vect(); }
  float energy() const { return mFourMomentum.e(); }
  float pt() const { return mFourMomentum.perp(); }
  float rapidity() const { return mFourMomentum.rapidity(); }
  float pseudoRapidity() const { return mFourMomentum.pseudoRapidity(); }
  StMcVertex* startVertex() { return mStartVertex; }
  const StMcVertex* startVertex() const { return mStartVertex; }
  StMcVertex* stopVertex() { return mStopVertex; }
  const StMcVertex* stopVertex() const { return mStopVertex; }
  StMcTrack* parent() { return mParent; }
  const StMcTrack* parent() const { return mParent; }
  StPtrVecMcVertex& intermediateVertices() { return mIntermediateVertices; }
  const StPtrVecMcVertex& intermediateVertices() const { return mIntermediateVertices; }
  StPtrVecMcTpcHit& tpcHits() { return mTpcHits; }
  const StPtrVecMcTpcHit& tpcHits() const { return mTpcHits; }
  StPtrVecMcSvtHit& svtHits() { return mSvtHits; }
  const StPtrVecMcSvtHit& svtHits() const { return mSvtHits; }
  StPtrVecMcSsdHit& ssdHits() { return mSsdHits; }
  const StPtrVecMcSsdHit& ssdHits() const { return mSsdHits; }
  StPtrVecMcFtpcHit& ftpcHits() { return mFtpcHits; }
  const StPtrVecMcFtpcHit& ftpcHits() const { return mFtpcHits; }
  StPtrVecMcRichHit& richHits() { return mRichHits; }
  const StPtrVecMcRichHit& richHits() const { return mRichHits; }
  StPtrVecMcCtbHit& ctbHits() { return mCtbHits; }
  const StPtrVecMcCtbHit& ctbHits() const { return mCtbHits; }
  StPtrVecMcCalorimeterHit& bemcHits() { return mBemcHits; }
  const StPtrVecMcCalorimeterHit& bemcHits() const { return mBemcHits; }
  StPtrVecMcCalorimeterHit& bprsHits() { return mBprsHits; }
  const StPtrVecMcCalorimeterHit& bprsHits() const { return mBprsHits; }
  StPtrVecMcCalorimeterHit& bsmdeHits() { return mBsmdeHits; }
  const StPtrVecMcCalorimeterHit& bsmdeHits() const { return mBsmdeHits; }
  StPtrVecMcCalorimeterHit& bsmdpHits() { return mBsmdpHits; }
  const StPtrVecMcCalorimeterHit& bsmdpHits() const { return mBsmdpHits; }
  StPtrVecMcTofHit& tofHits() { return mTofHits; }
  const StPtrVecMcTofHit& tofHits() const { return mTofHits; }
  StPtrVecMcMtdHit& mtdHits() { return mMtdHits; }
  const StPtrVecMcMtdHit& mtdHits() const { return mMtdHits; }
  StPtrVecMcCalorimeterHit& eemcHits() { return mEemcHits; }
  const StPtrVecMcCalorimeterHit& eemcHits() const { return mEemcHits; }
  StPtrVecMcCalorimeterHit& eprsHits() { return mEprsHits; }
  const StPtrVecMcCalorimeterHit& eprsHits() const { return mEprsHits; }
  StPtrVecMcCalorimeterHit& esmduHits() { return mEsmduHits; }
  const StPtrVecMcCalorimeterHit& esmduHits() const { return mEsmduHits; }
  StPtrVecMcCalorimeterHit& esmdvHits() { return mEsmdvHits; }
  const StPtrVecMcCalorimeterHit& esmdvHits() const { return mEsmdvHits; }
  StPtrVecMcCalorimeterHit& fpdHits() { return mFpdHits; }
  const StPtrVecMcCalorimeterHit& fpdHits() const { return mFpdHits; }
  StPtrVecMcCalorimeterHit& fscHits() { return mFscHits; }
  const StPtrVecMcCalorimeterHit& fscHits() const { return mFscHits; }
  StPtrVecMcPxlHit& pxlHits() { return mPxlHits; }
  const StPtrVecMcPxlHit& pxlHits() const { return mPxlHits; }
  StPtrVecMcIstHit& istHits() { return mIstHits; }
  const StPtrVecMcIstHit& istHits() const { return mIstHits; }
  StPtrVecMcFgtHit& fgtHits() { return mFgtHits; }
  const StPtrVecMcFgtHit& fgtHits() const { return mFgtHits; }
  StPtrVecMcEtrHit& etrHits() { return mEtrHits; }
  const StPtrVecMcEtrHit& etrHits() const { return mEtrHits; }
  StParticleDefinition* particleDefinition();
  const StParticleDefinition* particleDefinition() const { return mParticleDefinition; }
  const StPtrVecMcHit *Hits(StDetectorId Id) const;
  const StPtrVecMcCalorimeterHit *CalorimeterHits(StDetectorId Id) const;
  int isShower() const { return mIsShower; }
  long geantId() const { return mGeantId; }
  long pdgId() const { return mPdgId; }
  long key() const { return mKey; }
  long eventGenLabel() const { return mEventGenLabel; }

  // "Set" Methods
    void setFourMomentum(const StLorentzVectorF&); 
    void setStartVertex(StMcVertex*); 
    void setStopVertex(StMcVertex*); 
    void setIntermediateVertices(StPtrVecMcVertex&); 
    void setTpcHits(StPtrVecMcTpcHit&); 
    void setSvtHits(StPtrVecMcSvtHit&); 
    void setSsdHits(StPtrVecMcSsdHit&); 
    void setFtpcHits(StPtrVecMcFtpcHit&); 
    void setRichHits(StPtrVecMcRichHit&); 
    void setCtbHits(StPtrVecMcCtbHit&); 
    void setBemcHits(StPtrVecMcCalorimeterHit&); 
    void setBprsHits(StPtrVecMcCalorimeterHit&); 
    void setBsmdeHits(StPtrVecMcCalorimeterHit&); 
    void setBsmdpHits(StPtrVecMcCalorimeterHit&); 
    void setTofHits(StPtrVecMcTofHit&); 
    void setMtdHits(StPtrVecMcMtdHit&); 
    void setEemcHits(StPtrVecMcCalorimeterHit&); 
    void setEprsHits(StPtrVecMcCalorimeterHit&); 
    void setEsmduHits(StPtrVecMcCalorimeterHit&); 
    void setEsmdvHits(StPtrVecMcCalorimeterHit&); 
    void setFscHits(StPtrVecMcCalorimeterHit&); 
    void setPxlHits(StPtrVecMcPxlHit&); 
    void setIstHits(StPtrVecMcIstHit&); 
    void setFgtHits(StPtrVecMcFgtHit&); 
    void setEtrHits(StPtrVecMcEtrHit&); 

    void setShower(char); 
    void setGeantId(long); 
    void setPdgId(long); 
    void setKey(long);     
    void setEventGenLabel(long);     
    void setParent(StMcTrack*);     
  void setPrimary(Bool_t val) {mIsPrimary = val;}

    void addTpcHit(StMcTpcHit*); 
    void addSvtHit(StMcSvtHit*); 
    void addSsdHit(StMcSsdHit*); 
    void addFtpcHit(StMcFtpcHit*); 
    void addRichHit(StMcRichHit*); 
    void addCtbHit(StMcCtbHit*); 
    void addBemcHit(StMcCalorimeterHit*); 
    void addBprsHit(StMcCalorimeterHit*); 
    void addBsmdeHit(StMcCalorimeterHit*); 
    void addBsmdpHit(StMcCalorimeterHit*); 
    void addTofHit(StMcTofHit*); 
    void addMtdHit(StMcMtdHit*); 
    void addEemcHit(StMcCalorimeterHit*); 
    void addEprsHit(StMcCalorimeterHit*); 
    void addEsmduHit(StMcCalorimeterHit*); 
    void addEsmdvHit(StMcCalorimeterHit*); 
    void addFpdHit(StMcCalorimeterHit*);
    void addFscHit(StMcCalorimeterHit*);
    void addPxlHit(StMcPxlHit*); 
    void addIstHit(StMcIstHit*);
    void addFgtHit(StMcFgtHit*); 
    void addEtrHit(StMcEtrHit*); 
    void removeTpcHit(StMcTpcHit*); 
    void removeSvtHit(StMcSvtHit*); 
    void removeSsdHit(StMcSsdHit*); 
    void removeFtpcHit(StMcFtpcHit*); 
    void removeRichHit(StMcRichHit*); 
    void removeCtbHit(StMcCtbHit*); 
    void removeCalorimeterHit(StPtrVecMcCalorimeterHit&, StMcCalorimeterHit*); 
    void removeBemcHit(StMcCalorimeterHit*); 
    void removeBprsHit(StMcCalorimeterHit*); 
    void removeBsmdeHit(StMcCalorimeterHit*); 
    void removeBsmdpHit(StMcCalorimeterHit*); 
    void removeTofHit(StMcTofHit*); 
    void removeMtdHit(StMcMtdHit*); 
    void removeEemcHit(StMcCalorimeterHit*); 
    void removeEprsHit(StMcCalorimeterHit*); 
    void removeEsmduHit(StMcCalorimeterHit*); 
    void removeEsmdvHit(StMcCalorimeterHit*); 
    void removePxlHit(StMcPxlHit*); 
    void removeIstHit(StMcIstHit*); 
    void removeFgtHit(StMcFgtHit*); 
    void removeEtrHit(StMcEtrHit*); 
  void Print(Option_t *option="") const;
  Bool_t IsPrimary() const {return mIsPrimary;}
    //    void setTopologyMap(StTrackTopologyMap&); 
    
protected:
    StLorentzVectorF         mFourMomentum;  
    StMcVertex*              mStartVertex; 
    StMcVertex*              mStopVertex; 
    StPtrVecMcVertex         mIntermediateVertices; 
    StPtrVecMcTpcHit         mTpcHits; 
    StPtrVecMcSvtHit         mSvtHits; 
    StPtrVecMcSsdHit         mSsdHits; 
    StPtrVecMcFtpcHit        mFtpcHits; 
    StPtrVecMcRichHit        mRichHits; 
    StPtrVecMcCtbHit         mCtbHits; 
    StPtrVecMcCalorimeterHit mBemcHits; 
    StPtrVecMcCalorimeterHit mBprsHits; 
    StPtrVecMcCalorimeterHit mBsmdeHits; 
    StPtrVecMcCalorimeterHit mBsmdpHits; 
    StPtrVecMcTofHit         mTofHits; 
    StPtrVecMcMtdHit         mMtdHits; 
    StPtrVecMcCalorimeterHit mEemcHits; 
    StPtrVecMcCalorimeterHit mEprsHits; 
    StPtrVecMcCalorimeterHit mEsmduHits; 
    StPtrVecMcCalorimeterHit mEsmdvHits; 
    StPtrVecMcCalorimeterHit mFpdHits; 
    StPtrVecMcCalorimeterHit mFscHits; 
    StPtrVecMcPxlHit         mPxlHits; 
    StPtrVecMcIstHit         mIstHits;
    StPtrVecMcFgtHit         mFgtHits; 
    StPtrVecMcEtrHit         mEtrHits; 
  StParticleDefinition*    mParticleDefinition; 
    StMcTrack*               mParent;
    char                     mIsShower; 
    long                     mGeantId; 
    long                     mPdgId; 
    long                     mKey;     
    long                     mEventGenLabel; 
  Bool_t                   mIsPrimary;
    ClassDef(StMcTrack,2)
};
#endif