G4DNABrownianTransportation Class Reference

#include <G4DNABrownianTransportation.hh>

Inheritance diagram for G4DNABrownianTransportation:

Classes
struct	G4ITBrownianState

Public Member Functions
	G4DNABrownianTransportation (const G4String &aName="DNABrownianTransportation", G4int verbosityLevel=0)
virtual	~G4DNABrownianTransportation ()
	G4DNABrownianTransportation (const G4DNABrownianTransportation &)=delete
G4DNABrownianTransportation &	operator= (const G4DNABrownianTransportation &)=delete
void	SetBrownianAction (G4BrownianAction *)
void	SetUserBrownianAction (G4VUserBrownianAction *)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	StartTracking (G4Track *aTrack)
virtual void	ComputeStep (const G4Track &, const G4Step &, const G4double, G4double &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &)
void	UseMaximumTimeBeforeReachingBoundary (bool flag=true)
void	UseCumulativeDensitFunction (bool flag=true)
void	UseLimitingTimeSteps (bool flag=true)
void	SpeedLevel (int level)
Public Member Functions inherited from G4ITTransportation
	G4ITTransportation (const G4String &aName="ITTransportation", G4int verbosityLevel=0)
virtual	~G4ITTransportation ()
	G4ITTransportation (const G4ITTransportation &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	ComputeStep (const G4Track &, const G4Step &, const double timeStep, double &spaceStep)
virtual void	StartTracking (G4Track *aTrack)
G4bool	IsStepLimitedByGeometry ()
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &, G4double, G4ForceCondition *pForceCond)
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &)
G4PropagatorInField *	GetPropagatorInField ()
void	SetPropagatorInField (G4PropagatorInField *pFieldPropagator)
void	SetVerboseLevel (G4int verboseLevel)
G4int	GetVerboseLevel () const
G4double	GetThresholdWarningEnergy () const
G4double	GetThresholdImportantEnergy () const
G4int	GetThresholdTrials () const
void	SetThresholdWarningEnergy (G4double newEnWarn)
void	SetThresholdImportantEnergy (G4double newEnImp)
void	SetThresholdTrials (G4int newMaxTrials)
G4double	GetMaxEnergyKilled () const
G4double	GetSumEnergyKilled () const
void	ResetKilledStatistics (G4int report=1)
void	EnableShortStepOptimisation (G4bool optimise=true)
Public Member Functions inherited from G4VITProcess
	G4VITProcess (const G4String &name, G4ProcessType type=fNotDefined)
virtual	~G4VITProcess ()
	G4VITProcess (const G4VITProcess &other)
G4VITProcess &	operator= (const G4VITProcess &other)
G4bool	operator== (const G4VITProcess &right) const
G4bool	operator!= (const G4VITProcess &right) const
size_t	GetProcessID () const
G4shared_ptr< G4ProcessState_Lock >	GetProcessState ()
void	SetProcessState (G4shared_ptr< G4ProcessState_Lock > aProcInfo)
void	ResetProcessState ()
virtual void	StartTracking (G4Track *)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
G4double	GetInteractionTimeLeft ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4bool	ProposesTimeStep () const
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4VProcess &	operator= (const G4VProcess &)=delete
G4bool	operator== (const G4VProcess &right) const
G4bool	operator!= (const G4VProcess &right) const
virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)=0
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4bool	IsApplicable (const G4ParticleDefinition &)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual const G4VProcess *	GetCreatorProcess () const
virtual void	StartTracking (G4Track *)
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
virtual void	ProcessDescription (std::ostream &outfile) const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
virtual void	SetMasterProcess (G4VProcess *masterP)
const G4VProcess *	GetMasterProcess () const
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Member Functions
G4double	ComputeGeomLimit (const G4Track &track, G4double &presafety, G4double limit)
void	Diffusion (const G4Track &track)
Protected Member Functions inherited from G4ITTransportation
G4bool	DoesGlobalFieldExist ()
void	SetInstantiateProcessState (G4bool flag)
G4bool	InstantiateProcessState ()
Protected Member Functions inherited from G4VITProcess
void	RetrieveProcessInfo ()
void	CreateInfo ()
template<typename T >
T *	GetState ()
virtual void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)
virtual void	ClearInteractionTimeLeft ()
virtual void	ClearNumberOfInteractionLengthLeft ()
void	SetInstantiateProcessState (G4bool flag)
G4bool	InstantiateProcessState ()
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)
void	ClearNumberOfInteractionLengthLeft ()

