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 (const G4DNABoundingBox &boundingBox)
void	ReVoxelizing (G4int)
void	SetEndTime (const G4double &)
G4double	GetStartTime () const
G4double	GetEndTime () const
G4double	GetTimeStep () const
G4double	GetGlobalTime () 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 >)
void	ParticleBasedCounter ()
void	ResetCounter ()
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())
{}

Referenced by G4DNAEventScheduler(), and operator=().

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

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

CheckingReactionRadius()

G4bool G4DNAEventScheduler::CheckingReactionRadius ( G4double resolution )

static

Definition at line 613 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 Voxelizing().

ClearAndReChargeCounter()

void G4DNAEventScheduler::ClearAndReChargeCounter

(

)

GetCounterMap()

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

(

)

const

Definition at line 598 of file G4DNAEventScheduler.cc.

{
  return fCounterMap;
}

GetEndTime()

G4double G4DNAEventScheduler::GetEndTime

(

)

const

Definition at line 287 of file G4DNAEventScheduler.cc.

{ return fEndTime; }

Referenced by Initialize().

GetGlobalTime()

G4double G4DNAEventScheduler::GetGlobalTime

(

)

const

Definition at line 285 of file G4DNAEventScheduler.cc.

{ return fGlobalTime; }

Referenced by ParticleBasedCounter().

GetMesh()

G4DNAMesh * G4DNAEventScheduler::GetMesh

(

)

const

Definition at line 609 of file G4DNAEventScheduler.cc.

{ return fpMesh.get(); }

GetPixels()

G4int G4DNAEventScheduler::GetPixels

(

)

const

Definition at line 611 of file G4DNAEventScheduler.cc.

{ return fPixel; }

GetStartTime()

G4double G4DNAEventScheduler::GetStartTime

(

)

const

Definition at line 283 of file G4DNAEventScheduler.cc.

{ return fStartTime; }

GetTimeStep()

G4double G4DNAEventScheduler::GetTimeStep

(

)

const

Definition at line 289 of file G4DNAEventScheduler.cc.

{
  return fTimeStep;
}

GetVerbose()

G4int G4DNAEventScheduler::GetVerbose ( ) const

inline

Definition at line 294 of file G4DNAEventScheduler.cc.

{ return fVerbose; }

Initialize()

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

Definition at line 205 of file G4DNAEventScheduler.cc.

{
  if(!fInitialized)
  {
    fPixel = pixel;
    // 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(boundingBox);
    fEndTime = std::min(G4ITTrackHolder::Instance()->GetNextTime(), G4Scheduler::Instance()->GetEndTime()-1*ps);
 
    //G4cout<<"fEndTime" <<fEndTime<<"  G4ITTrackHolder::Instance()->GetNextTime() : "<<G4ITTrackHolder::Instance()->GetNextTime()<<G4endl;
 
    fpGillespieReaction->SetVoxelMesh(*fpMesh);
    fpGillespieReaction->SetEventSet(fpEventSet.get());
    fpGillespieReaction->SetTimeStep(0);// reset fTimeStep = 0 in fpGillespieReaction
    fpGillespieReaction->Initialize();
    fpGillespieReaction->CreateEvents();
    fpUpdateSystem->SetMesh(fpMesh.get());
    fInitialized = true;
  }
 
  if(fVerbose > 0)
  {
    fpUpdateSystem->SetVerbose(1);
  }
 
  if(fVerbose > 2)
  {
    fpMesh->PrintMesh();
  }
}

InitializeInMesh()

void G4DNAEventScheduler::InitializeInMesh

(

)

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

ParticleBasedCounter()

void G4DNAEventScheduler::ParticleBasedCounter

(

)

Definition at line 663 of file G4DNAEventScheduler.cc.

                                               {
  if(fLastRecoredTime == fTimeToRecord.end())
  {
    return;
  }
  auto recordTime = *fLastRecoredTime;
  if (recordTime < G4Scheduler::Instance()->GetGlobalTime()) {
 
    //check meso if exist
 
    if(fpMesh != nullptr){
      //G4cout<<"there is a mesh"<<G4endl;
      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;
        }
      }
    }
 
    //then particle based
    auto pMainList = G4ITTrackHolder::Instance()->GetMainList();
    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;
      }
      fCounterMap[recordTime][molType]++;
    }
    fLastRecoredTime++;
    //PrintRecordTime();
  }
}

PrintRecordTime()

void G4DNAEventScheduler::PrintRecordTime

(

)

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

