G4RichTrajectory Class Reference

#include <G4RichTrajectory.hh>

Inheritance diagram for G4RichTrajectory:

Public Member Functions
	G4RichTrajectory ()=default
	G4RichTrajectory (const G4Track *aTrack)
	~G4RichTrajectory () override
	G4RichTrajectory (G4RichTrajectory &)
G4RichTrajectory &	operator= (const G4RichTrajectory &)=delete
G4bool	operator== (const G4RichTrajectory &r) const
void *	operator new (size_t)
void	operator delete (void *)
void	ShowTrajectory (std::ostream &os=G4cout) const override
void	DrawTrajectory () const override
void	AppendStep (const G4Step *aStep) override
void	MergeTrajectory (G4VTrajectory *secondTrajectory) override
G4int	GetPointEntries () const override
G4VTrajectoryPoint *	GetPoint (G4int i) const override
const std::map< G4String, G4AttDef > *	GetAttDefs () const override
std::vector< G4AttValue > *	CreateAttValues () const override
Public Member Functions inherited from G4Trajectory
	G4Trajectory ()=default
	G4Trajectory (const G4Track *aTrack)
	G4Trajectory (G4Trajectory &)
	~G4Trajectory () override
void *	operator new (size_t)
void	operator delete (void *)
G4bool	operator== (const G4Trajectory &r) const
G4int	GetTrackID () const override
G4int	GetParentID () const override
G4String	GetParticleName () const override
G4double	GetCharge () const override
G4int	GetPDGEncoding () const override
G4double	GetInitialKineticEnergy () const
G4ThreeVector	GetInitialMomentum () const override
void	ShowTrajectory (std::ostream &os=G4cout) const override
void	DrawTrajectory () const override
void	AppendStep (const G4Step *aStep) override
G4int	GetPointEntries () const override
G4VTrajectoryPoint *	GetPoint (G4int i) const override
void	MergeTrajectory (G4VTrajectory *secondTrajectory) override
G4ParticleDefinition *	GetParticleDefinition ()
const std::map< G4String, G4AttDef > *	GetAttDefs () const override
std::vector< G4AttValue > *	CreateAttValues () const override
Public Member Functions inherited from G4VTrajectory
	G4VTrajectory ()=default
virtual	~G4VTrajectory ()=default
G4bool	operator== (const G4VTrajectory &right) const

Detailed Description

Definition at line 58 of file G4RichTrajectory.hh.

Constructor & Destructor Documentation

G4RichTrajectory() [1/3]

G4RichTrajectory::G4RichTrajectory ( )

default

G4RichTrajectory() [2/3]

G4RichTrajectory::G4RichTrajectory

(

const G4Track *

aTrack

)

Definition at line 63 of file G4RichTrajectory.cc.

  : G4Trajectory(aTrack)  // Note: this initialises the base class data
                          // members and, unfortunately but never mind,
                          // creates a G4TrajectoryPoint in
                          // TrajectoryPointContainer that we cannot
                          // access because it's private.  We store the
                          // same information (plus more) in a
                          // G4RichTrajectoryPoint in the
                          // RichTrajectoryPointsContainer
{
  fpInitialVolume = aTrack->GetTouchableHandle();
  fpInitialNextVolume = aTrack->GetNextTouchableHandle();
  fpCreatorProcess = aTrack->GetCreatorProcess();
  fCreatorModelID = aTrack->GetCreatorModelID();
 
  // On construction, set final values to initial values.
  // Final values are updated at the addition of every step - see AppendStep.
  //
  fpFinalVolume = aTrack->GetTouchableHandle();
  fpFinalNextVolume = aTrack->GetNextTouchableHandle();
  fpEndingProcess = aTrack->GetCreatorProcess();
  fFinalKineticEnergy = aTrack->GetKineticEnergy();
 
  // Insert the first rich trajectory point (see note above)...
  //
  fpRichPointsContainer = new RichTrajectoryPointsContainer;
  fpRichPointsContainer->push_back(new G4RichTrajectoryPoint(aTrack));
}

~G4RichTrajectory()

G4RichTrajectory::~G4RichTrajectory ( )

override

Definition at line 109 of file G4RichTrajectory.cc.

{
  if (fpRichPointsContainer != nullptr) {
    for (auto& i : *fpRichPointsContainer) {
      delete i;
    }
    fpRichPointsContainer->clear();
    delete fpRichPointsContainer;
  }
}

G4RichTrajectory() [3/3]

G4RichTrajectory::G4RichTrajectory

(

G4RichTrajectory &

right

)

