G4DNAEventScheduler Class Reference

#include <G4DNAEventScheduler.hh>

Inheritance diagram for G4DNAEventScheduler:

Public Types
using	MolType = const G4MolecularConfiguration*
using	MapList = std::map<MolType, size_t>
using	MapCounter = std::map<MolType, G4int>

Public Member Functions
	G4DNAEventScheduler ()
	~G4DNAEventScheduler () override
	G4DNAEventScheduler (const G4DNAEventScheduler &)=delete
G4DNAEventScheduler &	operator= (const G4DNAEventScheduler &right)=delete
void	Initialize (const G4DNABoundingBox &boundingBox, G4int pixel)
void	InitializeInMesh ()
void	Voxelizing ()
void	ReVoxelizing (G4int)
void	SetEndTime (const G4double &)
G4double	GetStartTime () const
G4double	GetEndTime () const
G4double	GetTimeStep () const
void	SetStartTime (G4double time)
void	SetVerbose (G4int verbose)
G4int	GetVerbose () const
void	Stepping ()
void	SetChangeMesh (G4bool change)
void	Reset ()
void	ResetInMesh ()
void	RunInMesh ()
void	Run ()
void	AddTimeToRecord (const G4double &time)
void	RecordTime ()
void	ClearAndReChargeCounter ()
void	PrintRecordTime ()
void	Stop ()
void	SetMaxNbSteps (G4int)
std::map< G4double, MapCounter >	GetCounterMap () const
G4DNAMesh *	GetMesh () const
G4int	GetPixels () const
void	SetUserMeshAction (std::unique_ptr< G4UserMeshAction >)
Public Member Functions inherited from IEventScheduler
	IEventScheduler ()=default
virtual	~IEventScheduler ()=default

Static Public Member Functions
static G4bool	CheckingReactionRadius (G4double resolution)

Detailed Description

Definition at line 54 of file G4DNAEventScheduler.hh.

Member Typedef Documentation

MapCounter

using G4DNAEventScheduler::MapCounter = std::map<MolType, G4int>

Definition at line 59 of file G4DNAEventScheduler.hh.

MapList

using G4DNAEventScheduler::MapList = std::map<MolType, size_t>

Definition at line 58 of file G4DNAEventScheduler.hh.

MolType

using G4DNAEventScheduler::MolType = const G4MolecularConfiguration*

Definition at line 57 of file G4DNAEventScheduler.hh.

Constructor & Destructor Documentation

G4DNAEventScheduler() [1/2]

G4DNAEventScheduler::G4DNAEventScheduler

(

)

Definition at line 41 of file G4DNAEventScheduler.cc.

  : fpGillespieReaction(new G4DNAGillespieDirectMethod())
  , fpEventSet(new G4DNAEventSet())
  , fpUpdateSystem(new G4DNAUpdateSystemModel())
{}

~G4DNAEventScheduler()

G4DNAEventScheduler::~G4DNAEventScheduler ( )

overridedefault

G4DNAEventScheduler() [2/2]

G4DNAEventScheduler::G4DNAEventScheduler ( const G4DNAEventScheduler & )

delete

Member Function Documentation

AddTimeToRecord()

void G4DNAEventScheduler::AddTimeToRecord

(

const G4double &

time

)

Definition at line 106 of file G4DNAEventScheduler.cc.

{
  if(fTimeToRecord.find(time) == fTimeToRecord.end())
  {
    fTimeToRecord.insert(time);
  }
}

CheckingReactionRadius()

G4bool G4DNAEventScheduler::CheckingReactionRadius ( G4double resolution )

static

Definition at line 626 of file G4DNAEventScheduler.cc.

{
  auto pMolecularReactionTable = G4DNAMolecularReactionTable::Instance();
  auto reactionDataList = pMolecularReactionTable->GetVectorOfReactionData();
  if(reactionDataList.empty())
  {
    G4cout << "reactionDataList.empty()" << G4endl;
    return true;
  }
  
  for(auto it : reactionDataList)
  {
    if(it->GetEffectiveReactionRadius() >= resolution / CLHEP::pi)
    {
      G4cout << it->GetReactant1()->GetName() << " + "
             << it->GetReactant2()->GetName() << G4endl;
      G4cout << "G4DNAEventScheduler::ReactionRadius : "
             << G4BestUnit(it->GetEffectiveReactionRadius(), "Length")
             << G4endl;
      G4cout << "resolution : " << G4BestUnit(resolution, "Length") << G4endl;
      return false;
    }
  }
  return true;
}

