Gabriele Cosmo
551 lines
16 KiB
C++
551 lines
16 KiB
C++
//
|
|
// ********************************************************************
|
|
// * License and Disclaimer *
|
|
// * *
|
|
// * The Geant4 software is copyright of the Copyright Holders of *
|
|
// * the Geant4 Collaboration. It is provided under the terms and *
|
|
// * conditions of the Geant4 Software License, included in the file *
|
|
// * LICENSE and available at http://cern.ch/geant4/license . These *
|
|
// * include a list of copyright holders. *
|
|
// * *
|
|
// * Neither the authors of this software system, nor their employing *
|
|
// * institutes,nor the agencies providing financial support for this *
|
|
// * work make any representation or warranty, express or implied, *
|
|
// * regarding this software system or assume any liability for its *
|
|
// * use. Please see the license in the file LICENSE and URL above *
|
|
// * for the full disclaimer and the limitation of liability. *
|
|
// * *
|
|
// * This code implementation is the result of the scientific and *
|
|
// * technical work of the GEANT4 collaboration. *
|
|
// * By using, copying, modifying or distributing the software (or *
|
|
// * any work based on the software) you agree to acknowledge its *
|
|
// * use in resulting scientific publications, and indicate your *
|
|
// * acceptance of all terms of the Geant4 Software license. *
|
|
// ********************************************************************
|
|
//
|
|
// G4SteppingManager
|
|
//
|
|
// Class description:
|
|
//
|
|
// This is the class which plays an essential role in tracking particles.
|
|
// It takes cares of all message passing between objects in the different
|
|
// categories (for example, geometry - including transportation, interactions
|
|
// in matter, etc). Its public method 'stepping' steers to step the particle.
|
|
// Only used within the Geant4 kernel.
|
|
|
|
// Contact:
|
|
// Questions and comments to this code should be sent to
|
|
// Katsuya Amako (e-mail: Katsuya.Amako@kek.jp)
|
|
// Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp)
|
|
//
|
|
// History:
|
|
// 12.03.1998, H.Kurashige - modified for use of G4ParticleChange
|
|
// --------------------------------------------------------------------
|
|
#ifndef G4SteppingManager_hh
|
|
#define G4SteppingManager_hh 1
|
|
|
|
#include <iomanip> // Include from 'system'
|
|
#include <vector> // Include from 'system'
|
|
#include "globals.hh" // Include from 'global'
|
|
#include "Randomize.hh" // Include from 'global'
|
|
|
|
#include "G4Navigator.hh" // Include from 'geometry'
|
|
#include "G4LogicalVolume.hh" // Include from 'geometry'
|
|
#include "G4VPhysicalVolume.hh" // Include from 'geometry'
|
|
#include "G4ProcessManager.hh" // Include from 'processes'
|
|
|
|
#include "G4Track.hh" // Include from 'tracking'
|
|
#include "G4TrackVector.hh" // Include from 'tracking'
|
|
#include "G4TrackStatus.hh" // Include from 'tracking'
|
|
#include "G4StepStatus.hh" // Include from 'tracking'
|
|
#include "G4UserSteppingAction.hh" // Include from 'tracking'
|
|
#include "G4Step.hh" // Include from 'tracking'
|
|
#include "G4StepPoint.hh" // Include from 'tracking'
|
|
#include "G4VSteppingVerbose.hh" // Include from 'tracking'
|
|
#include "G4TouchableHandle.hh" // Include from 'geometry'
|
|
#include "G4TouchableHistoryHandle.hh" // Include from 'geometry'
|
|
|
|
using G4SelectedAtRestDoItVector = std::vector<G4int>;
|
|
using G4SelectedAlongStepDoItVector = std::vector<G4int>;
|
|
using G4SelectedPostStepDoItVector = std::vector<G4int>;
|
|
|
|
class G4VSensitiveDetector;
|
|
|
|
class G4SteppingManager
|
|
{
|
|
public:
|
|
|
|
// Constructor/Destructor
|
|
|
|
G4SteppingManager();
|
|
// SteppingManger should be dynamically allocated, therefore
|
|
// you need to invoke new() when you call this constructor.
|
|
// "Secodary track vector" will be dynamically created by this
|
|
// constructor. G4UserSteppingAction will be also created
|
|
// in this constructor, and "this" pointer will be passed to
|
|
// G4UserSteppingAction.
|
|
|
|
~G4SteppingManager();
|
|
|
|
// Get/Set functions
|
|
|
|
const G4TrackVector* GetSecondary() const;
|
|
void SetUserAction(G4UserSteppingAction* apAction);
|
|
G4Track* GetTrack() const;
|
|
void SetVerboseLevel(G4int vLevel);
|
|
void SetVerbose(G4VSteppingVerbose*);
|
|
G4Step* GetStep() const;
|
|
void SetNavigator(G4Navigator* value);
|
|
|
|
// Other member functions
|
|
|
|
G4StepStatus Stepping();
|
|
// Steers to move the give particle from the TrackingManger by one Step.
|
|
|
|
void SetInitialStep(G4Track* valueTrack);
|
|
// Sets up initial track information (enegry, position, etc) to
|
|
// the PreStepPoint of the G4Step. This funciton has to be called
|
|
// just once before the stepping loop in the "TrackingManager".
|
|
|
|
void GetProcessNumber();
|
|
|
|
// Get methods
|
|
|
|
G4double GetPhysicalStep();
|
|
G4double GetGeometricalStep();
|
|
G4double GetCorrectedStep();
|
|
G4bool GetPreStepPointIsGeom();
|
|
G4bool GetFirstStep();
|
|
G4StepStatus GetfStepStatus();
|
|
G4double GetTempInitVelocity();
|
|
G4double GetTempVelocity();
|
|
G4double GetMass();
|
|
G4double GetsumEnergyChange();
|
|
G4VParticleChange* GetfParticleChange();
|
|
G4Track* GetfTrack();
|
|
G4TrackVector* GetfSecondary();
|
|
G4Step* GetfStep();
|
|
G4StepPoint* GetfPreStepPoint();
|
|
G4StepPoint* GetfPostStepPoint();
|
|
G4VPhysicalVolume* GetfCurrentVolume();
|
|
G4VSensitiveDetector* GetfSensitive();
|
|
G4VProcess* GetfCurrentProcess();
|
|
G4ProcessVector* GetfAtRestDoItVector();
|
|
G4ProcessVector* GetfAlongStepDoItVector();
|
|
G4ProcessVector* GetfPostStepDoItVector();
|
|
G4ProcessVector* GetfAlongStepGetPhysIntVector();
|
|
G4ProcessVector* GetfPostStepGetPhysIntVector();
|
|
G4ProcessVector* GetfAtRestGetPhysIntVector();
|
|
G4double GetcurrentMinimumStep();
|
|
G4double GetnumberOfInteractionLengthLeft();
|
|
std::size_t GetfAtRestDoItProcTriggered();
|
|
std::size_t GetfAlongStepDoItProcTriggered();
|
|
std::size_t GetfPostStepDoItProcTriggered();
|
|
G4int GetfN2ndariesAtRestDoIt();
|
|
G4int GetfN2ndariesAlongStepDoIt();
|
|
G4int GetfN2ndariesPostStepDoIt();
|
|
G4Navigator* GetfNavigator();
|
|
G4int GetverboseLevel();
|
|
std::size_t GetMAXofAtRestLoops();
|
|
std::size_t GetMAXofAlongStepLoops();
|
|
std::size_t GetMAXofPostStepLoops();
|
|
G4SelectedAtRestDoItVector* GetfSelectedAtRestDoItVector();
|
|
G4SelectedAlongStepDoItVector* GetfSelectedAlongStepDoItVector();
|
|
G4SelectedPostStepDoItVector* GetfSelectedPostStepDoItVector();
|
|
G4double GetfPreviousStepSize();
|
|
const G4TouchableHandle& GetTouchableHandle();
|
|
G4SteppingControl GetStepControlFlag();
|
|
G4UserSteppingAction* GetUserAction();
|
|
G4double GetphysIntLength();
|
|
G4ForceCondition GetfCondition();
|
|
G4GPILSelection GetfGPILSelection();
|
|
|
|
private:
|
|
|
|
// Member functions
|
|
|
|
void DefinePhysicalStepLength();
|
|
// Calculate corresponding physical length from the mean free path
|
|
// left for each discrete physics process. The minimum allowable
|
|
// step for each continuous process will be also calculated.
|
|
void InvokeAtRestDoItProcs();
|
|
void InvokeAlongStepDoItProcs();
|
|
void InvokePostStepDoItProcs();
|
|
void InvokePSDIP(size_t); //
|
|
G4double CalculateSafety();
|
|
// Return the estimated safety value at the PostStepPoint
|
|
void ApplyProductionCut(G4Track*);
|
|
|
|
// Member data
|
|
|
|
static const size_t SizeOfSelectedDoItVector = 100;
|
|
|
|
G4bool KillVerbose = false;
|
|
|
|
G4UserSteppingAction* fUserSteppingAction = nullptr;
|
|
|
|
G4VSteppingVerbose* fVerbose = nullptr;
|
|
|
|
G4double PhysicalStep = 0.0;
|
|
G4double GeometricalStep = 0.0;
|
|
G4double CorrectedStep = 0.0;
|
|
G4bool PreStepPointIsGeom = false;
|
|
G4bool FirstStep = false;
|
|
G4StepStatus fStepStatus = fUndefined;
|
|
|
|
G4double TempInitVelocity = 0.0;
|
|
G4double TempVelocity = 0.0;
|
|
G4double Mass = 0.0;
|
|
|
|
G4double sumEnergyChange = 0.0;
|
|
|
|
G4VParticleChange* fParticleChange = nullptr;
|
|
G4Track* fTrack = nullptr;
|
|
G4TrackVector* fSecondary = nullptr;
|
|
G4Step* fStep = nullptr;
|
|
G4StepPoint* fPreStepPoint = nullptr;
|
|
G4StepPoint* fPostStepPoint = nullptr;
|
|
|
|
G4VPhysicalVolume* fCurrentVolume = nullptr;
|
|
G4VSensitiveDetector* fSensitive = nullptr;
|
|
G4VProcess* fCurrentProcess = nullptr;
|
|
// The pointer to the process of which DoIt() or
|
|
// GetPhysicalInteractionLength() has been just executed.
|
|
|
|
|
|
G4ProcessVector* fAtRestDoItVector = nullptr;
|
|
G4ProcessVector* fAlongStepDoItVector = nullptr;
|
|
G4ProcessVector* fPostStepDoItVector = nullptr;
|
|
|
|
G4ProcessVector* fAtRestGetPhysIntVector = nullptr;
|
|
G4ProcessVector* fAlongStepGetPhysIntVector = nullptr;
|
|
G4ProcessVector* fPostStepGetPhysIntVector = nullptr;
|
|
|
|
std::size_t MAXofAtRestLoops = 0;
|
|
std::size_t MAXofAlongStepLoops = 0;
|
|
std::size_t MAXofPostStepLoops = 0;
|
|
|
|
std::size_t fAtRestDoItProcTriggered = 0;
|
|
std::size_t fAlongStepDoItProcTriggered = 0;
|
|
std::size_t fPostStepDoItProcTriggered = 0;
|
|
|
|
G4int fN2ndariesAtRestDoIt = 0;
|
|
G4int fN2ndariesAlongStepDoIt = 0;
|
|
G4int fN2ndariesPostStepDoIt = 0;
|
|
// These are the numbers of secondaries generated by the process
|
|
// just executed.
|
|
|
|
G4Navigator* fNavigator = nullptr;
|
|
|
|
G4int verboseLevel = 0;
|
|
|
|
G4SelectedAtRestDoItVector* fSelectedAtRestDoItVector = nullptr;
|
|
G4SelectedAlongStepDoItVector* fSelectedAlongStepDoItVector = nullptr;
|
|
G4SelectedPostStepDoItVector* fSelectedPostStepDoItVector = nullptr;
|
|
|
|
G4double fPreviousStepSize = 0.0;
|
|
|
|
G4TouchableHandle fTouchableHandle;
|
|
|
|
G4SteppingControl StepControlFlag = NormalCondition;
|
|
|
|
G4double kCarTolerance = 0.0;
|
|
// Cached geometrical tolerance on surface
|
|
G4double proposedSafety = 0.0;
|
|
// This keeps the minimum safety value proposed by AlongStepGPILs.
|
|
G4ThreeVector endpointSafOrigin;
|
|
G4double endpointSafety = 0.0;
|
|
// To get the true safety value at the PostStepPoint, you have
|
|
// to subtract the distance to 'endpointSafOrigin' from this value.
|
|
G4double physIntLength = 0.0;
|
|
G4ForceCondition fCondition = InActivated;
|
|
G4GPILSelection fGPILSelection = NotCandidateForSelection;
|
|
// Above three variables are for the method
|
|
// DefinePhysicalStepLength(). To pass these information to
|
|
// the method Verbose, they are kept at here. Need a more
|
|
// elegant mechanism.
|
|
};
|
|
|
|
//*******************************************************************
|
|
//
|
|
// Inline functions
|
|
//
|
|
//*******************************************************************
|
|
|
|
inline G4double G4SteppingManager::GetPhysicalStep()
|
|
{
|
|
return PhysicalStep;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetGeometricalStep()
|
|
{
|
|
return GeometricalStep;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetCorrectedStep()
|
|
{
|
|
return CorrectedStep;
|
|
}
|
|
|
|
inline G4bool G4SteppingManager::GetPreStepPointIsGeom()
|
|
{
|
|
return PreStepPointIsGeom;
|
|
}
|
|
|
|
inline G4bool G4SteppingManager::GetFirstStep()
|
|
{
|
|
return FirstStep;
|
|
}
|
|
|
|
inline G4StepStatus G4SteppingManager::GetfStepStatus()
|
|
{
|
|
return fStepStatus;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetTempInitVelocity()
|
|
{
|
|
return TempInitVelocity;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetTempVelocity()
|
|
{
|
|
return TempVelocity;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetMass()
|
|
{
|
|
return Mass;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetsumEnergyChange()
|
|
{
|
|
return sumEnergyChange;
|
|
}
|
|
|
|
inline G4VParticleChange* G4SteppingManager::GetfParticleChange()
|
|
{
|
|
return fParticleChange;
|
|
}
|
|
|
|
inline G4Track* G4SteppingManager::GetfTrack()
|
|
{
|
|
return fTrack;
|
|
}
|
|
|
|
inline G4TrackVector* G4SteppingManager::GetfSecondary()
|
|
{
|
|
return fStep->GetfSecondary();
|
|
}
|
|
|
|
inline G4Step* G4SteppingManager::GetfStep()
|
|
{
|
|
return fStep;
|
|
}
|
|
|
|
inline G4StepPoint* G4SteppingManager::GetfPreStepPoint()
|
|
{
|
|
return fPreStepPoint;
|
|
}
|
|
|
|
inline G4StepPoint* G4SteppingManager::GetfPostStepPoint()
|
|
{
|
|
return fPostStepPoint;
|
|
}
|
|
|
|
inline G4VPhysicalVolume* G4SteppingManager::GetfCurrentVolume()
|
|
{
|
|
return fCurrentVolume;
|
|
}
|
|
|
|
inline G4VSensitiveDetector* G4SteppingManager::GetfSensitive()
|
|
{
|
|
return fSensitive;
|
|
}
|
|
|
|
inline G4VProcess* G4SteppingManager::GetfCurrentProcess()
|
|
{
|
|
return fCurrentProcess;
|
|
}
|
|
|
|
inline G4ProcessVector* G4SteppingManager::GetfAtRestDoItVector()
|
|
{
|
|
return fAtRestDoItVector;
|
|
}
|
|
|
|
inline G4ProcessVector* G4SteppingManager::GetfAlongStepDoItVector()
|
|
{
|
|
return fAlongStepDoItVector;
|
|
}
|
|
|
|
inline G4ProcessVector* G4SteppingManager::GetfPostStepDoItVector()
|
|
{
|
|
return fPostStepDoItVector;
|
|
}
|
|
|
|
inline G4ProcessVector* G4SteppingManager::GetfAtRestGetPhysIntVector()
|
|
{
|
|
return fAtRestGetPhysIntVector;
|
|
}
|
|
|
|
inline G4ProcessVector* G4SteppingManager::GetfAlongStepGetPhysIntVector()
|
|
{
|
|
return fAlongStepGetPhysIntVector;
|
|
}
|
|
|
|
inline G4ProcessVector* G4SteppingManager::GetfPostStepGetPhysIntVector()
|
|
{
|
|
return fPostStepGetPhysIntVector;
|
|
}
|
|
|
|
inline size_t G4SteppingManager::GetMAXofAtRestLoops()
|
|
{
|
|
return MAXofAtRestLoops;
|
|
}
|
|
|
|
inline size_t G4SteppingManager::GetMAXofAlongStepLoops()
|
|
{
|
|
return MAXofAlongStepLoops;
|
|
}
|
|
|
|
inline size_t G4SteppingManager::GetMAXofPostStepLoops()
|
|
{
|
|
return MAXofPostStepLoops;
|
|
}
|
|
|
|
inline size_t G4SteppingManager::GetfAtRestDoItProcTriggered()
|
|
{
|
|
return fAtRestDoItProcTriggered;
|
|
}
|
|
|
|
inline size_t G4SteppingManager::GetfAlongStepDoItProcTriggered()
|
|
{
|
|
return fAtRestDoItProcTriggered;
|
|
}
|
|
|
|
inline size_t G4SteppingManager::GetfPostStepDoItProcTriggered()
|
|
{
|
|
return fPostStepDoItProcTriggered;
|
|
}
|
|
|
|
inline G4int G4SteppingManager::GetfN2ndariesAtRestDoIt()
|
|
{
|
|
return fN2ndariesAtRestDoIt;
|
|
}
|
|
|
|
inline G4int G4SteppingManager::GetfN2ndariesAlongStepDoIt()
|
|
{
|
|
return fN2ndariesAlongStepDoIt;
|
|
}
|
|
|
|
inline G4int G4SteppingManager::GetfN2ndariesPostStepDoIt()
|
|
{
|
|
return fN2ndariesPostStepDoIt;
|
|
}
|
|
|
|
inline G4Navigator* G4SteppingManager::GetfNavigator()
|
|
{
|
|
return fNavigator;
|
|
}
|
|
|
|
inline G4int G4SteppingManager::GetverboseLevel()
|
|
{
|
|
return verboseLevel;
|
|
}
|
|
|
|
inline G4SelectedAtRestDoItVector*
|
|
G4SteppingManager::GetfSelectedAtRestDoItVector()
|
|
{
|
|
return fSelectedAtRestDoItVector;
|
|
}
|
|
|
|
inline G4SelectedAlongStepDoItVector*
|
|
G4SteppingManager::GetfSelectedAlongStepDoItVector()
|
|
{
|
|
return fSelectedAlongStepDoItVector;
|
|
}
|
|
|
|
inline G4SelectedPostStepDoItVector*
|
|
G4SteppingManager::GetfSelectedPostStepDoItVector()
|
|
{
|
|
return fSelectedPostStepDoItVector;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetfPreviousStepSize()
|
|
{
|
|
return fPreviousStepSize;
|
|
}
|
|
|
|
inline const G4TouchableHandle& G4SteppingManager::GetTouchableHandle()
|
|
{
|
|
return fTouchableHandle;
|
|
}
|
|
|
|
inline G4SteppingControl G4SteppingManager::GetStepControlFlag()
|
|
{
|
|
return StepControlFlag;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::GetphysIntLength()
|
|
{
|
|
return physIntLength;
|
|
}
|
|
|
|
inline G4ForceCondition G4SteppingManager::GetfCondition()
|
|
{
|
|
return fCondition;
|
|
}
|
|
|
|
inline G4GPILSelection G4SteppingManager::GetfGPILSelection()
|
|
{
|
|
return fGPILSelection;
|
|
}
|
|
|
|
inline const G4TrackVector* G4SteppingManager::GetSecondary() const
|
|
{
|
|
return fStep->GetSecondary();
|
|
}
|
|
|
|
inline void G4SteppingManager::SetNavigator(G4Navigator* value)
|
|
{
|
|
fNavigator = value;
|
|
}
|
|
|
|
inline void G4SteppingManager::SetUserAction(G4UserSteppingAction* apAction)
|
|
{
|
|
fUserSteppingAction = apAction;
|
|
}
|
|
|
|
inline G4UserSteppingAction* G4SteppingManager::GetUserAction()
|
|
{
|
|
return fUserSteppingAction;
|
|
}
|
|
|
|
inline G4Track* G4SteppingManager::GetTrack() const
|
|
{
|
|
return fTrack;
|
|
}
|
|
|
|
inline void G4SteppingManager::SetVerboseLevel(G4int vLevel)
|
|
{
|
|
verboseLevel = vLevel;
|
|
}
|
|
|
|
inline void G4SteppingManager::SetVerbose(G4VSteppingVerbose* yourVerbose)
|
|
{
|
|
fVerbose = yourVerbose;
|
|
}
|
|
|
|
inline G4Step* G4SteppingManager::GetStep() const
|
|
{
|
|
return fStep;
|
|
}
|
|
|
|
inline G4double G4SteppingManager::CalculateSafety()
|
|
{
|
|
return std::max( endpointSafety -
|
|
(endpointSafOrigin - fPostStepPoint->GetPosition()).mag(),
|
|
kCarTolerance );
|
|
}
|
|
|
|
#endif
|