{
  if(fLastRecoredTime == fTimeToRecord.end())
  {
    return;
  }
  auto recordTime = *fLastRecoredTime;
  if(fGlobalTime >= recordTime && fCounterMap[recordTime].empty())
  {
    if(fpMesh == nullptr) return;
    //G4cout<<"recordTime for meso: "<<recordTime<<"  fGlobalTime : "<<fGlobalTime<<G4endl;
    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 175 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();
  if(fpMesh != nullptr) {
    fpMesh->Reset();
    fpMesh.reset();
    //reset for each event
  }
  fpGillespieReaction->ResetEquilibrium();
}

ResetCounter()

void G4DNAEventScheduler::ResetCounter

(

)

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

ResetInMesh()

void G4DNAEventScheduler::ResetInMesh

(

)

Definition at line 267 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 138 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 308 of file G4DNAEventScheduler.cc.

{
  G4Timer localtimer;
  if(fVerbose > 2)
  {
    localtimer.Start();
    G4cout << "***G4DNAEventScheduler::Run*** for Pixel : " << fPixel << G4endl;
  }
  while(fEndTime > fGlobalTime && fRunning)
  {
    RunInMesh();
  }
  fInitialized = false;
  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;
  }
}

RunInMesh()

void G4DNAEventScheduler::RunInMesh

(

)

Definition at line 346 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(fGlobalTime + 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 78 of file G4DNAEventScheduler.hh.

{ fSetChangeMesh = change; }

SetEndTime()

void G4DNAEventScheduler::SetEndTime

(

const G4double &

endTime

)

Definition at line 541 of file G4DNAEventScheduler.cc.

{
  fEndTime = endTime;
}

SetMaxNbSteps()

void G4DNAEventScheduler::SetMaxNbSteps

(

G4int

max

)

Definition at line 296 of file G4DNAEventScheduler.cc.

{
  fMaxStep = max;
}

SetStartTime()

void G4DNAEventScheduler::SetStartTime

(

G4double

time

)

Definition at line 301 of file G4DNAEventScheduler.cc.

{
  fStartTime  = time;
  fGlobalTime = fStartTime;
}

SetUserMeshAction()

void G4DNAEventScheduler::SetUserMeshAction

(

std::unique_ptr< G4UserMeshAction >

pUserMeshAction

)

Definition at line 603 of file G4DNAEventScheduler.cc.

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

SetVerbose()

void G4DNAEventScheduler::SetVerbose ( G4int verbose )

inline

Definition at line 75 of file G4DNAEventScheduler.hh.

{ fVerbose = verbose; }

Stepping()

void G4DNAEventScheduler::Stepping

(

)

Definition at line 457 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();
 
  if(fTimeStep + fStartTime >fEndTime){ return;}
 
  // 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 307 of file G4DNAEventScheduler.cc.

{ fRunning = false; }

Voxelizing()

void G4DNAEventScheduler::Voxelizing

(

const G4DNABoundingBox &

boundingBox

)

Definition at line 58 of file G4DNAEventScheduler.cc.

{
  std::map<G4VDNAMesh::Index, MapList> TrackKeyMap;
  if(fpMesh == nullptr){
    fpMesh = std::make_unique<G4DNAMesh>(boundingBox, fPixel);
  }else
  {
    auto newMesh = new G4DNAMesh(fpMesh->GetBoundingBox(), fPixel);
 
    auto begin = fpMesh->begin();//old mesh, should be homogeneous
    auto end   = fpMesh->end();
    for(; begin != end; begin++)
    {
      auto numberOfBoxes = fPixel*fPixel*fPixel;
      const auto& mapData = std::get<2>(*begin);
      for(auto it : mapData)
      {
        if(it.second == 0) continue;
 
        G4int base_mol = std::floor((G4double)it.second / numberOfBoxes);
        G4int remainder = (G4int)it.second % numberOfBoxes;
        for(G4int i = 0; i < remainder; i++)
        {
          auto oldIndex = std::get<0>(*begin);
          auto idx = newMesh->GetRandomIndex(oldIndex, fpMesh->GetResolution());
          TrackKeyMap[idx][it.first] += base_mol + 1;
        }
      }
    }
    fpMesh.reset(newMesh);
  }
 
  if(!CheckingReactionRadius(fpMesh->GetResolution()))
  {
    G4String WarMessage = "resolution is not good : " +
                          std::to_string(fpMesh->GetResolution() / nm);
    G4Exception("G4DNAEventScheduler::InitializeInMesh()", "WrongResolution",
                JustWarning, WarMessage);
  }
 
  auto pMainList = G4ITTrackHolder::Instance()->GetMainList();
  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;
    }
    track->SetTrackStatus(fStopAndKill);//kill the track
  }
  G4ITReactionSet::Instance()->CleanAllReaction();
 
  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