Referenced by Initialize().

ClearAndReChargeCounter()

void G4DNAEventScheduler::ClearAndReChargeCounter

(

)

Definition at line 47 of file G4DNAEventScheduler.cc.

{
  fCounterMap.clear();
  if(fTimeToRecord.empty())
  {
    G4String WarMessage = "fTimeToRecord is empty ";
    G4Exception("G4DNAEventScheduler::ClearAndReChargeCounter()",
                "TimeToRecord is empty", JustWarning, WarMessage);
  }
  fLastRecoredTime = fTimeToRecord.begin();
 
  if(G4VMoleculeCounter::Instance()->InUse())  // copy from MoleculeCounter
  {
    G4MoleculeCounter::RecordedMolecules species;
    species = G4MoleculeCounter::Instance()->GetRecordedMolecules();
    if(species.get() == nullptr)
    {
      return;
    }
    if(species->empty())
    {
      G4MoleculeCounter::Instance()->ResetCounter();
      return;
    }
    for(auto time_mol : fTimeToRecord)
    {
      if(time_mol > fStartTime)
      {
        continue;
      }
 
      for(auto molecule : *species)
      {
        G4int n_mol = G4MoleculeCounter::Instance()->GetNMoleculesAtTime(
          molecule, time_mol);
 
        if(n_mol < 0)
        {
          G4cerr << "G4DNAEventScheduler::ClearAndReChargeCounter() ::N "
                    "molecules not valid < 0 "
                 << G4endl;
          G4Exception("", "N<0", FatalException, "");
        }
        fCounterMap[time_mol][molecule] = n_mol;
      }
      fLastRecoredTime++;
    }
    G4MoleculeCounter::Instance()->ResetCounter();  // reset
    G4MoleculeCounter::Instance()->Use(false);      // no more used
  }
  else
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "G4VMoleculeCounter is not used";
    G4Exception("G4DNAEventScheduler::ClearAndReChargeCounter()",
                "G4DNAEventScheduler010", JustWarning, exceptionDescription);
  }
}

Referenced by Initialize().

GetCounterMap()

std::map< G4double, G4DNAEventScheduler::MapCounter > G4DNAEventScheduler::GetCounterMap

(

)

const

Definition at line 611 of file G4DNAEventScheduler.cc.

{
  return fCounterMap;
}

GetEndTime()

G4double G4DNAEventScheduler::GetEndTime

(

)

const

Definition at line 308 of file G4DNAEventScheduler.cc.

{ return fEndTime; }

GetMesh()

G4DNAMesh * G4DNAEventScheduler::GetMesh

(

)

const

Definition at line 622 of file G4DNAEventScheduler.cc.

{ return fpMesh.get(); }

GetPixels()

G4int G4DNAEventScheduler::GetPixels

(

)

const

Definition at line 624 of file G4DNAEventScheduler.cc.

{ return fPixel; }

GetStartTime()

G4double G4DNAEventScheduler::GetStartTime

(

)

const

Definition at line 306 of file G4DNAEventScheduler.cc.

{ return fStartTime; }

GetTimeStep()

G4double G4DNAEventScheduler::GetTimeStep

(

)

const

Definition at line 310 of file G4DNAEventScheduler.cc.

{
  return fTimeStep;
}

GetVerbose()

G4int G4DNAEventScheduler::GetVerbose ( ) const

inline

Definition at line 315 of file G4DNAEventScheduler.cc.

{ return fVerbose; }

Initialize()

void G4DNAEventScheduler::Initialize	(	const G4DNABoundingBox &	boundingBox,
		G4int	pixel )

Definition at line 221 of file G4DNAEventScheduler.cc.

