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 *)
G4VTrajectory *	CloneForMaster () const override
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
void	MergeTrajectory (G4VTrajectory *secondTrajectory) override
G4int	GetPointEntries () const override
G4VTrajectoryPoint *	GetPoint (G4int i) const 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

Friends
class	G4ClonedRichTrajectory

Detailed Description

Definition at line 70 of file G4RichTrajectory.hh.

Constructor & Destructor Documentation

G4RichTrajectory() [1/3]

G4RichTrajectory::G4RichTrajectory ( )

default

Referenced by G4RichTrajectory(), G4RichTrajectory(), MergeTrajectory(), operator delete(), operator=(), and operator==().

G4RichTrajectory() [2/3]

G4RichTrajectory::G4RichTrajectory

(

const G4Track *

aTrack

)

Definition at line 69 of file G4RichTrajectory.cc.

{
  G4ParticleDefinition* fpParticleDefinition = aTrack->GetDefinition();
  ParticleName = fpParticleDefinition->GetParticleName();
  PDGCharge = fpParticleDefinition->GetPDGCharge();
  PDGEncoding = fpParticleDefinition->GetPDGEncoding();
  fTrackID = aTrack->GetTrackID();
  fParentID = aTrack->GetParentID();
  initialKineticEnergy = aTrack->GetKineticEnergy();
  initialMomentum = aTrack->GetMomentum();
  positionRecord = new G4TrajectoryPointContainer();
 
  // Following is for the first trajectory point
  positionRecord->push_back(new G4RichTrajectoryPoint(aTrack));
 
  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)...
  //
  fpRichPointContainer = new G4TrajectoryPointContainer;
  fpRichPointContainer->push_back(new G4RichTrajectoryPoint(aTrack));
}

~G4RichTrajectory()

G4RichTrajectory::~G4RichTrajectory ( )

override

Definition at line 134 of file G4RichTrajectory.cc.

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

G4RichTrajectory() [3/3]

G4RichTrajectory::G4RichTrajectory

(

G4RichTrajectory &

right

)

Definition at line 103 of file G4RichTrajectory.cc.

{
  ParticleName = right.ParticleName;
  PDGCharge = right.PDGCharge;
  PDGEncoding = right.PDGEncoding;
  fTrackID = right.fTrackID;
  fParentID = right.fParentID;
  initialKineticEnergy = right.initialKineticEnergy;
  initialMomentum = right.initialMomentum;
  positionRecord = new G4TrajectoryPointContainer();
 
  for (auto& i : *right.positionRecord) {
    auto rightPoint = (G4RichTrajectoryPoint*)i;
    positionRecord->push_back(new G4RichTrajectoryPoint(*rightPoint));
  }
 
  fpInitialVolume = right.fpInitialVolume;
  fpInitialNextVolume = right.fpInitialNextVolume;
  fpCreatorProcess = right.fpCreatorProcess;
  fCreatorModelID = right.fCreatorModelID;
  fpFinalVolume = right.fpFinalVolume;
  fpFinalNextVolume = right.fpFinalNextVolume;
  fpEndingProcess = right.fpEndingProcess;
  fFinalKineticEnergy = right.fFinalKineticEnergy;
  fpRichPointContainer = new G4TrajectoryPointContainer;
  for (auto& i : *right.fpRichPointContainer) {
    auto rightPoint = (G4RichTrajectoryPoint*)i;
    fpRichPointContainer->push_back(new G4RichTrajectoryPoint(*rightPoint));
  }
}

Member Function Documentation

AppendStep()

void G4RichTrajectory::AppendStep ( const G4Step * aStep )

overridevirtual

Implements G4VTrajectory.

Definition at line 145 of file G4RichTrajectory.cc.

{
  fpRichPointContainer->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();
  }
}

CloneForMaster()

G4VTrajectory * G4RichTrajectory::CloneForMaster ( ) const

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 360 of file G4RichTrajectory.cc.

{
  G4AutoLock lock(&CloneRichTrajectoryMutex);
  auto* cloned = new G4ClonedRichTrajectory(*this);
  return cloned;
}

CreateAttValues()

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

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 278 of file G4RichTrajectory.cc.