Protected Attributes
G4bool	fUseMaximumTimeBeforeReachingBoundary
G4Material *	fNistWater
G4bool	fUseSchedulerMinTimeSteps
G4double	fInternalMinTimeStep
G4bool	fSpeedMeUp
const std::vector< G4double > *	fpWaterDensity
G4BrownianAction *	fpBrownianAction
G4VUserBrownianAction *	fpUserBrownianAction
Protected Attributes inherited from G4ITTransportation
G4ITNavigator *	fLinearNavigator
G4PropagatorInField *	fFieldPropagator
G4ParticleChangeForTransport	fParticleChange
G4double	fThreshold_Warning_Energy
G4double	fThreshold_Important_Energy
G4int	fThresholdTrials
G4double	fUnimportant_Energy
G4double	fSumEnergyKilled
G4double	fMaxEnergyKilled
G4bool	fShortStepOptimisation
G4ITSafetyHelper *	fpSafetyHelper
G4int	fVerboseLevel
Protected Attributes inherited from G4VITProcess
G4shared_ptr< G4ProcessState >	fpState
G4bool	fProposesTimeStep
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr
G4VParticleChange *	pParticleChange = nullptr
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft = -1.0
G4double	currentInteractionLength = -1.0
G4double	theInitialNumberOfInteractionLength = -1.0
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType = fNotDefined
G4int	theProcessSubType = -1
G4double	thePILfactor = 1.0
G4int	verboseLevel = 0
G4bool	enableAtRestDoIt = true
G4bool	enableAlongStepDoIt = true
G4bool	enablePostStepDoIt = true

Additional Inherited Members
Static Public Member Functions inherited from G4VITProcess
static const size_t &	GetMaxProcessIndex ()
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Detailed Description

Definition at line 109 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;
  fpUserBrownianAction = nullptr;
}

~G4DNABrownianTransportation()

G4DNABrownianTransportation::~G4DNABrownianTransportation ( )

virtual

Definition at line 144 of file G4DNABrownianTransportation.cc.

{
  delete fpUserBrownianAction;
}

G4DNABrownianTransportation() [2/2]

G4DNABrownianTransportation::G4DNABrownianTransportation ( const G4DNABrownianTransportation &  )

delete

Member Function Documentation

AlongStepDoIt()

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

virtual

Reimplemented from G4ITTransportation.

Definition at line 800 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;
    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);
 
    if(State(theInteractionTimeLeft) <= fInternalMinTimeStep)
    {
      spaceStep = State(fEndPointDistance);
      State(fGeometryLimitedStep) = true;
    }
    else
    {
      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();
 
    //hoang exp
    if(fpUserBrownianAction != nullptr)
    {
      // Let the user Brownian action class decide what to do
      G4ThreeVector nextPosition{track.GetPosition().getX() + x,
                                 track.GetPosition().getY() + y,
                                 track.GetPosition().getZ() + z};
      fpUserBrownianAction->Transport(nextPosition);
      State(fTransportEndPosition) = nextPosition;
    }
    //hoang exp
  }
 
  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;
}

AlongStepGetPhysicalInteractionLength()

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

virtual

Reimplemented from G4ITTransportation.

Definition at line 569 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;
  //============================================================================
//Hoang exp
  if(fpUserBrownianAction != nullptr)
  {
    // Let the user Brownian action class decide what to do
    G4double distanceToBoundary = fpUserBrownianAction->GetDistanceToBoundary(track);
    geometryStepLength = distanceToBoundary;
  }
 
//Hoang exp
 
 
  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;
}

BuildPhysicsTable()

void G4DNABrownianTransportation::BuildPhysicsTable ( const G4ParticleDefinition &  particle )

virtual

Reimplemented from G4ITTransportation.

Definition at line 167 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);
}

ComputeGeomLimit()

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

protected

Definition at line 550 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;
}

ComputeStep()

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

virtual

Reimplemented from G4ITTransportation.

Definition at line 183 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;
    G4double x = G4RandGauss::shoot(0,sqrt_2Dt);
    G4double y = G4RandGauss::shoot(0,sqrt_2Dt);
    G4double z = G4RandGauss::shoot(0,sqrt_2Dt);
 
    if(State(fTimeStepReachedLimit)== true)
    {
      //========================================================================
      State(fGeometryLimitedStep) = true;// important
      //========================================================================
      spaceStep = State(fEndPointDistance);
   //   G4cout << "State(fTimeStepReachedLimit)== true" << G4endl;
    }
    else
    {
      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();
      }
    }
    if(fpUserBrownianAction != nullptr)
    {
      // Let the user Brownian action class decide what to do:
      G4ThreeVector nextPosition{track.GetPosition().getX() + x,
                                 track.GetPosition().getY() + y,
                                 track.GetPosition().getZ() + z};
      fpUserBrownianAction->Transport(nextPosition);
      State(fTransportEndPosition) = nextPosition;
    }
  }
  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));