{
  if(!fInitialized)
  {
    fPixel = pixel;
    fpMesh = std::make_unique<G4DNAMesh>(boundingBox, pixel);
 
    if(!CheckingReactionRadius(fpMesh->GetResolution()))
    {
      G4String WarMessage = "resolution is not good : " +
                            std::to_string(fpMesh->GetResolution() / nm);
      G4Exception("G4DNAEventScheduler::InitializeInMesh()", "WrongResolution",
                  JustWarning, WarMessage);
    }
 
    // Scavenger();
 
    auto pScavengerMaterial = dynamic_cast<G4DNAScavengerMaterial*>(
      G4Scheduler::Instance()->GetScavengerMaterial());
    if(pScavengerMaterial == nullptr)
    {
      G4cout << "There is no scavenger" << G4endl;
    }
    else
    {
      if(fVerbose > 1)
      {
        pScavengerMaterial->PrintInfo();
      }
    }
 
    Voxelizing();
    fpGillespieReaction->SetVoxelMesh(*fpMesh);
    fpGillespieReaction->SetEventSet(fpEventSet.get());
    fpGillespieReaction->SetTimeStep(0);// reset fTimeStep = 0 in fpGillespieReaction
    fpGillespieReaction->Initialize();
    fpGillespieReaction->CreateEvents();
    fpUpdateSystem->SetMesh(fpMesh.get());
    ClearAndReChargeCounter();
    fInitialized = true;
  }
 
  if(fVerbose > 0)
  {
    fpUpdateSystem->SetVerbose(1);
  }
 
  if(fVerbose > 2)
  {
    fpMesh->PrintMesh();
  }
}

InitializeInMesh()

void G4DNAEventScheduler::InitializeInMesh

(

)

Definition at line 274 of file G4DNAEventScheduler.cc.

{
  if(fPixel <= 1)
  {
    fRunning = false;
    return;
  }
  // TEST /3
  ReVoxelizing(fPixel / 2);  //
  // ReVoxelizing(fPixel/3);//
 
  fpGillespieReaction->SetVoxelMesh(*fpMesh);
  fpUpdateSystem->SetMesh(fpMesh.get());
  fpGillespieReaction->CreateEvents();
}

Referenced by RunInMesh().

operator=()

G4DNAEventScheduler & G4DNAEventScheduler::operator= ( const G4DNAEventScheduler & right )

delete

PrintRecordTime()

void G4DNAEventScheduler::PrintRecordTime

(

)

Definition at line 588 of file G4DNAEventScheduler.cc.

{
  G4cout << "CounterMap.size : " << fCounterMap.size() << G4endl;
  for(const auto& i : fCounterMap)
  {
    auto map   = i.second;
    auto begin = map.begin();  //
    auto end   = map.end();    //
    for(; begin != end; begin++)
    {
      auto molecule = begin->first;
      auto number   = begin->second;
      if(number == 0)
      {
        continue;
      }
      G4cout << "molecule : " << molecule->GetName() << " number : " << number
             << G4endl;
    }
  }
}

RecordTime()

void G4DNAEventScheduler::RecordTime

(

)

Definition at line 565 of file G4DNAEventScheduler.cc.

{
  auto recordTime = *fLastRecoredTime;
  if(fGlobalTime >= recordTime && fCounterMap[recordTime].empty())
  {
    auto begin = fpMesh->begin();
    auto end   = fpMesh->end();
    for(; begin != end; begin++)
    {
      const auto& mapData = std::get<2>(*begin);
      if(mapData.empty())
      {
        continue;
      }
      for(const auto& it : mapData)
      {
        fCounterMap[recordTime][it.first] += it.second;
      }
    }
    fLastRecoredTime++;
  }
}

Referenced by Stepping().

Reset()

void G4DNAEventScheduler::Reset

(

)

Definition at line 194 of file G4DNAEventScheduler.cc.

{
  // find another solultion
  fGlobalTime = fEndTime;
 
  //
  LastRegisterForCounter();//Last register for counter
 
  if(fVerbose > 0)
  {
    G4cout << "End Processing and reset Gird, ScavengerTable, EventSet for new "
              "simulation!!!!"
           << G4endl;
  }
  fInitialized    = false;
  fTimeStep       = 0;
  fStepNumber     = 0;
  fGlobalTime     = fStartTime;
  fRunning        = true;
  fReactionNumber = 0;
  fJumpingNumber  = 0;
 
  fpEventSet->RemoveEventSet();
  fpMesh->Reset();
  fpGillespieReaction->ResetEquilibrium();
}

Referenced by Run().

ResetInMesh()

void G4DNAEventScheduler::ResetInMesh

(

)

Definition at line 290 of file G4DNAEventScheduler.cc.

