G4ITTransportation Class Reference

#include <G4ITTransportation.hh>

Inheritance diagram for G4ITTransportation:

Public Member Functions
	G4ITTransportation (const G4String &aName="ITTransportation", G4int verbosityLevel=1)
virtual	~G4ITTransportation ()
	G4ITTransportation (const G4ITTransportation &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	ComputeStep (const G4Track &, const G4Step &, const double timeStep, double &spaceStep)
virtual void	StartTracking (G4Track *aTrack)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double, G4ForceCondition *pForceCond)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &)
G4PropagatorInField *	GetPropagatorInField ()
void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
	This class is a slightly modified version of G4Transportation initially written by J. Apostolakis and colleagues But it should use the exact same algorithm.
void	SetVerboseLevel (G4int verboseLevel)
G4int	GetVerboseLevel () const
G4double	GetThresholdWarningEnergy () const
G4double	GetThresholdImportantEnergy () const
G4int	GetThresholdTrials () const
void	SetThresholdWarningEnergy (G4double newEnWarn)
void	SetThresholdImportantEnergy (G4double newEnImp)
void	SetThresholdTrials (G4int newMaxTrials)
G4double	GetMaxEnergyKilled () const
G4double	GetSumEnergyKilled () const
void	ResetKilledStatistics (G4int report=1)
void	EnableShortStepOptimisation (G4bool optimise=true)
Protected Member Functions
G4bool	DoesGlobalFieldExist ()
void	SetInstantiateProcessState (G4bool flag)
G4bool	InstantiateProcessState ()
Protected Attributes
G4ITTransportationState *const &	fTransportationState
G4ITNavigator *	fLinearNavigator
G4PropagatorInField *	fFieldPropagator
G4ParticleChangeForTransport	fParticleChange
G4double	fThreshold_Warning_Energy
G4double	fThreshold_Important_Energy
G4int	fThresholdTrials
G4double	fUnimportant_Energy
G4double	fSumEnergyKilled
G4double	fMaxEnergyKilled
G4bool	fShortStepOptimisation
G4SafetyHelper *	fpSafetyHelper
G4int	fVerboseLevel
Data Structures
struct	G4ITTransportationState

---

Detailed Description

Definition at line 57 of file G4ITTransportation.hh.

---

Constructor & Destructor Documentation

G4ITTransportation::G4ITTransportation	(	const G4String &	aName = "ITTransportation",
		G4int	verbosityLevel = 1
	)

Definition at line 81 of file G4ITTransportation.cc.

References G4VProcess::enableAlongStepDoIt, G4VProcess::enableAtRestDoIt, G4VProcess::enablePostStepDoIt, fFieldPropagator, fLinearNavigator, fParticleChange, fpSafetyHelper, G4ITTransportationManager::GetNavigatorForTracking(), G4TransportationManager::GetPropagatorInField(), G4ITTransportationManager::GetTransportationManager(), G4TransportationManager::GetTransportationManager(), G4VProcess::pParticleChange, G4VITProcess::SetInstantiateProcessState(), SetInstantiateProcessState(), and G4VProcess::SetProcessSubType().

                                                                         :
    G4VITProcess(aName, fTransportation),
    InitProcessState(fTransportationState, fpState),
    fThreshold_Warning_Energy( 100 * MeV ),
    fThreshold_Important_Energy( 250 * MeV ),
    fThresholdTrials( 10 ),
    fUnimportant_Energy( 1 * MeV ),  // Not used
    fSumEnergyKilled( 0.0 ), fMaxEnergyKilled( 0.0 ),
    fShortStepOptimisation(false),    // Old default: true (=fast short steps)
    fVerboseLevel( verbose )
{
    pParticleChange = &fParticleChange;
    G4TransportationManager* transportMgr ;
    transportMgr = G4TransportationManager::GetTransportationManager() ;
    G4ITTransportationManager* ITtransportMgr ;
    ITtransportMgr = G4ITTransportationManager::GetTransportationManager() ;
    fLinearNavigator = ITtransportMgr->GetNavigatorForTracking() ;
    fFieldPropagator = transportMgr->GetPropagatorInField() ;
    fpSafetyHelper =   0; // transportMgr->GetSafetyHelper();  // New

    // Cannot determine whether a field exists here, as it would
    //  depend on the relative order of creating the detector's
    //  field and this process. That order is not guaranted.
    // Instead later the method DoesGlobalFieldExist() is called

    enableAtRestDoIt    = false;
    enableAlongStepDoIt = true;
    enablePostStepDoIt  = true;
    SetProcessSubType(60);
    SetInstantiateProcessState(true);
    G4VITProcess::SetInstantiateProcessState(false);
    fInstantiateProcessState = true;
}

G4ITTransportation::~G4ITTransportation

(

)

[virtual]

Definition at line 189 of file G4ITTransportation.cc.

References fMaxEnergyKilled, fSumEnergyKilled, fVerboseLevel, G4cout, and G4endl.

{
#ifdef G4VERBOSE
    if( (fVerboseLevel > 0) && (fSumEnergyKilled > 0.0 ) )
    {
        G4cout << " G4ITTransportation: Statistics for looping particles " << G4endl;
        G4cout << "   Sum of energy of loopers killed: " <<  fSumEnergyKilled << G4endl;
        G4cout << "   Max energy of loopers killed: " <<  fMaxEnergyKilled << G4endl;
    }
#endif
}

G4ITTransportation::G4ITTransportation

(

const G4ITTransportation &

)

Definition at line 116 of file G4ITTransportation.cc.

