#include <G4DNABrownianTransportation.hh>

Inheritance diagram for G4DNABrownianTransportation:

Data Structures
struct	G4ITBrownianState

Public Member Functions
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

virtual void	BuildPhysicsTable (const G4ParticleDefinition &)

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	ComputeStep (const G4Track &, const G4Step &, const G4double, G4double &)

virtual void	DumpInfo () const

void	EnableShortStepOptimisation (G4bool optimise=true)

virtual void	EndTracking ()

	G4DNABrownianTransportation (const G4DNABrownianTransportation &)

	G4DNABrownianTransportation (const G4String &aName="DNABrownianTransportation", G4int verbosityLevel=0)

G4double	GetCurrentInteractionLength () const

G4double	GetInteractionTimeLeft ()

const G4VProcess *	GetMasterProcess () const

G4double	GetMaxEnergyKilled () const

G4double	GetNumberOfInteractionLengthLeft () const

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

G4double	GetPILfactor () const

size_t	GetProcessID () const

virtual const G4ProcessManager *	GetProcessManager ()

const G4String &	GetProcessName () const

G4shared_ptr< G4ProcessState_Lock >	GetProcessState ()

G4int	GetProcessSubType () const

G4ProcessType	GetProcessType () const

G4PropagatorInField *	GetPropagatorInField ()

G4double	GetSumEnergyKilled () const

G4double	GetThresholdImportantEnergy () const

G4int	GetThresholdTrials () const

G4double	GetThresholdWarningEnergy () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4int	GetVerboseLevel () const

G4bool	isAlongStepDoItIsEnabled () const

virtual G4bool	IsApplicable (const G4ParticleDefinition &)

G4bool	isAtRestDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

G4bool	IsStepLimitedByGeometry ()

G4bool	operator!= (const G4VITProcess &right) const

G4bool	operator!= (const G4VProcess &right) const

G4DNABrownianTransportation &	operator= (const G4DNABrownianTransportation &)

G4bool	operator== (const G4VITProcess &right) const

G4bool	operator== (const G4VProcess &right) const

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &)

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double, G4ForceCondition *pForceCond)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

virtual void	ProcessDescription (std::ostream &outfile) const

G4bool	ProposesTimeStep () const

void	ResetKilledStatistics (G4int report=1)

virtual void	ResetNumberOfInteractionLengthLeft ()

void	ResetProcessState ()

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

void	SetBrownianAction (G4BrownianAction *)

virtual void	SetMasterProcess (G4VProcess *masterP)

void	SetPILfactor (G4double value)

virtual void	SetProcessManager (const G4ProcessManager *)

void	SetProcessState (G4shared_ptr< G4ProcessState_Lock > aProcInfo)

void	SetProcessSubType (G4int)

void	SetProcessType (G4ProcessType)

void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)

void	SetThresholdImportantEnergy (G4double newEnImp)

void	SetThresholdTrials (G4int newMaxTrials)

void	SetThresholdWarningEnergy (G4double newEnWarn)

void	SetVerboseLevel (G4int verboseLevel)

void	SpeedLevel (int level)

virtual void	StartTracking (G4Track *aTrack)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

void	UseCumulativeDensitFunction (bool flag=true)

void	UseLimitingTimeSteps (bool flag=true)

void	UseMaximumTimeBeforeReachingBoundary (bool flag=true)

virtual	~G4DNABrownianTransportation ()

Static Public Member Functions
static const size_t &	GetMaxProcessIndex ()

static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions
virtual void	ClearInteractionTimeLeft ()

virtual void	ClearNumberOfInteractionLengthLeft ()

G4double	ComputeGeomLimit (const G4Track &track, G4double &presafety, G4double limit)

void	CreateInfo ()

void	Diffusion (const G4Track &track)

G4bool	DoesGlobalFieldExist ()

template<typename T >
T *	GetState ()

G4bool	InstantiateProcessState ()

void	RetrieveProcessInfo ()

void	SetInstantiateProcessState (G4bool flag)

virtual void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

Protected Attributes
G4ParticleChange	aParticleChange

const G4ProcessManager *	aProcessManager = nullptr

G4bool	enableAlongStepDoIt = true

G4bool	enableAtRestDoIt = true

G4bool	enablePostStepDoIt = true

G4PropagatorInField *	fFieldPropagator

G4double	fInternalMinTimeStep

G4ITNavigator *	fLinearNavigator

G4double	fMaxEnergyKilled

G4Material *	fNistWater

G4ParticleChangeForTransport	fParticleChange

G4BrownianAction *	fpBrownianAction

G4bool	fProposesTimeStep

G4ITSafetyHelper *	fpSafetyHelper

G4shared_ptr< G4ProcessState >	fpState

const std::vector< G4double > *	fpWaterDensity

G4bool	fShortStepOptimisation

G4bool	fSpeedMeUp

G4double	fSumEnergyKilled

G4double	fThreshold_Important_Energy

G4double	fThreshold_Warning_Energy

G4int	fThresholdTrials

G4double	fUnimportant_Energy

G4bool	fUseMaximumTimeBeforeReachingBoundary

G4bool	fUseSchedulerMinTimeSteps

G4int	fVerboseLevel

G4VParticleChange *	pParticleChange = nullptr

G4double	theInitialNumberOfInteractionLength = -1.0

G4String	thePhysicsTableFileName

G4double	thePILfactor = 1.0

G4String	theProcessName

G4int	theProcessSubType = -1

G4ProcessType	theProcessType = fNotDefined

G4int	verboseLevel = 0

Private Attributes
G4double *	currentInteractionLength

G4bool	fInstantiateProcessState

static size_t *	fNbProcess = 0

size_t	fProcessID

G4ProcessTable *	fProcessTable = nullptr

G4VProcess *	masterProcessShadow = nullptr

G4double *	theInteractionTimeLeft

G4double *	theNumberOfInteractionLengthLeft

Detailed Description

Definition at line 108 of file G4DNABrownianTransportation.hh.

Constructor & Destructor Documentation

◆ G4DNABrownianTransportation() [1/2]

G4DNABrownianTransportation::G4DNABrownianTransportation	(	const G4String &	aName = `"DNABrownianTransportation"`,
		G4int	verbosityLevel = `0`
	)

Definition at line 120 of file G4DNABrownianTransportation.cc.

                                                                          :
    G4ITTransportation(aName, verbosity)
{
 
  fVerboseLevel = 0;
 
  fpState.reset(new G4ITBrownianState());
 
  //ctor
  SetProcessSubType(fLowEnergyBrownianTransportation);
 
  fNistWater = G4NistManager::Instance()->FindOrBuildMaterial("G4_WATER");
  fpWaterDensity = 0;
 
  fUseMaximumTimeBeforeReachingBoundary = true;
  fUseSchedulerMinTimeSteps = false;
  fSpeedMeUp = true;
 
  fInternalMinTimeStep = 1*picosecond;
  fpBrownianAction = 0;
}

References G4NistManager::FindOrBuildMaterial(), fInternalMinTimeStep, fLowEnergyBrownianTransportation, fNistWater, fpBrownianAction, G4VITProcess::fpState, fpWaterDensity, fSpeedMeUp, fUseMaximumTimeBeforeReachingBoundary, fUseSchedulerMinTimeSteps, G4ITTransportation::fVerboseLevel, G4NistManager::Instance(), picosecond, and G4VProcess::SetProcessSubType().

◆ ~G4DNABrownianTransportation()

G4DNABrownianTransportation::~G4DNABrownianTransportation ( )

virtual

Definition at line 143 of file G4DNABrownianTransportation.cc.

{
  if(fpBrownianAction) delete fpBrownianAction;
}

References fpBrownianAction.

◆ G4DNABrownianTransportation() [2/2]

G4DNABrownianTransportation::G4DNABrownianTransportation ( const G4DNABrownianTransportation & right )

Definition at line 148 of file G4DNABrownianTransportation.cc.

                                                                                                 :
    G4ITTransportation(right)
{
  //copy ctor
  SetProcessSubType(fLowEnergyBrownianTransportation);
  fUseMaximumTimeBeforeReachingBoundary = right
      .fUseMaximumTimeBeforeReachingBoundary;
  fUseSchedulerMinTimeSteps = right.fUseSchedulerMinTimeSteps;
  fNistWater = right.fNistWater;
  fpWaterDensity = right.fpWaterDensity;
  fInternalMinTimeStep = right.fInternalMinTimeStep;
  fSpeedMeUp = right.fSpeedMeUp;
  fpBrownianAction = right.fpBrownianAction;
}

References fInternalMinTimeStep, fLowEnergyBrownianTransportation, fNistWater, fpBrownianAction, fpWaterDensity, fSpeedMeUp, fUseMaximumTimeBeforeReachingBoundary, fUseSchedulerMinTimeSteps, and G4VProcess::SetProcessSubType().

Member Function Documentation

◆ AlongStepDoIt()

G4VParticleChange * G4DNABrownianTransportation::AlongStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Reimplemented from G4ITTransportation.

Definition at line 803 of file G4DNABrownianTransportation.cc.