{
  if(fVerbose > 0)
  {
    G4cout
      << "*** End Processing In Mesh and reset Mesh, EventSet for new Mesh!!!!"
      << G4endl;
  }
  fpEventSet->RemoveEventSet();
  fInitialized      = false;
  fIsChangeMesh     = false;
  fReactionNumber   = 0;
  fJumpingNumber    = 0;
  fStepNumberInMesh = 0;
}

Referenced by RunInMesh().

ReVoxelizing()

void G4DNAEventScheduler::ReVoxelizing

(

G4int

pixel

)

Definition at line 157 of file G4DNAEventScheduler.cc.

{
  fPixel       = pixel;
  auto newMesh = new G4DNAMesh(fpMesh->GetBoundingBox(), fPixel);
 
  auto begin = fpMesh->begin();
  auto end   = fpMesh->end();
  std::map<G4VDNAMesh::Index, MapList> TrackKeyMap;
  for(; begin != end; begin++)
  {
    auto index    = std::get<0>(*begin);
    auto newIndex = fpMesh->ConvertIndex(index, fPixel);
    if(TrackKeyMap.find(newIndex) == TrackKeyMap.end())
    {
      TrackKeyMap[newIndex] = std::get<2>(*begin);
    }
    else
    {
      for(const auto& it : std::get<2>(*begin))
      {
        TrackKeyMap[newIndex][it.first] += it.second;
      }
      if(fVerbose > 1)
      {
        G4cout << " ReVoxelizing:: Old index : " << index
               << " new index : " << fpMesh->ConvertIndex(index, fPixel)
               << " number: " << std::get<2>(*begin).begin()->second << G4endl;
      }
    }
  }
  fpMesh.reset(newMesh);
 
  for(auto& it : TrackKeyMap)
  {
    fpMesh->InitializeVoxel(it.first, std::move(it.second));
  }
}

Referenced by InitializeInMesh().

Run()

void G4DNAEventScheduler::Run

(

)

Definition at line 329 of file G4DNAEventScheduler.cc.

{
  G4Timer localtimer;
  if(fVerbose > 2)
  {
    localtimer.Start();
    G4cout << "***G4DNAEventScheduler::Run*** for Pixel : " << fPixel << G4endl;
  }
  while(fEndTime > fGlobalTime && fRunning)
  {
    RunInMesh();
  }
  if(fVerbose > 2)
  {
    if(!fRunning)
    {
      G4cout << " StepNumber(" << fStepNumber << ") = MaxStep(" << fMaxStep
             << ")" << G4endl;
    }
    else if(fEndTime <= fGlobalTime)
    {
      G4cout << " GlobalTime(" << fGlobalTime << ") > EndTime(" << fEndTime
             << ")"
             << " StepNumber : " << fStepNumber << G4endl;
    }
    localtimer.Stop();
    G4cout << "***G4DNAEventScheduler::Ending::"
           << G4BestUnit(fGlobalTime, "Time")
           << " Events left : " << fpEventSet->size() << G4endl;
    if(fVerbose > 1)
    {
      fpMesh->PrintMesh();
    }
    G4cout << " Computing Time : " << localtimer << G4endl;
  }
  Reset();
}

RunInMesh()

void G4DNAEventScheduler::RunInMesh

(

)

Definition at line 367 of file G4DNAEventScheduler.cc.

