---

MCTruth.h

Go to the documentation of this file.

//  $Header: /nfs/slac/g/glast/ground/cvs/instrument/instrument/MCTruth.h,v 1.9 2001/08/23 06:05:27 burnett Exp $
//
//

#ifndef __MCTruth_H
#define __MCTruth_H

// includes
#include "instrument/GlastDetector.h"
#include "facilities/bpkt_streams.h"

// forward declarations
class DetectorVisitor;
class Generator;

class MCTruth : public GlastDetector
{
protected:
    MCTruth (const DOM_Element& elem);
    
public:
    // type declarations
    typedef unsigned int    id_type;
    
    class _Factory : public GlastDetector::_Factory {
    public:
        virtual xml::PersistentObject*   create(const DOM_Element& elem) { 
            return new MCTruth(elem); 
        }
    };
    class _Particle {
    public:
        virtual void    write ( std::ostream&) const {};
        virtual void    write_data ( bpkt::ostream& ) const {};
        virtual void    read ( std::istream&) {};
        virtual void    read_data ( bpkt::istream& ) {};
        virtual void    printOn ( std::ostream& ) const {};
        
        // accss to quantities
        virtual double  int_material_Z () const {return -1;};
        
        virtual Point position()const{return Point();}
        virtual Vector momentum()const{return Vector();}
        virtual double energy()const {return 0;}
        virtual long id()const {return 9999;}
        virtual std::string name()const{return std::string("not set");}

        virtual void setPosition(const Point& pos){}
        virtual void setMomentum(const Vector& p){}
        virtual void setEnergy(double e){}
        virtual void setName(const std::string& name){}
       
        
        virtual Generator*  generator () const { return (Generator*)0;}
    };
    
    
    class   ParticleData : public  _Particle{
    public:  
        // declare how the children are stored
        typedef std::vector<ParticleData*>  ChildList;
        
        // ctor/dtor
        ParticleData () {}
        virtual ~ParticleData (){};
        
        void    read (std::istream& in);
        virtual void    write ( std::ostream&) const;

        
        Point position()const{return m_pos;}
        Vector momentum()const{return m_p;}
        double energy()const{return m_energy;;}
        long id()const{return m_idcode;}
        std::string name()const{return m_name;}

        void setPosition(const Point& pos){m_pos=pos;}
        void setMomentum(const Vector& p){m_p=p;}
        void setEnergy(double e){m_energy = e;}
        void setName(const std::string& name){m_name=name;}
    private:    
        long    m_idcode;   // some particle ID code
        int     m_status;   // some particle status code
        Vector  m_p;        // momentum
        Point   m_pos;      // position
        Vector  m_dir;      // initial direction
        double  m_energy;       // energy
        std::string m_name;
        
        ChildList  m_kids;  // list of child particles
        
    };
    

    MCTruth( _Particle* p = 0);
    
    virtual ~MCTruth();
    
    // visitation
    virtual void accept(DetectorVisitor&);
    virtual void accept(DetectorConverter&);
    virtual void accept(DetectorConverter&) const;
    
    // GlastDetector overrides
    virtual bool empty ()const { return false;}
    virtual void read (std::istream& in) { in >> m_id; m_particle->read (in); } 
    virtual void write (std::ostream& out) const 
    { out << m_id; m_particle->write (out); }
    virtual void printOn (std::ostream& out) const 
    { if( m_particle ) m_particle->printOn (out); 
    else{ out << "MCTruth: no particle object"; } }
    virtual const char* nameOf () const { return "MCTruth"; }
    
    // access
    const _Particle*    particle () const { return m_particle; }
    _Particle*      particle () { return m_particle; }
    void    particle (_Particle* p) { m_particle = p; }
    
    const id_type&  id () const { return m_id; }
    void            id ( const id_type& anid ) { m_id = anid; }
    
    Generator*  generator(){return particle()->generator();}
    
    // singleton
    static  MCTruth*    instance () { return s_instance; }
    
    // "persistence"
    static const GlastDetector::_PersistKey classPersistKey;
    //  virtual DOM_Element&   persist (DOM_Element& e) const 
    virtual DOM_Element   persist (DOM_Element& e) const 
    { return GlastDetector::persist(e); }
    
    protected:
        // "persistence"
        virtual const GlastDetector::_PersistKey&   persistKey () const
        { return classPersistKey; }
        
        // friends
        friend class _Factory;
        
    private: 
        // private data members
        _Particle*  m_particle; // some abstract particle representation
        id_type     m_id;           // id type for the current event.
        
        // static data members
        static MCTruth* s_instance; // singleton instance
};
#endif

---