G4DNAGillespieDirectMethod Class Reference

#include <G4DNAGillespieDirectMethod.hh>

Public Types
using	MolType = const G4MolecularConfiguration *
using	Index = G4VDNAMesh::Index
using	Voxel = G4DNAMesh::Voxel
using	JumpingData = std::pair< MolType, Index >
using	ReactionData = const G4DNAMolecularReactionData
using	EventIt = G4DNAEventSet::EventSet::iterator

Public Member Functions
	G4DNAGillespieDirectMethod ()
	~G4DNAGillespieDirectMethod ()
G4double	PropensityFunction (const Voxel &voxel, ReactionData *data)
G4double	PropensityFunction (const Voxel &voxel, MolType moleType)
void	SetVoxelMesh (G4DNAMesh &mesh)
void	SetTimeStep (const G4double &stepTime)
void	Initialize ()
void	CreateEvent (const Index &index)
void	SetEventSet (G4DNAEventSet *)

Detailed Description

Definition at line 40 of file G4DNAGillespieDirectMethod.hh.

Member Typedef Documentation

EventIt

using G4DNAGillespieDirectMethod::EventIt = G4DNAEventSet::EventSet::iterator

Definition at line 50 of file G4DNAGillespieDirectMethod.hh.

Index

using G4DNAGillespieDirectMethod::Index = G4VDNAMesh::Index

Definition at line 46 of file G4DNAGillespieDirectMethod.hh.

JumpingData

using G4DNAGillespieDirectMethod::JumpingData = std::pair<MolType, Index>

Definition at line 48 of file G4DNAGillespieDirectMethod.hh.

MolType

using G4DNAGillespieDirectMethod::MolType = const G4MolecularConfiguration*

Definition at line 45 of file G4DNAGillespieDirectMethod.hh.

ReactionData

using G4DNAGillespieDirectMethod::ReactionData = const G4DNAMolecularReactionData

Definition at line 49 of file G4DNAGillespieDirectMethod.hh.

Voxel

using G4DNAGillespieDirectMethod::Voxel = G4DNAMesh::Voxel

Definition at line 47 of file G4DNAGillespieDirectMethod.hh.

Constructor & Destructor Documentation

G4DNAGillespieDirectMethod()

G4DNAGillespieDirectMethod::G4DNAGillespieDirectMethod

(

)

Definition at line 37 of file G4DNAGillespieDirectMethod.cc.

  : fMolecularReactions(G4DNAMolecularReactionTable::Instance())
{}

~G4DNAGillespieDirectMethod()

G4DNAGillespieDirectMethod::~G4DNAGillespieDirectMethod ( )

default

Member Function Documentation

CreateEvent()

void G4DNAGillespieDirectMethod::CreateEvent

(

const Index &

index

)

Definition at line 178 of file G4DNAGillespieDirectMethod.cc.

{
  const auto& voxel = fpMesh->GetVoxel(index);
  if(std::get<2>(voxel).empty())
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "This voxel : " << index
                         << " is not ready to make event" << G4endl;
    G4Exception("G4DNAGillespieDirectMethod::CreateEvent",
                "G4DNAGillespieDirectMethod05", FatalErrorInArgument,
                exceptionDescription);
  }
  G4double r1         = G4UniformRand();
  G4double r2         = G4UniformRand();
  G4double dAlpha0    = DiffusiveJumping(voxel);
  G4double rAlpha0    = Reaction(voxel);
  G4double alphaTotal = dAlpha0 + rAlpha0;
 
  if(alphaTotal == 0)
  {
    return;
  }
  auto timeStep = ((1.0 / (alphaTotal)) * std::log(1.0 / r1)) + fTimeStep;
 
#ifdef DEBUG
  G4cout << "r2 : " << r2 << " rAlpha0 : " << rAlpha0
         << " dAlpha0 : " << dAlpha0 << "    rAlpha0 / (dAlpha0 + rAlpha0) : "
         << rAlpha0 / (dAlpha0 + rAlpha0) << G4endl;
#endif
  if(r2 < rAlpha0 / alphaTotal)
  {
    if(fVerbose > 1)
    {
      G4cout << "=>>>>reaction at : " << timeStep << " timeStep : "
             << G4BestUnit(((1.0 / alphaTotal) * std::log(1.0 / r1)), "Time")
             << G4endl;
    }
    auto rSelectedIter = fReactionDataMap.upper_bound(r2 * alphaTotal);
    fpEventSet->CreateEvent(timeStep, index, rSelectedIter->second);
  }
  else if(dAlpha0 > 0)
  {
    if(fVerbose > 1)
    {
      G4cout << "=>>>>jumping at : " << timeStep << " timeStep : "
             << G4BestUnit(((1.0 / alphaTotal) * std::log(1.0 / r1)), "Time")
             << G4endl;
    }
 
    auto dSelectedIter = fJumpingDataMap.upper_bound(r2 * alphaTotal - rAlpha0);
    auto pDSelected =
      std::make_unique<std::pair<MolType, Index>>(dSelectedIter->second);
    fpEventSet->CreateEvent(timeStep, index, std::move(pDSelected));
  }