References G4VProcess::enableAlongStepDoIt, G4VProcess::enableAtRestDoIt, G4VProcess::enablePostStepDoIt, fFieldPropagator, fInstantiateProcessState, fLinearNavigator, fMaxEnergyKilled, fParticleChange, fpSafetyHelper, fShortStepOptimisation, fSumEnergyKilled, fThreshold_Important_Energy, fThreshold_Warning_Energy, fThresholdTrials, fUnimportant_Energy, fVerboseLevel, G4ITTransportationManager::GetNavigatorForTracking(), G4TransportationManager::GetPropagatorInField(), G4ITTransportationManager::GetTransportationManager(), G4TransportationManager::GetTransportationManager(), G4VProcess::pParticleChange, G4VITProcess::SetInstantiateProcessState(), and SetInstantiateProcessState().

                                                                      :
    G4VITProcess(right),
    InitProcessState(fTransportationState, fpState)
{
    // Copy attributes
    fVerboseLevel               = right.fVerboseLevel ;
    fThreshold_Warning_Energy   = right.fThreshold_Warning_Energy;
    fThreshold_Important_Energy = right.fThreshold_Important_Energy;
    fThresholdTrials            = right.fThresholdTrials;
    fUnimportant_Energy         = right.fUnimportant_Energy;
    fSumEnergyKilled            = right.fSumEnergyKilled;
    fMaxEnergyKilled            = right.fMaxEnergyKilled;
    fShortStepOptimisation      = right.fShortStepOptimisation;

    // Setup Navigators
    G4TransportationManager* transportMgr ;
    transportMgr = G4TransportationManager::GetTransportationManager() ;
    G4ITTransportationManager* ITtransportMgr ;
    ITtransportMgr = G4ITTransportationManager::GetTransportationManager() ;
    fLinearNavigator = ITtransportMgr->GetNavigatorForTracking() ;
    fFieldPropagator = transportMgr->GetPropagatorInField() ;
    fpSafetyHelper =   0; //transportMgr->GetSafetyHelper();  // New

    // Cannot determine whether a field exists here, as it would
    //  depend on the relative order of creating the detector's
    //  field and this process. That order is not guaranted.
    // Instead later the method DoesGlobalFieldExist() is called

    enableAtRestDoIt    = false;
    enableAlongStepDoIt = true;
    enablePostStepDoIt  = true;

    pParticleChange = &fParticleChange;
    SetInstantiateProcessState(true);
    G4VITProcess::SetInstantiateProcessState(false);
    fInstantiateProcessState = right.fInstantiateProcessState;
}

---

Member Function Documentation

G4VParticleChange * G4ITTransportation::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	stepData
	)			[virtual]

Implements G4VProcess.

Reimplemented in G4DNABrownianTransportation.

Definition at line 610 of file G4ITTransportation.cc.

References G4Track::CalculateVelocityForOpticalPhoton(), fFieldPropagator, G4ParticleTable::FindParticle(), fMaxEnergyKilled, fParticleChange, fStopAndKill, fSumEnergyKilled, fThreshold_Important_Energy, fThreshold_Warning_Energy, fThresholdTrials, fVerboseLevel, G4cout, G4endl, G4Track::GetGlobalTime(), G4Track::GetKineticEnergy(), G4Track::GetLocalTime(), G4Track::GetParticleDefinition(), G4ParticleTable::GetParticleTable(), G4Step::GetPreStepPoint(), G4Track::GetStepLength(), G4StepPoint::GetVelocity(), G4PropagatorInField::GimmeTrajectoryVectorAndForgetIt(), G4ParticleChangeForTransport::Initialize(), G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeGlobalTime(), G4ParticleChange::ProposeLocalTime(), G4ParticleChange::ProposeMomentumDirection(), G4ParticleChange::ProposePolarization(), G4ParticleChange::ProposePosition(), G4VParticleChange::ProposeTrackStatus(), G4ParticleChange::ProposeVelocity(), G4ParticleChangeForTransport::SetMomentumChanged(), G4ParticleChangeForTransport::SetPointerToVectorOfAuxiliaryPoints(), and State.

Referenced by G4DNABrownianTransportation::AlongStepDoIt().

{

    //    G4cout << "G4ITTransportation::AlongStepDoIt" << G4endl;
    // set  pdefOpticalPhoton
    static  G4ParticleDefinition* pdefOpticalPhoton =
            G4ParticleTable::GetParticleTable()->FindParticle("opticalphoton");

    static G4int noCalls=0;
    noCalls++;

    fParticleChange.Initialize(track) ;

    //  Code for specific process
    //
    fParticleChange.ProposePosition(State(fTransportEndPosition)) ;
    fParticleChange.ProposeMomentumDirection(State(fTransportEndMomentumDir)) ;
    fParticleChange.ProposeEnergy(State(fTransportEndKineticEnergy)) ;
    fParticleChange.SetMomentumChanged(State(fMomentumChanged)) ;

    fParticleChange.ProposePolarization(State(fTransportEndSpin));

    G4double deltaTime = 0.0 ;

    // Calculate  Lab Time of Flight (ONLY if field Equations used it!)
    // G4double endTime   = State(fCandidateEndGlobalTime);
    // G4double delta_time = endTime - startTime;

    G4double startTime = track.GetGlobalTime() ;
    if (State(fEndGlobalTimeComputed) == false)
    {
        // The time was not integrated .. make the best estimate possible
        //
        G4double initialVelocity = stepData.GetPreStepPoint()->GetVelocity() ;
        G4double stepLength      = track.GetStepLength() ;

        deltaTime= 0.0;  // in case initialVelocity = 0
        if (track.GetParticleDefinition() == pdefOpticalPhoton)
        {
            // For only Optical Photon, final velocity is used
            double finalVelocity = track.CalculateVelocityForOpticalPhoton();
            fParticleChange.ProposeVelocity(finalVelocity);
            deltaTime = stepLength/finalVelocity ;
        }
        else if( initialVelocity > 0.0 )
        {
            deltaTime = stepLength/initialVelocity ;
        }

        State(fCandidateEndGlobalTime)   = startTime + deltaTime ;
    }
    else
    {
        deltaTime = State(fCandidateEndGlobalTime) - startTime ;
    }

    fParticleChange.ProposeGlobalTime( State(fCandidateEndGlobalTime) ) ;
    fParticleChange.ProposeLocalTime(  track.GetLocalTime() + deltaTime) ;
    /*
    // Now Correct by Lorentz factor to get delta "proper" Time

    G4double  restMass       = track.GetDynamicParticle()->GetMass() ;
    G4double deltaProperTime = deltaTime*( restMass/track.GetTotalEnergy() ) ;

    fParticleChange.ProposeProperTime(track.GetProperTime() + deltaProperTime) ;
*/

    fParticleChange. ProposeTrueStepLength( track.GetStepLength() ) ;


    // If the particle is caught looping or is stuck (in very difficult
    // boundaries) in a magnetic field (doing many steps)
    //   THEN this kills it ...
    //
    if ( State(fParticleIsLooping) )
    {
        G4double endEnergy= State(fTransportEndKineticEnergy);

        if( (endEnergy < fThreshold_Important_Energy)
                || (State(fNoLooperTrials) >= fThresholdTrials ) )
        {
            // Kill the looping particle
            //
            //            G4cout << "G4ITTransportation will killed the molecule"<< G4endl;
            fParticleChange.ProposeTrackStatus( fStopAndKill )  ;

            // 'Bare' statistics
            fSumEnergyKilled += endEnergy;
            if( endEnergy > fMaxEnergyKilled)
            {
                fMaxEnergyKilled= endEnergy;
            }

#ifdef G4VERBOSE
            if( (fVerboseLevel > 1) ||
                    ( endEnergy > fThreshold_Warning_Energy )  )
            {
                G4cout << " G4ITTransportation is killing track that is looping or stuck "
                       << G4endl
                       << "   This track has " << track.GetKineticEnergy() / MeV
                       << " MeV energy." << G4endl;
                G4cout << "   Number of trials = " << State(fNoLooperTrials)
                       << "   No of calls to AlongStepDoIt = " << noCalls
                       << G4endl;
            }
#endif
            State(fNoLooperTrials)=0;
        }
        else
        {
            State(fNoLooperTrials) ++;
#ifdef G4VERBOSE
            if( (fVerboseLevel > 2) )
            {
                G4cout << "   G4ITTransportation::AlongStepDoIt(): Particle looping -  "
                       << "   Number of trials = " << State(fNoLooperTrials)
                       << "   No of calls to  = " << noCalls
                       << G4endl;
            }
#endif
        }
    }
    else
    {
        State(fNoLooperTrials)=0;
    }

    // Another (sometimes better way) is to use a user-limit maximum Step size
    // to alleviate this problem ..

    // Introduce smooth curved trajectories to particle-change
    //
    fParticleChange.SetPointerToVectorOfAuxiliaryPoints
            (fFieldPropagator->GimmeTrajectoryVectorAndForgetIt() );

    return &fParticleChange ;
}

