StarGenParticle.h

#ifndef __StarGenParticle_h__
#define __StarGenParticle_h__

#include "TObject.h"
#include "TRef.h"
#include "TMath.h"
#include "TLorentzVector.h"

class StarGenParticle : public TObject
{
 public:
  StarGenParticle();
  ~StarGenParticle(){ };


  enum State { kNull,          
               kFinal,         
               kDecayed,       
               kDocumentation, 
               kIncident,      
               kUnknown        
  };

                  
  void  SetStatus( Int_t status ){ mStatus = status; }

  Int_t GetStatus() { return mStatus; }
  void  SetId( Int_t id );
  Int_t GetId() { return mId; }
  void SetFirstMother( Int_t first ) { mMother[0]=first; }
  void SetFirstMother( StarGenParticle *p ){ SetFirstMother(p->GetIndex()); }
  Int_t GetFirstMother() { return mMother[0]; }
  void SetLastMother( Int_t last ) { mMother[1]=last; }
  void SetLastMother( StarGenParticle *p ){ SetLastMother(p->GetIndex()); }
  Int_t GetLastMother(){ return mMother[1]; }
  void SetFirstDaughter( Int_t first ) { mDaughter[0]=first; }
  void SetFirstDaughter( StarGenParticle *p ) {SetFirstDaughter(p->GetIndex()); }
  Int_t GetFirstDaughter() { return mDaughter[0]; }
  void SetLastDaughter( Int_t last ) { mDaughter[1]=last; }
  void SetLastDaughter( StarGenParticle *p ) {SetLastDaughter(p->GetIndex()); }
  Int_t GetLastDaughter(){ return mDaughter[1]; }

  void SetPx( Float_t px ){ mPx = px; }
  Float_t GetPx(){ return mPx; }
  void SetPy( Float_t py ){ mPy = py; }
  Float_t GetPy(){ return mPy; }
  void SetPz( Float_t pz ){ mPz = pz; }
  Float_t GetPz(){ return mPz; }

  Float_t pt(){ return TMath::Sqrt(pt2()); }
  Float_t pt2(){ return mPx*mPx+mPy*mPy; }
  Float_t mt(){ return TMath::Sqrt(mt2()); }
  Float_t mt2(){ return mMass*mMass+mPx*mPx+mPy*mPy; }

  TLorentzVector momentum(){ return TLorentzVector(mPx,mPy,mPz,mEnergy); }



  void SetEnergy( Float_t energy ){ mEnergy = energy; }
  Float_t GetEnergy(){ return mEnergy; }
  void SetMass( Float_t mass ){ mMass = mass; }
  Float_t GetMass(){ return mMass; }

  void SetVx( Float_t vx ){ mVx = vx; }
  Float_t GetVx(){ return mVx; }
  void SetVy( Float_t vy ){ mVy = vy; }
  Float_t GetVy(){ return mVy; }
  void SetVz( Float_t vz ){ mVz = vz; }
  Float_t GetVz(){ return mVz; }
  void SetTof( Float_t tof ){ mTof = tof; }
  Float_t GetTof(){ return mTof; }

  void SetIndex( Int_t i ) { mIndex = i; }
  Int_t GetIndex(){ return mIndex; }

  void SetStack( Int_t i ){ mStack = i; }
  Int_t GetStack(){ return mStack; }

  void SetPrimaryKey( Int_t k ){ mPrimaryKey = k; }
  Int_t GetPrimaryKey(){ return mPrimaryKey; }

  void SetGeneratorId( Int_t id ){ mGeneratorId = id; }
  Int_t GetGeneratorId(){ return mGeneratorId; }

  void Print( const Option_t *opts="" ) const;

  Bool_t Simulate();

 private:

  // ------------------------------------------------------
  // Start of hepevt entry.  These variables must remain
  // packed together in this order in order to emulate the
  // HEPEVT record
  Int_t   mStatus;      
  Int_t   mId;
  Int_t   mMother[2];
  Int_t   mDaughter[2];
  Float_t mPx, mPy, mPz, mEnergy, mMass;
  Float_t mVx, mVy, mVz, mTof;
  // End of hepevt entry.  Address is returned using, and 
  // used in StarPrimaryMaker to fill the g2t particle 
  // table for backwards compatability with the starsim era
  // framework
  void *get_hepevt_address(){ return &mStatus; }
  // ------------------------------------------------------  




 protected:
  Int_t mIndex;
  Int_t mStack;
  Int_t mPrimaryKey;

  Int_t mGeneratorId;

  friend class StarPrimaryMaker;

  ClassDef(StarGenParticle,1);
};

#endif
/*
struct particle_st {
        int     isthep; //status code of the entry 
        int     idhep;  //particle identity, accordingly to the PDG standard 
        int     jmohep[2];      //pointer(s) to position where the mother(s) stored 
        int     jdahep[2];      //pointers to position of the first/last daughter 
        float   phep[5];        //p4 and mass (GeV) 
        float   vhep[4];        //production vertex (mm) and time (mm/c) 
}
 */