G4ClonedRichTrajectoryPoint Class Reference

#include <G4ClonedRichTrajectoryPoint.hh>

Inheritance diagram for G4ClonedRichTrajectoryPoint:

Public Member Functions
	G4ClonedRichTrajectoryPoint ()=default
	G4ClonedRichTrajectoryPoint (const G4Track *)
	G4ClonedRichTrajectoryPoint (const G4Step *)
	G4ClonedRichTrajectoryPoint (const G4RichTrajectoryPoint &right)
	~G4ClonedRichTrajectoryPoint () override
G4ClonedRichTrajectoryPoint &	operator= (const G4ClonedRichTrajectoryPoint &)=delete
G4bool	operator== (const G4ClonedRichTrajectoryPoint &right) const
void *	operator new (size_t)
void	operator delete (void *aRichTrajectoryPoint)
const G4ThreeVector	GetPosition () const override
const std::vector< G4ThreeVector > *	GetAuxiliaryPoints () const override
const std::map< G4String, G4AttDef > *	GetAttDefs () const override
std::vector< G4AttValue > *	CreateAttValues () const override
Public Member Functions inherited from G4VTrajectoryPoint
	G4VTrajectoryPoint ()=default
virtual	~G4VTrajectoryPoint ()=default
G4bool	operator== (const G4VTrajectoryPoint &right) const

Detailed Description

Definition at line 57 of file G4ClonedRichTrajectoryPoint.hh.

Constructor & Destructor Documentation

G4ClonedRichTrajectoryPoint() [1/4]

G4ClonedRichTrajectoryPoint::G4ClonedRichTrajectoryPoint ( )

default

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

G4ClonedRichTrajectoryPoint() [2/4]

G4ClonedRichTrajectoryPoint::G4ClonedRichTrajectoryPoint

(

const G4Track *

aTrack

)

Definition at line 56 of file G4ClonedRichTrajectoryPoint.cc.

  : fPosition(aTrack->GetPosition()),
    fPreStepPointGlobalTime(aTrack->GetGlobalTime()),
    fPostStepPointGlobalTime(aTrack->GetGlobalTime()),
    fpPreStepPointVolume(aTrack->GetTouchableHandle()),
    fpPostStepPointVolume(aTrack->GetNextTouchableHandle()),
    fPreStepPointWeight(aTrack->GetWeight()),
    fPostStepPointWeight(aTrack->GetWeight())
{}

G4ClonedRichTrajectoryPoint() [3/4]

G4ClonedRichTrajectoryPoint::G4ClonedRichTrajectoryPoint

(

const G4Step *

aStep

)

Definition at line 66 of file G4ClonedRichTrajectoryPoint.cc.

  : fPosition(aStep->GetPostStepPoint()->GetPosition()),
    fpAuxiliaryPointVector(aStep->GetPointerToVectorOfAuxiliaryPoints()),
    fTotEDep(aStep->GetTotalEnergyDeposit())
{
  G4StepPoint* preStepPoint = aStep->GetPreStepPoint();
  G4StepPoint* postStepPoint = aStep->GetPostStepPoint();
  if (aStep->GetTrack()->GetCurrentStepNumber() <= 0)  // First step
  {
    fRemainingEnergy = aStep->GetTrack()->GetKineticEnergy();
  }
  else {
    fRemainingEnergy = preStepPoint->GetKineticEnergy() - fTotEDep;
  }
  fpProcess = postStepPoint->GetProcessDefinedStep();
  fPreStepPointStatus = preStepPoint->GetStepStatus();
  fPostStepPointStatus = postStepPoint->GetStepStatus();
  fPreStepPointGlobalTime = preStepPoint->GetGlobalTime();
  fPostStepPointGlobalTime = postStepPoint->GetGlobalTime();
  fpPreStepPointVolume = preStepPoint->GetTouchableHandle();
  fpPostStepPointVolume = postStepPoint->GetTouchableHandle();
  fPreStepPointWeight = preStepPoint->GetWeight();
  fPostStepPointWeight = postStepPoint->GetWeight();
}

G4ClonedRichTrajectoryPoint() [4/4]

G4ClonedRichTrajectoryPoint::G4ClonedRichTrajectoryPoint

(

const G4RichTrajectoryPoint &

right

)

Definition at line 91 of file G4ClonedRichTrajectoryPoint.cc.