G4double G4ITTransportation::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	,
		G4double	currentMinimumStep,
		G4double &	currentSafety,
		G4GPILSelection *	selection
	)			[virtual]

Implements G4VProcess.

Reimplemented in G4DNABrownianTransportation.

Definition at line 218 of file G4ITTransportation.cc.

References CandidateForSelection, G4ITNavigator::ComputeSafety(), G4ITNavigator::ComputeStep(), G4FieldManager::ConfigureForTrack(), FatalException, fFieldPropagator, G4PropagatorInField::FindAndSetFieldManager(), fLinearNavigator, fpSafetyHelper, fShortStepOptimisation, G4cout, G4endl, G4Exception(), G4DynamicParticle::GetCharge(), G4FieldManager::GetDetectorField(), G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4Track::GetKineticEnergy(), G4DynamicParticle::GetMomentumDirection(), G4Track::GetPolarization(), G4Track::GetPosition(), G4Track::GetTouchableHandle(), G4Track::GetVelocity(), G4Track::GetVolume(), G4SafetyHelper::SetCurrentSafety(), sqr(), and State.

Referenced by G4DNABrownianTransportation::AlongStepGetPhysicalInteractionLength().

{
    G4double geometryStepLength(-1.0), newSafety(-1.0) ;

    State(fParticleIsLooping) = false ;
    State(fEndGlobalTimeComputed) = false ;
    State(fGeometryLimitedStep) = false ;

    // Initial actions moved to  StartTrack()
    // --------------------------------------
    // Note: in case another process changes touchable handle
    //    it will be necessary to add here (for all steps)
    State(fCurrentTouchableHandle) = track.GetTouchableHandle();

    // GPILSelection is set to defaule value of CandidateForSelection
    // It is a return value
    //
    *selection = CandidateForSelection ;

    // 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() ;

    // G4double   theTime        = track.GetGlobalTime() ;

    // 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 - State(fPreviousSftOrigin) ;
    G4double      MagSqShift  = OriginShift.mag2() ;
    if( MagSqShift >= sqr(State(fPreviousSafety)) )
    {
        currentSafety = 0.0 ;
    }
    else
    {
        currentSafety = State(fPreviousSafety) - std::sqrt(MagSqShift) ;
    }

    // Is the particle charged ?
    //
    G4double              particleCharge = pParticle->GetCharge() ;


    // There is no need to locate the current volume. It is Done elsewhere:
    //   On track construction
    //   By the tracking, after all AlongStepDoIts, in "Relocation"

    // Check whether the particle have an (EM) field force exerting upon it
    //
    G4FieldManager* fieldMgr=0;
    G4bool          fieldExertsForce = false ;
    if( (particleCharge != 0.0) )
    {
        fieldMgr= fFieldPropagator->FindAndSetFieldManager( track.GetVolume() );
        if (fieldMgr != 0)
        {
            // Message the field Manager, to configure it for this track
            fieldMgr->ConfigureForTrack( &track );
            // Moved here, in order to allow a transition
            //   from a zero-field  status (with fieldMgr->(field)0
            //   to a finite field  status

            // If the field manager has no field, there is no field !
            fieldExertsForce = (fieldMgr->GetDetectorField() != 0);
        }
    }

    // G4cout << " G4Transport:  field exerts force= " << fieldExertsForce
    //   << "  fieldMgr= " << fieldMgr << G4endl;

    // Choose the calculation of the transportation: Field or not
    //
    if( !fieldExertsForce )
    {
        G4double linearStepLength ;
        if( fShortStepOptimisation && (currentMinimumStep <= currentSafety) )
        {
            // The Step is guaranteed to be taken
            //
            geometryStepLength   = currentMinimumStep ;
            State(fGeometryLimitedStep) = false ;
        }
        else
        {
            //  Find whether the straight path intersects a volume
            //
            linearStepLength = fLinearNavigator->ComputeStep( startPosition,
                                                              startMomentumDir,
                                                              currentMinimumStep,
                                                              newSafety) ;
            // Remember last safety origin & value.
            //
            State(fPreviousSftOrigin) = startPosition ;
            State(fPreviousSafety)    = newSafety ;
            // fpSafetyHelper->SetCurrentSafety( newSafety, startPosition);

            // The safety at the initial point has been re-calculated:
            //
            currentSafety = newSafety ;

            State(fGeometryLimitedStep)= (linearStepLength <= currentMinimumStep);
            if( State(fGeometryLimitedStep) )
            {
                // The geometry limits the Step size (an intersection was found.)
                geometryStepLength   = linearStepLength ;
            }
            else
            {
                // The full Step is taken.
                geometryStepLength   = currentMinimumStep ;
            }
        }
        State(endpointDistance) = geometryStepLength ;

        // Calculate final position
        //
        State(fTransportEndPosition) = startPosition+geometryStepLength*startMomentumDir ;

        // Momentum direction, energy and polarisation are unchanged by transport
        //
        State(fTransportEndMomentumDir)   = startMomentumDir ;
        State(fTransportEndKineticEnergy) = track.GetKineticEnergy() ;
        State(fTransportEndSpin)          = track.GetPolarization();
        State(fParticleIsLooping)         = false ;
        State(fMomentumChanged)           = false ;
        State(fEndGlobalTimeComputed)     = true ;
        State(theInteractionTimeLeft)     = State(endpointDistance)/track.GetVelocity();
        State(fCandidateEndGlobalTime)    = State(theInteractionTimeLeft)+track.GetGlobalTime();

        //        G4cout << "track.GetVelocity() : " << track.GetVelocity() << G4endl;
        //        G4cout << "State(endpointDistance) : " << G4BestUnit(State(endpointDistance),"Length") << G4endl;
        //        G4cout << "State(theInteractionTimeLeft) : " << G4BestUnit(State(theInteractionTimeLeft),"Time") << G4endl;
        //        G4cout << "track.GetGlobalTime() : " << G4BestUnit(track.GetGlobalTime(),"Time") << G4endl;

    }
    else   //  A field exerts force
    {

        G4ExceptionDescription exceptionDescription;
        exceptionDescription << "ITTransportation does not support external fields.";
        exceptionDescription << " If you are dealing with a tradiational MC simulation, ";
        exceptionDescription << "please use G4Transportation.";

        G4Exception("G4ITTransportation::AlongStepGetPhysicalInteractionLength","NoExternalFieldSupport",
                    FatalException,exceptionDescription);
 /*
        G4double       momentumMagnitude = pParticle->GetTotalMomentum() ;
        //        G4ThreeVector  EndUnitMomentum ;
        G4double       lengthAlongCurve ;
        G4double       restMass = pParticleDef->GetPDGMass() ;

        fFieldPropagator->SetChargeMomentumMass( particleCharge,    // in e+ units
                                                 momentumMagnitude, // in Mev/c
                                                 restMass           ) ;

        G4ThreeVector spin        = track.GetPolarization() ;
        G4FieldTrack  aFieldTrack = G4FieldTrack( startPosition,
                                                  track.GetMomentumDirection(),
                                                  0.0,
                                                  track.GetKineticEnergy(),
                                                  restMass,
                                                  track.GetVelocity(),
                                                  track.GetGlobalTime(), // Lab.
                                                  track.GetProperTime(), // Part.
                                                  &spin                  ) ;
        if( currentMinimumStep > 0 )
        {
            // Do the Transport in the field (non recti-linear)
            //
            lengthAlongCurve = fFieldPropagator->ComputeStep( aFieldTrack,
                                                              currentMinimumStep,
                                                              currentSafety,
                                                              track.GetVolume() ) ;
            State(fGeometryLimitedStep)= lengthAlongCurve < currentMinimumStep;
            if( State(fGeometryLimitedStep) )
            {
                geometryStepLength   = lengthAlongCurve ;
            }
            else
            {
                geometryStepLength   = currentMinimumStep ;
            }

            // Remember last safety origin & value.
            //
            State(fPreviousSftOrigin) = startPosition ;
            State(fPreviousSafety)    = currentSafety ;
            fpSafetyHelper->SetCurrentSafety( newSafety, startPosition);
        }
        else
        {
            geometryStepLength   = lengthAlongCurve= 0.0 ;
            State(fGeometryLimitedStep) = false ;
        }

        // Get the End-Position and End-Momentum (Dir-ection)
        //
        State(fTransportEndPosition) = aFieldTrack.GetPosition() ;

        // Momentum:  Magnitude and direction can be changed too now ...
        //
        State(fMomentumChanged)         = true ;
        State(fTransportEndMomentumDir) = aFieldTrack.GetMomentumDir() ;

        State(fTransportEndKineticEnergy)  = aFieldTrack.GetKineticEnergy() ;

        if( fFieldPropagator->GetCurrentFieldManager()->DoesFieldChangeEnergy() )
        {
            // If the field can change energy, then the time must be integrated
            //    - so this should have been updated
            //
            State(fCandidateEndGlobalTime)   = aFieldTrack.GetLabTimeOfFlight();
            State(fEndGlobalTimeComputed)    = true;

            State(theInteractionTimeLeft) = State(fCandidateEndGlobalTime) - track.GetGlobalTime() ;

            // was ( State(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
            //
            State(fEndGlobalTimeComputed) = false;

            // Check that the integration preserved the energy
            //     -  and if not correct this!
            G4double  startEnergy= track.GetKineticEnergy();
            G4double  endEnergy= State(fTransportEndKineticEnergy);

            static 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 ...
            }
#ifdef G4VERBOSE
            if( fVerboseLevel > 1 )
            {
                if( std::fabs(startEnergy- endEnergy) > perThousand * endEnergy )
                {
                    static G4int no_warnings= 0, warnModulo=1,  moduloFactor= 10;
                    no_large_ediff ++;
                    if( (no_large_ediff% warnModulo) == 0 )
                    {
                        no_warnings++;
                        G4cout << "WARNING - G4Transportation::AlongStepGetPIL() "
                               << "   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;
                        G4cout << " Energy has been corrected -- however, review"
                               << " field propagation parameters for accuracy."  << G4endl;
                        if( (fVerboseLevel > 2 ) || (no_warnings<4) || (no_large_ediff == warnModulo * moduloFactor) )
                        {
                            G4cout << " These include EpsilonStepMax(/Min) in G4FieldManager "
                                   << " which determine fractional error per step for integrated quantities. " << G4endl
                                   << " Note also the influence of the permitted number of integration steps."
                                   << G4endl;
                        }
                        G4cerr << "ERROR - G4Transportation::AlongStepGetPIL()" << G4endl
                               << "        Bad 'endpoint'. Energy change detected"
                               << " and corrected. "
                               << " Has occurred already "
                               << no_large_ediff << " times." << G4endl;
                        if( no_large_ediff == warnModulo * moduloFactor )
                        {
                            warnModulo *= moduloFactor;
                        }
                    }
                }
            }  // end of if (fVerboseLevel)
#endif
            // Correct the energy for fields that conserve it
            //  This - hides the integration error
            //       - but gives a better physical answer
            State(fTransportEndKineticEnergy)= track.GetKineticEnergy();
        }

        State(fTransportEndSpin) = aFieldTrack.GetSpin();
        State(fParticleIsLooping) = fFieldPropagator->IsParticleLooping() ;
        State(endpointDistance)   = (State(fTransportEndPosition) - startPosition).mag() ;
        //        State(theInteractionTimeLeft) = track.GetVelocity()/State(endpointDistance) ;
*/
    }

    // 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 )
        {
            State(fGeometryLimitedStep) = true ;
//            G4cout << "!!!! Safety is NULL, on the Boundary !!!!!" << G4endl;
//            G4cout << " Track position : " << track.GetPosition() /nanometer << G4endl;
        }
    }

    // Update the safety starting from the end-point,
    // if it will become negative at the end-point.
    //
    if( currentSafety < State(endpointDistance) )
    {
        // if( particleCharge == 0.0 )
        //    G4cout  << "  Avoiding call to ComputeSafety : charge = 0.0 " << G4endl;

        if( particleCharge != 0.0 )
        {

            G4double endSafety =
                    fLinearNavigator->ComputeSafety( State(fTransportEndPosition)) ;
            currentSafety      = endSafety ;
            State(fPreviousSftOrigin) = State(fTransportEndPosition) ;
            State(fPreviousSafety)    = currentSafety ;
            fpSafetyHelper->SetCurrentSafety( currentSafety, State(fTransportEndPosition));

            // Because the Stepping Manager assumes it is from the start point,
            //  add the StepLength
            //
            currentSafety     += State(endpointDistance) ;

#ifdef G4DEBUG_TRANSPORT
            G4cout.precision(12) ;
            G4cout << "***G4Transportation::AlongStepGPIL ** " << G4endl  ;
            G4cout << "  Called Navigator->ComputeSafety at " << State(fTransportEndPosition)
                   << "    and it returned safety= " << endSafety << G4endl ;
            G4cout << "  Adding endpoint distance " << State(endpointDistance)
                   << "   to obtain pseudo-safety= " << currentSafety << G4endl ;
#endif
        }
    }

    //    fParticleChange.ProposeTrueStepLength(geometryStepLength) ;

    return geometryStepLength ;
}

