---

RCParticle.h

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/gismo/gismo/RCParticle.h,v 1.1 2001/09/22 16:41:37 burnett Exp $
//
//
#ifndef GISMO_RCParticle_H
#define GISMO_RCParticle_H

#include "gismo/GParticle.h"
#include "geometry/Ray.h"
#include <vector>

class Medium;

//
//  This class generates and contains methods that provide information  
//  about the material that is encountered along a Ray in Glast as well  
//  as the location on the Ray as is passes through the various Glast Mediums. 
//  The propagating particle is a 1 GeV, non-interacting "electron." 
// 
class RCParticle : public GParticle
{
    
public:
    RCParticle(Point x0, Vector t0, float dist);
    
    ~RCParticle();
    
    enum Status {ALIVE, LEFT, LOST, STUCK, DONE};
    
    RCParticle::Status status() const;
    void setStatus(RCParticle::Status);

    void setMaxArcLength(float dist); 

    float increaseMaxArcLenBy(float dist); 

    virtual void propagate();
 
    bool propagate(const char * title);

    void printOn( std::ostream& ) const;
    
    
    int stepCount() const ;
    float stepLength() const;
    float arclength() const;
    float radlength() const;
    float currentTime() const;
    Point position(float s) const;
    Point position() const;
    Point getHit(int) const; 
    Vector direction(float s) const;
    Vector direction() const;
    float mScat_Angle(float momentum, float s) const;
    float mScat_Angle(float momentum, int step_no) const;
    float mScat_Dist(float momentum, float s) const;
    float mScat_Dist(float momentum, int step_no) const;
    
    const Medium *medium() const;

    int findMedium(const char * name) const;

    const Medium*  getCurrentMedium () { return m_currentMedium; }

    const Medium*  getMedium (int) const;

    // Internal class Step to record all the Mediums crossed. The location is 
    // the entry point into the medium or the starting point in the case
    // of the starting medium. 

    class Step 
    {
    public:
        Step(const Medium * med, Point x, Vector t, float s, float x0);
        ~Step() {};
        
        Point  position()  const {return m_pos;}
        Vector direction() const {return m_dir;}
        float  length()    const {return m_step_length;}
        float  rad_len()   const {return m_rad_length;}
        const  Medium * place() const {return m_region;}
        void   printOn( std::ostream& ) const;
        
    private:
        Point  m_pos;           // Starting point
        Vector m_dir;           // Direction unit vector        
        float m_step_length;    // Distance along trajectory to traverse Medium
        float m_rad_length;     // Radiation lengths accumulated in this Medium         
        const Medium * m_region;// Pointer to the Medium inwhich this seg. occurs
    };

    // Access methods for getting the individual steps
    typedef std::vector<Step> StepList; 
    typedef std::vector<Step>::const_iterator const_iterator;

    const StepList& steps() const {return m_stepList;}
    const_iterator begin()  const {return m_stepList.begin();}
    const_iterator end()    const {return m_stepList.end();}

    // A Pointer to the simulation World geometry 
    static const Medium* s_world;

    protected:
        
        Status m_status;            // current status
        const Medium *m_lastMedium; // pointer to medium in which track ends
        void  stepBy(float, Ray&);  // Method to increment through Mediums
        void ini();                 // Zero's out counts... initializes particle
             
        StepList m_stepList;          // List of Steps along trajectory (see above)
        
        double   m_startingEnergy;  // Energy at start of step 
        float    m_arcLength;       // Total distance swum so far
        float    m_radLength;       // Total radiation length swum so far
        float    m_properTime;      // Total proper time since creation.
        float    m_step;            // Distance of present step
        float    m_maxStep;         // max. allowed distance for the current step
        float    m_maxArcLen;       // Distance through which to swim trajectory
        int      m_stepcount;       // Step counter   
        const Medium* m_currentMedium; // The current medium
        
};

inline RCParticle::Status RCParticle::status()const{return m_status;}
inline void RCParticle::setStatus(RCParticle::Status s){m_status = s;}
inline int RCParticle::stepCount()    const  {return m_stepcount;}

inline void  RCParticle::setMaxArcLength(float dist)   {m_maxArcLen = dist; return;}
inline float RCParticle::increaseMaxArcLenBy(float dist)
{
            m_maxArcLen += dist; return m_maxArcLen;
}  
inline float RCParticle::stepLength() const  {return m_step;}
inline float RCParticle::arclength()  const  {return m_arcLength;}
inline float RCParticle::radlength()  const  {return m_radLength;}
inline float RCParticle::currentTime()const  {return m_properTime;}
inline Point RCParticle::position()   const
{
    return GParticle::position();
}
inline Vector RCParticle::direction() const
{
    return GParticle::direction();
}
inline Point RCParticle::position(float s) const
{ 
   return position() + s*direction();
}
inline Vector RCParticle::direction(float s) const
{
   return GParticle::direction();
}

inline const Medium * RCParticle::medium()const {return m_lastMedium;}
inline const Medium * RCParticle::getMedium(int ith) const
{
    return m_stepList[ith].place();
}
inline Point RCParticle::getHit(int ith) const
{
    return m_stepList[ith].position();
}
#endif

---