Gabriele Cosmo
437 lines
15 KiB
C++
437 lines
15 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. *
|
|
// ********************************************************************
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//---------------------------------------------------------------
|
|
//
|
|
// G4FastSimulationProcess.cc
|
|
//
|
|
// Description:
|
|
// The process that triggers the parameterised simulations,
|
|
// if any.
|
|
//
|
|
// History:
|
|
// August 97: First implementation. Verderi && MoraDeFreitas.
|
|
// October 06: move to parallel geometry scheme, M. Verderi
|
|
//---------------------------------------------------------------
|
|
|
|
#include "G4ios.hh"
|
|
#include "G4FastSimulationManagerProcess.hh"
|
|
#include "G4GlobalFastSimulationManager.hh"
|
|
#include "G4TransportationManager.hh"
|
|
#include "G4PathFinder.hh"
|
|
#include "G4ParticleChange.hh"
|
|
#include "G4FieldTrackUpdator.hh"
|
|
|
|
#define PARANOIA
|
|
|
|
G4FastSimulationManagerProcess::
|
|
G4FastSimulationManagerProcess(const G4String& processName,
|
|
G4ProcessType theType) :
|
|
G4VProcess(processName,theType),
|
|
fWorldVolume ( nullptr ),
|
|
fIsTrackingTime ( false ),
|
|
fIsFirstStep ( false ),
|
|
fGhostNavigator ( nullptr ),
|
|
fGhostNavigatorIndex ( -1 ),
|
|
fIsGhostGeometry ( false ),
|
|
fGhostSafety ( -1.0 ),
|
|
fFieldTrack ( '0' ),
|
|
fFastSimulationManager( nullptr ),
|
|
fFastSimulationTrigger( false )
|
|
{
|
|
// -- set Process Sub Type
|
|
SetProcessSubType(static_cast<int>(FASTSIM_ManagerProcess));
|
|
|
|
|
|
fPathFinder = G4PathFinder::GetInstance();
|
|
fTransportationManager = G4TransportationManager::GetTransportationManager();
|
|
|
|
SetWorldVolume(fTransportationManager->GetNavigatorForTracking()->GetWorldVolume()->GetName());
|
|
if (verboseLevel>0) G4cout << "G4FastSimulationManagerProcess `" << GetProcessName()
|
|
<< "' is created, and will message geometry with world volume `"
|
|
<< fWorldVolume->GetName() << "'." << G4endl;
|
|
G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()->AddFSMP(this);
|
|
}
|
|
|
|
|
|
G4FastSimulationManagerProcess::
|
|
G4FastSimulationManagerProcess(const G4String& processName,
|
|
const G4String& worldVolumeName,
|
|
G4ProcessType theType) :
|
|
G4VProcess(processName,theType),
|
|
fWorldVolume ( nullptr ),
|
|
fIsTrackingTime ( false ),
|
|
fIsFirstStep ( false ),
|
|
fGhostNavigator ( nullptr ),
|
|
fGhostNavigatorIndex ( -1 ),
|
|
fIsGhostGeometry ( false ),
|
|
fGhostSafety ( -1.0 ),
|
|
fFieldTrack ( '0' ),
|
|
fFastSimulationManager( nullptr ),
|
|
fFastSimulationTrigger( false )
|
|
{
|
|
// -- set Process Sub Type
|
|
SetProcessSubType(static_cast<int>(FASTSIM_ManagerProcess));
|
|
|
|
|
|
fPathFinder = G4PathFinder::GetInstance();
|
|
fTransportationManager = G4TransportationManager::GetTransportationManager();
|
|
|
|
SetWorldVolume(worldVolumeName);
|
|
if (verboseLevel>0) G4cout << "G4FastSimulationManagerProcess `" << GetProcessName()
|
|
<< "' is created, and will message geometry with world volume `"
|
|
<< fWorldVolume->GetName() << "'." << G4endl;
|
|
G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()->AddFSMP(this);
|
|
}
|
|
|
|
|
|
G4FastSimulationManagerProcess::
|
|
G4FastSimulationManagerProcess(const G4String& processName,
|
|
G4VPhysicalVolume* worldVolume,
|
|
G4ProcessType theType) :
|
|
G4VProcess(processName,theType),
|
|
fWorldVolume ( nullptr ),
|
|
fIsTrackingTime ( false ),
|
|
fIsFirstStep ( false ),
|
|
fGhostNavigator ( nullptr ),
|
|
fGhostNavigatorIndex ( -1 ),
|
|
fIsGhostGeometry ( false ),
|
|
fGhostSafety ( -1.0 ),
|
|
fFieldTrack ( '0' ),
|
|
fFastSimulationManager( nullptr ),
|
|
fFastSimulationTrigger( false )
|
|
{
|
|
// -- set Process Sub Type
|
|
SetProcessSubType(static_cast<int>(FASTSIM_ManagerProcess));
|
|
|
|
|
|
fPathFinder = G4PathFinder::GetInstance();
|
|
fTransportationManager = G4TransportationManager::GetTransportationManager();
|
|
|
|
SetWorldVolume(worldVolume);
|
|
if (verboseLevel>0) G4cout << "G4FastSimulationManagerProcess `" << GetProcessName()
|
|
<< "' is created, and will message geometry with world volume `"
|
|
<< fWorldVolume->GetName() << "'." << G4endl;
|
|
G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()->AddFSMP(this);
|
|
}
|
|
|
|
|
|
G4FastSimulationManagerProcess::~G4FastSimulationManagerProcess()
|
|
{
|
|
G4GlobalFastSimulationManager::GetGlobalFastSimulationManager()->RemoveFSMP(this);
|
|
}
|
|
|
|
|
|
// -----------------------
|
|
// User access methods:
|
|
// -----------------------
|
|
void G4FastSimulationManagerProcess::SetWorldVolume(G4String newWorldName)
|
|
{
|
|
if (fIsTrackingTime)
|
|
{
|
|
G4ExceptionDescription ed;
|
|
ed << "G4FastSimulationManagerProcess `" << GetProcessName()
|
|
<< "': changing of world volume at tracking time is not allowed." << G4endl;
|
|
G4Exception("G4FastSimulationManagerProcess::SetWorldVolume(const G4String)",
|
|
"FastSim002",
|
|
JustWarning, ed,
|
|
"Call ignored.");
|
|
}
|
|
else
|
|
{
|
|
G4VPhysicalVolume* newWorld = fTransportationManager->IsWorldExisting(newWorldName);
|
|
if (newWorld == 0)
|
|
{
|
|
G4ExceptionDescription tellWhatIsWrong;
|
|
tellWhatIsWrong << "Volume newWorldName = `" << newWorldName
|
|
<< "' is not a parallel world nor the mass world volume."
|
|
<< G4endl;
|
|
G4Exception("G4FastSimulationManagerProcess::SetWorldVolume(const G4String)",
|
|
"FastSim003",
|
|
FatalException,
|
|
tellWhatIsWrong);
|
|
}
|
|
if (verboseLevel>0)
|
|
{
|
|
if (fWorldVolume) G4cout << "G4FastSimulationManagerProcess `" << GetProcessName()
|
|
<< "': changing world volume from '" << fWorldVolume->GetName()
|
|
<< "' to `" << newWorld << "'." << G4endl;
|
|
else G4cout << "G4FastSimulationManagerProcess `" << GetProcessName()
|
|
<< "': setting world volume from to `"<< newWorld->GetName() << "'." << G4endl;
|
|
}
|
|
fWorldVolume = newWorld;
|
|
}
|
|
}
|
|
|
|
|
|
void G4FastSimulationManagerProcess::SetWorldVolume(G4VPhysicalVolume* newWorld)
|
|
{
|
|
if (newWorld) SetWorldVolume(newWorld->GetName());
|
|
else
|
|
{
|
|
G4ExceptionDescription tellWhatIsWrong;
|
|
tellWhatIsWrong << "Null pointer passed for world volume." << G4endl;
|
|
G4Exception("G4FastSimulationManagerProcess::SetWorldVolume(const G4VPhysicalVolume* newWorld)",
|
|
"FastSim004",
|
|
FatalException,
|
|
tellWhatIsWrong);
|
|
}
|
|
}
|
|
|
|
|
|
// --------------------
|
|
// Start/End tracking:
|
|
// --------------------
|
|
void G4FastSimulationManagerProcess::StartTracking(G4Track* track)
|
|
{
|
|
fIsTrackingTime = true;
|
|
fIsFirstStep = true;
|
|
|
|
// -- fetch the navigator (and its index) and activate it:
|
|
G4TransportationManager* transportationManager = G4TransportationManager::GetTransportationManager();
|
|
fGhostNavigator = transportationManager->GetNavigator(fWorldVolume);
|
|
fIsGhostGeometry = (fGhostNavigator != transportationManager->GetNavigatorForTracking());
|
|
if (fIsGhostGeometry) fGhostNavigatorIndex = transportationManager->ActivateNavigator(fGhostNavigator);
|
|
else fGhostNavigatorIndex = -1;
|
|
|
|
fPathFinder->PrepareNewTrack(track->GetPosition(), track->GetMomentumDirection());
|
|
}
|
|
|
|
|
|
void
|
|
G4FastSimulationManagerProcess::
|
|
EndTracking()
|
|
{
|
|
fIsTrackingTime = false;
|
|
if ( fIsGhostGeometry ) fTransportationManager->DeActivateNavigator(fGhostNavigator);
|
|
}
|
|
|
|
|
|
// ------------------------------------------
|
|
// PostStepGetPhysicalInteractionLength():
|
|
// ------------------------------------------
|
|
G4double
|
|
G4FastSimulationManagerProcess::
|
|
PostStepGetPhysicalInteractionLength(const G4Track& track,
|
|
G4double,
|
|
G4ForceCondition* condition)
|
|
{
|
|
// -- Get current volume, and check for presence of fast simulation manager.
|
|
// -- For the case of the navigator for tracking (fGhostNavigatorIndex == 0)
|
|
// -- we use the track volume. This allows the code to be valid for both
|
|
// -- cases where the PathFinder is used (G4CoupledTranportation) or not
|
|
// -- (G4Transportation).
|
|
const G4VPhysicalVolume* currentVolume(0);
|
|
if ( fIsGhostGeometry ) currentVolume = fPathFinder->GetLocatedVolume(fGhostNavigatorIndex);
|
|
else currentVolume = track.GetVolume();
|
|
|
|
if ( currentVolume )
|
|
{
|
|
fFastSimulationManager = currentVolume->GetLogicalVolume()->GetFastSimulationManager();
|
|
if( fFastSimulationManager )
|
|
{
|
|
// Ask for trigger:
|
|
fFastSimulationTrigger = fFastSimulationManager->PostStepGetFastSimulationManagerTrigger(track, fGhostNavigator);
|
|
if( fFastSimulationTrigger )
|
|
{
|
|
// Take control over stepping:
|
|
*condition = ExclusivelyForced;
|
|
return 0.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
// -- no fast simulation occuring there:
|
|
*condition = NotForced;
|
|
return DBL_MAX;
|
|
}
|
|
|
|
//------------------------------------
|
|
// PostStepDoIt()
|
|
//------------------------------------
|
|
G4VParticleChange*
|
|
G4FastSimulationManagerProcess::
|
|
PostStepDoIt(const G4Track&,
|
|
const G4Step&)
|
|
{
|
|
G4VParticleChange* finalState = fFastSimulationManager->InvokePostStepDoIt();
|
|
|
|
// If the particle is still alive, suspend it to force physics re-initialisation:
|
|
if (finalState->GetTrackStatus() != fStopAndKill) finalState->ProposeTrackStatus(fSuspend);
|
|
|
|
return finalState;
|
|
}
|
|
|
|
|
|
G4double
|
|
G4FastSimulationManagerProcess::
|
|
AlongStepGetPhysicalInteractionLength(const G4Track& track,
|
|
G4double previousStepSize,
|
|
G4double currentMinimumStep,
|
|
G4double& proposedSafety,
|
|
G4GPILSelection* selection)
|
|
{
|
|
|
|
*selection = NotCandidateForSelection;
|
|
G4double returnedStep = DBL_MAX;
|
|
|
|
// ---------------------------------------------------
|
|
// -- Below code valid for ghost geometry, otherwise
|
|
// -- useless for fast simulation attached to mass
|
|
// -- geometry. Warn user in case along used for
|
|
// -- mass geometry ?
|
|
// --------------------------------------------------
|
|
if ( fIsGhostGeometry )
|
|
{
|
|
static G4ThreadLocal G4FieldTrack *endTrack_G4MT_TLS_ = 0 ;
|
|
if (!endTrack_G4MT_TLS_) endTrack_G4MT_TLS_ = new G4FieldTrack ('0') ;
|
|
G4FieldTrack &endTrack = *endTrack_G4MT_TLS_;
|
|
|
|
static G4ThreadLocal ELimited *eLimited_G4MT_TLS_ = 0 ;
|
|
if (!eLimited_G4MT_TLS_) eLimited_G4MT_TLS_ = new ELimited ;
|
|
ELimited &eLimited = *eLimited_G4MT_TLS_;
|
|
|
|
if (previousStepSize > 0.) fGhostSafety -= previousStepSize;
|
|
if (fGhostSafety < 0.) fGhostSafety = 0.0;
|
|
|
|
// ------------------------------------------
|
|
// Determination of the proposed step length:
|
|
// ------------------------------------------
|
|
if (currentMinimumStep <= fGhostSafety && currentMinimumStep > 0.)
|
|
{
|
|
// -- No chance to limit the step, as proposed move inside safety
|
|
returnedStep = currentMinimumStep;
|
|
proposedSafety = fGhostSafety - currentMinimumStep;
|
|
}
|
|
else
|
|
{
|
|
// -- Proposed move exceeds safety, need to state
|
|
G4FieldTrackUpdator::Update(&fFieldTrack, &track);
|
|
returnedStep = fPathFinder->ComputeStep(fFieldTrack,
|
|
currentMinimumStep,
|
|
fGhostNavigatorIndex,
|
|
track.GetCurrentStepNumber(),
|
|
fGhostSafety,
|
|
eLimited,
|
|
endTrack,
|
|
track.GetVolume());
|
|
|
|
if(eLimited == kDoNot) fGhostSafety = fGhostNavigator->ComputeSafety(endTrack.GetPosition()); // -- step no limited by ghost
|
|
proposedSafety = fGhostSafety;
|
|
if (eLimited == kUnique || eLimited == kSharedOther) *selection = CandidateForSelection;
|
|
else if (eLimited == kSharedTransport) returnedStep *= (1.0 + 1.0e-9); // -- Expand to disable its selection in Step Manager comparison
|
|
}
|
|
}
|
|
|
|
|
|
// ----------------------------------------------
|
|
// Returns the fGhostSafety as the proposedSafety
|
|
// The SteppingManager will take care of keeping
|
|
// the smallest one.
|
|
// ----------------------------------------------
|
|
return returnedStep;
|
|
}
|
|
|
|
G4VParticleChange*
|
|
G4FastSimulationManagerProcess::
|
|
AlongStepDoIt(const G4Track& track,
|
|
const G4Step&)
|
|
{
|
|
fDummyParticleChange.Initialize(track);
|
|
return &fDummyParticleChange;
|
|
}
|
|
|
|
|
|
//--------------------------------------------
|
|
// At Rest parameterisation:
|
|
//--------------------------------------------
|
|
// AtRestGetPhysiscalInteractionLength:
|
|
//--------------------------------------------
|
|
G4double
|
|
G4FastSimulationManagerProcess::
|
|
AtRestGetPhysicalInteractionLength(const G4Track& track,
|
|
G4ForceCondition* condition)
|
|
{
|
|
const G4VPhysicalVolume* currentVolume(0);
|
|
if ( fIsGhostGeometry ) currentVolume = fPathFinder->GetLocatedVolume(fGhostNavigatorIndex);
|
|
else currentVolume = track.GetVolume();
|
|
fFastSimulationManager = currentVolume->GetLogicalVolume()->GetFastSimulationManager();
|
|
if( fFastSimulationManager )
|
|
{
|
|
// Ask for trigger:
|
|
fFastSimulationTrigger = fFastSimulationManager->AtRestGetFastSimulationManagerTrigger(track, fGhostNavigator);
|
|
if( fFastSimulationTrigger )
|
|
{
|
|
// Dirty trick to take control over stepping. Does anyone will ever use that ?
|
|
*condition = NotForced;
|
|
return -1.0;
|
|
}
|
|
}
|
|
|
|
// -- no fast simulation occuring there:
|
|
*condition = NotForced;
|
|
return DBL_MAX;
|
|
}
|
|
|
|
//-----------------------------------------------
|
|
// AtRestDoIt:
|
|
//-----------------------------------------------
|
|
G4VParticleChange* G4FastSimulationManagerProcess::AtRestDoIt(const G4Track&, const G4Step&)
|
|
{
|
|
return fFastSimulationManager->InvokeAtRestDoIt();
|
|
}
|
|
|
|
|
|
void G4FastSimulationManagerProcess::Verbose() const
|
|
{
|
|
/* G4cout << " >>>>> Trigger Status : ";
|
|
switch(fFastSimulationManager->GetTriggerStatus())
|
|
{
|
|
case NoModel:
|
|
G4cout << "NoModel" << G4endl;
|
|
break;
|
|
case OnBoundaryButLeaving:
|
|
G4cout << "OnBoundaryButLeaving" << G4endl;
|
|
break;
|
|
case OneModelTrigger:
|
|
G4cout << "OneModelTrigger" << G4endl;
|
|
break;
|
|
case NoModelTrigger:
|
|
G4cout << "NoModelTrigger" << G4endl;
|
|
break;
|
|
case Undefined:
|
|
G4cout << "Undefined" << G4endl;
|
|
break;
|
|
default:
|
|
G4cout << " Bizarre..." << G4endl;
|
|
break;
|
|
}*/
|
|
}
|
|
|
|
|