Definition at line 92 of file G4RichTrajectory.cc.

                                                          : G4Trajectory(right)
{
  fpInitialVolume = right.fpInitialVolume;
  fpInitialNextVolume = right.fpInitialNextVolume;
  fpCreatorProcess = right.fpCreatorProcess;
  fCreatorModelID = right.fCreatorModelID;
  fpFinalVolume = right.fpFinalVolume;
  fpFinalNextVolume = right.fpFinalNextVolume;
  fpEndingProcess = right.fpEndingProcess;
  fFinalKineticEnergy = right.fFinalKineticEnergy;
  fpRichPointsContainer = new RichTrajectoryPointsContainer;
  for (auto& i : *right.fpRichPointsContainer) {
    auto rightPoint = (G4RichTrajectoryPoint*)i;
    fpRichPointsContainer->push_back(new G4RichTrajectoryPoint(*rightPoint));
  }
}

Member Function Documentation

AppendStep()

void G4RichTrajectory::AppendStep ( const G4Step * aStep )

overridevirtual

Implements G4VTrajectory.

Definition at line 120 of file G4RichTrajectory.cc.

{
  fpRichPointsContainer->push_back(new G4RichTrajectoryPoint(aStep));
 
  // Except for first step, which is a sort of virtual step to start
  // the track, compute the final values...
  //
  const G4Track* track = aStep->GetTrack();
  const G4StepPoint* postStepPoint = aStep->GetPostStepPoint();
  if (track->GetCurrentStepNumber() > 0) {
    fpFinalVolume = track->GetTouchableHandle();
    fpFinalNextVolume = track->GetNextTouchableHandle();
    fpEndingProcess = postStepPoint->GetProcessDefinedStep();
    fFinalKineticEnergy =
      aStep->GetPreStepPoint()->GetKineticEnergy() - aStep->GetTotalEnergyDeposit();
  }
}

CreateAttValues()

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

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 230 of file G4RichTrajectory.cc.

{
  // Create base class att values...
  std::vector<G4AttValue>* values = G4Trajectory::CreateAttValues();
 
  if (fpInitialVolume && (fpInitialVolume->GetVolume() != nullptr)) {
    values->push_back(G4AttValue("IVPath", Path(fpInitialVolume), ""));
  }
  else {
    values->push_back(G4AttValue("IVPath", "None", ""));
  }
 
  if (fpInitialNextVolume && (fpInitialNextVolume->GetVolume() != nullptr)) {
    values->push_back(G4AttValue("INVPath", Path(fpInitialNextVolume), ""));
  }
  else {
    values->push_back(G4AttValue("INVPath", "None", ""));
  }
 
  if (fpCreatorProcess != nullptr) {
    values->push_back(G4AttValue("CPN", fpCreatorProcess->GetProcessName(), ""));
    G4ProcessType type = fpCreatorProcess->GetProcessType();
    values->push_back(G4AttValue("CPTN", G4VProcess::GetProcessTypeName(type), ""));
    values->push_back(G4AttValue("CMID", G4UIcommand::ConvertToString(fCreatorModelID), ""));
    const G4String& creatorModelName = G4PhysicsModelCatalog::GetModelNameFromID(fCreatorModelID);
    values->push_back(G4AttValue("CMN", creatorModelName, ""));
  }
  else {
    values->push_back(G4AttValue("CPN", "None", ""));
    values->push_back(G4AttValue("CPTN", "None", ""));
    values->push_back(G4AttValue("CMID", "None", ""));
    values->push_back(G4AttValue("CMN", "None", ""));
  }
 
  if (fpFinalVolume && (fpFinalVolume->GetVolume() != nullptr)) {
    values->push_back(G4AttValue("FVPath", Path(fpFinalVolume), ""));
  }
  else {
    values->push_back(G4AttValue("FVPath", "None", ""));
  }
 
  if (fpFinalNextVolume && (fpFinalNextVolume->GetVolume() != nullptr)) {
    values->push_back(G4AttValue("FNVPath", Path(fpFinalNextVolume), ""));
  }
  else {
    values->push_back(G4AttValue("FNVPath", "None", ""));
  }
 
  if (fpEndingProcess != nullptr) {
    values->push_back(G4AttValue("EPN", fpEndingProcess->GetProcessName(), ""));
    G4ProcessType type = fpEndingProcess->GetProcessType();
    values->push_back(G4AttValue("EPTN", G4VProcess::GetProcessTypeName(type), ""));
  }
  else {
    values->push_back(G4AttValue("EPN", "None", ""));
    values->push_back(G4AttValue("EPTN", "None", ""));
  }
 
  values->push_back(G4AttValue("FKE", G4BestUnit(fFinalKineticEnergy, "Energy"), ""));
 
#ifdef G4ATTDEBUG
  G4cout << G4AttCheck(values, GetAttDefs());
#endif
 
  return values;
}

DrawTrajectory()

void G4RichTrajectory::DrawTrajectory ( ) const

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 162 of file G4RichTrajectory.cc.

{
  // Invoke the default implementation in G4VTrajectory...
  //
  G4VTrajectory::DrawTrajectory();
 
  // ... or override with your own code here.
}

