#include <LXeTrajectory.hh>

Inheritance diagram for LXeTrajectory:

Collaboration diagram for LXeTrajectory:

Public Member Functions
	LXeTrajectory ()

	LXeTrajectory (const G4Track *aTrack)

	LXeTrajectory (LXeTrajectory &)

virtual	~LXeTrajectory ()

virtual void	DrawTrajectory () const

void *	operator new (size_t)

void	operator delete (void *)

void	SetDrawTrajectory (G4bool b)

void	WLS ()

void	SetForceDrawTrajectory (G4bool b)

void	SetForceNoDrawTrajectory (G4bool b)

Public Member Functions inherited from G4Trajectory
	G4Trajectory ()

	G4Trajectory (const G4Track *aTrack)

	G4Trajectory (G4Trajectory &)

virtual	~G4Trajectory ()

void *	operator new (size_t)

void	operator delete (void *)

int	operator== (const G4Trajectory &right) const

G4int	GetTrackID () const

G4int	GetParentID () const

G4String	GetParticleName () const

G4double	GetCharge () const

G4int	GetPDGEncoding () const

G4double	GetInitialKineticEnergy () const

G4ThreeVector	GetInitialMomentum () const

virtual void	ShowTrajectory (std::ostream &os=G4cout) const

virtual void	AppendStep (const G4Step *aStep)

virtual int	GetPointEntries () const

virtual G4VTrajectoryPoint *	GetPoint (G4int i) const

virtual void	MergeTrajectory (G4VTrajectory *secondTrajectory)

G4ParticleDefinition *	GetParticleDefinition ()

virtual const std::map < G4String, G4AttDef > *	GetAttDefs () const

virtual std::vector< G4AttValue > *	CreateAttValues () const

Public Member Functions inherited from G4VTrajectory
	G4VTrajectory ()

virtual	~G4VTrajectory ()

G4bool	operator== (const G4VTrajectory &right) const

Detailed Description

Definition at line 45 of file LXeTrajectory.hh.

Constructor & Destructor Documentation

LXeTrajectory::LXeTrajectory ( )

Definition at line 49 of file LXeTrajectory.cc.

   :G4Trajectory(),fWls(false),fDrawit(false),fForceNoDraw(false),fForceDraw(false)
 {
   fParticleDefinition=0;
 }

LXeTrajectory::LXeTrajectory ( const G4Track * aTrack )

Definition at line 57 of file LXeTrajectory.cc.

   :G4Trajectory(aTrack),fWls(false),fDrawit(false)
 {
   fParticleDefinition=aTrack->GetDefinition();
 }

Here is the call graph for this function:

LXeTrajectory::LXeTrajectory ( LXeTrajectory & right )

Definition at line 65 of file LXeTrajectory.cc.

   :G4Trajectory(right),fWls(right.fWls),fDrawit(right.fDrawit)
 {
   fParticleDefinition=right.fParticleDefinition;
 }

LXeTrajectory::~LXeTrajectory ( )

virtual

Definition at line 73 of file LXeTrajectory.cc.

73 {}

Member Function Documentation

void LXeTrajectory::DrawTrajectory ( ) const

virtual

Reimplemented from G4Trajectory.

Definition at line 77 of file LXeTrajectory.cc.

 {
   // i_mode is no longer available as an argument of G4VTrajectory.
   // In this exampple it was always called with an argument of 50.
   const G4int i_mode = 50;
   // Consider using commands /vis/modeling/trajectories.
   
   //Taken from G4VTrajectory and modified to select colours based on particle
   //type and to selectively eliminate drawing of certain trajectories.
 
   if(!fForceDraw && (!fDrawit || fForceNoDraw))
     return;
 
   // If i_mode>=0, draws a trajectory as a polyline and, if i_mode!=0,
   // adds markers - yellow circles for step points and magenta squares
   // for auxiliary points, if any - whose screen size in pixels is
   // given by std::abs(i_mode)/1000.  E.g: i_mode = 5000 gives easily
   // visible markers.
  
   G4VVisManager* pVVisManager = G4VVisManager::GetConcreteInstance();
   if (!pVVisManager) return;
  
   const G4double markerSize = std::abs(i_mode)/1000;
   G4bool lineRequired (i_mode >= 0);
   G4bool markersRequired (markerSize > 0.);
  
   G4Polyline trajectoryLine;
   G4Polymarker stepPoints;
   G4Polymarker auxiliaryPoints;
  
   for (G4int i = 0; i < GetPointEntries() ; i++) {
     G4VTrajectoryPoint* aTrajectoryPoint = GetPoint(i);
     const std::vector<G4ThreeVector>* auxiliaries
       = aTrajectoryPoint->GetAuxiliaryPoints();
     if (auxiliaries) {
       for (size_t iAux = 0; iAux < auxiliaries->size(); ++iAux) {
         const G4ThreeVector pos((*auxiliaries)[iAux]);
         if (lineRequired) {
           trajectoryLine.push_back(pos);
         }
         if (markersRequired) {
           auxiliaryPoints.push_back(pos);
         }
       }
     }
     const G4ThreeVector pos(aTrajectoryPoint->GetPosition());
     if (lineRequired) {
       trajectoryLine.push_back(pos);
     }
     if (markersRequired) {
       stepPoints.push_back(pos);
     }
   }
  
   if (lineRequired) {
     G4Colour colour;
  
     if(fParticleDefinition==G4OpticalPhoton::OpticalPhotonDefinition()){
       if(fWls) //WLS photons are red
         colour = G4Colour(1.,0.,0.);
       else{ //Scintillation and Cerenkov photons are green
         colour = G4Colour(0.,1.,0.);
       }
     }
     else //All other particles are blue
       colour = G4Colour(0.,0.,1.);
  
     G4VisAttributes trajectoryLineAttribs(colour);
     trajectoryLine.SetVisAttributes(&trajectoryLineAttribs);
     pVVisManager->Draw(trajectoryLine);
   }
   if (markersRequired) {
     auxiliaryPoints.SetMarkerType(G4Polymarker::squares);
     auxiliaryPoints.SetScreenSize(markerSize);
     auxiliaryPoints.SetFillStyle(G4VMarker::filled);
     G4VisAttributes auxiliaryPointsAttribs(G4Colour(0.,1.,1.));  // Magenta
     auxiliaryPoints.SetVisAttributes(&auxiliaryPointsAttribs);
     pVVisManager->Draw(auxiliaryPoints);
 
     stepPoints.SetMarkerType(G4Polymarker::circles);
     stepPoints.SetScreenSize(markerSize);
     stepPoints.SetFillStyle(G4VMarker::filled);
     G4VisAttributes stepPointsAttribs(G4Colour(1.,1.,0.));  // Yellow
     stepPoints.SetVisAttributes(&stepPointsAttribs);
     pVVisManager->Draw(stepPoints);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void LXeTrajectory::operator delete ( void * aTrajectory )

inline

Definition at line 82 of file LXeTrajectory.hh.

 {
   LXeTrajectoryAllocator->FreeSingle((LXeTrajectory*)aTrajectory);
 }

void * LXeTrajectory::operator new ( size_t )

inline

Definition at line 75 of file LXeTrajectory.hh.

 {
   if(!LXeTrajectoryAllocator)
       LXeTrajectoryAllocator = new G4Allocator<LXeTrajectory>;
   return (void*)LXeTrajectoryAllocator->MallocSingle();
 }