{
#ifdef DEBUG_MEM
  MemStat mem_first, mem_second, mem_diff;
#endif
 
#ifdef DEBUG_MEM
  mem_first = MemoryUsage();
#endif
 
  if (GetIT(track)->GetTrackingInfo()->IsLeadingStep()
      && State(fComputeLastPosition)
      && State(fGeometryLimitedStep)//Hoang added 26/8/2019
      )
  {
    //==========================================================================
    // DEBUG
    //
//     assert(fabs(State(theInteractionTimeLeft)-
//                G4VScheduler::Instance()->GetTimeStep()) < DBL_EPSILON);
    //==========================================================================
 
    G4double spaceStep = DBL_MAX;
 
    if(State(theInteractionTimeLeft) <= fInternalMinTimeStep)
    {
      spaceStep = State(fEndPointDistance);
      State(fGeometryLimitedStep) = true;
    }
    else
    {
      G4double diffusionCoefficient = GetMolecule(track)->
      GetDiffusionCoefficient();
 
      G4double sqrt_2Dt= sqrt(2 * diffusionCoefficient * State(theInteractionTimeLeft));
      G4double x = G4RandGauss::shoot(0, sqrt_2Dt);
      G4double y = G4RandGauss::shoot(0, sqrt_2Dt);
      G4double z = G4RandGauss::shoot(0, sqrt_2Dt);
 
      spaceStep = sqrt(x * x + y * y + z * z);
 
      if(spaceStep >= State(fEndPointDistance))
      {
        State(fGeometryLimitedStep) = true;
       if (
           //fSpeedMeUp == false&&
           fUseSchedulerMinTimeSteps == false
           && spaceStep >= State(fEndPointDistance))
       {
         spaceStep = State(fEndPointDistance);
       }
      }
      else
      {
        State(fGeometryLimitedStep) = false;
      }
    }
 
//    assert( (spaceStep <  State(fEndPointDistance) && State(fGeometryLimitedStep) == false)
//|| (spaceStep >= State(fEndPointDistance) && State(fGeometryLimitedStep)));
 
    // Calculate final position
    //
    State(fTransportEndPosition) = track.GetPosition()
               + spaceStep * track.GetMomentumDirection();
  }
 
  if(fVerboseLevel)
  {
    G4cout << GREEN_ON_BLUE
            << "G4DNABrownianTransportation::AlongStepDoIt: "
                "GeometryLimitedStep = "
            << State(fGeometryLimitedStep)
            << RESET_COLOR
            << G4endl;
  }
 
//  static G4ThreadLocal G4int noCalls = 0;
//  noCalls++;
 
//  fParticleChange.Initialize(track);
 
  G4ITTransportation::AlongStepDoIt(track, step);
 
#ifdef DEBUG_MEM
  MemStat mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || After calling G4ITTransportation::"
  "AlongStepDoIt for "<< track.GetTrackID() << ", diff is : "
  << mem_diff << G4endl;
#endif
 
  if(track.GetStepLength() != 0 // && State(fGeometryLimitedStep)
      //========================================================================
      // TODO: avoid changing direction after too small time steps
//    && (G4VScheduler::Instance()->GetTimeStep() > fInternalMinTimeStep
//        || fSpeedMeUp == false)
      //========================================================================
        )
  {
    Diffusion(track);
  }
  //else
  //{
  //  fParticleChange.ProposeMomentumDirection(State(fTransportEndMomentumDir));
  //}
/*
  if (State(fParticleIsLooping))
  {
    if ((State(fNoLooperTrials)>= fThresholdTrials))
    {
      fParticleChange.ProposeTrackStatus(fStopAndKill);
      State(fNoLooperTrials) = 0;
#ifdef G4VERBOSE
      if ((fVerboseLevel > 1))
      {
        G4cout
            << " G4DNABrownianTransportation is killing track that is looping or stuck "
            << G4endl;
        G4cout << "   Number of trials = " << State(fNoLooperTrials)
        << "   No of calls to AlongStepDoIt = " << noCalls
        << G4endl;
      }
#endif
    }
    else
    {
      State(fNoLooperTrials)++;
    }
  }
  else
  {
    State(fNoLooperTrials)=0;
  }
*/
#ifdef DEBUG_MEM
  mem_intermediaire = MemoryUsage();
  mem_diff = mem_intermediaire-mem_first;
  G4cout << "\t\t\t >> || MEM || After calling G4DNABrownianTransportation::"
  "Diffusion for "<< track.GetTrackID() << ", diff is : "
  << mem_diff << G4endl;
#endif
 
  return &fParticleChange;
}

References G4ITTransportation::AlongStepDoIt(), DBL_MAX, Diffusion(), fInternalMinTimeStep, G4ITTransportation::fParticleChange, fUseSchedulerMinTimeSteps, G4ITTransportation::fVerboseLevel, G4cout, G4endl, GetIT(), GetMolecule(), G4Track::GetMomentumDirection(), G4Track::GetPosition(), G4Track::GetStepLength(), G4Track::GetTrackID(), GREEN_ON_BLUE, G4MemStat::MemoryUsage(), RESET_COLOR, G4INCL::DeJongSpin::shoot(), State, and G4VITProcess::theInteractionTimeLeft.

◆ AlongStepGetPhysicalInteractionLength()

G4double G4DNABrownianTransportation::AlongStepGetPhysicalInteractionLength	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	currentSafety,
		G4GPILSelection *	selection
	)

virtual

Reimplemented from G4ITTransportation.

Definition at line 582 of file G4DNABrownianTransportation.cc.

{
#ifdef G4VERBOSE
  if(fVerboseLevel)
  {
    G4cout << " G4DNABrownianTransportation::AlongStepGetPhysicalInteractionLength - track ID: "
           << track.GetTrackID() << G4endl;
    G4cout << "In volume : " << track.GetVolume()->GetName()
           << " position : " << G4BestUnit(track.GetPosition() , "Length") << G4endl;
  }
#endif
 
  G4double geometryStepLength =
      G4ITTransportation::AlongStepGetPhysicalInteractionLength(
          track, previousStepSize, currentMinimumStep, currentSafety,
          selection);
 
  if(geometryStepLength==0)
  { 
//    G4cout << "geometryStepLength==0" << G4endl;
    if(State(fGeometryLimitedStep))
    {
//      G4cout << "if(State(fGeometryLimitedStep))" << G4endl;
      G4TouchableHandle newTouchable = new G4TouchableHistory;
 
      newTouchable->UpdateYourself(State(fCurrentTouchableHandle)->GetVolume(),
                                   State(fCurrentTouchableHandle)->GetHistory());
 
       fLinearNavigator->SetGeometricallyLimitedStep();
       fLinearNavigator->LocateGlobalPointAndUpdateTouchableHandle(
           track.GetPosition(), track.GetMomentumDirection(),
           newTouchable, true);
 
       if(newTouchable->GetVolume() == 0)
       {
          return 0;
       }
 
       State(fCurrentTouchableHandle) = newTouchable;
 
       //=======================================================================
       // TODO: speed up navigation update
//       geometryStepLength = fLinearNavigator->ComputeStep(track.GetPosition(),
//                                     track.GetMomentumDirection(),
//                                     currentMinimumStep,
//                                     currentSafety);
       //=======================================================================
 
 
       //=======================================
       // Longer but safer ...
       geometryStepLength =
             G4ITTransportation::AlongStepGetPhysicalInteractionLength(
                 track, previousStepSize, currentMinimumStep, currentSafety,
                 selection);
 
      }
  }
 
  //============================================================================
  // DEBUG
 // G4cout << "geometryStepLength: " << G4BestUnit(geometryStepLength, "Length")
 //        << " | trackID: " << track.GetTrackID()
 //        << G4endl;
  //============================================================================
 
  G4double diffusionCoefficient = 0;
 
  /*
  G4Material* material = track.GetMaterial();
  G4double waterDensity = (*fpWaterDensity)[material->GetIndex()];
 
  if (waterDensity == 0.0)
  {
    if(fpBrownianAction)
    {
      diffusionCoefficient = fpBrownianAction->GetDiffusionCoefficient(material,
                                                                       GetMolecule(track));
    }
 
    if(diffusionCoefficient <= 0)
    {
      State(fGeometryLimitedStep) = false;
      State(theInteractionTimeLeft) = 0;
      State(fTransportEndPosition) = track.GetPosition();
      return 0;
    }
 
  }
  else
  {
    diffusionCoefficient = GetMolecule(track)->GetDiffusionCoefficient();
  }
  */
  
  diffusionCoefficient = GetMolecule(track)->GetDiffusionCoefficient();
  
  // To avoid divide by zero of diffusionCoefficient  
  if(diffusionCoefficient <= 0)
  {
    State(fGeometryLimitedStep) = false;
    State(theInteractionTimeLeft) = DBL_MAX;
    State(fTransportEndPosition) = track.GetPosition();
    return 0;
  }
  
 
  State(fComputeLastPosition) = false;
  State(fTimeStepReachedLimit) = false;
 
  if (State(fGeometryLimitedStep))
  {
    // 95 % of the space step distribution is lower than
    // d_95 = 2 * sqrt(2*D*t)
    // where t is the corresponding time step
    // so by inversion :
    if (fUseMaximumTimeBeforeReachingBoundary)
    {
      if(fSpeedMeUp)
      {
      State(theInteractionTimeLeft) = (geometryStepLength * geometryStepLength)
          / (diffusionCoefficient); // d_50 - use straight line
      }
      else
      {
         State(theInteractionTimeLeft) = (currentSafety * currentSafety)
                  / (diffusionCoefficient); // d_50 - use safety
 
         //=====================================================================
         // State(theInteractionTimeLeft) = (currentSafety * currentSafety)
         //          / (8 * diffusionCoefficient); // d_95
         //=====================================================================
      }
      State(fComputeLastPosition) = true;
    }
    else
    // Will use a random time - this is precise but long to compute in certain
    // circumstances (many particles - small volumes)
    {
      State(fRandomNumber) = G4UniformRand();
      State(theInteractionTimeLeft) = 1 / (4 * diffusionCoefficient)
          * pow(geometryStepLength / InvErfc(State(fRandomNumber)),2);
 
      State(fTransportEndPosition) = geometryStepLength*
          track.GetMomentumDirection() + track.GetPosition();
    }
 
    if (fUseSchedulerMinTimeSteps)
    {
      G4double minTimeStepAllowed = G4VScheduler::Instance()->GetLimitingTimeStep();
      //========================================================================
      // TODO
//      double currentMinTimeStep = G4VScheduler::Instance()->GetTimeStep();
      //========================================================================
 
      if (State(theInteractionTimeLeft) < minTimeStepAllowed)
      {
        State(theInteractionTimeLeft) = minTimeStepAllowed;
        State(fTimeStepReachedLimit) = true;
        State(fComputeLastPosition) = true;
      }
    }
    else if(State(theInteractionTimeLeft) < fInternalMinTimeStep)
      // TODO: find a better way when fForceLimitOnMinTimeSteps is not used
    {
      State(fTimeStepReachedLimit) = true;
      State(theInteractionTimeLeft) = fInternalMinTimeStep;
      if (fUseMaximumTimeBeforeReachingBoundary)
      {
        State(fComputeLastPosition) = true;
      }
    }
 
    State(fCandidateEndGlobalTime) =
        track.GetGlobalTime() + State(theInteractionTimeLeft);
 
    State(fEndGlobalTimeComputed) = true; // MK: ADDED ON 20/11/2014
 
    State(fPathLengthWasCorrected) = false;
  }
  else
  {
    // Transform geometrical step
    geometryStepLength = 2
        * sqrt(diffusionCoefficient * State(theInteractionTimeLeft))
        * InvErf(G4UniformRand());
    State(fPathLengthWasCorrected) = true;
    //State(fEndPointDistance) = geometryStepLength;
    State(fTransportEndPosition) = geometryStepLength*
              track.GetMomentumDirection() + track.GetPosition();
  }
 
#ifdef G4VERBOSE
  //    DEBUG
  if (fVerboseLevel > 1)
  {
  G4cout << GREEN_ON_BLUE
         << "G4DNABrownianTransportation::AlongStepGetPhysicalInteractionLength = "
         << G4BestUnit(geometryStepLength, "Length")
         << " | trackID = "
         << track.GetTrackID()
         << RESET_COLOR
         << G4endl;
  }
#endif
 
// assert(geometryStepLength <  State(fEndPointDistance)
//  || (geometryStepLength >= State(fEndPointDistance) && State(fGeometryLimitedStep)));
 
  return geometryStepLength;
}

