---

MCParticle.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/gismo/gismo/MCParticle.h,v 1.4 2001/05/31 19:40:07 chehtman Exp $
//
//
#ifndef GISMO_MCPARTICLE_H
#define GISMO_MCPARTICLE_H

#include "gismo/GParticle.h"
#include "geometry/Ray.h"

#include "gismo/Interactor.h"

class Medium;
class Track;


class MCParticle : public GParticle
{
    
public:
    MCParticle(long id, float mass=-1);
    MCParticle(const char*, float mass=-1);
    MCParticle(const PData*, float mass=-1);
    MCParticle(const MCParticle&);
    
    ~MCParticle();
 
    enum Status {ALIVE, DECAYED, INTERACTED,
        LEFT, STOPPED, LOOPING,
        LOST, STUCK, PRIMARY, SHOWER};
    
    MCParticle::Status status() const;
    void setStatus(MCParticle::Status);
    
    static int   saveTrack;
    
    float energyLoss()const;
    
    virtual void propagate(const Medium *);
    
    const MCParticle* parent()const;
    
    MCParticle* child(int i)const;
    
    virtual GParticle* addChild(const PData*, float mass=-1);
    
    int interact(const Medium*);
    float interactionLength(const Medium*);
    
    
    static void addInteractor(Interactor *);
    
    void printOn( std::ostream& ) const;
    
    
    static int stepCount();
    int generationCount();
    float stepLength();
    float arclength();
    float currentTime();
    Point position(float s) const;
    Point position() const;
    Vector direction(float s) const;
    Vector direction() const;
    
    const Ray* segment()const{return s_segment;}
    
    const Medium *medium() const;
    
    Interactor* interactor()const{ return pData->interaction();}
    
    const Track* track()const { return _track;}
    
    static const Medium*  getCurrentMedium () { return currentMedium; }
    
protected:
    
    Track* _track;
    // geometric path used for drawing
    
    Status _status;
    // current status
    
    const Medium *lastMedium;
    // pointer to medium in which track ends
    
    
    float checkStep();
    void stepBy(float, Ray&);
    void endStep();
    
    
    // following are static since they are only needed during propagation,
    // which is done a particle at a time while alive
    
    static Ray *        s_segment;        // Trajectory of last step
    static double    startingEnergy; // energy at start of step
    
    static float    arcLength;  // total distance swum so far
    static float    properTime; // total proper time since creation.
    static float    timeOfDecay;        // actual decay time
    static float    step;         // distance of present step
    
    static int stepcount;
    // step counter
    static int generation;
    // generation counter
    
    static float    turnAngle;  
    // total angular deflection so far (propagation parameter)
    
    static float elossFraction;
    // the maximum fraction of energy loss allowed for a step
    
    static float ecut;
    // the minimum energy allowed if losing energy in a medium
    
    static const Medium* currentMedium;
    // the current medium
    
    
    //  Define some limits used for propagation
    static const float MAX_TIME;   //nsec...
    static const float MAX_BEND;   //radians .. 5 loops...
    static const int   MAX_GENERATION;  //limits depth of a shower
    static const int   MAX_STEPS;   // limits number of steps for a particle
    
};

inline MCParticle::Status MCParticle::status()const{return _status;}
inline void MCParticle::setStatus(MCParticle::Status s){_status = s;}
inline float MCParticle::energyLoss()const {return startingEnergy-e();}

inline int MCParticle::stepCount()      {return stepcount;}
inline int MCParticle::generationCount(){return generation;}


inline float MCParticle::stepLength(){return step;}
inline float MCParticle::arclength(){return arcLength;}
inline float MCParticle::currentTime(){return properTime;}
inline Point MCParticle::position() const
{return GParticle::position();}
inline Vector MCParticle::direction() const
{return GParticle::direction();}
inline Point MCParticle::position(float s) const
{ if(s_segment)return s_segment->position(s);
else       return GParticle::position();
}
inline Vector MCParticle::direction(float s) const
{if(s_segment) return s_segment->direction(s);
else         return GParticle::direction();
}

inline int MCParticle::interact(const Medium* m){
    return pData->interaction()->interact(this,m);}
inline float MCParticle::interactionLength(const Medium* m){
    return pData->interaction()->interactionLength(this,m);}

inline const Medium *
MCParticle::medium()const {return lastMedium;}


#endif

---