lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.7.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2020-12-04 12:30:43 +01:00
parent 67ba86d073
commit dab42d2018
3770 changed files with 226369 additions and 286486 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/transportation/History
+10 -1
View File
@@ -16,6 +16,15 @@ committal in the CVS repository !
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
Oct 26th 2020, G. Amadio & J.Apostolakis transport-V10-06-00
A substantial reorganisation of G4Transportation::AlongStepGPIL
to use values already in cache, reduce the number of branches, and
use extra local variables for track properties to avoid indirections.
The method is one of the heaviest in many types of simulation workloads.
Profiling identified a persistent reduction in misses of instruction-TLB
loads after these changes.
Nov 1st 2019, J.Apostolakis transport-V10-05-02
----------------------------
- Optimisation in G4Transportation and G4CoupledTransportation:
@@ -311,7 +320,7 @@ Jan. 15th, 2013, A.Dotti
Jul. 12th, 2011, J.Apostolakis transport-V09-05-02
------------------------------
- G4Transportation.cc:
Corrected issues with initilisation of data members reported by Coverity.
Corrected issues with initialisation of data members reported by Coverity.
Renamed data member endpointdistance to fEndPointDistance (to conform).
Jul. 5th, 2012 Gabriele Cosmo transport-V09-05-01
source/processes/transportation/sources.cmake
+2 -23
View File
@@ -4,7 +4,7 @@
# Package: Geant4.src.G4processes.G4transportation
#
# Sources description for a library.
# Lists the sources and headers of the code explicitely.
# Lists the sources and headers of the code explicitly.
# Lists include paths needed.
# Lists the internal granular and global dependencies of the library.
# Source specific properties should be added at the end.
@@ -14,30 +14,9 @@
#
#------------------------------------------------------------------------------
# List external includes needed.
include_directories(${CLHEP_INCLUDE_DIRS})
# List internal includes needed.
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/biasing/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/magneticfield/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/navigation/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/volumes/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPGeometry/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPRandom/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/intercoms/include)
include_directories(${CMAKE_SOURCE_DIR}/source/materials/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/cuts/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/utils/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/track/include)
#
# Define the Geant4 Module.
#
include(Geant4MacroDefineModule)
GEANT4_DEFINE_MODULE(NAME G4transportation
HEADERS
G4CoupledTransportation.hh
@@ -58,7 +37,7 @@ GEANT4_DEFINE_MODULE(NAME G4transportation
G4NeutronKillerMessenger.cc
G4StepLimiter.cc
G4Transportation.cc
G4TransportationLogger.cc
G4TransportationLogger.cc
G4UserSpecialCuts.cc
G4VTrackTerminator.cc
GRANULAR_DEPENDENCIES
source/processes/transportation/src/G4Transportation.cc
+242 -286
View File
@@ -178,354 +178,310 @@ G4Transportation::PrintStatistics( std::ostream& outStr) const
// Calculate the new value of the safety and return it.
// Store the final time, position and momentum.
G4double G4Transportation::
AlongStepGetPhysicalInteractionLength( const G4Track& track,
G4double, // previousStepSize
G4double currentMinimumStep,
G4double& currentSafety,
G4GPILSelection* selection )
G4double G4Transportation::AlongStepGetPhysicalInteractionLength(
const G4Track& track,
G4double, // previousStepSize
G4double currentMinimumStep, G4double& currentSafety,
G4GPILSelection* selection)
{
G4double geometryStepLength= -1.0, newSafety= -1.0;
fParticleIsLooping = false ;
// Initial actions moved to StartTrack()
// Initial actions moved to StartTrack()
// --------------------------------------
// Note: in case another process changes touchable handle
// it will be necessary to add here (for all steps)
// it will be necessary to add here (for all steps)
// fCurrentTouchableHandle = aTrack->GetTouchableHandle();
// GPILSelection is set to defaule value of CandidateForSelection
// It is a return value
//
*selection = CandidateForSelection ;
*selection = CandidateForSelection;
fFirstStepInVolume= fNewTrack || fLastStepInVolume;
fLastStepInVolume= false;
fNewTrack = false;
fParticleChange.ProposeFirstStepInVolume(fFirstStepInVolume);
// Get initial Energy/Momentum of the track
//
const G4DynamicParticle* pParticle = track.GetDynamicParticle() ;
const G4ParticleDefinition* pParticleDef = pParticle->GetDefinition() ;
G4ThreeVector startMomentumDir = pParticle->GetMomentumDirection() ;
G4ThreeVector startPosition = track.GetPosition() ;
const G4ThreeVector startPosition = track.GetPosition();
const G4ThreeVector startMomentumDir = track.GetMomentumDirection();
// The Step Point safety can be limited by other geometries and/or the
// The Step Point safety can be limited by other geometries and/or the
// assumptions of any process - it's not always the geometrical safety.
// We calculate the starting point's isotropic safety here.
//
G4ThreeVector OriginShift = startPosition - fPreviousSftOrigin ;
G4double MagSqShift = OriginShift.mag2() ;
if( MagSqShift >= sqr(fPreviousSafety) )
{
currentSafety = 0.0 ;
}
else
{
currentSafety = fPreviousSafety - std::sqrt(MagSqShift) ;
const G4double MagSqShift = (startPosition - fPreviousSftOrigin).mag2();
if(MagSqShift >= sqr(fPreviousSafety))
currentSafety = 0.0;
else
currentSafety = fPreviousSafety - std::sqrt(MagSqShift);
}
// Is the particle charged or has it a magnetic moment?
//
G4double particleCharge = pParticle->GetCharge() ;
G4double magneticMoment = pParticle->GetMagneticMoment() ;
G4double restMass = pParticle->GetMass() ;
const G4DynamicParticle* pParticle = track.GetDynamicParticle();
fGeometryLimitedStep = false ;
const G4double particleMass = pParticle->GetMass();
const G4double particleCharge = pParticle->GetCharge();
const G4double kineticEnergy = pParticle->GetKineticEnergy();
const G4double magneticMoment = pParticle->GetMagneticMoment();
const G4ThreeVector particleSpin = pParticle->GetPolarization();
// There is no need to locate the current volume. It is Done elsewhere:
// On track construction
// On track construction
// By the tracking, after all AlongStepDoIts, in "Relocation"
// Check if the particle has a force, EM or gravitational, exerted on it
//
G4FieldManager* fieldMgr=0;
G4bool fieldExertsForce = false ;
fieldMgr = fFieldPropagator->FindAndSetFieldManager( track.GetVolume() );
G4bool eligibleEM = (particleCharge != 0.0)
|| ( fUseMagneticMoment && (magneticMoment != 0.0) );
G4bool eligibleGrav = fUseGravity && (restMass != 0.0) ;
G4bool eligibleEM =
(particleCharge != 0.0) || ((magneticMoment != 0.0) && fUseMagneticMoment);
G4bool eligibleGrav = (particleMass != 0.0) && fUseGravity;
if( (fieldMgr!=nullptr) && (eligibleEM||eligibleGrav) )
fFieldExertedForce = false;
if(eligibleEM || eligibleGrav)
{
// User can configure the field Manager for this track
fieldMgr->ConfigureForTrack( &track );
// Called here to allow a transition from no-field pointer
// to finite field (non-zero pointer).
// If the field manager has no field ptr, the field is zero
// by definition ( = there is no field ! )
const G4Field* ptrField= fieldMgr->GetDetectorField();
if( ptrField )
{
fieldExertsForce = eligibleEM
|| ( eligibleGrav && ptrField->IsGravityActive() );
}
// || (gravityOn && (restMass != 0.0)) )
if(G4FieldManager* fieldMgr =
fFieldPropagator->FindAndSetFieldManager(track.GetVolume()))
{
// User can configure the field Manager for this track
fieldMgr->ConfigureForTrack(&track);
// Called here to allow a transition from no-field pointer
// to finite field (non-zero pointer).
// If the field manager has no field ptr, the field is zero
// by definition ( = there is no field ! )
if(const G4Field* ptrField = fieldMgr->GetDetectorField())
fFieldExertedForce =
eligibleEM || (eligibleGrav && ptrField->IsGravityActive());
}
}
fFieldExertedForce = fieldExertsForce;
if( !fieldExertsForce )
G4double geometryStepLength = currentMinimumStep;
if(currentMinimumStep == 0.0)
{
G4double linearStepLength ;
if( fShortStepOptimisation && (currentMinimumStep <= currentSafety) )
{
// The Step is guaranteed to be taken
//
geometryStepLength = currentMinimumStep ;
fGeometryLimitedStep = false ;
}
else
{
// Find whether the straight path intersects a volume
//
linearStepLength = fLinearNavigator->ComputeStep( startPosition,
startMomentumDir,
currentMinimumStep,
newSafety) ;
// Remember last safety origin & value.
//
fPreviousSftOrigin = startPosition ;
fPreviousSafety = newSafety ;
fpSafetyHelper->SetCurrentSafety( newSafety, startPosition);
fEndPointDistance = 0.0;
// flag step as geometry limited if current safety is also zero
fGeometryLimitedStep = (currentSafety == 0.0);
currentSafety = newSafety ;
fGeometryLimitedStep= (linearStepLength <= currentMinimumStep);
if( fGeometryLimitedStep )
{
// The geometry limits the Step size (an intersection was found.)
geometryStepLength = linearStepLength ;
}
else
{
// The full Step is taken.
geometryStepLength = currentMinimumStep ;
}
}
fEndPointDistance = geometryStepLength ;
// Calculate final position
//
fTransportEndPosition = startPosition+geometryStepLength*startMomentumDir;
// Momentum direction, energy and polarisation are unchanged by transport
//
fTransportEndMomentumDir = startMomentumDir ;
fTransportEndKineticEnergy = track.GetKineticEnergy() ;
fTransportEndSpin = track.GetPolarization();
fParticleIsLooping = false ;
fMomentumChanged = false ;
fEndGlobalTimeComputed = false ;
fMomentumChanged = false;
fParticleIsLooping = false;
fEndGlobalTimeComputed = false;
fTransportEndPosition = startPosition;
fTransportEndMomentumDir = startMomentumDir;
fTransportEndKineticEnergy = kineticEnergy;
fTransportEndSpin = particleSpin;
}
else // A field exerts force
else if(!fFieldExertedForce)
{
G4double momentumMagnitude = pParticle->GetTotalMomentum() ;
G4ThreeVector EndUnitMomentum ;
G4double lengthAlongCurve ;
fGeometryLimitedStep = false;
if(geometryStepLength > currentSafety || !fShortStepOptimisation)
{
const G4double linearStepLength = fLinearNavigator->ComputeStep(
startPosition, startMomentumDir, currentMinimumStep, currentSafety);
// The charge can change (dynamic)
//
G4ChargeState chargeState(particleCharge,
magneticMoment,
pParticleDef->GetPDGSpin() );
auto equationOfMotion = fFieldPropagator->GetCurrentEquationOfMotion();
if(linearStepLength <= currentMinimumStep)
{
geometryStepLength = linearStepLength;
fGeometryLimitedStep = true;
}
// Remember last safety origin & value.
//
fPreviousSftOrigin = startPosition;
fPreviousSafety = currentSafety;
fpSafetyHelper->SetCurrentSafety(currentSafety, startPosition);
}
equationOfMotion->SetChargeMomentumMass( chargeState,
momentumMagnitude,
restMass);
G4FieldTrack aFieldTrack = G4FieldTrack( startPosition,
track.GetGlobalTime(), // Lab.
track.GetMomentumDirection(),
track.GetKineticEnergy(),
restMass,
particleCharge,
track.GetPolarization(),
pParticleDef->GetPDGMagneticMoment(),
0.0, // Length along track
pParticleDef->GetPDGSpin() );
fEndPointDistance = geometryStepLength;
if( currentMinimumStep > 0 )
{
// Do the Transport in the field (non recti-linear)
//
lengthAlongCurve = fFieldPropagator->ComputeStep( aFieldTrack,
currentMinimumStep,
currentSafety,
track.GetVolume(),
track.GetKineticEnergy() < fThreshold_Important_Energy );
fMomentumChanged = false;
fParticleIsLooping = false;
fEndGlobalTimeComputed = false;
fTransportEndPosition =
startPosition + geometryStepLength * startMomentumDir;
fTransportEndMomentumDir = startMomentumDir;
fTransportEndKineticEnergy = kineticEnergy;
fTransportEndSpin = particleSpin;
}
else // A field exerts force
{
const auto pParticleDef = pParticle->GetDefinition();
const auto particlePDGSpin = pParticleDef->GetPDGSpin();
const auto particlePDGMagM = pParticleDef->GetPDGMagneticMoment();
fGeometryLimitedStep= fFieldPropagator->IsLastStepInVolume();
//
// It is possible that step was reduced in PropagatorInField due to
// previous zero steps. To cope with case that reduced step is taken
// in full, we must rely on PiF to obtain this value
auto equationOfMotion = fFieldPropagator->GetCurrentEquationOfMotion();
geometryStepLength = std::min( lengthAlongCurve, currentMinimumStep );
// Remember last safety origin & value.
//
fPreviousSftOrigin = startPosition ;
fPreviousSafety = currentSafety ;
fpSafetyHelper->SetCurrentSafety( currentSafety, startPosition);
}
else
{
geometryStepLength = lengthAlongCurve= 0.0 ;
fGeometryLimitedStep = false ;
}
// Get the End-Position and End-Momentum (Dir-ection)
//
fTransportEndPosition = aFieldTrack.GetPosition() ;
// The charge can change (dynamic), therefore the use of G4ChargeState
//
equationOfMotion->SetChargeMomentumMass(
G4ChargeState(particleCharge, magneticMoment, particlePDGSpin),
pParticle->GetTotalMomentum(), particleMass);
fTransportEndSpin = aFieldTrack.GetSpin();
fParticleIsLooping = fFieldPropagator->IsParticleLooping() ;
fEndPointDistance = (fTransportEndPosition - startPosition).mag() ;
// Momentum: Magnitude and direction can be changed too now ...
//
fMomentumChanged = true ;
fTransportEndMomentumDir = aFieldTrack.GetMomentumDir() ;
G4FieldTrack aFieldTrack(startPosition,
track.GetGlobalTime(), // Lab.
startMomentumDir, kineticEnergy, particleMass,
particleCharge, particleSpin, particlePDGMagM,
0.0, // Length along track
particlePDGSpin);
fTransportEndKineticEnergy = aFieldTrack.GetKineticEnergy() ;
// Do the Transport in the field (non recti-linear)
//
const G4double lengthAlongCurve = fFieldPropagator->ComputeStep(
aFieldTrack, currentMinimumStep, currentSafety, track.GetVolume(),
kineticEnergy < fThreshold_Important_Energy);
if( fFieldPropagator->GetCurrentFieldManager()->DoesFieldChangeEnergy() )
{
// If the field can change energy, then the time must be integrated
// - so this should have been updated
//
fCandidateEndGlobalTime = aFieldTrack.GetLabTimeOfFlight();
fEndGlobalTimeComputed = true;
if(lengthAlongCurve < geometryStepLength)
geometryStepLength = lengthAlongCurve;
// was ( fCandidateEndGlobalTime != track.GetGlobalTime() );
// a cleaner way is to have FieldTrack knowing whether time is updated.
}
else
{
// The energy should be unchanged by field transport,
// - so the time changed will be calculated elsewhere
//
fEndGlobalTimeComputed = false;
// Remember last safety origin & value.
//
fPreviousSftOrigin = startPosition;
fPreviousSafety = currentSafety;
fpSafetyHelper->SetCurrentSafety(currentSafety, startPosition);
// Check that the integration preserved the energy
// - and if not correct this!
G4double startEnergy= track.GetKineticEnergy();
G4double endEnergy= fTransportEndKineticEnergy;
fGeometryLimitedStep = fFieldPropagator->IsLastStepInVolume();
//
// It is possible that step was reduced in PropagatorInField due to
// previous zero steps. To cope with case that reduced step is taken
// in full, we must rely on PiF to obtain this value
static G4ThreadLocal G4int no_inexact_steps=0, no_large_ediff;
G4double absEdiff = std::fabs(startEnergy- endEnergy);
if( absEdiff > perMillion * endEnergy )
G4bool changesEnergy =
fFieldPropagator->GetCurrentFieldManager()->DoesFieldChangeEnergy();
fMomentumChanged = true;
fParticleIsLooping = fFieldPropagator->IsParticleLooping();
fEndGlobalTimeComputed = changesEnergy;
fTransportEndPosition = aFieldTrack.GetPosition();
fTransportEndMomentumDir = aFieldTrack.GetMomentumDir();
fEndPointDistance = (fTransportEndPosition - startPosition).mag();
// Ignore change in energy for fields that conserve energy
// This hides the integration error, but gives a better physical answer
fTransportEndKineticEnergy =
changesEnergy ? aFieldTrack.GetKineticEnergy() : kineticEnergy;
fTransportEndSpin = aFieldTrack.GetSpin();
if(fEndGlobalTimeComputed)
{
// If the field can change energy, then the time must be integrated
// - so this should have been updated
//
fCandidateEndGlobalTime = aFieldTrack.GetLabTimeOfFlight();
// was ( fCandidateEndGlobalTime != track.GetGlobalTime() );
// a cleaner way is to have FieldTrack knowing whether time is updated.
}
#if defined(G4VERBOSE) || defined(G4DEBUG_TRANSPORT)
else
{
// The energy should be unchanged by field transport,
// - so the time changed will be calculated elsewhere
//
// Check that the integration preserved the energy
// - and if not correct this!
G4double startEnergy = kineticEnergy;
G4double endEnergy = fTransportEndKineticEnergy;
static G4ThreadLocal G4int no_inexact_steps = 0, no_large_ediff;
G4double absEdiff = std::fabs(startEnergy - endEnergy);
if(absEdiff > perMillion * endEnergy)
{
no_inexact_steps++;
// Possible statistics keeping here ...
}
if(verboseLevel > 1)
{
if(std::fabs(startEnergy - endEnergy) > perThousand * endEnergy)
{
no_inexact_steps++;
// Possible statistics keeping here ...
}
if( verboseLevel > 1 )
{
if( std::fabs(startEnergy- endEnergy) > perThousand * endEnergy )
static G4ThreadLocal G4int no_warnings = 0, warnModulo = 1,
moduloFactor = 10;
no_large_ediff++;
if((no_large_ediff % warnModulo) == 0)
{
static G4ThreadLocal G4int no_warnings= 0, warnModulo=1,
moduloFactor= 10;
no_large_ediff ++;
if( (no_large_ediff% warnModulo) == 0 )
no_warnings++;
std::ostringstream message;
message << "Energy change in Step is above 1^-3 relative value. "
<< G4endl << " Relative change in 'tracking' step = "
<< std::setw(15) << (endEnergy - startEnergy) / startEnergy
<< G4endl << " Starting E= " << std::setw(12)
<< startEnergy / MeV << " MeV " << G4endl
<< " Ending E= " << std::setw(12) << endEnergy / MeV
<< " MeV " << G4endl
<< "Energy has been corrected -- however, review"
<< " field propagation parameters for accuracy." << G4endl;
if((verboseLevel > 2) || (no_warnings < 4) ||
(no_large_ediff == warnModulo * moduloFactor))
{
no_warnings++;
std::ostringstream message;
message << "Energy change in Step is above 1^-3 relative value. "
<< G4endl
<< " Relative change in 'tracking' step = "
<< std::setw(15) << (endEnergy-startEnergy)/startEnergy
<< G4endl
<< " Starting E= " << std::setw(12) << startEnergy / MeV
<< " MeV " << G4endl
<< " Ending E= " << std::setw(12) << endEnergy / MeV
<< " MeV " << G4endl
<< "Energy has been corrected -- however, review"
<< " field propagation parameters for accuracy." << G4endl;
if ( (verboseLevel > 2 ) || (no_warnings<4)
|| (no_large_ediff == warnModulo * moduloFactor) )
{
message << "These include EpsilonStepMax(/Min) in G4FieldManager " << G4endl
<< "which determine fractional error per step for integrated quantities. " << G4endl
<< "Note also the influence of the permitted number of integration steps."
<< G4endl;
}
message << "Bad 'endpoint'. Energy change detected and corrected."
message << "These include EpsilonStepMax(/Min) in G4FieldManager "
<< G4endl
<< "Has occurred already " << no_large_ediff << " times.";
G4Exception("G4Transportation::AlongStepGetPIL()",
"EnergyChange", JustWarning, message);
if( no_large_ediff == warnModulo * moduloFactor )
{
warnModulo *= moduloFactor;
}
<< "which determine fractional error per step for "
"integrated quantities. "
<< G4endl
<< "Note also the influence of the permitted number of "
"integration steps."
<< G4endl;
}
message << "Bad 'endpoint'. Energy change detected and corrected."
<< G4endl << "Has occurred already " << no_large_ediff
<< " times.";
G4Exception("G4Transportation::AlongStepGetPIL()", "EnergyChange",
JustWarning, message);
if(no_large_ediff == warnModulo * moduloFactor)
{
warnModulo *= moduloFactor;
}
}
} // end of if (verboseLevel)
// Correct the energy for fields that conserve it
// This - hides the integration error
// - but gives a better physical answer
//
fTransportEndKineticEnergy= track.GetKineticEnergy();
}
}
// If we are asked to go a step length of 0, and we are on a boundary
// then a boundary will also limit the step -> we must flag this.
//
if( currentMinimumStep == 0.0 )
{
if( currentSafety == 0.0 ) { fGeometryLimitedStep = true; }
}
} // end of if (verboseLevel)
}
#endif
}
// Update the safety starting from the end-point,
// if it will become negative at the end-point.
//
if( currentSafety < fEndPointDistance )
if(currentSafety < fEndPointDistance)
{
if( particleCharge != 0.0 )
{
G4double endSafety =
fLinearNavigator->ComputeSafety( fTransportEndPosition) ;
currentSafety = endSafety ;
fPreviousSftOrigin = fTransportEndPosition ;
fPreviousSafety = currentSafety ;
fpSafetyHelper->SetCurrentSafety(currentSafety, fTransportEndPosition);
if(particleCharge != 0.0)
{
G4double endSafety =
fLinearNavigator->ComputeSafety(fTransportEndPosition);
currentSafety = endSafety;
fPreviousSftOrigin = fTransportEndPosition;
fPreviousSafety = currentSafety;
fpSafetyHelper->SetCurrentSafety(currentSafety, fTransportEndPosition);
// Because the Stepping Manager assumes it is from the start point,
// add the StepLength
//
currentSafety += fEndPointDistance ;
// Because the Stepping Manager assumes it is from the start point,
// add the StepLength
//
currentSafety += fEndPointDistance;
#ifdef G4DEBUG_TRANSPORT
G4cout.precision(12) ;
G4cout << "***G4Transportation::AlongStepGPIL ** " << G4endl ;
G4cout << " Called Navigator->ComputeSafety at " << fTransportEndPosition
<< " and it returned safety= " << endSafety << G4endl ;
G4cout << " Adding endpoint distance " << fEndPointDistance
<< " to obtain pseudo-safety= " << currentSafety << G4endl ;
}
else
{
G4cout << "***G4Transportation::AlongStepGPIL ** " << G4endl ;
G4cout << " Avoiding call to ComputeSafety : " << G4endl;
G4cout << " charge = " << particleCharge << G4endl;
G4cout << " mag moment = " << magneticMoment << G4endl;
#ifdef G4DEBUG_TRANSPORT
G4cout.precision(12);
G4cout << "***G4Transportation::AlongStepGPIL ** " << G4endl;
G4cout << " Called Navigator->ComputeSafety at " << fTransportEndPosition
<< " and it returned safety= " << endSafety << G4endl;
G4cout << " Adding endpoint distance " << fEndPointDistance
<< " to obtain pseudo-safety= " << currentSafety << G4endl;
}
else
{
G4cout << "***G4Transportation::AlongStepGPIL ** " << G4endl;
G4cout << " Avoiding call to ComputeSafety : " << G4endl;
G4cout << " charge = " << particleCharge << G4endl;
G4cout << " mag moment = " << magneticMoment << G4endl;
#endif
}
}
}
}
fParticleChange.ProposeTrueStepLength(geometryStepLength) ;
fFirstStepInVolume = fNewTrack || fLastStepInVolume;
fLastStepInVolume = false;
fNewTrack = false;
return geometryStepLength ;
fParticleChange.ProposeFirstStepInVolume(fFirstStepInVolume);
fParticleChange.ProposeTrueStepLength(geometryStepLength);
return geometryStepLength;
}
//////////////////////////////////////////////////////////////////////////