virtual G4VParticleChange* G4ITTransportation::AtRestDoIt	(	const G4Track &	,
		const G4Step &
	)			[inline, virtual]

Implements G4VProcess.

Definition at line 91 of file G4ITTransportation.hh.

    {
        return 0;
    }

virtual G4double G4ITTransportation::AtRestGetPhysicalInteractionLength	(	const G4Track &	,
		G4ForceCondition *
	)			[inline, virtual]

Implements G4VProcess.

Definition at line 82 of file G4ITTransportation.hh.

    {
        return -1.0;
    }

virtual void G4ITTransportation::BuildPhysicsTable

(

const G4ParticleDefinition &

)

[inline, virtual]

Reimplemented from G4VITProcess.

Reimplemented in G4DNABrownianTransportation.

Definition at line 69 of file G4ITTransportation.hh.

{;}

void G4ITTransportation::ComputeStep	(	const G4Track &	,
		const G4Step &	,
		const double	timeStep,
		double &	spaceStep
	)			[virtual]

Reimplemented in G4DNABrownianTransportation.

Definition at line 570 of file G4ITTransportation.cc.

References G4Track::CalculateVelocity(), fParticleChange, G4Track::GetDynamicParticle(), G4Track::GetGlobalTime(), G4DynamicParticle::GetMomentumDirection(), G4Track::GetPosition(), G4Track::GetVelocity(), G4ParticleChange::ProposeVelocity(), and State.

