G4RichTrajectoryPoint Class Reference

#include <G4RichTrajectoryPoint.hh>

Inheritance diagram for G4RichTrajectoryPoint:

Collaboration diagram for G4RichTrajectoryPoint:

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

Private Member Functions
G4RichTrajectoryPoint &	operator= (const G4RichTrajectoryPoint &)

Private Attributes
std::vector< G4ThreeVector > *	fpAuxiliaryPointVector
G4double	fTotEDep
G4double	fRemainingEnergy
const G4VProcess *	fpProcess
G4StepStatus	fPreStepPointStatus
G4StepStatus	fPostStepPointStatus
G4double	fPreStepPointGlobalTime
G4double	fPostStepPointGlobalTime
G4TouchableHandle	fpPreStepPointVolume
G4TouchableHandle	fpPostStepPointVolume
G4double	fPreStepPointWeight
G4double	fPostStepPointWeight

Detailed Description

Definition at line 72 of file G4RichTrajectoryPoint.hh.

Constructor & Destructor Documentation

G4RichTrajectoryPoint() [1/4]

G4RichTrajectoryPoint::G4RichTrajectoryPoint

(

)

Definition at line 66 of file G4RichTrajectoryPoint.cc.

                                            :
  fpAuxiliaryPointVector(0),
  fTotEDep(0.),
  fRemainingEnergy(0.),
  fpProcess(0),
  fPreStepPointStatus(fUndefined),
  fPostStepPointStatus(fUndefined),
  fPreStepPointGlobalTime(0),
  fPostStepPointGlobalTime(0),
  fPreStepPointWeight(1.),
  fPostStepPointWeight(1.)
{}

Here is the caller graph for this function:

G4RichTrajectoryPoint() [2/4]

G4RichTrajectoryPoint::G4RichTrajectoryPoint

(

const G4Track *

aTrack

)

Definition at line 79 of file G4RichTrajectoryPoint.cc.

                                                                 :
  G4TrajectoryPoint(aTrack->GetPosition()),
  fpAuxiliaryPointVector(0),
  fTotEDep(0.),
  fRemainingEnergy(aTrack->GetKineticEnergy()),
  fpProcess(0),
  fPreStepPointStatus(fUndefined),
  fPostStepPointStatus(fUndefined),
  fPreStepPointGlobalTime(aTrack->GetGlobalTime()),
  fPostStepPointGlobalTime(aTrack->GetGlobalTime()),
  fpPreStepPointVolume(aTrack->GetTouchableHandle()),
  fpPostStepPointVolume(aTrack->GetNextTouchableHandle()),
  fPreStepPointWeight(aTrack->GetWeight()),
  fPostStepPointWeight(aTrack->GetWeight())
{}

G4RichTrajectoryPoint() [3/4]

G4RichTrajectoryPoint::G4RichTrajectoryPoint

(

const G4Step *

aStep

)

Definition at line 95 of file G4RichTrajectoryPoint.cc.

                                                               :
  G4TrajectoryPoint(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();
}

Here is the call graph for this function:

G4RichTrajectoryPoint() [4/4]

G4RichTrajectoryPoint::G4RichTrajectoryPoint

(

const G4RichTrajectoryPoint &

right

)

Definition at line 119 of file G4RichTrajectoryPoint.cc.

                                    :
  G4TrajectoryPoint(right),
  fpAuxiliaryPointVector(right.fpAuxiliaryPointVector),
  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)
{}

~G4RichTrajectoryPoint()

G4RichTrajectoryPoint::~G4RichTrajectoryPoint ( )

virtual

Definition at line 135 of file G4RichTrajectoryPoint.cc.

{
  if(fpAuxiliaryPointVector) {
    /*
    G4cout << "Deleting fpAuxiliaryPointVector at "
       << (void*) fpAuxiliaryPointVector
       << G4endl;
    */
    delete fpAuxiliaryPointVector;
  }
}

Member Function Documentation

CreateAttValues()

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

virtual

Reimplemented from G4TrajectoryPoint.

Definition at line 232 of file G4RichTrajectoryPoint.cc.