{
  if(!fInitialized)
  {
    InitializeInMesh();
  }
  if(fVerbose > 0)
  {
    G4double resolution = fpMesh->GetResolution();
    G4cout << "At Time : " << std::setw(7) << G4BestUnit(fGlobalTime, "Time")
           << " the Mesh has " << fPixel << " x " << fPixel << " x " << fPixel
           << " voxels with Resolution " << G4BestUnit(resolution, "Length")
           << " during next "
           << G4BestUnit(resolution * resolution * C / (6 * D), "Time")
           << G4endl;
  }
 
  if(fVerbose > 2)
  {
    fpMesh->PrintMesh();
  }
 
  if(fpUserMeshAction != nullptr)
  {
    fpUserMeshAction->BeginOfMesh(fpMesh.get(), fGlobalTime);
  }
 
  // if diffusive jumping is avaiable, EventSet is never empty
 
  while(!fpEventSet->Empty() && !fIsChangeMesh && fEndTime > fGlobalTime)
  {
    Stepping();
    fGlobalTime = fTimeStep + fStartTime;
 
    if(fpUserMeshAction != nullptr)
    {
      fpUserMeshAction->InMesh(fpMesh.get(), fGlobalTime);
    }
 
    if(fVerbose > 2)
    {
      G4cout << "fGlobalTime : " << G4BestUnit(fGlobalTime, "Time")
             << " fTimeStep : " << G4BestUnit(fTimeStep, "Time") << G4endl;
    }
    G4double resolution = fpMesh->GetResolution();
    fTransferTime       = resolution * resolution * C / (6 * D);
    if(fTransferTime == 0)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription << "fTransferTime == 0";
      G4Exception("G4DNAEventScheduler::RunInMesh", "G4DNAEventScheduler001",
                  FatalErrorInArgument, exceptionDescription);
    }
    if(fTransferTime < fTimeStep &&
       fPixel != 1)  // dont change Mesh if fPixel == 1
    {
      if(fSetChangeMesh)
      {
        if(fVerbose > 1)
        {
          G4cout << " Pixels : " << fPixel << "  resolution : "
                 << G4BestUnit(fpMesh->GetResolution(), "Length")
                 << "  fStepNumberInMesh : " << fStepNumberInMesh
                 << " at fGlobalTime : " << G4BestUnit(fGlobalTime, "Time")
                 << " at fTimeStep : " << G4BestUnit(fTimeStep, "Time")
                 << "  fReactionNumber : " << fReactionNumber
                 << " transferTime : " << G4BestUnit(fTransferTime, "Time")
                 << G4endl;
        }
        fIsChangeMesh = true;
      }
    }
  }
 
  if(fVerbose > 1)
  {
    G4cout << "***G4DNAEventScheduler::Ending::"
           << G4BestUnit(fGlobalTime, "Time")
           << " Event left : " << fpEventSet->size() << G4endl;
    G4cout << " Due to : ";
    if(fpEventSet->Empty())
    {
      G4cout << "EventSet is Empty" << G4endl;
    }
    else if(fIsChangeMesh)
    {
      G4cout << "Changing Mesh from : " << fPixel
             << " pixels to : " << fPixel / 2 << " pixels" << G4endl;
      G4cout << "Info : ReactionNumber : " << fReactionNumber
             << "   JumpingNumber : " << fJumpingNumber << G4endl;
    }
    else if(fEndTime > fGlobalTime)
    {
      G4cout << " GlobalTime(" << fGlobalTime << ") > EndTime(" << fEndTime
             << ")"
             << " StepNumber : " << fStepNumber << G4endl;
    }
    if(fVerbose > 2)
    {
      fpMesh->PrintMesh();
    }
    G4cout << G4endl;
  }
 
  if(fpUserMeshAction != nullptr)
  {
    fpUserMeshAction->EndOfMesh(fpMesh.get(), fGlobalTime);
  }
  ResetInMesh();
}

Referenced by Run().

SetChangeMesh()

void G4DNAEventScheduler::SetChangeMesh ( G4bool change )

inline

Definition at line 77 of file G4DNAEventScheduler.hh.

{ fSetChangeMesh = change; }

SetEndTime()

void G4DNAEventScheduler::SetEndTime

(

const G4double &

endTime

)

Definition at line 560 of file G4DNAEventScheduler.cc.

{
  fEndTime = endTime;
}

SetMaxNbSteps()

void G4DNAEventScheduler::SetMaxNbSteps

(

G4int

max

)

Definition at line 317 of file G4DNAEventScheduler.cc.

{
  fMaxStep = max;
}

SetStartTime()

void G4DNAEventScheduler::SetStartTime

(

G4double

time

)

Definition at line 322 of file G4DNAEventScheduler.cc.

{
  fStartTime  = time;
  fGlobalTime = fStartTime;
}

SetUserMeshAction()

void G4DNAEventScheduler::SetUserMeshAction

(

std::unique_ptr< G4UserMeshAction >

pUserMeshAction

)

Definition at line 616 of file G4DNAEventScheduler.cc.

{
  fpUserMeshAction = std::move(pUserMeshAction);
}

SetVerbose()

void G4DNAEventScheduler::SetVerbose ( G4int verbose )

inline

Definition at line 74 of file G4DNAEventScheduler.hh.

{ fVerbose = verbose; }

Stepping()

void G4DNAEventScheduler::Stepping

(

)