Referenced by G4ITStepProcessor::DoDefinePhysicalStepLength(), and G4ITStepProcessor::FindTransportationStep().

{
    const G4DynamicParticle*    pParticle  = track.GetDynamicParticle() ;
    G4ThreeVector startMomentumDir       = pParticle->GetMomentumDirection() ;
    G4ThreeVector startPosition          = track.GetPosition() ;

    track.CalculateVelocity();
    G4double initialVelocity   = track.GetVelocity() ;

    State(fGeometryLimitedStep) = false;

    // !!! CASE NO FIELD !!!
    State(fCandidateEndGlobalTime) = timeStep + track.GetGlobalTime();
    State(fEndGlobalTimeComputed) = true ;

    // Choose the calculation of the transportation: Field or not
    //
    if( !State(fMomentumChanged) )
    {
        //        G4cout << "Momentum has not changed" << G4endl;
        fParticleChange.ProposeVelocity(initialVelocity);
        oPhysicalStep =  initialVelocity*timeStep ;

        // Calculate final position
        //
        State(fTransportEndPosition) = startPosition + oPhysicalStep*startMomentumDir ;
    }
}

G4bool G4ITTransportation::DoesGlobalFieldExist

(

)

[protected]

Definition at line 201 of file G4ITTransportation.cc.

References G4FieldManager::DoesFieldExist(), G4TransportationManager::GetFieldManager(), and G4TransportationManager::GetTransportationManager().

Referenced by StartTracking().

{
    G4TransportationManager* transportMgr;
    transportMgr= G4TransportationManager::GetTransportationManager();

    // fFieldExists= transportMgr->GetFieldManager()->DoesFieldExist();
    // return fFieldExists;
    return transportMgr->GetFieldManager()->DoesFieldExist();
}