{
  fPosition = right.fPosition;
  fTotEDep = right.fTotEDep;
  fRemainingEnergy = right.fRemainingEnergy;
  fpProcess = right.fpProcess;
  fPreStepPointStatus = right.fPreStepPointStatus;
  fPostStepPointStatus = right.fPostStepPointStatus;
  fPreStepPointGlobalTime = right.fPreStepPointGlobalTime;
  fPostStepPointGlobalTime = right.fPostStepPointGlobalTime;
  fpPreStepPointVolume = right.fpPreStepPointVolume;
  fpPostStepPointVolume = right.fpPostStepPointVolume;
  fPreStepPointWeight = right.fPreStepPointWeight;
  fPostStepPointWeight = right.fPostStepPointWeight;
  if(right.fpAuxiliaryPointVector!=nullptr && right.fpAuxiliaryPointVector->size()>0)
  {
    fpAuxiliaryPointVector = new std::vector<G4ThreeVector>;
    for(auto& i : *(right.fpAuxiliaryPointVector))
    { fpAuxiliaryPointVector->push_back(i); }
  }
}

~G4ClonedRichTrajectoryPoint()

G4ClonedRichTrajectoryPoint::~G4ClonedRichTrajectoryPoint ( )

override

Definition at line 113 of file G4ClonedRichTrajectoryPoint.cc.

{ delete fpAuxiliaryPointVector; }

Member Function Documentation

CreateAttValues()

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

overridevirtual

Reimplemented from G4VTrajectoryPoint.

Definition at line 201 of file G4ClonedRichTrajectoryPoint.cc.

{
  // Create base class att values...
 
  auto values = new std::vector<G4AttValue>;
  values->push_back(G4AttValue("Pos", G4BestUnit(fPosition, "Length"), ""));
 
#ifdef G4ATTDEBUG
  G4cout << G4AttCheck(values, GetAttDefs());
#endif
 
  if (fpAuxiliaryPointVector != nullptr) {
    for (const auto& iAux : *fpAuxiliaryPointVector) {
      values->push_back(G4AttValue("Aux", G4BestUnit(iAux, "Length"), ""));
    }
  }
 
  values->push_back(G4AttValue("TED", G4BestUnit(fTotEDep, "Energy"), ""));
  values->push_back(G4AttValue("RE", G4BestUnit(fRemainingEnergy, "Energy"), ""));
 
  if (fpProcess != nullptr) {
    values->push_back(G4AttValue("PDS", fpProcess->GetProcessName(), ""));
    values->push_back(
      G4AttValue("PTDS", G4VProcess::GetProcessTypeName(fpProcess->GetProcessType()), ""));
  }
  else {
    values->push_back(G4AttValue("PDS", "None", ""));
    values->push_back(G4AttValue("PTDS", "None", ""));
  }
 
  values->push_back(G4AttValue("PreStatus", Status(fPreStepPointStatus), ""));
 
  values->push_back(G4AttValue("PostStatus", Status(fPostStepPointStatus), ""));
 
  values->push_back(G4AttValue("PreT", G4BestUnit(fPreStepPointGlobalTime, "Time"), ""));
 
  values->push_back(G4AttValue("PostT", G4BestUnit(fPostStepPointGlobalTime, "Time"), ""));
 
  if (fpPreStepPointVolume && (fpPreStepPointVolume->GetVolume() != nullptr)) {
    values->push_back(G4AttValue("PreVPath", Path(fpPreStepPointVolume), ""));
  }
  else {
    values->push_back(G4AttValue("PreVPath", "None", ""));
  }
 
  if (fpPostStepPointVolume && (fpPostStepPointVolume->GetVolume() != nullptr)) {
    values->push_back(G4AttValue("PostVPath", Path(fpPostStepPointVolume), ""));
  }
  else {
    values->push_back(G4AttValue("PostVPath", "None", ""));
  }
 
  std::ostringstream oss1;
  oss1 << fPreStepPointWeight;
  values->push_back(G4AttValue("PreW", oss1.str(), ""));
 
  std::ostringstream oss2;
  oss2 << fPostStepPointWeight;
  values->push_back(G4AttValue("PostW", oss2.str(), ""));
 
#ifdef G4ATTDEBUG
  G4cout << G4AttCheck(values, GetAttDefs());
#endif
 
  return values;
}

GetAttDefs()

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