References G4ITTransportation::AlongStepGetPhysicalInteractionLength(), DBL_MAX, fInternalMinTimeStep, G4ITTransportation::fLinearNavigator, fSpeedMeUp, fUseMaximumTimeBeforeReachingBoundary, fUseSchedulerMinTimeSteps, G4ITTransportation::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4UniformRand, G4Molecule::GetDiffusionCoefficient(), G4Track::GetGlobalTime(), G4VScheduler::GetLimitingTimeStep(), GetMolecule(), G4Track::GetMomentumDirection(), G4VPhysicalVolume::GetName(), G4Track::GetPosition(), G4Track::GetTrackID(), G4Track::GetVolume(), G4VTouchable::GetVolume(), GREEN_ON_BLUE, G4VScheduler::Instance(), InvErf(), InvErfc(), RESET_COLOR, State, G4VITProcess::theInteractionTimeLeft, and G4VTouchable::UpdateYourself().

◆ AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL	(	const G4Track &	track,
		G4double	previousStepSize,
		G4double	currentMinimumStep,
		G4double &	proposedSafety,
		G4GPILSelection *	selection
	)

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ AtRestDoIt()

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

inlinevirtualinherited

Implements G4VProcess.

Definition at line 113 of file G4ITTransportation.hh.

  {
    return 0;
  }

◆ AtRestGetPhysicalInteractionLength()

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

inlinevirtualinherited

Implements G4VProcess.

Definition at line 106 of file G4ITTransportation.hh.

  {
    return -1.0;
  }

◆ AtRestGPIL()

G4double G4VProcess::AtRestGPIL	(	const G4Track &	track,
		G4ForceCondition *	condition
	)

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

◆ BuildPhysicsTable()

void G4DNABrownianTransportation::BuildPhysicsTable ( const G4ParticleDefinition & particle )

virtual

Reimplemented from G4ITTransportation.

Definition at line 188 of file G4DNABrownianTransportation.cc.

{
  if(verboseLevel > 0)
  {
    G4cout << G4endl<< GetProcessName() << ":   for  "
    << setw(24) << particle.GetParticleName()
    << "\tSubType= " << GetProcessSubType() << G4endl;
  }
  // Initialize water density pointer
  fpWaterDensity = G4DNAMolecularMaterial::Instance()->
  GetDensityTableFor(G4Material::GetMaterial("G4_WATER"));
 
  fpSafetyHelper->InitialiseHelper();
  G4ITTransportation::BuildPhysicsTable(particle);
}

