---

GParticle.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/gismo/gismo/GParticle.h,v 1.3 2000/01/17 23:37:18 burnett Exp $
//
//
//
// This is the definition of the GParticle class.
//
//

#ifndef _GPARTICLE_H_
#define _GPARTICLE_H_

#include "gismo/PData.h"
#include "CLHEP/Vector/LorentzVector.h"
class PDT;

#include "geometry/Point.h"



class GParticle: public HepLorentzVector {

public:


    GParticle(const char* name,  float mass=-1);
    GParticle(long          id,  float mass=-1);
    GParticle(const PData * data,float mass=-1);

    GParticle(const GParticle&);
    virtual ~GParticle();


    double px() const;
    double py() const;
    double pz() const;
    double e() const;
    Vector momentum() const;
    double pTot()const;

    double tx() const;
    double ty() const;
    double tz() const;
    Vector direction() const;

    double mass() const;

    HepBoolean hasPostionInfo() const;

    double x0() const;
    double y0() const;
    double z0() const;
    Point productionVertex() const;

    double x() const;
    double y() const;
    double z() const;
    Point position() const;
    Point decayVertex() const;
    GParticle& setPosition(const Point&);


    float t() const;

    void setT(float);

    float timeOfDecay() const;


    GParticle& setMomentum(const Vector &);

 

    GParticle& setEnergy(float);

    float eta()const;

    void decayOnce();


    virtual void printOn(std::ostream&)const;
    void printAll(std::ostream&)const;

    const char* name()const;
    float   charge()const;
    long    idCode()const;
    float   spin()const;
    double  lifeTime()const;

    const GParticle* parent()const;

    int  numChildren()const;

    GParticle* child(int n)const;
    virtual GParticle* addChild(const PData* childData, float mass=-1);
    void removeChildren();

    void boost(const Vector&);

    void scatterBy(double theta, double phi);

    static void setPDT(PDT* thePDT);
    static  PDT* thePDT();

    float  GenerateTimeOfDecay();

protected:
    const PData * pData;        // pointer to particle table entry
    GParticle* addChild(GParticle *);
    void setE(float);
    void setMass(float);
    void setParent(GParticle*);

private:
    const GParticle* m_parent;    // pointer to parent particle
    GParticle*   m_first_child;  // first of children (0 if none)
    GParticle*   m_next_sibling; // next sibling (0 for last)


    float _mass;                        // actual mass

    Point _r;
    float _time;
    // current position and time (lab frame), or a decay

    static  PDT* _thePDT;
    static const unsigned MAX_TRIES;
};
// -----------------GParticle inlines--------------------------
inline std::ostream& operator<<(std::ostream& out, const GParticle& p)
{ 
        p.printAll(out);
        return out;
}
inline std::ostream& operator<<(std::ostream& out, const GParticle* p)
{
        p->printAll(out);
        return out;
}

inline double
GParticle::px()const{return HepLorentzVector::x();}
inline double
GParticle::py()const{return HepLorentzVector::y();}
inline double
GParticle::pz()const{return HepLorentzVector::z();}
inline double
GParticle::e()const{return HepLorentzVector::t();}
inline void
GParticle::setE(float e){HepLorentzVector::setT(e);}
inline Vector
GParticle::momentum()const{return Vector(*this);}


inline double
GParticle::x()const{return _r.x();}
inline double
GParticle::y()const{return _r.y();}
inline double
GParticle::z()const{return _r.z();}
inline float
GParticle::t()const{return _time;}
inline void
GParticle::setT(float t){_time=t;}
inline Point
GParticle::decayVertex() const{return _r;}

inline Point
GParticle::position() const{return _r;}

inline GParticle&
GParticle::setPosition(const Point& r){_r=r; return *this;}

inline double
GParticle::x0()const{return m_parent->_r.x();}
inline double
GParticle::y0()const{return m_parent->_r.y();}
inline double
GParticle::z0()const{return m_parent->_r.z();}
inline Point
GParticle::productionVertex()const{return m_parent->_r;}
inline double
GParticle::tx()const{return x()/vect().mag();}
inline double
GParticle::ty()const{return y()/vect().mag();}
inline double
GParticle::tz()const{return z()/vect().mag();}
inline Vector
GParticle::direction()const{return vect().unit();}


inline double
GParticle::mass()const{return _mass;}

inline    const char*
GParticle::name()const {return pData->name();}

inline    float
GParticle::charge()const {return pData->charge();}

inline    long
GParticle::idCode()const {return pData->idCode();}

inline    float
GParticle::spin()const {return pData->spin();}

inline    double
GParticle::lifeTime()const {return pData->lifeTime();}

inline    void
GParticle::setPDT(PDT* thePDT){_thePDT = thePDT;}

inline    PDT*
GParticle::thePDT(){return _thePDT;}

inline   float
GParticle::eta()const{return vect().mag()/_mass;}

inline double
GParticle::pTot()const{return vect().mag();}


#endif // _GPARTICLE_H_

---