G4ClonedRichTrajectory Class Reference

#include <G4ClonedRichTrajectory.hh>

Inheritance diagram for G4ClonedRichTrajectory:

Public Member Functions
	G4ClonedRichTrajectory ()=default
	~G4ClonedRichTrajectory () override
	G4ClonedRichTrajectory (const G4RichTrajectory &)
G4ClonedRichTrajectory &	operator= (const G4ClonedRichTrajectory &)=delete
G4bool	operator== (const G4ClonedRichTrajectory &r) const
void *	operator new (size_t)
void	operator delete (void *)
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
virtual G4VTrajectory *	CloneForMaster () const

Detailed Description

Definition at line 58 of file G4ClonedRichTrajectory.hh.

Constructor & Destructor Documentation

G4ClonedRichTrajectory() [1/2]

G4ClonedRichTrajectory::G4ClonedRichTrajectory ( )

default

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

~G4ClonedRichTrajectory()

G4ClonedRichTrajectory::~G4ClonedRichTrajectory ( )

override

Definition at line 89 of file G4ClonedRichTrajectory.cc.

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

G4ClonedRichTrajectory() [2/2]

G4ClonedRichTrajectory::G4ClonedRichTrajectory

(

const G4RichTrajectory &

right

)

Definition at line 57 of file G4ClonedRichTrajectory.cc.

{
  ParticleName = right.ParticleName;
  PDGCharge = right.PDGCharge;
  PDGEncoding = right.PDGEncoding;
  fTrackID = right.fTrackID;
  fParentID = right.fParentID;
  initialKineticEnergy = right.initialKineticEnergy;
  initialMomentum = right.initialMomentum;
  //positionRecord = new G4ClonedTrajectoryPointContainer();
  //for (auto& i : *right.positionRecord) {
  //  auto rightPoint = (G4ClonedTrajectoryPoint*)i;
  //  positionRecord->push_back(new G4ClonedTrajectoryPoint(*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;
  if(right.fpRichPointContainer!=nullptr && right.fpRichPointContainer->size()>0)
  {
    fpRichPointContainer = new G4TrajectoryPointContainer;
    for (auto& i : *right.fpRichPointContainer) {
      auto rightPoint = (G4RichTrajectoryPoint*)i;
      fpRichPointContainer->push_back(new G4ClonedRichTrajectoryPoint(*rightPoint));
    }
  }
}

Member Function Documentation

AppendStep()

void G4ClonedRichTrajectory::AppendStep ( const G4Step * aStep )

overridevirtual

Implements G4VTrajectory.

Definition at line 100 of file G4ClonedRichTrajectory.cc.

{
  fpRichPointContainer->push_back(new G4ClonedRichTrajectoryPoint(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 > * G4ClonedRichTrajectory::CreateAttValues ( ) const

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 233 of file G4ClonedRichTrajectory.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 G4ClonedRichTrajectory::DrawTrajectory ( ) const

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 142 of file G4ClonedRichTrajectory.cc.

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

GetAttDefs()

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

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 151 of file G4ClonedRichTrajectory.cc.

{
  G4bool isNew;
  std::map<G4String, G4AttDef>* store = G4AttDefStore::GetInstance("G4ClonedRichTrajectory", 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().

GetCharge()

G4double G4ClonedRichTrajectory::GetCharge ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 82 of file G4ClonedRichTrajectory.hh.

{ return PDGCharge; }

GetInitialKineticEnergy()

G4double G4ClonedRichTrajectory::GetInitialKineticEnergy ( ) const

inline

Definition at line 84 of file G4ClonedRichTrajectory.hh.

{ return initialKineticEnergy; }

GetInitialMomentum()

G4ThreeVector G4ClonedRichTrajectory::GetInitialMomentum ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 85 of file G4ClonedRichTrajectory.hh.

{ return initialMomentum; }

GetParentID()

G4int G4ClonedRichTrajectory::GetParentID ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 80 of file G4ClonedRichTrajectory.hh.

{ return fParentID; }

GetParticleDefinition()

G4ParticleDefinition * G4ClonedRichTrajectory::GetParticleDefinition

(

)

Definition at line 310 of file G4ClonedRichTrajectory.cc.

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

GetParticleName()

G4String G4ClonedRichTrajectory::GetParticleName ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 81 of file G4ClonedRichTrajectory.hh.

{ return ParticleName; }

GetPDGEncoding()

G4int G4ClonedRichTrajectory::GetPDGEncoding ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 83 of file G4ClonedRichTrajectory.hh.

{ return PDGEncoding; }

GetPoint()

G4VTrajectoryPoint * G4ClonedRichTrajectory::GetPoint ( G4int i ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 146 of file G4ClonedRichTrajectory.hh.

{
  return (*fpRichPointContainer)[i];
}

GetPointEntries()

G4int G4ClonedRichTrajectory::GetPointEntries ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 141 of file G4ClonedRichTrajectory.hh.

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

Referenced by CreateAttValues().

GetTrackID()

G4int G4ClonedRichTrajectory::GetTrackID ( ) const

inlineoverridevirtual

Implements G4VTrajectory.

Definition at line 79 of file G4ClonedRichTrajectory.hh.

{ return fTrackID; }

MergeTrajectory()

void G4ClonedRichTrajectory::MergeTrajectory ( G4VTrajectory * secondTrajectory )

overridevirtual

Implements G4VTrajectory.

Definition at line 118 of file G4ClonedRichTrajectory.cc.

{
  if (secondTrajectory == nullptr) return;
 
  auto seco = (G4ClonedRichTrajectory*)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 G4ClonedRichTrajectory::operator delete ( void * aRichTrajectory )

inline

Definition at line 136 of file G4ClonedRichTrajectory.hh.

{
  aClonedRichTrajectoryAllocator()->FreeSingle((G4ClonedRichTrajectory*)aRichTrajectory);
}

operator new()

void * G4ClonedRichTrajectory::operator new ( size_t )

inline

Definition at line 128 of file G4ClonedRichTrajectory.hh.

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

operator=()

G4ClonedRichTrajectory & G4ClonedRichTrajectory::operator= ( const G4ClonedRichTrajectory & )

delete

operator==()

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

inline

Definition at line 72 of file G4ClonedRichTrajectory.hh.

{ return (this == &r); }

ShowTrajectory()

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

overridevirtual

Reimplemented from G4VTrajectory.

Definition at line 133 of file G4ClonedRichTrajectory.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:

• G4ClonedRichTrajectory.hh
• G4ClonedRichTrajectory.cc