{
  // Create base class att values...
  //std::vector<G4AttValue>* values = G4VTrajectory::CreateAttValues();
  auto values = new std::vector<G4AttValue>;
  values->push_back(G4AttValue("ID", G4UIcommand::ConvertToString(fTrackID), ""));
  values->push_back(G4AttValue("PID", G4UIcommand::ConvertToString(fParentID), ""));
  values->push_back(G4AttValue("PN", ParticleName, ""));
  values->push_back(G4AttValue("Ch", G4UIcommand::ConvertToString(PDGCharge), ""));
  values->push_back(G4AttValue("PDG", G4UIcommand::ConvertToString(PDGEncoding), ""));
  values->push_back(G4AttValue("IKE", G4BestUnit(initialKineticEnergy, "Energy"), ""));
  values->push_back(G4AttValue("IMom", G4BestUnit(initialMomentum, "Energy"), ""));
  values->push_back(G4AttValue("IMag", G4BestUnit(initialMomentum.mag(), "Energy"), ""));
  values->push_back(G4AttValue("NTP", G4UIcommand::ConvertToString(GetPointEntries()), ""));
 
  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 187 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 196 of file G4RichTrajectory.cc.

{
  G4bool isNew;
  std::map<G4String, G4AttDef>* store = G4AttDefStore::GetInstance("G4RichTrajectory", isNew);
  if (isNew) {
    G4String ID;
 
    ID = "ID";
    (*store)[ID] = G4AttDef(ID, "Track ID", "Physics", "", "G4int");
 
    ID = "PID";
    (*store)[ID] = G4AttDef(ID, "Parent ID", "Physics", "", "G4int");
 
    ID = "PN";
    (*store)[ID] = G4AttDef(ID, "Particle Name", "Physics", "", "G4String");
 
    ID = "Ch";
    (*store)[ID] = G4AttDef(ID, "Charge", "Physics", "e+", "G4double");
 
    ID = "PDG";
    (*store)[ID] = G4AttDef(ID, "PDG Encoding", "Physics", "", "G4int");
 
    ID = "IKE";
    (*store)[ID] = G4AttDef(ID, "Initial kinetic energy", "Physics", "G4BestUnit", "G4double");
 
    ID = "IMom";
    (*store)[ID] = G4AttDef(ID, "Initial momentum", "Physics", "G4BestUnit", "G4ThreeVector");
 
    ID = "IMag";
    (*store)[ID] = G4AttDef(ID, "Initial momentum magnitude", "Physics", "G4BestUnit", "G4double");
 
    ID = "NTP";
    (*store)[ID] = G4AttDef(ID, "No. of points", "Physics", "", "G4int");
 
    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().

GetCharge()

G4double G4RichTrajectory::GetCharge ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 100 of file G4RichTrajectory.hh.

{ return PDGCharge; }

GetInitialKineticEnergy()

G4double G4RichTrajectory::GetInitialKineticEnergy ( ) const

inline

Definition at line 102 of file G4RichTrajectory.hh.

{ return initialKineticEnergy; }

GetInitialMomentum()

G4ThreeVector G4RichTrajectory::GetInitialMomentum ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 103 of file G4RichTrajectory.hh.

{ return initialMomentum; }

GetParentID()

G4int G4RichTrajectory::GetParentID ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 98 of file G4RichTrajectory.hh.

{ return fParentID; }

GetParticleDefinition()

G4ParticleDefinition * G4RichTrajectory::GetParticleDefinition

(

)

Definition at line 355 of file G4RichTrajectory.cc.

{
  return (G4ParticleTable::GetParticleTable()->FindParticle(ParticleName));
}

GetParticleName()

G4String G4RichTrajectory::GetParticleName ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 99 of file G4RichTrajectory.hh.

{ return ParticleName; }

GetPDGEncoding()

G4int G4RichTrajectory::GetPDGEncoding ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 101 of file G4RichTrajectory.hh.

{ return PDGEncoding; }

GetPoint()

G4VTrajectoryPoint * G4RichTrajectory::GetPoint ( G4int i ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 164 of file G4RichTrajectory.hh.

{
  return (*fpRichPointContainer)[i];
}

GetPointEntries()

G4int G4RichTrajectory::GetPointEntries ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 159 of file G4RichTrajectory.hh.

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

Referenced by CreateAttValues().

GetTrackID()

G4int G4RichTrajectory::GetTrackID ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 97 of file G4RichTrajectory.hh.

{ return fTrackID; }

MergeTrajectory()

void G4RichTrajectory::MergeTrajectory ( G4VTrajectory * secondTrajectory )

overridevirtual

Implements G4VTrajectory.

Definition at line 163 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
    //
    fpRichPointContainer->push_back((*(seco->fpRichPointContainer))[i]);
  }
  delete (*seco->fpRichPointContainer)[0];
  seco->fpRichPointContainer->clear();
}

operator delete()

void G4RichTrajectory::operator delete ( void * aRichTrajectory )

inline

Definition at line 154 of file G4RichTrajectory.hh.

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

operator new()

void * G4RichTrajectory::operator new ( size_t )

inline

Definition at line 146 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 87 of file G4RichTrajectory.hh.

{ return (this == &r); }

ShowTrajectory()

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

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 178 of file G4RichTrajectory.cc.

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

Friends And Related Symbol Documentation

G4ClonedRichTrajectory

friend class G4ClonedRichTrajectory

friend

Definition at line 74 of file G4RichTrajectory.hh.

Referenced by CloneForMaster(), and G4ClonedRichTrajectory.

---

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

• G4RichTrajectory.hh
• G4RichTrajectory.cc