void G4ITTransportation::EnableShortStepOptimisation

(

G4bool

optimise = true

)

[inline]

Definition at line 124 of file G4ITTransportation.icc.

References fShortStepOptimisation.

{
  fShortStepOptimisation=optimiseShortStep;
}

G4double G4ITTransportation::GetMaxEnergyKilled

(

)

const [inline]

Definition at line 101 of file G4ITTransportation.icc.

References fMaxEnergyKilled.

{
  return fMaxEnergyKilled;
}

G4PropagatorInField * G4ITTransportation::GetPropagatorInField

(

)

[inline]

Definition at line 51 of file G4ITTransportation.icc.

References fFieldPropagator.

{
   return fFieldPropagator;
}

G4double G4ITTransportation::GetSumEnergyKilled

(

)

const [inline]

Definition at line 106 of file G4ITTransportation.icc.

References fSumEnergyKilled.

{
  return fSumEnergyKilled;
}

G4double G4ITTransportation::GetThresholdImportantEnergy

(

)

const [inline]

Definition at line 71 of file G4ITTransportation.icc.

References fThreshold_Important_Energy.

{
  return fThreshold_Important_Energy;
}

G4int G4ITTransportation::GetThresholdTrials

(

)

const [inline]

Definition at line 76 of file G4ITTransportation.icc.

References fThresholdTrials.

{
  return fThresholdTrials;
}

G4double G4ITTransportation::GetThresholdWarningEnergy

(

)

const [inline]

Definition at line 66 of file G4ITTransportation.icc.

References fThreshold_Warning_Energy.

{
  return fThreshold_Warning_Energy;
}

G4int G4ITTransportation::GetVerboseLevel

(

)

const [inline]

Reimplemented from G4VProcess.

Definition at line 61 of file G4ITTransportation.icc.

References fVerboseLevel.

{
  return fVerboseLevel;
}

G4bool G4ITTransportation::InstantiateProcessState

(

)

[inline, protected]

Reimplemented from G4VITProcess.

Definition at line 239 of file G4ITTransportation.hh.

{ return fInstantiateProcessState; }

G4VParticleChange * G4ITTransportation::PostStepDoIt	(	const G4Track &	track,
		const G4Step &
	)			[virtual]

Implements G4VProcess.

Reimplemented in G4DNABrownianTransportation.

Definition at line 774 of file G4ITTransportation.cc.

References G4ITNavigator::EnteredDaughterVolume(), G4ITNavigator::ExitedMotherVolume(), FatalErrorInArgument, fLinearNavigator, fParticleChange, fStopAndKill, fVerboseLevel, G4cout, G4endl, G4Exception(), G4VPhysicalVolume::GetLogicalVolume(), G4MaterialCutsCouple::GetMaterial(), G4LogicalVolume::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4LogicalVolume::GetMaterialCutsCouple(), G4Track::GetMomentumDirection(), G4Track::GetPosition(), G4MaterialCutsCouple::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4LogicalVolume::GetSensitiveDetector(), G4Track::GetTouchableHandle(), G4Track::GetTrackID(), G4Track::GetTrackStatus(), G4ParticleChangeForTransport::Initialize(), G4ITNavigator::LocateGlobalPointWithinVolume(), G4VParticleChange::ProposeLastStepInVolume(), G4VParticleChange::ProposeTrackStatus(), G4ITNavigator::SetGeometricallyLimitedStep(), G4ParticleChangeForTransport::SetMaterialCutsCoupleInTouchable(), G4ParticleChangeForTransport::SetMaterialInTouchable(), G4ParticleChangeForTransport::SetSensitiveDetectorInTouchable(), G4ParticleChangeForTransport::SetTouchableHandle(), and State.

Referenced by G4DNABrownianTransportation::PostStepDoIt().