GetAttDefs()

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

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 171 of file G4RichTrajectory.cc.

{
  G4bool isNew;
  std::map<G4String, G4AttDef>* store = G4AttDefStore::GetInstance("G4RichTrajectory", isNew);
  if (isNew) {
    // Get att defs from base class...
    //
    *store = *(G4Trajectory::GetAttDefs());
 
    G4String ID;
 
    ID = "IVPath";
    (*store)[ID] = G4AttDef(ID, "Initial Volume Path", "Physics", "", "G4String");
 
    ID = "INVPath";
    (*store)[ID] = G4AttDef(ID, "Initial Next Volume Path", "Physics", "", "G4String");
 
    ID = "CPN";
    (*store)[ID] = G4AttDef(ID, "Creator Process Name", "Physics", "", "G4String");
 
    ID = "CPTN";
    (*store)[ID] = G4AttDef(ID, "Creator Process Type Name", "Physics", "", "G4String");
 
    ID = "CMID";
    (*store)[ID] = G4AttDef(ID, "Creator Model ID", "Physics", "", "G4int");
 
    ID = "CMN";
    (*store)[ID] = G4AttDef(ID, "Creator Model Name", "Physics", "", "G4String");
 
    ID = "FVPath";
    (*store)[ID] = G4AttDef(ID, "Final Volume Path", "Physics", "", "G4String");
 
    ID = "FNVPath";
    (*store)[ID] = G4AttDef(ID, "Final Next Volume Path", "Physics", "", "G4String");
 
    ID = "EPN";
    (*store)[ID] = G4AttDef(ID, "Ending Process Name", "Physics", "", "G4String");
 
    ID = "EPTN";
    (*store)[ID] = G4AttDef(ID, "Ending Process Type Name", "Physics", "", "G4String");
 
    ID = "FKE";
    (*store)[ID] = G4AttDef(ID, "Final kinetic energy", "Physics", "G4BestUnit", "G4double");
  }
 
  return store;
}

Referenced by CreateAttValues(), G4VisCommandList::SetNewValue(), and G4VisCommandSceneAddTrajectories::SetNewValue().

GetPoint()

G4VTrajectoryPoint * G4RichTrajectory::GetPoint ( G4int i ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 126 of file G4RichTrajectory.hh.

{
  return (*fpRichPointsContainer)[i];
}

Referenced by G4TrajectoryDrawByEncounteredVolume::Draw(), and G4TrajectoryEncounteredVolumeFilter::Evaluate().

GetPointEntries()

G4int G4RichTrajectory::GetPointEntries ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 121 of file G4RichTrajectory.hh.

{
  return G4int(fpRichPointsContainer->size());
}

Referenced by G4TrajectoryDrawByEncounteredVolume::Draw(), and G4TrajectoryEncounteredVolumeFilter::Evaluate().

MergeTrajectory()

void G4RichTrajectory::MergeTrajectory ( G4VTrajectory * secondTrajectory )

overridevirtual

Implements G4VTrajectory.

Definition at line 138 of file G4RichTrajectory.cc.

{
  if (secondTrajectory == nullptr) return;
 
  auto seco = (G4RichTrajectory*)secondTrajectory;
  G4int ent = seco->GetPointEntries();
  for (G4int i = 1; i < ent; ++i) {
    // initial point of the second trajectory should not be merged
    //
    fpRichPointsContainer->push_back((*(seco->fpRichPointsContainer))[i]);
  }
  delete (*seco->fpRichPointsContainer)[0];
  seco->fpRichPointsContainer->clear();
}

operator delete()

void G4RichTrajectory::operator delete ( void * aRichTrajectory )

inline

Definition at line 116 of file G4RichTrajectory.hh.

{
  aRichTrajectoryAllocator()->FreeSingle((G4RichTrajectory*)aRichTrajectory);
}

operator new()

void * G4RichTrajectory::operator new ( size_t )

inline

Definition at line 108 of file G4RichTrajectory.hh.

{
  if (aRichTrajectoryAllocator() == nullptr) {
    aRichTrajectoryAllocator() = new G4Allocator<G4RichTrajectory>;
  }
  return (void*)aRichTrajectoryAllocator()->MallocSingle();
}

operator=()

G4RichTrajectory & G4RichTrajectory::operator= ( const G4RichTrajectory & )

delete

operator==()

G4bool G4RichTrajectory::operator== ( const G4RichTrajectory & r ) const

inline

Definition at line 73 of file G4RichTrajectory.hh.

{ return (this == &r); }

ShowTrajectory()

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

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 153 of file G4RichTrajectory.cc.

{
  // Invoke the default implementation in G4VTrajectory...
  //
  G4VTrajectory::ShowTrajectory(os);
 
  // ... or override with your own code here.
}

---

The documentation for this class was generated from the following files:

• G4RichTrajectory.hh
• G4RichTrajectory.cc