#ifdef DEBUG
  G4cout << G4endl;
#endif
}

Referenced by Initialize().

Initialize()

void G4DNAGillespieDirectMethod::Initialize

(

)

Definition at line 156 of file G4DNAGillespieDirectMethod.cc.

{
  // for Scavenger
  fpScavengerMaterial = dynamic_cast<G4DNAScavengerMaterial*>(
    G4Scheduler::Instance()->GetScavengerMaterial());
 
  auto begin = fpMesh->begin();
  auto end   = fpMesh->end();
  for(; begin != end; begin++)
  {
    auto index = std::get<0>(*begin);
#ifdef DEBUG
    fpMesh->PrintVoxel(index);
#endif
    CreateEvent(index);
  }
}

PropensityFunction() [1/2]

G4double G4DNAGillespieDirectMethod::PropensityFunction	(	const Voxel &	voxel,
		MolType	moleType
	)

Definition at line 67 of file G4DNAGillespieDirectMethod.cc.

{
  if(moleType->GetDiffusionCoefficient() == 0)
  {
    return 0.;
  }
  const auto& node = std::get<2>(voxel);
  const auto& box  = std::get<1>(voxel);
 
  G4double alpha = 0;
  auto it        = node.find(moleType);
  if(it != node.end())
  {
    auto LengthY = box.Getyhi() - box.Getylo();
    G4double d   = it->first->GetDiffusionCoefficient() / std::pow(LengthY, 2);
    alpha        = d * it->second;
 
#ifdef DEBUG
    G4cout << it->first->GetName() << " " << it->second
           << " D : " << it->first->GetDiffusionCoefficient()
           << " LengthY : " << LengthY << " PropensityFunction : " << alpha
           << G4endl;
#endif
  }
  return alpha;
}

PropensityFunction() [2/2]

G4double G4DNAGillespieDirectMethod::PropensityFunction	(	const Voxel &	voxel,
		ReactionData *	data
	)

Definition at line 95 of file G4DNAGillespieDirectMethod.cc.

{
  G4double value;
  auto ConfA               = data->GetReactant1();
  auto ConfB               = data->GetReactant2();
  G4double scavengerNumber = 0;
  auto typeANumber         = FindScavenging(voxel, ConfA, scavengerNumber)
                               ? scavengerNumber
                               : ComputeNumberInNode(voxel, ConfA);
 
  auto typeBNumber = FindScavenging(voxel, ConfB, scavengerNumber)
                       ? scavengerNumber
                       : ComputeNumberInNode(voxel, ConfB);
 
  if(typeANumber == 0 || typeBNumber == 0)
  {
    return 0;
  }
 
  auto k =
    data->GetObservedReactionRateConstant() / (Avogadro * VolumeOfNode(voxel));
  if(ConfA == ConfB)
  {
    value = typeANumber * (typeBNumber - 1) * k;
  }
  else
  {
    value = typeANumber * typeBNumber * k;
  }
 
  if(value < 0)
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription
      << "G4DNAGillespieDirectMethod::PropensityFunction for : "
      << ConfA->GetName() << "(" << typeANumber << ") + " << ConfB->GetName()
      << "(" << typeBNumber << ") : propensity : " << value
      << " GetObservedReactionRateConstant : "
      << data->GetObservedReactionRateConstant()
      << " GetEffectiveReactionRadius : "
      << G4BestUnit(data->GetEffectiveReactionRadius(), "Length")
      << " k : " << k << " volume : " << VolumeOfNode(voxel) << G4endl;
    G4Exception("G4DNAGillespieDirectMethod::PropensityFunction",
                "G4DNAGillespieDirectMethod013", FatalErrorInArgument,
                exceptionDescription);
  }
 
#ifdef DEBUG
  if(value > 0)
    G4cout << "G4DNAGillespieDirectMethod::PropensityFunction for : "
           << ConfA->GetName() << "(" << typeANumber << ") + "
           << ConfB->GetName() << "(" << typeBNumber
           << ") : propensity : " << value
           << "  Time to Reaction : " << G4BestUnit(timeToReaction, "Time")
           << " k : " << k << " Index : " << index << G4endl;
#endif
 
  return value;
}

SetEventSet()

void G4DNAGillespieDirectMethod::SetEventSet

(

G4DNAEventSet *

pEventSet

)

Definition at line 43 of file G4DNAGillespieDirectMethod.cc.

{
  fpEventSet = pEventSet;
}

SetTimeStep()

void G4DNAGillespieDirectMethod::SetTimeStep

(

const G4double &

stepTime

)

Definition at line 174 of file G4DNAGillespieDirectMethod.cc.

{
  fTimeStep = stepTime;
}

SetVoxelMesh()

void G4DNAGillespieDirectMethod::SetVoxelMesh ( G4DNAMesh &  mesh )

inline

Definition at line 54 of file G4DNAGillespieDirectMethod.hh.

{ fpMesh = &mesh; }

---

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

• G4DNAGillespieDirectMethod.hh
• G4DNAGillespieDirectMethod.cc