Trajectory.hh

Go to the documentation of this file.

// $Header: /cvs/lcd/slic/include/Trajectory.hh,v 1.17 2006/09/05 23:21:49 jeremy Exp $

#ifndef SLIC_TRAJECTORY_HH
#define SLIC_TRAJECTORY_HH 1

// geant4
#include "G4VTrajectory.hh"
#include "G4Allocator.hh"
#include "G4Track.hh"
#include "G4VTrajectoryPoint.hh"
#include "globals.hh"

namespace slic
{

  typedef std::vector<G4VTrajectoryPoint*> TrajectoryPointContainer;

  class Trajectory : public G4VTrajectory
  {
  public:

    enum EFinalStatus {
      eUnset = 0,
      eDecayedInTracker = 1,
      eLeftDetector = 2,
      eStopped = 3,
      eDecayedInCalorimeter = 4
    };

  public:

    // no arg ctor
    Trajectory();

    // create from track
    Trajectory(const G4Track *aTrack);

    // copy ctor from trajectory
    Trajectory(Trajectory &);

    virtual ~Trajectory();

  public:

    virtual void DrawTrajectory(G4int i_mode) const
    {
      G4VTrajectory::DrawTrajectory( i_mode );
    }

    // static string of final status
    static const std::string& getFinalStatusString(EFinalStatus fs);

    // non-static version
    const std::string& getFinalStatusString() const
    {
      return Trajectory::getFinalStatusString( m_finalStatus );
    }

    // new op
    inline void* operator new(size_t);

    // del op
    inline void operator delete(void*);

    inline int operator == (const Trajectory& right) const
    {
      return (this==&right);
    }

    inline G4int GetTrackID() const
    {
      return m_trackID;
    }

    inline G4int GetParentID() const
    {
      return m_parentID;
    }

    inline G4String GetParticleName() const
    {
      return m_particleName;
    }

    inline G4double GetCharge() const
    {
      return m_PDGCharge;
    }

    inline G4int GetPDGEncoding() const
    {
      return m_PDGEncoding;
    }

    inline G4ThreeVector GetInitialMomentum() const
    {
      return m_initialMomentum;
    }

    inline const G4ParticleDefinition* GetParticleDefinition()
    {
      return m_particleDefinition;
    }

    inline G4double GetGlobalTime()
    {
      return m_globalTime;
    }

    // has endpoint daughters
    inline G4bool getHasEndpointDaughters() const
    {
      return m_hasEndpointDaughters;
    }

    inline void setHasEndpointDaughters(G4bool d)
    {
      m_hasEndpointDaughters = d;
    }

    // backscatter
    inline G4bool getBackscatter() const
    {
      return m_backscatter;
    }

    inline void setBackscatter(G4bool b)
    {
      m_backscatter = b;
    }

    // vertexIsNotEndpointOfParent
    inline G4bool getVertexIsNotEndpointOfParent() const
    {
      return m_vertexIsNotEndpointOfParent;
    }

    inline void setVertexIsNotEndpointOfParent(G4bool = true)
    {
      m_vertexIsNotEndpointOfParent = true;
    }

    // final status
    inline void setFinalStatus(EFinalStatus fstatus)
    {
      m_finalStatus = fstatus;
    }

    inline EFinalStatus getFinalStatus() const
    {
      return m_finalStatus;
    }

    // createdInSimulation
    inline void setCreatedInSimulation(G4bool c)
    {
      m_createdInSimulation = c;
    }

    inline G4bool getCreatedInSimulation() const
    {
      return m_createdInSimulation;
    }

    // set additional info from track
    void setupManuallyFromTrack(const G4Track* aTrack);

    inline void setEndpointEnergy(G4double e)
    {
      m_endpointEnergy = e;
    }

    G4double getEndPointEnergy()
    {
      return m_endpointEnergy;
    }

  public:
    virtual void AppendStep(const G4Step *aStep);
    virtual void MergeTrajectory(G4VTrajectory *secondTrajectory);

    virtual G4int GetPointEntries() const { return m_posRecord->size(); }
    virtual G4VTrajectoryPoint* GetPoint(G4int i) const {return (*m_posRecord)[i]; }

  private:

    // track info
    G4ParticleDefinition* m_particleDefinition;
    G4String m_particleName;
    G4double m_PDGCharge;
    G4int m_PDGEncoding;
    G4int m_trackID;
    G4int m_parentID;
    TrajectoryPointContainer* m_posRecord;
    G4ThreeVector m_initialMomentum;
    G4double m_globalTime;
    G4double m_endpointEnergy;

    // non-exclusive sim statuses
    G4bool m_createdInSimulation;
    G4bool m_hasEndpointDaughters;
    G4bool m_backscatter;
    G4bool m_vertexIsNotEndpointOfParent;

    // mutually exclusive final states: see enums
    EFinalStatus m_finalStatus;
  };

  extern G4Allocator<Trajectory> TrajectoryAllocator;

  inline void* Trajectory::operator new(size_t)
  {
    void *aTrajectory;
    aTrajectory = (void*) TrajectoryAllocator.MallocSingle();
    return aTrajectory;
  }

  inline void Trajectory::operator delete(void* aTrajectory)
  {
    TrajectoryAllocator.FreeSingle( ( Trajectory* ) aTrajectory );
  }
}

#endif

---