References G4ITTransportation::BuildPhysicsTable(), G4ITTransportation::fpSafetyHelper, fpWaterDensity, G4cout, G4endl, G4Material::GetMaterial(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4ITSafetyHelper::InitialiseHelper(), G4DNAMolecularMaterial::Instance(), and G4VProcess::verboseLevel.

◆ BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

◆ ClearInteractionTimeLeft()

void G4VITProcess::ClearInteractionTimeLeft ( )

inlineprotectedvirtualinherited

Definition at line 258 of file G4VITProcess.hh.

{
  fpState->theInteractionTimeLeft = -1.0;
}

References G4VITProcess::fpState.

Referenced by G4VITRestProcess::AtRestDoIt(), G4DNAElectronHoleRecombination::AtRestDoIt(), and G4DNAMolecularDissociation::AtRestDoIt().

◆ ClearNumberOfInteractionLengthLeft()

void G4VITProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedvirtualinherited

Definition at line 263 of file G4VITProcess.hh.

{
  fpState->theNumberOfInteractionLengthLeft = -1.0;
}

References G4VITProcess::fpState.

Referenced by G4VITRestProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4DNAElectronHoleRecombination::AtRestDoIt(), G4DNAMolecularDissociation::AtRestDoIt(), G4VITDiscreteProcess::PostStepDoIt(), and G4VITRestDiscreteProcess::PostStepDoIt().

◆ ComputeGeomLimit()

G4double G4DNABrownianTransportation::ComputeGeomLimit	(	const G4Track &	track,
		G4double &	presafety,
		G4double	limit
	)

protected

Definition at line 563 of file G4DNABrownianTransportation.cc.

{
  G4double res = DBL_MAX;
  if(track.GetVolume() != fpSafetyHelper->GetWorldVolume())
  {
    G4TrackStateManager& trackStateMan = GetIT(track)->GetTrackingInfo()
    ->GetTrackStateManager();
    fpSafetyHelper->LoadTrackState(trackStateMan);
    res = fpSafetyHelper->CheckNextStep(
        track.GetStep()->GetPreStepPoint()->GetPosition(),
        track.GetMomentumDirection(),
        limit, presafety);
    fpSafetyHelper->ResetTrackState();
  }
  return res;
}

References G4ITSafetyHelper::CheckNextStep(), DBL_MAX, G4ITTransportation::fpSafetyHelper, GetIT(), G4Track::GetMomentumDirection(), G4StepPoint::GetPosition(), G4Step::GetPreStepPoint(), G4Track::GetStep(), G4IT::GetTrackingInfo(), G4TrackingInformation::GetTrackStateManager(), G4Track::GetVolume(), G4ITSafetyHelper::GetWorldVolume(), G4TrackStateDependent< T >::LoadTrackState(), and G4TrackStateDependent< T >::ResetTrackState().

◆ ComputeStep()

void G4DNABrownianTransportation::ComputeStep	(	const G4Track &	track,
		const G4Step &	step,
		const G4double	timeStep,
		G4double &	spaceStep
	)

virtual

Reimplemented from G4ITTransportation.

Definition at line 204 of file G4DNABrownianTransportation.cc.

{
  // G4cout << "G4ITBrownianTransportation::ComputeStep" << G4endl;
 
  /* If this method is called, this step
   * cannot be geometry limited.
   * In case the step is limited by the geometry,
   * this method should not be called.
   * The fTransportEndPosition calculated in
   * the method AlongStepIL should be taken
   * into account.
   * In order to do so, the flag IsLeadingStep
   * is on. Meaning : this track has the minimum
   * interaction length over all others.
   */
  if(GetIT(track)->GetTrackingInfo()->IsLeadingStep())
  {
    const G4VITProcess* ITProc = ((const G4VITProcess*) step.GetPostStepPoint()
        ->GetProcessDefinedStep());
    G4bool makeException = true;
 
    if(ITProc && ITProc->ProposesTimeStep()) makeException = false;
 
    if(makeException)
    {
 
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "ComputeStep is called while the track has"
                              "the minimum interaction time";
      exceptionDescription << " so it should not recompute a timeStep ";
      G4Exception("G4DNABrownianTransportation::ComputeStep",
                  "G4DNABrownianTransportation001", FatalErrorInArgument,
                  exceptionDescription);
    }
  }
 
  State(fGeometryLimitedStep) = false;
 
  G4Molecule* molecule = GetMolecule(track);
 
  if(timeStep > 0)
  {
    spaceStep = DBL_MAX;
 
    // TODO : generalize this process to all kind of Brownian objects
    G4double diffCoeff = molecule->GetDiffusionCoefficient(track.GetMaterial(),
                                                           track.GetMaterial()->GetTemperature());
 
    static G4double sqrt_2 = sqrt(2.);
    G4double sqrt_Dt = sqrt(diffCoeff*timeStep);
    G4double sqrt_2Dt = sqrt_2*sqrt_Dt;
 
    if(State(fTimeStepReachedLimit)== true)
    {
      //========================================================================
      State(fGeometryLimitedStep) = true;// important
      //========================================================================
      spaceStep = State(fEndPointDistance);
   //   G4cout << "State(fTimeStepReachedLimit)== true" << G4endl;
    }
    else
    {
      G4double x = G4RandGauss::shoot(0,sqrt_2Dt);
      G4double y = G4RandGauss::shoot(0,sqrt_2Dt);
      G4double z = G4RandGauss::shoot(0,sqrt_2Dt);
 
      spaceStep = sqrt(x*x + y*y + z*z);
 
      if(spaceStep >= State(fEndPointDistance))
      {
        //G4cout << "spaceStep >= State(fEndPointDistance)" << G4endl;
        //======================================================================
        State(fGeometryLimitedStep) = true;// important
        //======================================================================
/*
        if(fSpeedMeUp)
        {
          G4cout << "SpeedMeUp" << G4endl;
        }
        else
*/
        if(fUseSchedulerMinTimeSteps == false)// jump over barrier NOT used
        {
#ifdef G4VERBOSE
          if (fVerboseLevel > 1)
          {
            G4cout << GREEN_ON_BLUE
            << "G4ITBrownianTransportation::ComputeStep() : "
            << "Step was limited to boundary"
            << RESET_COLOR
            << G4endl;
          }
#endif
          //TODO
          if(State(fRandomNumber)>=0) // CDF is used
          {
            /*
             //=================================================================
             State(fGeometryLimitedStep) = true;// important
             //=================================================================
             spaceStep = State(fEndPointDistance);
             */
 
            //==================================================================
            // BE AWARE THAT THE TECHNIQUE USED BELOW IS A 1D APPROXIMATION
            // Cumulative density function for the 3D case is not yet
            // implemented
            //==================================================================
//            G4cout << GREEN_ON_BLUE
//                   << "G4ITBrownianTransportation::ComputeStep() : "
//                   << "A random number was selected"
//                   << RESET_COLOR
//                   << G4endl;
            G4double value = State(fRandomNumber)+(1-State(fRandomNumber))*G4UniformRand();
            G4double invErfc = InvErfc(value);
            spaceStep = invErfc*2*sqrt_Dt;
 
            if(State(fTimeStepReachedLimit)== false)
            {
              //================================================================
              State(fGeometryLimitedStep) = false;// important
              //================================================================
            }
            //==================================================================
            // DEBUG
//            if(spaceStep > State(fEndPointDistance))
//            {
//              G4cout << "value = " << value << G4endl;
//              G4cout << "invErfc = " << invErfc << G4endl;
//              G4cout << "spaceStep = " << G4BestUnit(spaceStep, "Length")
//              << G4endl;
//              G4cout << "end point distance= " << G4BestUnit(State(fEndPointDistance), "Length")
//              << G4endl;
//            }
//
//            assert(spaceStep <= State(fEndPointDistance));
            //==================================================================
 
          }
          else if(fUseMaximumTimeBeforeReachingBoundary == false) // CDF is used
          {
            G4double min_randomNumber = Erfc(State(fEndPointDistance)/2*sqrt_Dt);
            G4double value = min_randomNumber+(1-min_randomNumber)*G4UniformRand();
            G4double invErfc = InvErfc(value);
            spaceStep = invErfc*2*sqrt_Dt;
            if(spaceStep >= State(fEndPointDistance))
            {
              //================================================================
              State(fGeometryLimitedStep) = true;// important
              //================================================================
            }
            else if(State(fTimeStepReachedLimit)== false)
            {
              //================================================================
              State(fGeometryLimitedStep) = false;// important
              //================================================================
            }
          }
          else // CDF is NOT used
          {
            //==================================================================
            State(fGeometryLimitedStep) = true;// important
            //==================================================================
            spaceStep = State(fEndPointDistance);
            //TODO
 
            /*
            //==================================================================
            // 1D approximation to place the brownian between its starting point
            // and the geometry boundary
            //==================================================================
            double min_randomNumber = Erfc(State(fEndPointDistance)/2*sqrt_Dt);
            double value = State(fRandomNumber)+(1-State(fRandomNumber))*G4UniformRand();
            double invErfc = InvErfc(value*G4UniformRand());
            spaceStep = invErfc*2*sqrt_Dt;
            State(fGeometryLimitedStep) = false;
            */
          }
        }
 
        State(fTransportEndPosition)= spaceStep*
//             step.GetPostStepPoint()->GetMomentumDirection() 
             track.GetMomentumDirection()
             + track.GetPosition();
      }
      else
      {
        //======================================================================
        State(fGeometryLimitedStep) = false;// important
        //======================================================================
        State(fTransportEndPosition)= spaceStep*step.GetPostStepPoint()->
        GetMomentumDirection() + track.GetPosition();
      }
    }
  }
  else
  {
    spaceStep = 0.;
    State(fTransportEndPosition) = track.GetPosition();
    State(fGeometryLimitedStep) = false;
  }
 
  State(fCandidateEndGlobalTime) = step.GetPreStepPoint()->GetGlobalTime()
      + timeStep;
  State(fEndGlobalTimeComputed) = true;
 
#ifdef G4VERBOSE
  //    DEBUG
  if (fVerboseLevel > 1)
  {
    G4cout << GREEN_ON_BLUE
           << "G4ITBrownianTransportation::ComputeStep() : "
           << " trackID : " << track.GetTrackID() << " : Molecule name: "
           << molecule->GetName() << G4endl
           << "Initial position:" << G4BestUnit(track.GetPosition(), "Length")
           << G4endl
           << "Initial direction:" << track.GetMomentumDirection() << G4endl
           << "Final position:" << G4BestUnit(State(fTransportEndPosition), "Length")
           << G4endl
           << "Initial magnitude:" << G4BestUnit(track.GetPosition().mag(), "Length")
           << G4endl
           << "Final magnitude:" << G4BestUnit(State(fTransportEndPosition).mag(), "Length")
           << G4endl
           << "Diffusion length : "
           << G4BestUnit(spaceStep, "Length")
           << " within time step : " << G4BestUnit(timeStep,"Time")
           << G4endl
           << "State(fTimeStepReachedLimit)= " << State(fTimeStepReachedLimit) << G4endl
           << "State(fGeometryLimitedStep)=" << State(fGeometryLimitedStep) << G4endl
           << "End point distance was: " << G4BestUnit(State(fEndPointDistance), "Length")
           << G4endl
           << RESET_COLOR
           << G4endl<< G4endl;
  }
#endif
 
//==============================================================================
// DEBUG
//assert(spaceStep <  State(fEndPointDistance)
//  || (spaceStep >= State(fEndPointDistance) && State(fGeometryLimitedStep)));
//assert(track.GetMomentumDirection() == State(fTransportEndMomentumDir));
//==============================================================================
}

References DBL_MAX, Erfc(), FatalErrorInArgument, fUseMaximumTimeBeforeReachingBoundary, fUseSchedulerMinTimeSteps, G4ITTransportation::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4Exception(), G4UniformRand, G4Molecule::GetDiffusionCoefficient(), G4StepPoint::GetGlobalTime(), GetIT(), G4Track::GetMaterial(), GetMolecule(), G4Track::GetMomentumDirection(), G4Molecule::GetName(), G4Track::GetPosition(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4StepPoint::GetProcessDefinedStep(), G4Material::GetTemperature(), G4Track::GetTrackID(), GREEN_ON_BLUE, InvErfc(), CLHEP::Hep3Vector::mag(), G4VITProcess::ProposesTimeStep(), RESET_COLOR, G4INCL::DeJongSpin::shoot(), and State.

◆ CreateInfo()

void G4VITProcess::CreateInfo ( )

protectedinherited

◆ Diffusion()

void G4DNABrownianTransportation::Diffusion ( const G4Track & track )

protected

Definition at line 475 of file G4DNABrownianTransportation.cc.

{
 
#ifdef DEBUG_MEM
  MemStat mem_first = MemoryUsage();
#endif
 
#ifdef G4VERBOSE
  // DEBUG
  if (fVerboseLevel > 1)
  {
    G4cout << GREEN_ON_BLUE << setw(18)
           << "G4DNABrownianTransportation::Diffusion :" << setw(8)
           << GetIT(track)->GetName() << "\t trackID:" << track.GetTrackID()
           << "\t" << " Global Time = "
           << G4BestUnit(track.GetGlobalTime(), "Time")
           << RESET_COLOR
           << G4endl
           << G4endl;
  }
#endif
 
/*
  fParticleChange.ProposePosition(State(fTransportEndPosition));
  //fParticleChange.ProposeEnergy(State(fTransportEndKineticEnergy));
  fParticleChange.SetMomentumChanged(State(fMomentumChanged));
 
  fParticleChange.ProposeGlobalTime(State(fCandidateEndGlobalTime));
  fParticleChange.ProposeLocalTime(State(fCandidateEndGlobalTime));
  fParticleChange.ProposeTrueStepLength(track.GetStepLength());
*/
  G4Material* material = track.GetMaterial();
 
  G4double waterDensity = (*fpWaterDensity)[material->GetIndex()];
 
  if (waterDensity == 0.0)
  {
    if(fpBrownianAction)
    {
      // Let the user Brownian action class decide what to do
      fpBrownianAction->Transport(track,
                                  fParticleChange);
      return;
    }
    else
    {
#ifdef G4VERBOSE
      if(fVerboseLevel)
      {
        G4cout << "A track is outside water material : trackID = "
        << track.GetTrackID() << " (" << GetMolecule(track)->GetName() <<")"
        << G4endl;
        G4cout << "Local Time : " << G4BestUnit(track.GetGlobalTime(), "Time")
        << G4endl;
        G4cout << "Step Number :" << track.GetCurrentStepNumber() << G4endl;
      }
#endif
      fParticleChange.ProposeEnergy(0.);
      fParticleChange.ProposeTrackStatus(fStopAndKill);
      return;// &fParticleChange is the final returned object
    }
  }
 
 
   #ifdef DEBUG_MEM
   MemStat mem_intermediaire = MemoryUsage();
   mem_diff = mem_intermediaire-mem_first;
   G4cout << "\t\t\t >> || MEM || In G4DNABrownianTransportation::Diffusion "
   "after dealing with waterDensity for "<< track.GetTrackID()
   << ", diff is : " << mem_diff << G4endl;
   #endif
 
  fParticleChange.ProposeMomentumDirection(G4RandomDirection());
  State(fMomentumChanged) = true;
  fParticleChange.SetMomentumChanged(true);
   //
   #ifdef DEBUG_MEM
   mem_intermediaire = MemoryUsage();
   mem_diff = mem_intermediaire-mem_first;
   G4cout << "\t\t\t >> || MEM || In G4DNABrownianTransportation::"
          "After proposing new direction to fParticleChange for "
          << track.GetTrackID() << ", diff is : " << mem_diff << G4endl;
   #endif
 
  return;// &fParticleChange is the final returned object
}

References G4ITTransportation::fParticleChange, fpBrownianAction, fStopAndKill, G4ITTransportation::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4RandomDirection(), G4Track::GetCurrentStepNumber(), G4Track::GetGlobalTime(), GetIT(), G4Track::GetMaterial(), GetMolecule(), G4Molecule::GetName(), G4IT::GetName(), G4Track::GetTrackID(), GREEN_ON_BLUE, eplot::material, G4MemStat::MemoryUsage(), G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeTrackStatus(), RESET_COLOR, G4ParticleChangeForTransport::SetMomentumChanged(), State, and G4BrownianAction::Transport().

Referenced by AlongStepDoIt().

◆ DoesGlobalFieldExist()

G4bool G4ITTransportation::DoesGlobalFieldExist ( )

protectedinherited

Definition at line 235 of file G4ITTransportation.cc.

{
  G4TransportationManager* transportMgr;
  transportMgr = G4TransportationManager::GetTransportationManager();
 
  // fFieldExists= transportMgr->GetFieldManager()->DoesFieldExist();
  // return fFieldExists;
  return transportMgr->GetFieldManager()->DoesFieldExist();
}

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

Referenced by G4ITTransportation::StartTracking().

◆ DumpInfo()

void G4VProcess::DumpInfo ( ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4Cerenkov, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 167 of file G4VProcess.cc.

{
  G4cout << "Process Name " << theProcessName ;
  G4cout << " : Type[" << GetProcessTypeName(theProcessType) << "]";
  G4cout << " : SubType[" << theProcessSubType << "]"<< G4endl;
}

References G4cout, G4endl, G4VProcess::GetProcessTypeName(), G4VProcess::theProcessName, G4VProcess::theProcessSubType, and G4VProcess::theProcessType.

Referenced by G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Scintillation::ProcessDescription(), G4Cerenkov::ProcessDescription(), and G4ProcessManagerMessenger::SetNewValue().

◆ EnableShortStepOptimisation()

void G4ITTransportation::EnableShortStepOptimisation ( G4bool optimise = true )

inlineinherited

◆ EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

◆ GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

◆ GetInteractionTimeLeft()

G4double G4VITProcess::GetInteractionTimeLeft ( )

inlineinherited

Definition at line 273 of file G4VITProcess.hh.

{
  if (fpState) return fpState->theInteractionTimeLeft;
 
  return -1;
}

References G4VITProcess::fpState.

Referenced by G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

◆ GetMaxEnergyKilled()

G4double G4ITTransportation::GetMaxEnergyKilled ( ) const

inlineinherited

◆ GetMaxProcessIndex()

const size_t & G4VITProcess::GetMaxProcessIndex ( )

inlinestaticinherited

Definition at line 285 of file G4VITProcess.hh.

{
  if (!fNbProcess) fNbProcess = new size_t(0);
  return *fNbProcess;
}

References G4VITProcess::fNbProcess.

Referenced by G4TrackingInformation::GetProcessState().

◆ GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

◆ GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName	(	const G4ParticleDefinition *	particle,
		const G4String &	directory,
		const G4String &	tableName,
		G4bool	ascii = `false`
	)

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

◆ GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ GetProcessID()

size_t G4VITProcess::GetProcessID ( ) const

inlineinherited

Definition at line 115 of file G4VITProcess.hh.

  {
    return fProcessID;
  }

References G4VITProcess::fProcessID.

Referenced by G4ITStepProcessor::DoDefinePhysicalStepLength(), G4ITStepProcessor::FindTransportationStep(), G4ITStepProcessor::GetAtRestIL(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4ITStepProcessor::InvokeAtRestDoItProcs(), and G4ITStepProcessor::InvokePSDIP().

◆ GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

◆ GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

◆ GetProcessState()

G4shared_ptr< G4ProcessState_Lock > G4VITProcess::GetProcessState ( )

inlineinherited

Definition at line 120 of file G4VITProcess.hh.

  {
    return UpcastProcessState(G4ProcessState_Lock);
  }

References UpcastProcessState.

◆ GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

◆ GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

◆ GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

◆ GetPropagatorInField()

G4PropagatorInField * G4ITTransportation::GetPropagatorInField ( )

inherited

◆ GetState()

template<typename T >

T * G4VITProcess::GetState ( )

inlineprotectedinherited

Definition at line 212 of file G4VITProcess.hh.

    {
      return fpState->GetState<T>();
    }

References G4VITProcess::fpState.

◆ GetSumEnergyKilled()

G4double G4ITTransportation::GetSumEnergyKilled ( ) const

inlineinherited

◆ GetThresholdImportantEnergy()

G4double G4ITTransportation::GetThresholdImportantEnergy ( ) const

inlineinherited

◆ GetThresholdTrials()

G4int G4ITTransportation::GetThresholdTrials ( ) const

inlineinherited

◆ GetThresholdWarningEnergy()

G4double G4ITTransportation::GetThresholdWarningEnergy ( ) const

inlineinherited

◆ GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

◆ GetVerboseLevel()

G4int G4ITTransportation::GetVerboseLevel ( ) const

inlineinherited

◆ InstantiateProcessState()

G4bool G4ITTransportation::InstantiateProcessState ( )

inlineprotectedinherited

Definition at line 259 of file G4ITTransportation.hh.

  {
    return fInstantiateProcessState;
  }

References G4ITTransportation::fInstantiateProcessState.

◆ isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsApplicable()

virtual G4bool G4VProcess::IsApplicable ( const G4ParticleDefinition & )

inlinevirtualinherited

Reimplemented in G4DNAAttachment, G4DNAChargeDecrease, G4DNAChargeIncrease, G4DNADissociation, G4DNAElastic, G4DNAElectronSolvation, G4DNAExcitation, G4DNAIonisation, G4DNAPlasmonExcitation, G4DNAPositronium, G4DNARotExcitation, G4DNAVibExcitation, G4hImpactIonisation, G4RadioactiveDecay, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronicAbsorptionFritiofWithBinaryCascade, G4HadronStoppingProcess, G4MuonicAtomDecay, G4MuonMinusAtomicCapture, G4MuonMinusCapture, G4WrapperProcess, G4PhononDownconversion, G4NeutronKiller, G4ComptonScattering, G4GammaConversion, G4PhotoElectricEffect, G4GammaGeneralProcess, G4Decay, G4UnknownDecay, G4AdjointProcessEquivalentToDirectProcess, G4DNAElectronHoleRecombination, G4DNAMolecularDissociation, G4AnnihiToMuPair, G4GammaConversionToMuons, G4JAEAElasticScattering, G4LowECapture, G4MicroElecElastic, G4MicroElecInelastic, G4MicroElecLOPhononScattering, G4RayleighScattering, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedPhotoElectric, G4SynchrotronRadiation, G4SynchrotronRadiationInMat, G4VXTRenergyLoss, G4HadronInelasticProcess, G4NoProcess, G4ChargeExchangeProcess, G4MuonNuclearProcess, G4UCNAbsorption, G4UCNBoundaryProcess, G4UCNLoss, G4UCNMultiScattering, G4NeutronCaptureProcess, G4MicroElecSurface, G4ErrorEnergyLoss, G4Cerenkov, G4Scintillation, G4TransitionRadiation, G4VTransitionRadiation, G4OpAbsorption, G4OpBoundaryProcess, G4OpMieHG, G4OpRayleigh, G4OpWLS, G4OpWLS2, G4Channeling, G4VPhononProcess, G4NeutronFissionProcess, G4CoulombScattering, G4eBremsstrahlung, G4eIonisation, G4eMultipleScattering, G4eplusAnnihilation, G4hMultipleScattering, G4ionIonisation, G4NuclearStopping, G4AdjointhMultipleScattering, G4eAdjointMultipleScattering, G4eeToHadrons, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuMultipleScattering, G4MuPairProduction, G4PolarizedIonisation, G4hIonisation, G4VEmProcess, and G4BiasingProcessInterface.

Definition at line 182 of file G4VProcess.hh.

182{ return true; }

Referenced by G4ProcessManager::AddProcess(), export_G4VProcess(), G4WrapperProcess::IsApplicable(), G4AdjointProcessEquivalentToDirectProcess::IsApplicable(), and G4BiasingProcessInterface::IsApplicable().

◆ isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

◆ IsStepLimitedByGeometry()

G4bool G4ITTransportation::IsStepLimitedByGeometry ( )

inlineinherited

Definition at line 97 of file G4ITTransportation.hh.

  {
    return GetState<G4ITTransportationState>()->fGeometryLimitedStep;
  }

◆ operator!=() [1/2]

G4bool G4VITProcess::operator!= ( const G4VITProcess & right ) const

inherited

◆ operator!=() [2/2]

G4bool G4VProcess::operator!= ( const G4VProcess & right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

◆ operator=()

G4DNABrownianTransportation & G4DNABrownianTransportation::operator= ( const G4DNABrownianTransportation & rhs )

Definition at line 163 of file G4DNABrownianTransportation.cc.

{
  if(this == &rhs) return *this; // handle self assignment
  //assignment operator
  return *this;
}

◆ operator==() [1/2]

G4bool G4VITProcess::operator== ( const G4VITProcess & right ) const

inherited

◆ operator==() [2/2]

G4bool G4VProcess::operator== ( const G4VProcess & right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

◆ PostStepDoIt()

G4VParticleChange * G4DNABrownianTransportation::PostStepDoIt	(	const G4Track &	track,
		const G4Step &	step
	)

virtual

Reimplemented from G4ITTransportation.

Definition at line 451 of file G4DNABrownianTransportation.cc.

{
  G4ITTransportation::PostStepDoIt(track, step);
 
#ifdef G4VERBOSE
  //    DEBUG
  if (fVerboseLevel > 1)
  {
    G4cout << GREEN_ON_BLUE << "G4ITBrownianTransportation::PostStepDoIt() :"
           << " trackID : " << track.GetTrackID() << " Molecule name: "
           << GetMolecule(track)->GetName() << G4endl;
    G4cout << "Diffusion length : "
           << G4BestUnit(step.GetStepLength(), "Length")
           <<" within time step : " << G4BestUnit(step.GetDeltaTime(),"Time")
           << "\t Current global time : "
           << G4BestUnit(track.GetGlobalTime(),"Time")
           << RESET_COLOR
           << G4endl<< G4endl;
  }
#endif
  return &fParticleChange;
}

References G4ITTransportation::fParticleChange, G4ITTransportation::fVerboseLevel, G4BestUnit, G4cout, G4endl, G4Step::GetDeltaTime(), G4Track::GetGlobalTime(), GetMolecule(), G4Molecule::GetName(), G4Step::GetStepLength(), G4Track::GetTrackID(), GREEN_ON_BLUE, G4ITTransportation::PostStepDoIt(), and RESET_COLOR.

◆ PostStepGetPhysicalInteractionLength()

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

virtualinherited

Implements G4VProcess.

Definition at line 859 of file G4ITTransportation.cc.

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

References DBL_MAX, and Forced.

◆ PostStepGPIL()

G4double G4VProcess::PostStepGPIL	(	const G4Track &	track,
		G4double	previousStepSize,
		G4ForceCondition *	condition
	)

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

◆ PreparePhysicsTable()

virtual void G4VProcess::PreparePhysicsTable ( const G4ParticleDefinition & )

inlinevirtualinherited

◆ PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition & part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

◆ ProcessDescription()

void G4VProcess::ProcessDescription ( std::ostream & outfile ) const

virtualinherited

Reimplemented in G4AdjointAlongStepWeightCorrection, G4AdjointForcedInteractionForGamma, G4AdjointhMultipleScattering, G4ContinuousGainOfEnergy, G4eAdjointMultipleScattering, G4eInverseBremsstrahlung, G4eInverseCompton, G4eInverseIonisation, G4InversePEEffect, G4IonInverseIonisation, G4eeToHadrons, G4hBremsstrahlung, G4hhIonisation, G4hPairProduction, G4mplIonisation, G4RayleighScattering, G4ePairProduction, G4MuBremsstrahlung, G4MuIonisation, G4MuMultipleScattering, G4MuPairProduction, G4PolarizedAnnihilation, G4PolarizedBremsstrahlung, G4PolarizedCompton, G4PolarizedGammaConversion, G4PolarizedIonisation, G4PolarizedPhotoElectric, G4ComptonScattering, G4CoulombScattering, G4eBremsstrahlung, G4eIonisation, G4eMultipleScattering, G4eplusAnnihilation, G4GammaConversion, G4hIonisation, G4hMultipleScattering, G4ionIonisation, G4NuclearStopping, G4PhotoElectricEffect, G4ForwardXrayTR, G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4Scintillation, G4StrawTubeXTRadiator, G4SynchrotronRadiation, G4TransitionRadiation, G4TransparentRegXTRadiator, G4VTransitionRadiation, G4VXTRenergyLoss, G4XTRGammaRadModel, G4XTRRegularRadModel, G4XTRTransparentRegRadModel, G4Cerenkov, G4Radioactivation, G4RadioactiveDecay, G4ElectronNuclearProcess, G4MuonNuclearProcess, G4NeutrinoElectronProcess, G4NeutronFissionProcess, G4PositronNuclearProcess, G4HadronicAbsorptionBertini, G4HadronicAbsorptionFritiof, G4HadronicAbsorptionFritiofWithBinaryCascade, G4HadronStoppingProcess, G4MuonicAtomDecay, G4MuonMinusAtomicCapture, G4MuonMinusCapture, G4Transportation, G4NeutronCaptureProcess, G4GammaGeneralProcess, G4Decay, G4DecayWithSpin, G4PionDecayMakeSpin, G4UnknownDecay, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4HadronicProcess, G4ElNeutrinoNucleusProcess, G4HadronElasticProcess, and G4MuNeutrinoNucleusProcess.

Definition at line 175 of file G4VProcess.cc.

{
  outFile << "This process has not yet been described\n";
}

Referenced by G4LossTableManager::DumpHtml(), G4HadronicProcessStore::PrintHtml(), and G4GammaGeneralProcess::ProcessDescription().

◆ ProposesTimeStep()

G4bool G4VITProcess::ProposesTimeStep ( ) const

inlineinherited

Definition at line 280 of file G4VITProcess.hh.

{
  return fProposesTimeStep;
}

References G4VITProcess::fProposesTimeStep.

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

◆ ResetKilledStatistics()

void G4ITTransportation::ResetKilledStatistics ( G4int report = 1 )

inlineinherited

◆ ResetNumberOfInteractionLengthLeft()

void G4VITProcess::ResetNumberOfInteractionLengthLeft ( )

inlinevirtualinherited

WARNING : Redefine the method of G4VProcess reset (determine the value of)NumberOfInteractionLengthLeft

Reimplemented from G4VProcess.

Definition at line 268 of file G4VITProcess.hh.

{
  fpState->theNumberOfInteractionLengthLeft = -std::log( G4UniformRand());
}

References G4VITProcess::fpState, and G4UniformRand.

Referenced by G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength().

◆ ResetProcessState()

void G4VITProcess::ResetProcessState ( )

inlineinherited

Definition at line 130 of file G4VITProcess.hh.

  {
    fpState.reset();
  }

References G4VITProcess::fpState.

Referenced by G4ITStepProcessor::DoDefinePhysicalStepLength(), G4ITStepProcessor::FindTransportationStep(), G4ITStepProcessor::GetAtRestIL(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4ITStepProcessor::InvokeAtRestDoItProcs(), and G4ITStepProcessor::InvokePSDIP().

◆ RetrievePhysicsTable()

virtual G4bool G4VProcess::RetrievePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4GammaGeneralProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4WrapperProcess, G4AdjointProcessEquivalentToDirectProcess, and G4BiasingProcessInterface.

Definition at line 211 of file G4VProcess.hh.

212 { return false; }

Referenced by export_G4VProcess(), G4WrapperProcess::RetrievePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::RetrievePhysicsTable(), and G4BiasingProcessInterface::RetrievePhysicsTable().

◆ RetrieveProcessInfo()

void G4VITProcess::RetrieveProcessInfo ( )

protectedinherited

◆ SetBrownianAction()

void G4DNABrownianTransportation::SetBrownianAction ( G4BrownianAction * brownianAction )

inline

Definition at line 242 of file G4DNABrownianTransportation.hh.

{
  fpBrownianAction = brownianAction;
}

References fpBrownianAction.

◆ SetInstantiateProcessState()

void G4ITTransportation::SetInstantiateProcessState ( G4bool flag )

inlineprotectedinherited

Definition at line 254 of file G4ITTransportation.hh.

  {
    fInstantiateProcessState = flag;
  }

References G4ITTransportation::fInstantiateProcessState.

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

◆ SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess * masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

◆ SetPILfactor()

void G4VProcess::SetPILfactor ( G4double value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

◆ SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager * procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

◆ SetProcessState()

void G4VITProcess::SetProcessState ( G4shared_ptr< G4ProcessState_Lock > aProcInfo )

inlineinherited

Definition at line 125 of file G4VITProcess.hh.

  {
    fpState = DowncastState(G4ProcessState, aProcInfo);
  }

References DowncastState, and G4VITProcess::fpState.

Referenced by G4ITStepProcessor::DoDefinePhysicalStepLength(), G4ITStepProcessor::FindTransportationStep(), G4ITStepProcessor::GetAtRestIL(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4ITStepProcessor::InvokeAtRestDoItProcs(), and G4ITStepProcessor::InvokePSDIP().

◆ SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

◆ SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

◆ SetPropagatorInField()

void G4ITTransportation::SetPropagatorInField ( G4PropagatorInField * pFieldPropagator )

inherited

◆ SetThresholdImportantEnergy()

void G4ITTransportation::SetThresholdImportantEnergy ( G4double newEnImp )

inlineinherited

◆ SetThresholdTrials()

void G4ITTransportation::SetThresholdTrials ( G4int newMaxTrials )

inlineinherited

◆ SetThresholdWarningEnergy()

void G4ITTransportation::SetThresholdWarningEnergy ( G4double newEnWarn )

inlineinherited

◆ SetVerboseLevel()

void G4ITTransportation::SetVerboseLevel ( G4int verboseLevel )

inlineinherited

◆ SpeedLevel()

void G4DNABrownianTransportation::SpeedLevel ( int level )

inline

Definition at line 171 of file G4DNABrownianTransportation.hh.

  {
    if(level < 0) level =0;
    else if(level > 2) level = 2;
 
    switch(level)
    {
      case 0:
        fSpeedMeUp = false;
        fUseSchedulerMinTimeSteps = false;
        return;
 
      case 1:
        fSpeedMeUp = true;
        fUseSchedulerMinTimeSteps = false;
        return;
 
      case 2:
        //======================================================================
        // NB: BE AWARE THAT IF NO MIN TIME STEPS NO TIME STEPS HAVE BEEN
        // PROVIDED TO G4Scheduler THIS LEVEL MIGHT BE SLOWER THAN LEVEL 1
        //======================================================================
        fSpeedMeUp = true;
        fUseSchedulerMinTimeSteps = true;
        return;
    }
  }

References fSpeedMeUp, and fUseSchedulerMinTimeSteps.

◆ StartTracking()

void G4DNABrownianTransportation::StartTracking ( G4Track * aTrack )

virtual

Reimplemented from G4ITTransportation.

Definition at line 179 of file G4DNABrownianTransportation.cc.

{
  fpState.reset(new G4ITBrownianState());
//  G4cout << "G4DNABrownianTransportation::StartTracking : "
//  "Initialised track State" << G4endl;
  SetInstantiateProcessState(false);
  G4ITTransportation::StartTracking(track);
}

References G4VITProcess::fpState, G4ITTransportation::SetInstantiateProcessState(), and G4ITTransportation::StartTracking().

◆ StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable	(	const G4ParticleDefinition *	,
		const G4String &	,
		G4bool
	)

inlinevirtualinherited

Reimplemented in G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, and G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.hh.

207 { return true; }

Referenced by export_G4VProcess(), G4WrapperProcess::StorePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::StorePhysicsTable(), and G4BiasingProcessInterface::StorePhysicsTable().

◆ SubtractNumberOfInteractionLengthLeft()

void G4VITProcess::SubtractNumberOfInteractionLengthLeft ( G4double previousStepSize )

inlineprotectedvirtualinherited

Definition at line 292 of file G4VITProcess.hh.

{
  if (fpState->currentInteractionLength > 0.0)
  {
    fpState->theNumberOfInteractionLengthLeft -= previousStepSize
        / fpState->currentInteractionLength;
    if (fpState->theNumberOfInteractionLengthLeft < 0.)
    {
      fpState->theNumberOfInteractionLengthLeft = CLHEP::perMillion;
    }
 
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel > 0)
    {
      G4cerr << "G4VITProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" << G4endl;
      G4cerr << " currentInteractionLength = "
             << fpState->currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << previousStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
             G4String msg = "Negative currentInteractionLength for ";
             msg += theProcessName;
             G4Exception("G4VITProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201",EventMustBeAborted,
                msg);
  }
}

References EventMustBeAborted, G4VITProcess::fpState, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength().

◆ UseCumulativeDensitFunction()

void G4DNABrownianTransportation::UseCumulativeDensitFunction ( bool flag = true )

inline

Definition at line 155 of file G4DNABrownianTransportation.hh.

  {
    if(flag == true)
    {
      fUseMaximumTimeBeforeReachingBoundary = false;
      return;
    }
    fUseMaximumTimeBeforeReachingBoundary = true;
  }

References fUseMaximumTimeBeforeReachingBoundary.

◆ UseLimitingTimeSteps()

void G4DNABrownianTransportation::UseLimitingTimeSteps ( bool flag = true )

inline

Definition at line 166 of file G4DNABrownianTransportation.hh.

  {
    fUseSchedulerMinTimeSteps = flag;
  }

References fUseSchedulerMinTimeSteps.

◆ UseMaximumTimeBeforeReachingBoundary()

void G4DNABrownianTransportation::UseMaximumTimeBeforeReachingBoundary ( bool flag = true )

inline

Definition at line 146 of file G4DNABrownianTransportation.hh.

  {
    fUseMaximumTimeBeforeReachingBoundary = flag;
  }

References fUseMaximumTimeBeforeReachingBoundary.

Field Documentation

◆ aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

◆ aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

◆ currentInteractionLength

G4double* G4VITProcess::currentInteractionLength

privateinherited

Definition at line 254 of file G4VITProcess.hh.

Referenced by G4VITProcess::G4VITProcess(), and G4VITProcess::StartTracking().

◆ enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

◆ enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

◆ enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

◆ fFieldPropagator

G4PropagatorInField* G4ITTransportation::fFieldPropagator

protectedinherited

Definition at line 220 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::AlongStepDoIt(), G4ITTransportation::AlongStepGetPhysicalInteractionLength(), G4ITTransportation::G4ITTransportation(), and G4ITTransportation::StartTracking().

◆ fInstantiateProcessState

G4bool G4ITTransportation::fInstantiateProcessState

privateinherited

Definition at line 265 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::G4ITTransportation(), G4ITTransportation::InstantiateProcessState(), G4ITTransportation::SetInstantiateProcessState(), and G4ITTransportation::StartTracking().

◆ fInternalMinTimeStep

G4double G4DNABrownianTransportation::fInternalMinTimeStep

protected

Definition at line 232 of file G4DNABrownianTransportation.hh.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), and G4DNABrownianTransportation().

◆ fLinearNavigator

G4ITNavigator* G4ITTransportation::fLinearNavigator

protectedinherited

Definition at line 219 of file G4ITTransportation.hh.

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

◆ fMaxEnergyKilled

G4double G4ITTransportation::fMaxEnergyKilled

protectedinherited

Definition at line 241 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::AlongStepDoIt(), G4ITTransportation::G4ITTransportation(), and G4ITTransportation::~G4ITTransportation().

◆ fNbProcess

size_t * G4VITProcess::fNbProcess = 0

privateinherited

Definition at line 248 of file G4VITProcess.hh.

Referenced by G4VITProcess::G4VITProcess(), and G4VITProcess::GetMaxProcessIndex().

◆ fNistWater

G4Material* G4DNABrownianTransportation::fNistWater

protected

Definition at line 229 of file G4DNABrownianTransportation.hh.

Referenced by G4DNABrownianTransportation().

◆ fParticleChange

G4ParticleChangeForTransport G4ITTransportation::fParticleChange

protectedinherited

Definition at line 226 of file G4ITTransportation.hh.

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

◆ fpBrownianAction

G4BrownianAction* G4DNABrownianTransportation::fpBrownianAction

protected

Definition at line 238 of file G4DNABrownianTransportation.hh.

Referenced by Diffusion(), G4DNABrownianTransportation(), SetBrownianAction(), and ~G4DNABrownianTransportation().

◆ fProcessID

size_t G4VITProcess::fProcessID

privateinherited

Definition at line 243 of file G4VITProcess.hh.

Referenced by G4VITProcess::G4VITProcess(), G4VITProcess::GetProcessID(), and G4VITProcess::StartTracking().

◆ fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

◆ fProposesTimeStep

G4bool G4VITProcess::fProposesTimeStep

protectedinherited

Definition at line 239 of file G4VITProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4VITProcess::G4VITProcess(), and G4VITProcess::ProposesTimeStep().

◆ fpSafetyHelper

G4ITSafetyHelper* G4ITTransportation::fpSafetyHelper

protectedinherited

Definition at line 247 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::AlongStepGetPhysicalInteractionLength(), G4ITTransportation::BuildPhysicsTable(), BuildPhysicsTable(), ComputeGeomLimit(), G4ITTransportation::G4ITTransportation(), and G4ITTransportation::StartTracking().

◆ fpState

G4shared_ptr<G4ProcessState> G4VITProcess::fpState

protectedinherited

Definition at line 217 of file G4VITProcess.hh.

Referenced by G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VITProcess::ClearInteractionTimeLeft(), G4VITProcess::ClearNumberOfInteractionLengthLeft(), G4DNAElectronHoleRecombination::FindReactant(), G4DNABrownianTransportation(), G4ITTransportation::G4ITTransportation(), G4VITProcess::G4VITProcess(), G4VITProcess::GetInteractionTimeLeft(), G4VITProcess::GetState(), G4DNAElectronHoleRecombination::MakeReaction(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), G4VITProcess::ResetNumberOfInteractionLengthLeft(), G4VITProcess::ResetProcessState(), G4VITProcess::SetProcessState(), G4VITProcess::StartTracking(), G4DNASecondOrderReaction::StartTracking(), G4DNAElectronHoleRecombination::StartTracking(), G4DNAScavengerProcess::StartTracking(), G4ITTransportation::StartTracking(), StartTracking(), and G4VITProcess::SubtractNumberOfInteractionLengthLeft().

◆ fpWaterDensity

const std::vector<G4double>* G4DNABrownianTransportation::fpWaterDensity

protected

Definition at line 236 of file G4DNABrownianTransportation.hh.

Referenced by BuildPhysicsTable(), and G4DNABrownianTransportation().

◆ fShortStepOptimisation

G4bool G4ITTransportation::fShortStepOptimisation

protectedinherited

Definition at line 245 of file G4ITTransportation.hh.

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

◆ fSpeedMeUp

G4bool G4DNABrownianTransportation::fSpeedMeUp

protected

Definition at line 233 of file G4DNABrownianTransportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), G4DNABrownianTransportation(), and SpeedLevel().

◆ fSumEnergyKilled

G4double G4ITTransportation::fSumEnergyKilled

protectedinherited

Definition at line 240 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::AlongStepDoIt(), G4ITTransportation::G4ITTransportation(), and G4ITTransportation::~G4ITTransportation().

◆ fThreshold_Important_Energy

G4double G4ITTransportation::fThreshold_Important_Energy

protectedinherited

Definition at line 232 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::AlongStepDoIt(), and G4ITTransportation::G4ITTransportation().

◆ fThreshold_Warning_Energy

G4double G4ITTransportation::fThreshold_Warning_Energy

protectedinherited

Definition at line 231 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::AlongStepDoIt(), and G4ITTransportation::G4ITTransportation().

◆ fThresholdTrials

G4int G4ITTransportation::fThresholdTrials

protectedinherited

Definition at line 233 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::AlongStepDoIt(), and G4ITTransportation::G4ITTransportation().

◆ fUnimportant_Energy

G4double G4ITTransportation::fUnimportant_Energy

protectedinherited

Definition at line 236 of file G4ITTransportation.hh.

Referenced by G4ITTransportation::G4ITTransportation().

◆ fUseMaximumTimeBeforeReachingBoundary

G4bool G4DNABrownianTransportation::fUseMaximumTimeBeforeReachingBoundary

protected

Definition at line 228 of file G4DNABrownianTransportation.hh.

Referenced by AlongStepGetPhysicalInteractionLength(), ComputeStep(), G4DNABrownianTransportation(), UseCumulativeDensitFunction(), and UseMaximumTimeBeforeReachingBoundary().

◆ fUseSchedulerMinTimeSteps

G4bool G4DNABrownianTransportation::fUseSchedulerMinTimeSteps

protected

Definition at line 231 of file G4DNABrownianTransportation.hh.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), ComputeStep(), G4DNABrownianTransportation(), SpeedLevel(), and UseLimitingTimeSteps().

◆ fVerboseLevel

G4int G4ITTransportation::fVerboseLevel

protectedinherited

Definition at line 250 of file G4ITTransportation.hh.

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

◆ masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

◆ pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

◆ theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

◆ theInteractionTimeLeft

G4double* G4VITProcess::theInteractionTimeLeft

privateinherited

Definition at line 255 of file G4VITProcess.hh.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), G4ITTransportation::AlongStepGetPhysicalInteractionLength(), G4VITProcess::G4VITProcess(), and G4VITProcess::StartTracking().

◆ theNumberOfInteractionLengthLeft

G4double* G4VITProcess::theNumberOfInteractionLengthLeft

privateinherited

Definition at line 253 of file G4VITProcess.hh.

Referenced by G4VITProcess::G4VITProcess(), and G4VITProcess::StartTracking().

◆ thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

◆ thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

◆ theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

◆ theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

◆ theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

◆ verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

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

source/processes/electromagnetic/dna/processes/include/G4DNABrownianTransportation.hh
source/processes/electromagnetic/dna/processes/src/G4DNABrownianTransportation.cc

Data Structures

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4DNABrownianTransportation() [1/2]

◆ ~G4DNABrownianTransportation()

◆ G4DNABrownianTransportation() [2/2]

Member Function Documentation

◆ AlongStepDoIt()

◆ AlongStepGetPhysicalInteractionLength()

◆ AlongStepGPIL()

◆ AtRestDoIt()

◆ AtRestGetPhysicalInteractionLength()

◆ AtRestGPIL()

◆ BuildPhysicsTable()

◆ BuildWorkerPhysicsTable()

◆ ClearInteractionTimeLeft()

◆ ClearNumberOfInteractionLengthLeft()

◆ ComputeGeomLimit()

◆ ComputeStep()

◆ CreateInfo()

◆ Diffusion()

◆ DoesGlobalFieldExist()

◆ DumpInfo()

◆ EnableShortStepOptimisation()

◆ EndTracking()

◆ GetCurrentInteractionLength()

◆ GetInteractionTimeLeft()

◆ GetMasterProcess()

◆ GetMaxEnergyKilled()

◆ GetMaxProcessIndex()

◆ GetNumberOfInteractionLengthLeft()

◆ GetPhysicsTableFileName()

◆ GetPILfactor()

◆ GetProcessID()

◆ GetProcessManager()

◆ GetProcessName()

◆ GetProcessState()

◆ GetProcessSubType()

◆ GetProcessType()

◆ GetProcessTypeName()

◆ GetPropagatorInField()

◆ GetState()

◆ GetSumEnergyKilled()

◆ GetThresholdImportantEnergy()

◆ GetThresholdTrials()

◆ GetThresholdWarningEnergy()

◆ GetTotalNumberOfInteractionLengthTraversed()

◆ GetVerboseLevel()

◆ InstantiateProcessState()

◆ isAlongStepDoItIsEnabled()

◆ IsApplicable()

◆ isAtRestDoItIsEnabled()

◆ isPostStepDoItIsEnabled()

◆ IsStepLimitedByGeometry()

◆ operator!=() [1/2]

◆ operator!=() [2/2]

◆ operator=()

◆ operator==() [1/2]

◆ operator==() [2/2]

◆ PostStepDoIt()

◆ PostStepGetPhysicalInteractionLength()

◆ PostStepGPIL()

◆ PreparePhysicsTable()

◆ PrepareWorkerPhysicsTable()

◆ ProcessDescription()

◆ ProposesTimeStep()

◆ ResetKilledStatistics()

◆ ResetNumberOfInteractionLengthLeft()

◆ ResetProcessState()

◆ RetrievePhysicsTable()

◆ RetrieveProcessInfo()

◆ SetBrownianAction()

◆ SetInstantiateProcessState()

◆ SetMasterProcess()

◆ SetPILfactor()