//==============================================================================
}

Diffusion()

void G4DNABrownianTransportation::Diffusion ( const G4Track &  track )

protected

Definition at line 462 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());
*/
  const 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
}

Referenced by AlongStepDoIt().

operator=()

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

delete

PostStepDoIt()

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

virtual

Reimplemented from G4ITTransportation.

Definition at line 438 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;
}

SetBrownianAction()

void G4DNABrownianTransportation::SetBrownianAction ( G4BrownianAction *  brownianAction )

inline

Definition at line 245 of file G4DNABrownianTransportation.hh.

{
  fpBrownianAction = brownianAction;
}

SetUserBrownianAction()

void G4DNABrownianTransportation::SetUserBrownianAction ( G4VUserBrownianAction *  brownianAction )

inline

Definition at line 250 of file G4DNABrownianTransportation.hh.

{
  fpUserBrownianAction = brownianAction;
}

SpeedLevel()

void G4DNABrownianTransportation::SpeedLevel ( int  level )

inline

Definition at line 172 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;
    }
  }

StartTracking()

void G4DNABrownianTransportation::StartTracking ( G4Track *  aTrack )

virtual

Reimplemented from G4ITTransportation.

Definition at line 158 of file G4DNABrownianTransportation.cc.

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

UseCumulativeDensitFunction()

void G4DNABrownianTransportation::UseCumulativeDensitFunction ( bool  flag = true )

inline

Definition at line 156 of file G4DNABrownianTransportation.hh.

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

UseLimitingTimeSteps()

void G4DNABrownianTransportation::UseLimitingTimeSteps ( bool  flag = true )

inline

Definition at line 167 of file G4DNABrownianTransportation.hh.

  {
    fUseSchedulerMinTimeSteps = flag;
  }

UseMaximumTimeBeforeReachingBoundary()

void G4DNABrownianTransportation::UseMaximumTimeBeforeReachingBoundary ( bool  flag = true )

inline

Definition at line 147 of file G4DNABrownianTransportation.hh.

  {
    fUseMaximumTimeBeforeReachingBoundary = flag;
  }

Member Data Documentation

fInternalMinTimeStep

G4double G4DNABrownianTransportation::fInternalMinTimeStep

protected

Definition at line 233 of file G4DNABrownianTransportation.hh.

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

fNistWater

G4Material* G4DNABrownianTransportation::fNistWater

protected

Definition at line 230 of file G4DNABrownianTransportation.hh.

Referenced by G4DNABrownianTransportation().

fpBrownianAction

G4BrownianAction* G4DNABrownianTransportation::fpBrownianAction

protected

Definition at line 239 of file G4DNABrownianTransportation.hh.

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

fpUserBrownianAction

G4VUserBrownianAction* G4DNABrownianTransportation::fpUserBrownianAction

protected

Definition at line 240 of file G4DNABrownianTransportation.hh.

Referenced by AlongStepDoIt(), AlongStepGetPhysicalInteractionLength(), ComputeStep(), G4DNABrownianTransportation(), SetUserBrownianAction(), and ~G4DNABrownianTransportation().

fpWaterDensity

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

protected

Definition at line 237 of file G4DNABrownianTransportation.hh.

Referenced by BuildPhysicsTable(), and G4DNABrownianTransportation().

fSpeedMeUp

G4bool G4DNABrownianTransportation::fSpeedMeUp

protected

Definition at line 234 of file G4DNABrownianTransportation.hh.

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

fUseMaximumTimeBeforeReachingBoundary

G4bool G4DNABrownianTransportation::fUseMaximumTimeBeforeReachingBoundary

protected

Definition at line 229 of file G4DNABrownianTransportation.hh.

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

fUseSchedulerMinTimeSteps

G4bool G4DNABrownianTransportation::fUseSchedulerMinTimeSteps

protected

Definition at line 232 of file G4DNABrownianTransportation.hh.

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

---

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

• G4DNABrownianTransportation.hh
• G4DNABrownianTransportation.cc