{
  // Create base class att values...
  std::vector<G4AttValue>* values = G4TrajectoryPoint::CreateAttValues();

  if (fpAuxiliaryPointVector) {
    std::vector<G4ThreeVector>::iterator iAux;
    for (iAux = fpAuxiliaryPointVector->begin();
     iAux != fpAuxiliaryPointVector->end(); ++iAux) {
      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) {
    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()) {
    values->push_back(G4AttValue("PreVPath",Path(fpPreStepPointVolume),""));
  } else {
    values->push_back(G4AttValue("PreVPath","None",""));
  }

  if (fpPostStepPointVolume && fpPostStepPointVolume->GetVolume()) {
    values->push_back(G4AttValue("PostVPath",Path(fpPostStepPointVolume),""));
  } else {
    values->push_back(G4AttValue("PostVPath","None",""));
  }

  {
    std::ostringstream oss;
    oss << fPreStepPointWeight;
    values->push_back
      (G4AttValue("PreW",oss.str(),""));
  }

  {
    std::ostringstream oss;
    oss << fPostStepPointWeight;
    values->push_back
      (G4AttValue("PostW",oss.str(),""));
  }

#ifdef G4ATTDEBUG
  G4cout << G4AttCheck(values,GetAttDefs());
#endif

  return values;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAttDefs()

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

virtual

Reimplemented from G4TrajectoryPoint.

Definition at line 148 of file G4RichTrajectoryPoint.cc.

{
  G4bool isNew;
  std::map<G4String,G4AttDef>* store
    = G4AttDefStore::GetInstance("G4RichTrajectoryPoint",isNew);
  if (isNew) {

    // Copy base class att defs...
    *store = *(G4TrajectoryPoint::GetAttDefs());

    G4String ID;

    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetAuxiliaryPoints()

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

inlinevirtual

Reimplemented from G4VTrajectoryPoint.

Definition at line 90 of file G4RichTrajectoryPoint.hh.

   { return fpAuxiliaryPointVector; }

operator delete()

void G4RichTrajectoryPoint::operator delete ( void *  aRichTrajectoryPoint )

inline

Definition at line 130 of file G4RichTrajectoryPoint.hh.

{
  aRichTrajectoryPointAllocator->FreeSingle
    ((G4RichTrajectoryPoint *) aRichTrajectoryPoint);
}

operator new()

void * G4RichTrajectoryPoint::operator new ( size_t  )

inline

Definition at line 123 of file G4RichTrajectoryPoint.hh.

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

operator=()

G4RichTrajectoryPoint& G4RichTrajectoryPoint::operator= ( const G4RichTrajectoryPoint &  )

private

operator==()

int G4RichTrajectoryPoint::operator== ( const G4RichTrajectoryPoint &  right ) const

inline

Definition at line 96 of file G4RichTrajectoryPoint.hh.

  { return (this==&right); }

Here is the call graph for this function:

Member Data Documentation

fpAuxiliaryPointVector

std::vector<G4ThreeVector>* G4RichTrajectoryPoint::fpAuxiliaryPointVector

private

Definition at line 106 of file G4RichTrajectoryPoint.hh.

fPostStepPointGlobalTime

G4double G4RichTrajectoryPoint::fPostStepPointGlobalTime

private

Definition at line 113 of file G4RichTrajectoryPoint.hh.

fPostStepPointStatus

G4StepStatus G4RichTrajectoryPoint::fPostStepPointStatus

private

Definition at line 111 of file G4RichTrajectoryPoint.hh.

fPostStepPointWeight

G4double G4RichTrajectoryPoint::fPostStepPointWeight

private

Definition at line 117 of file G4RichTrajectoryPoint.hh.

fpPostStepPointVolume

G4TouchableHandle G4RichTrajectoryPoint::fpPostStepPointVolume

private

Definition at line 115 of file G4RichTrajectoryPoint.hh.

fpPreStepPointVolume

G4TouchableHandle G4RichTrajectoryPoint::fpPreStepPointVolume

private

Definition at line 114 of file G4RichTrajectoryPoint.hh.

fpProcess

const G4VProcess* G4RichTrajectoryPoint::fpProcess

private

Definition at line 109 of file G4RichTrajectoryPoint.hh.

fPreStepPointGlobalTime

G4double G4RichTrajectoryPoint::fPreStepPointGlobalTime

private

Definition at line 112 of file G4RichTrajectoryPoint.hh.

fPreStepPointStatus

G4StepStatus G4RichTrajectoryPoint::fPreStepPointStatus

private

Definition at line 110 of file G4RichTrajectoryPoint.hh.

fPreStepPointWeight

G4double G4RichTrajectoryPoint::fPreStepPointWeight

private

Definition at line 116 of file G4RichTrajectoryPoint.hh.

fRemainingEnergy

G4double G4RichTrajectoryPoint::fRemainingEnergy

private

Definition at line 108 of file G4RichTrajectoryPoint.hh.

fTotEDep

G4double G4RichTrajectoryPoint::fTotEDep

private

Definition at line 107 of file G4RichTrajectoryPoint.hh.

---

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

• G4RichTrajectoryPoint.hh
• G4RichTrajectoryPoint.cc