{
    //    G4cout << "G4ITTransportation::PostStepDoIt" << G4endl;
    G4TouchableHandle retCurrentTouchable ;   // The one to return
    G4bool isLastStep= false;

    // Initialize ParticleChange  (by setting all its members equal
    //                             to corresponding members in G4Track)
    fParticleChange.Initialize(track) ;  // To initialise TouchableChange

    fParticleChange.ProposeTrackStatus(track.GetTrackStatus()) ;

    // If the Step was determined by the volume boundary,
    // logically relocate the particle

    if(State(fGeometryLimitedStep))
    {

        //        G4cout << "Step is limited by geometry " <<  "track ID : " << track.GetTrackID() << G4endl;

        // fCurrentTouchable will now become the previous touchable,
        // and what was the previous will be freed.
        // (Needed because the preStepPoint can point to the previous touchable)

        if( State(fCurrentTouchableHandle)->GetVolume() == 0 )
        {
            G4ExceptionDescription exceptionDescription ;
            exceptionDescription << "No current touchable found " ;
            G4Exception(" G4ITTransportation::PostStepDoIt","G4ITTransportation001",
                        FatalErrorInArgument,exceptionDescription);
        }

        fLinearNavigator->SetGeometricallyLimitedStep() ;
        fLinearNavigator->
                LocateGlobalPointAndUpdateTouchableHandle( track.GetPosition(),
                                                           track.GetMomentumDirection(),
                                                           State(fCurrentTouchableHandle),
                                                           true                      ) ;
        // Check whether the particle is out of the world volume
        // If so it has exited and must be killed.
        //
        if( State(fCurrentTouchableHandle)->GetVolume() == 0 )
        {
#ifdef G4VERBOSE
            if(fVerboseLevel > 0)
            {
                G4cout << "Track position : " << track.GetPosition() / nanometer << " [nm]"
                       << " Track ID : " << track.GetTrackID()<< G4endl;
                G4cout << "G4ITTransportation will killed the track because State(fCurrentTouchableHandle)->GetVolume() == 0"<< G4endl;
            }
#endif
            fParticleChange.ProposeTrackStatus( fStopAndKill ) ;
        }

        retCurrentTouchable = State(fCurrentTouchableHandle) ;

//        G4cout << "Current volume : " << track.GetVolume()->GetName()
//               << " Next volume : "
//               << (State(fCurrentTouchableHandle)->GetVolume() ? State(fCurrentTouchableHandle)->GetVolume()->GetName():"OutWorld")
//               << " Position : " << track.GetPosition() / nanometer
//               << " track ID : " << track.GetTrackID()
//               << G4endl;

        fParticleChange.SetTouchableHandle( State(fCurrentTouchableHandle) ) ;

        // Update the Step flag which identifies the Last Step in a volume
        isLastStep =  fLinearNavigator->ExitedMotherVolume()
                | fLinearNavigator->EnteredDaughterVolume() ;

#ifdef G4DEBUG_TRANSPORT
        //  Checking first implementation of flagging Last Step in Volume
        G4bool exiting =  fLinearNavigator->ExitedMotherVolume();
        G4bool entering = fLinearNavigator->EnteredDaughterVolume();

        if( ! (exiting || entering) )
        {
            G4cout << " Transport> :  Proposed isLastStep= " << isLastStep
                   << " Exiting "  << fLinearNavigator->ExitedMotherVolume()
                   << " Entering " << fLinearNavigator->EnteredDaughterVolume()
                   << " Track position : " << track.GetPosition() /nanometer << " [nm]"
                   << G4endl;
            G4cout << " Track position : " << track.GetPosition() /nanometer << G4endl;
        }
#endif
    }
    else                 // fGeometryLimitedStep  is false
    {
        // This serves only to move the Navigator's location
        //
        fLinearNavigator->LocateGlobalPointWithinVolume( track.GetPosition() ) ;

        // The value of the track's current Touchable is retained.
        // (and it must be correct because we must use it below to
        // overwrite the (unset) one in particle change)
        //  It must be fCurrentTouchable too ??
        //
        fParticleChange.SetTouchableHandle( track.GetTouchableHandle() ) ;
        retCurrentTouchable = track.GetTouchableHandle() ;

        isLastStep= false;
#ifdef G4DEBUG_TRANSPORT
        //  Checking first implementation of flagging Last Step in Volume
        G4cout << " Transport> Proposed isLastStep= " << isLastStep
               << " Geometry did not limit step. Position : "
               << track.GetPosition()/ nanometer << G4endl;
#endif
    }         // endif ( fGeometryLimitedStep )

    fParticleChange.ProposeLastStepInVolume(isLastStep);

    const G4VPhysicalVolume* pNewVol = retCurrentTouchable->GetVolume() ;
    const G4Material* pNewMaterial   = 0 ;
    const G4VSensitiveDetector* pNewSensitiveDetector   = 0 ;

    if( pNewVol != 0 )
    {
        pNewMaterial= pNewVol->GetLogicalVolume()->GetMaterial();
        pNewSensitiveDetector= pNewVol->GetLogicalVolume()->GetSensitiveDetector();
    }

    // ( <const_cast> pNewMaterial ) ;
    // ( <const_cast> pNewSensitiveDetector) ;

    fParticleChange.SetMaterialInTouchable( (G4Material *) pNewMaterial ) ;
    fParticleChange.SetSensitiveDetectorInTouchable( (G4VSensitiveDetector *) pNewSensitiveDetector ) ;

    const G4MaterialCutsCouple* pNewMaterialCutsCouple = 0;
    if( pNewVol != 0 )
    {
        pNewMaterialCutsCouple=pNewVol->GetLogicalVolume()->GetMaterialCutsCouple();
    }

    if( pNewVol!=0 && pNewMaterialCutsCouple!=0 && pNewMaterialCutsCouple->GetMaterial()!=pNewMaterial )
    {
        // for parametrized volume
        //
        pNewMaterialCutsCouple =
                G4ProductionCutsTable::GetProductionCutsTable()
                ->GetMaterialCutsCouple(pNewMaterial,
                                        pNewMaterialCutsCouple->GetProductionCuts());
    }
    fParticleChange.SetMaterialCutsCoupleInTouchable( pNewMaterialCutsCouple );

    // temporarily until Get/Set Material of ParticleChange,
    // and StepPoint can be made const.
    // Set the touchable in ParticleChange
    // this must always be done because the particle change always
    // uses this value to overwrite the current touchable pointer.
    //
    fParticleChange.SetTouchableHandle(retCurrentTouchable) ;

    return &fParticleChange ;
}

G4double G4ITTransportation::PostStepGetPhysicalInteractionLength	(	const G4Track &	,
		G4double	,
		G4ForceCondition *	pForceCond
	)			[virtual]

Implements G4VProcess.

Definition at line 761 of file G4ITTransportation.cc.

References DBL_MAX, and Forced.

{
    *pForceCond = Forced ;
    return DBL_MAX ;  // was kInfinity ; but convention now is DBL_MAX
}

void G4ITTransportation::ResetKilledStatistics

(

G4int

report = 1

)

[inline]

Definition at line 111 of file G4ITTransportation.icc.

References fMaxEnergyKilled, fSumEnergyKilled, G4cout, and G4endl.

{
  if( report ) {
    G4cout << " G4ITTransportation: Statistics for looping particles " << G4endl;
    G4cout << "   Sum of energy of loopers killed: " <<  fSumEnergyKilled << G4endl;
    G4cout << "   Max energy of loopers killed: " <<  fMaxEnergyKilled << G4endl;
  }

  fSumEnergyKilled= 0;
  fMaxEnergyKilled= -1.0*CLHEP::GeV;
}

void G4ITTransportation::SetInstantiateProcessState

(

G4bool

flag

)

[inline, protected]

Reimplemented from G4VITProcess.

Definition at line 236 of file G4ITTransportation.hh.

Referenced by G4ITTransportation(), and G4DNABrownianTransportation::StartTracking().

    { fInstantiateProcessState = flag; }

void G4ITTransportation::SetPropagatorInField

(

G4PropagatorInField *

pFieldPropagator

)

[inline]

This class is a slightly modified version of G4Transportation initially written by J. Apostolakis and colleagues But it should use the exact same algorithm.

Definition at line 46 of file G4ITTransportation.icc.

References fFieldPropagator.

{
   fFieldPropagator= pFieldPropagator;
}

void G4ITTransportation::SetThresholdImportantEnergy

(

G4double

newEnImp

)