Definition at line 478 of file G4DNAEventScheduler.cc.

{
  fStepNumber < fMaxStep ? fStepNumber++ : static_cast<int>(fRunning = false);
  if(fpEventSet->size() > fpMesh->size())
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription
      << "impossible that fpEventSet->size() > fpMesh->size()";
    G4Exception("G4DNAEventScheduler::Stepping", "G4DNAEventScheduler002",
                FatalErrorInArgument, exceptionDescription);
  }
 
  auto selected = fpEventSet->begin();
  auto index    = (*selected)->GetIndex();
 
  if(fVerbose > 1)
  {
    G4cout << "G4DNAEventScheduler::Stepping()*********************************"
              "*******"
           << G4endl;
    (*selected)->PrintEvent();
  }
 
  // get selected time step
  fTimeStep = (*selected)->GetTime();
 
  // selected data
  auto pJumping  = (*selected)->GetJumpingData();
  auto pReaction = (*selected)->GetReactionData();
 
  fpUpdateSystem->SetGlobalTime(fTimeStep +
                                fStartTime);  // this is just for printing
  fpGillespieReaction->SetTimeStep(fTimeStep);
  if(pJumping == nullptr && pReaction != nullptr)
  {
    fpUpdateSystem->UpdateSystem(index, *pReaction);
    fpEventSet->RemoveEvent(selected);
 
    //hoang's exp
    if(fpGillespieReaction->SetEquilibrium(pReaction))
    {
      ResetEventSet();
    }
    //end Hoang's exp
 
    // create new event
    fpGillespieReaction->CreateEvent(index);
    fReactionNumber++;
    // recordTime in reaction
    RecordTime();
  }
  else if(pJumping != nullptr && pReaction == nullptr)
  {
    // dont change this
    fpUpdateSystem->UpdateSystem(index, *pJumping);
    // save jumping Index before delete selected event
    auto jumpingIndex = pJumping->second;
    fpEventSet->RemoveEvent(selected);
    // create new event
    // should create Jumping before key
    fpGillespieReaction->CreateEvent(jumpingIndex);
    fpGillespieReaction->CreateEvent(index);
    fJumpingNumber++;
  }
  else
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "pJumping == nullptr && pReaction == nullptr";
    G4Exception("G4DNAEventScheduler::Stepping", "G4DNAEventScheduler003",
                FatalErrorInArgument, exceptionDescription);
  }
 
  if(fVerbose > 1)
  {
    G4cout << "G4DNAEventScheduler::Stepping::end "
              "Print***********************************"
           << G4endl;
    G4cout << G4endl;
  }
  fStepNumberInMesh++;
}

Referenced by RunInMesh().

Stop()

void G4DNAEventScheduler::Stop

(

)

Definition at line 328 of file G4DNAEventScheduler.cc.

{ fRunning = false; }

Voxelizing()

void G4DNAEventScheduler::Voxelizing

(

)

Definition at line 116 of file G4DNAEventScheduler.cc.

{
  auto pMainList = G4ITTrackHolder::Instance()->GetMainList();
  std::map<G4VDNAMesh::Index, MapList> TrackKeyMap;
  for(auto track : *pMainList)
  {
    auto molType = GetMolecule(track)->GetMolecularConfiguration();
 
    auto pScavengerMaterial = dynamic_cast<G4DNAScavengerMaterial*>(
      G4Scheduler::Instance()->GetScavengerMaterial());
    if(pScavengerMaterial != nullptr &&
       pScavengerMaterial->find(molType))  // avoid voxelize the scavenger
    {
      continue;
    }
 
    auto key = fpMesh->GetIndex(track->GetPosition());
    if(TrackKeyMap.find(key) != TrackKeyMap.end())
    {
      std::map<MolType, size_t>& TrackTypeMap = TrackKeyMap[key];
      if(TrackTypeMap.find(molType) != TrackTypeMap.end())
      {
        TrackTypeMap[molType]++;
      }
      else
      {
        TrackTypeMap[molType] = 1;
      }
    }
    else
    {
      TrackKeyMap[key][molType] = 1;
    }
  }
 
  for(auto& it : TrackKeyMap)
  {
    fpMesh->InitializeVoxel(it.first, std::move(it.second));
  }
}

Referenced by Initialize().

---

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

• G4DNAEventScheduler.hh
• G4DNAEventScheduler.cc