overridevirtual

Reimplemented from G4VTrajectoryPoint.

Definition at line 115 of file G4ClonedRichTrajectoryPoint.cc.

{
  G4bool isNew;
  std::map<G4String, G4AttDef>* store = G4AttDefStore::GetInstance("G4RichTrajectoryPoint", isNew);
  if (isNew) {
    G4String ID;
 
    ID = "Pos";
    (*store)[ID] = G4AttDef(ID, "Position", "Physics", "G4BestUnit", "G4ThreeVector");
    ID = "Aux";
    (*store)[ID] =
      G4AttDef(ID, "Auxiliary Point Position", "Physics", "G4BestUnit", "G4ThreeVector");
    ID = "TED";
    (*store)[ID] = G4AttDef(ID, "Total Energy Deposit", "Physics", "G4BestUnit", "G4double");
    ID = "RE";
    (*store)[ID] = G4AttDef(ID, "Remaining Energy", "Physics", "G4BestUnit", "G4double");
    ID = "PDS";
    (*store)[ID] = G4AttDef(ID, "Process Defined Step", "Physics", "", "G4String");
    ID = "PTDS";
    (*store)[ID] = G4AttDef(ID, "Process Type Defined Step", "Physics", "", "G4String");
    ID = "PreStatus";
    (*store)[ID] = G4AttDef(ID, "Pre-step-point status", "Physics", "", "G4String");
    ID = "PostStatus";
    (*store)[ID] = G4AttDef(ID, "Post-step-point status", "Physics", "", "G4String");
    ID = "PreT";
    (*store)[ID] = G4AttDef(ID, "Pre-step-point global time", "Physics", "G4BestUnit", "G4double");
    ID = "PostT";
    (*store)[ID] = G4AttDef(ID, "Post-step-point global time", "Physics", "G4BestUnit", "G4double");
    ID = "PreVPath";
    (*store)[ID] = G4AttDef(ID, "Pre-step Volume Path", "Physics", "", "G4String");
    ID = "PostVPath";
    (*store)[ID] = G4AttDef(ID, "Post-step Volume Path", "Physics", "", "G4String");
    ID = "PreW";
    (*store)[ID] = G4AttDef(ID, "Pre-step-point weight", "Physics", "", "G4double");
    ID = "PostW";
    (*store)[ID] = G4AttDef(ID, "Post-step-point weight", "Physics", "", "G4double");
  }
  return store;
}

Referenced by CreateAttValues().

GetAuxiliaryPoints()

const std::vector< G4ThreeVector > * G4ClonedRichTrajectoryPoint::GetAuxiliaryPoints ( ) const

inlineoverridevirtual

Reimplemented from G4VTrajectoryPoint.

Definition at line 123 of file G4ClonedRichTrajectoryPoint.hh.

{
  return fpAuxiliaryPointVector;
}

GetPosition()

const G4ThreeVector G4ClonedRichTrajectoryPoint::GetPosition ( ) const

inlineoverridevirtual

Implements G4VTrajectoryPoint.

Definition at line 78 of file G4ClonedRichTrajectoryPoint.hh.

{ return fPosition; }

Referenced by G4ClonedRichTrajectoryPoint(), and G4ClonedRichTrajectoryPoint().

operator delete()

void G4ClonedRichTrajectoryPoint::operator delete ( void * aRichTrajectoryPoint )

inline

Definition at line 113 of file G4ClonedRichTrajectoryPoint.hh.

{
  aClonedRichTrajectoryPointAllocator()->FreeSingle((G4ClonedRichTrajectoryPoint*)aRichTrajectoryPoint);
}

operator new()

void * G4ClonedRichTrajectoryPoint::operator new ( size_t )

inline

Definition at line 105 of file G4ClonedRichTrajectoryPoint.hh.

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

operator=()

G4ClonedRichTrajectoryPoint & G4ClonedRichTrajectoryPoint::operator= ( const G4ClonedRichTrajectoryPoint & )

delete

operator==()

G4bool G4ClonedRichTrajectoryPoint::operator== ( const G4ClonedRichTrajectoryPoint & right ) const

inline

Definition at line 118 of file G4ClonedRichTrajectoryPoint.hh.

{
  return (this == &r);
}

---

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

• G4ClonedRichTrajectoryPoint.hh
• G4ClonedRichTrajectoryPoint.cc