[inline]

Definition at line 86 of file G4ITTransportation.icc.

References fThreshold_Important_Energy.

{
  fThreshold_Important_Energy = newEnImp;
}

void G4ITTransportation::SetThresholdTrials

(

G4int

newMaxTrials

)

[inline]

Definition at line 91 of file G4ITTransportation.icc.

References fThresholdTrials.

{
  fThresholdTrials = newMaxTrials;
}

void G4ITTransportation::SetThresholdWarningEnergy

(

G4double

newEnWarn

)

[inline]

Definition at line 81 of file G4ITTransportation.icc.

References fThreshold_Warning_Energy.

{
  fThreshold_Warning_Energy= newEnWarn;
}

void G4ITTransportation::SetVerboseLevel

(

G4int

verboseLevel

)

[inline]

Reimplemented from G4VProcess.

Definition at line 56 of file G4ITTransportation.icc.

References fVerboseLevel.

{
  fVerboseLevel= verboseLev;
}

void G4ITTransportation::StartTracking

(

G4Track *

aTrack

)

[virtual]

Reimplemented from G4VITProcess.

Reimplemented in G4DNABrownianTransportation.

Definition at line 933 of file G4ITTransportation.cc.

References G4FieldManagerStore::ClearAllChordFindersState(), G4PropagatorInField::ClearPropagatorState(), DoesGlobalFieldExist(), fFieldPropagator, G4VITProcess::fpState, G4FieldManagerStore::GetInstance(), G4Track::GetTouchableHandle(), G4VITProcess::StartTracking(), G4VProcess::StartTracking(), and State.

Referenced by G4DNABrownianTransportation::StartTracking().

{
    G4VProcess::StartTracking(track);
    if(fInstantiateProcessState)
        G4VITProcess::fpState = new G4ITTransportationState();
    // Will set in the same time fTransportationState

    // The actions here are those that were taken in AlongStepGPIL
    //   when track.GetCurrentStepNumber()==1

    // reset safety value and center
    //
    //    State(fPreviousSafety)    = 0.0 ;
    //    State(fPreviousSftOrigin) = G4ThreeVector(0.,0.,0.) ;

    // reset looping counter -- for motion in field
    //    State(fNoLooperTrials)= 0;
    // Must clear this state .. else it depends on last track's value
    //  --> a better solution would set this from state of suspended track TODO ?
    // Was if( aTrack->GetCurrentStepNumber()==1 ) { .. }

    // ChordFinder reset internal state
    //
    if( DoesGlobalFieldExist() )
    {
        fFieldPropagator->ClearPropagatorState();
        // Resets all state of field propagator class (ONLY)
        //  including safety values (in case of overlaps and to wipe for first track).

        // G4ChordFinder* chordF= fFieldPropagator->GetChordFinder();
        // if( chordF ) chordF->ResetStepEstimate();
    }

    // Make sure to clear the chord finders of all fields (ie managers)
    static G4FieldManagerStore* fieldMgrStore= G4FieldManagerStore::GetInstance();
    fieldMgrStore->ClearAllChordFindersState();

    // Update the current touchable handle  (from the track's)
    //
    State(fCurrentTouchableHandle) = track->GetTouchableHandle();

    G4VITProcess::StartTracking(track);
}

---

Field Documentation

G4PropagatorInField* G4ITTransportation::fFieldPropagator [protected]

Definition at line 202 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), G4ITTransportation(), GetPropagatorInField(), SetPropagatorInField(), and StartTracking().

G4ITNavigator* G4ITTransportation::fLinearNavigator [protected]

Definition at line 201 of file G4ITTransportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), G4ITTransportation(), and PostStepDoIt().

G4double G4ITTransportation::fMaxEnergyKilled [protected]

Definition at line 223 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), G4ITTransportation(), GetMaxEnergyKilled(), ResetKilledStatistics(), and ~G4ITTransportation().

G4ParticleChangeForTransport G4ITTransportation::fParticleChange [protected]

Definition at line 207 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), G4DNABrownianTransportation::AlongStepDoIt(), ComputeStep(), G4DNABrownianTransportation::Diffusion(), G4ITTransportation(), PostStepDoIt(), and G4DNABrownianTransportation::PostStepDoIt().

G4SafetyHelper* G4ITTransportation::fpSafetyHelper [protected]

Definition at line 229 of file G4ITTransportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), and G4ITTransportation().

G4bool G4ITTransportation::fShortStepOptimisation [protected]

Definition at line 227 of file G4ITTransportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), EnableShortStepOptimisation(), and G4ITTransportation().

G4double G4ITTransportation::fSumEnergyKilled [protected]

Definition at line 222 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), G4ITTransportation(), GetSumEnergyKilled(), ResetKilledStatistics(), and ~G4ITTransportation().

G4double G4ITTransportation::fThreshold_Important_Energy [protected]

Definition at line 213 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), G4ITTransportation(), GetThresholdImportantEnergy(), and SetThresholdImportantEnergy().

G4double G4ITTransportation::fThreshold_Warning_Energy [protected]

Definition at line 212 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), G4ITTransportation(), GetThresholdWarningEnergy(), and SetThresholdWarningEnergy().

G4int G4ITTransportation::fThresholdTrials [protected]

Definition at line 214 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), G4ITTransportation(), GetThresholdTrials(), and SetThresholdTrials().

G4ITTransportationState* const& G4ITTransportation::fTransportationState [protected]

Definition at line 196 of file G4ITTransportation.hh.

G4double G4ITTransportation::fUnimportant_Energy [protected]

Definition at line 217 of file G4ITTransportation.hh.

Referenced by G4ITTransportation().

G4int G4ITTransportation::fVerboseLevel [protected]

Definition at line 232 of file G4ITTransportation.hh.

Referenced by AlongStepDoIt(), G4DNABrownianTransportation::ComputeStep(), G4DNABrownianTransportation::Diffusion(), G4ITTransportation(), GetVerboseLevel(), PostStepDoIt(), G4DNABrownianTransportation::PostStepDoIt(), SetVerboseLevel(), and ~G4ITTransportation().

---

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

• G4ITTransportation.hh
• G4ITTransportation.icc
• G4ITTransportation.cc

---