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 (const G4DNABoundingBox &boundingBox, G4int pixel)
	~G4DNAEventScheduler () override
	G4DNAEventScheduler (const G4DNAEventScheduler &)=delete
G4DNAEventScheduler &	operator= (const G4DNAEventScheduler &right)=delete
void	Initialize ()
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	(	const G4DNABoundingBox &	boundingBox,
		G4int	pixel
	)

Definition at line 41 of file G4DNAEventScheduler.cc.

  : IEventScheduler()
  , fPixel(pixel)
  , fInitialPixels(fPixel)
  , fpMesh(new G4DNAMesh(boundingBox, fPixel))
  , fpGillespieReaction(new G4DNAGillespieDirectMethod())
  , fpEventSet(new G4DNAEventSet())
  , fpUpdateSystem(new G4DNAUpdateSystemModel())
{
  if(!CheckingReactionRadius(fpMesh->GetResolution()))
  {
    G4String WarMessage = "resolution is not good : " +
                          std::to_string(fpMesh->GetResolution() / nm);
    G4Exception("G4DNAEventScheduler::InitializeInMesh()", "WrongResolution",
                JustWarning, WarMessage);
  }
}

~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 119 of file G4DNAEventScheduler.cc.

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

CheckingReactionRadius()

G4bool G4DNAEventScheduler::CheckingReactionRadius ( G4double  resolution )

static

Definition at line 621 of file G4DNAEventScheduler.cc.

{
  auto pMolecularReactionTable = G4DNAMolecularReactionTable::Instance();
  auto reactionDataList = pMolecularReactionTable->GetVectorOfReactionData();
  if(reactionDataList.empty())
  {
    G4cout << "reactionDataList.empty()" << G4endl;
    return true;
  }
  else
  {
    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 G4DNAEventScheduler().

ClearAndReChargeCounter()

void G4DNAEventScheduler::ClearAndReChargeCounter

(

)

Definition at line 60 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;
    }
    else 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 606 of file G4DNAEventScheduler.cc.

{
  return fCounterMap;
}

GetEndTime()

G4double G4DNAEventScheduler::GetEndTime

(

)

const

Definition at line 311 of file G4DNAEventScheduler.cc.

{ return fEndTime; }

GetMesh()

G4DNAMesh * G4DNAEventScheduler::GetMesh

(

)

const

Definition at line 617 of file G4DNAEventScheduler.cc.

{ return fpMesh.get(); }

GetPixels()

G4int G4DNAEventScheduler::GetPixels

(

)

const

Definition at line 619 of file G4DNAEventScheduler.cc.

{ return fPixel; }

GetStartTime()

G4double G4DNAEventScheduler::GetStartTime

(

)

const

Definition at line 309 of file G4DNAEventScheduler.cc.

{ return fStartTime; }

GetTimeStep()

G4double G4DNAEventScheduler::GetTimeStep

(

)

const

Definition at line 313 of file G4DNAEventScheduler.cc.

{
  return fTimeStep;
}

GetVerbose()

G4int G4DNAEventScheduler::GetVerbose ( ) const

inline

Definition at line 318 of file G4DNAEventScheduler.cc.

{ return fVerbose; }

Initialize()

void G4DNAEventScheduler::Initialize

(

)

Definition at line 233 of file G4DNAEventScheduler.cc.

{
  if(!fInitialized)
  {
    fPixel = fInitialPixels;
    fpMesh = std::make_unique<G4DNAMesh>(fpMesh->GetBoundingBox(), fPixel);
 
    // 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();
    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 277 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->Initialize();
}

Referenced by RunInMesh().

operator=()

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

delete

PrintRecordTime()

void G4DNAEventScheduler::PrintRecordTime

(

)

Definition at line 583 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 560 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 207 of file G4DNAEventScheduler.cc.

{
  // find another solultion
  fGlobalTime = fEndTime;
 
  //
  // RecordTime();//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();
}

Referenced by Run().

ResetInMesh()

void G4DNAEventScheduler::ResetInMesh

(

)

Definition at line 293 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 170 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 332 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 370 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 555 of file G4DNAEventScheduler.cc.

{
  fEndTime = endTime;
}

SetMaxNbSteps()

void G4DNAEventScheduler::SetMaxNbSteps

(

G4int

max

)

Definition at line 320 of file G4DNAEventScheduler.cc.

{
  fMaxStep = max;
}

SetStartTime()

void G4DNAEventScheduler::SetStartTime

(

G4double

time

)

Definition at line 325 of file G4DNAEventScheduler.cc.

{
  fStartTime  = time;
  fGlobalTime = fStartTime;
}

SetUserMeshAction()

void G4DNAEventScheduler::SetUserMeshAction

(

std::unique_ptr< G4UserMeshAction >

pUserMeshAction

)

Definition at line 611 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 481 of file G4DNAEventScheduler.cc.

{
  fStepNumber < fMaxStep ? fStepNumber++ : 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);
    // 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 331 of file G4DNAEventScheduler.cc.

{ fRunning = false; }

Voxelizing()

void G4DNAEventScheduler::Voxelizing

(

)

Definition at line 129 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