G4ITTrackHolder Class Reference

#include <G4ITTrackHolder.hh>

Inheritance diagram for G4ITTrackHolder:

Public Types
using	Key = int
using	MapOfPriorityLists = std::map<Key, PriorityList*>
using	MapOfDelayedLists = std::map<double, std::map<Key, G4TrackList*> >

Public Member Functions
	G4ITTrackHolder ()
	~G4ITTrackHolder () override
double	GetNextTime ()
void	Push (G4Track *) override
void	PushToKill (G4Track *track)
bool	MergeNextTimeToMainList (double &time)
void	MergeSecondariesWithMainList ()
void	MoveMainToWaitingList ()
void	KillTracks ()
void	Clear ()
bool	AddWatcher (int, G4TrackList::Watcher *, PriorityList::Type=PriorityList::MainList)
void	AddWatcherForMainList (G4TrackList::Watcher *)
void	AddWatcherForKillList (G4TrackList::Watcher *)
MapOfPriorityLists &	GetLists ()
PriorityList *	GetPriorityList (Key)
G4TrackList *	GetMainList (Key)
G4TrackManyList *	GetMainList ()
G4TrackManyList *	GetSecondariesList ()
MapOfDelayedLists &	GetDelayedLists ()
size_t	GetNTracks () override
bool	MainListsNOTEmpty ()
bool	SecondaryListsNOTEmpty ()
bool	DelayListsNOTEmpty ()
bool	CheckMapIsNOTEmpty (MapOfPriorityLists &mapOfLists, PriorityList::Type type)
void	SetVerbose (int verbose)
G4TrackList *	GetKillList ()
Public Member Functions inherited from G4VITTrackHolder

Static Public Member Functions
static G4ITTrackHolder *	Instance ()
static G4ITTrackHolder *	MasterInstance ()
static void	PushToMaster (G4Track *)
Static Public Member Functions inherited from G4VITTrackHolder
static G4VITTrackHolder *	Instance ()

Protected Member Functions
void	AddTrackID (G4Track *track)
void	_PushTrack (G4Track *track)
void	PushTo (G4Track *, PriorityList::Type)
void	PushDelayed (G4Track *track)
Protected Member Functions inherited from G4VITTrackHolder
	G4VITTrackHolder ()
virtual	~G4VITTrackHolder ()

Protected Attributes
std::map< Key, PriorityList * >	fLists
MapOfDelayedLists	fDelayedList
G4TrackList	fToBeKilledList
bool	fMainListHaveBeenSet
int	fVerbose
int	fNbTracks
double	fPostActivityGlobalTime
G4TrackManyList	fAllMainList
G4TrackManyList	fAllSecondariesList

Friends
class	G4Scheduler
class	G4ITStepProcessor
class	G4ITModelProcessor

Additional Inherited Members
Static Protected Attributes inherited from G4VITTrackHolder
static G4ThreadLocal G4VITTrackHolder *	fInstance

Detailed Description

Definition at line 121 of file G4ITTrackHolder.hh.

Member Typedef Documentation

Key

using G4ITTrackHolder::Key = int

Definition at line 138 of file G4ITTrackHolder.hh.

MapOfDelayedLists

using G4ITTrackHolder::MapOfDelayedLists = std::map<double, std::map<Key, G4TrackList*> >

Definition at line 140 of file G4ITTrackHolder.hh.

MapOfPriorityLists

using G4ITTrackHolder::MapOfPriorityLists = std::map<Key, PriorityList*>

Definition at line 139 of file G4ITTrackHolder.hh.

Constructor & Destructor Documentation

G4ITTrackHolder()

G4ITTrackHolder::G4ITTrackHolder

(

)

Definition at line 223 of file G4ITTrackHolder.cc.

{
  fNbTracks = -1;
  fMainListHaveBeenSet = false;
  fVerbose = 0;
 
  fPostActivityGlobalTime = -1;
//  fPreActivityGlobalTime = -1;
}

Referenced by Instance(), and MasterInstance().

~G4ITTrackHolder()

G4ITTrackHolder::~G4ITTrackHolder ( )

override

Definition at line 233 of file G4ITTrackHolder.cc.

{
  auto end = fLists.end();
 
  for (auto it = fLists.begin(); it != end;
      it++)
  {
    delete it->second;
    it->second = 0;
  }
 
  if (!fDelayedList.empty())
  {
    auto fDelayedList_i = fDelayedList.begin();
    auto fDelayedList_end = fDelayedList.end();
 
    for (; fDelayedList_i != fDelayedList_end; fDelayedList_i++)
    {
      auto it = fDelayedList_i->second.begin();
      auto __end =
          fDelayedList_i->second.end();
 
      for (; it != __end; it++)
      {
        delete (it->second);
        it->second = 0;
      }
    }
    fDelayedList.clear();
  }
 
  fAllMainList.RemoveLists();
  fAllSecondariesList.RemoveLists();
  fNbTracks = -1;
}

Member Function Documentation

_PushTrack()

void G4ITTrackHolder::_PushTrack ( G4Track * track )

protected

Definition at line 446 of file G4ITTrackHolder.cc.

{
  if (track == nullptr)
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription
        << "You are trying to push a non-existing track (track pointer is null)"
        << G4endl;
 
    G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager014",
                FatalErrorInArgument, exceptionDescription);
  }
 
  G4double globalTime = track->GetGlobalTime();
 
  if (track->GetTrackID() == 0)
  {
    // Set track ID
    AddTrackID(track);
  }
 
  double currentGlobalTime = G4Scheduler::Instance()->GetGlobalTime();
 
#ifdef G4VERBOSE
  if (fVerbose != 0)
  {
    G4cout << G4endl;
    G4cout << "\t"<< ">> Pushing a track -->  ";
    G4cout << GetIT(track)->GetName() << " (" << track->GetTrackID() <<")"
    << " -- ";
    G4cout << "Global current time: " << G4BestUnit(currentGlobalTime,"Time")
    << "\t";
    G4cout << "Track's time: " << G4BestUnit(track->GetGlobalTime(),"Time")
    << G4endl;
  }
#endif
 
  if (!G4Scheduler::Instance()->IsRunning())
  {
    if (globalTime < currentGlobalTime)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "You are trying to push a track with a global time"
          << " inferior to the current simulation time." << G4endl<< "The time is going back : " << G4endl
      << "The time in the step manager : "
      << G4BestUnit(currentGlobalTime,"Time")
      << G4endl
      << "The time of the track : "
      << G4BestUnit(globalTime,"Time")
      << G4endl
      << "(ITStepManager is not yet running)"
      << G4endl;
 
      G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager014",
                  FatalErrorInArgument, exceptionDescription);
    }
 
    // Push the track to the rigth track list :
    // If the track time is the same as the main track list,
    // it will be push to the main track list
    // otherwise, it will be pushed to the delayed track list.
    if (!fMainListHaveBeenSet)
    {
      PushDelayed(track);
    }
    else
    {
      if (globalTime == currentGlobalTime)
      {
        #ifdef G4VERBOSE
          if (fVerbose != 0)
          {
            G4cout << G4endl;
            G4cout << "\t"<< ">> Pushing to *main* list -->  ";
            G4cout << GetIT(track)->GetName() << " (" << track->GetTrackID() <<")"
            << " -- ";
            G4cout << "Global current time: " << G4BestUnit(currentGlobalTime,"Time")
            << "\t";
            G4cout << "Track's time: " << G4BestUnit(track->GetGlobalTime(),"Time")
            << G4endl;
          }
        #endif
        PushTo(track, PriorityList::MainList);
      }
      else
      {
        // if(currentGlobalTime > 1*CLHEP::picosecond) abort();
        #ifdef G4VERBOSE
          if (fVerbose != 0)
          {
            G4cout << G4endl;
            G4cout << "\t"<< ">> Pushing to *delayed* list -->  ";
            G4cout << GetIT(track)->GetName() << " (" << track->GetTrackID() <<")"
            << " -- ";
            G4cout << "Global current time: " << G4BestUnit(currentGlobalTime,"Time")
            << "\t";
            G4cout << "Track's time: " << G4BestUnit(track->GetGlobalTime(),"Time")
            << G4endl;
          }
        #endif
        PushDelayed(track);
      }
    }
  }
  else // Is running
  {
    double timeDifference = globalTime - currentGlobalTime;
    double timeTolerance = G4Scheduler::Instance()->GetTimeTolerance();
 
    if (timeDifference < -1 * timeTolerance)
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "You are trying to push a track with a global time"
          << " inferior to the current simulation time." << G4endl<< "The time is going back : "
      << G4endl
      << "The time in the step manager : "
      << G4BestUnit(timeDifference,"Time")
      << G4endl
      << "The time of the track : " << G4BestUnit(globalTime,"Time")
      << G4endl
      << "(ITStepManager is running)"
      << G4endl;
 
      G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager015",
                  FatalErrorInArgument, exceptionDescription);
    }
 
    // Push the track to the rigth track list :
    // If the track time is the same as the main track list,
    // it will be push to the secondary list
    // otherwise, it will be pushed to the delayed track list.
    if (fabs(timeDifference) < timeTolerance)
    {
//      G4cout << "Is pushing " << GetIT(track)->GetName() << G4endl;
 
      #ifdef G4VERBOSE
        if (fVerbose != 0)
        {
          G4cout << G4endl;
          G4cout << "\t"<< ">> Pushing to *secondary* list -->  ";
          G4cout << GetIT(track)->GetName() << " (" << track->GetTrackID() <<")"
          << " -- ";
          G4cout << "Global current time: " << G4BestUnit(currentGlobalTime,"Time")
          << "\t";
          G4cout << "Track's time: " << G4BestUnit(track->GetGlobalTime(),"Time")
          << G4endl;
        }
      #endif
      PushTo(track, PriorityList::SecondariesList);
    }
    else // globalTime < fGlobalTime already taken into account above
    {
      G4ExceptionDescription exceptionDescription;
      exceptionDescription
          << "While running you cannot push a track"
          << " with a bigger global time than the current global time" << G4endl<< "The time in the step manager : "
      << G4BestUnit(currentGlobalTime,"Time")
      << G4endl
      << "The time of the track : " << G4BestUnit(globalTime,"Time")
      << G4endl
      << "(ITStepManager is running)"
      << G4endl;
 
      G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager016",
                  FatalErrorInArgument, exceptionDescription);
      // PushDelayed(track, globalTime);
    }
  }
}

Referenced by Push(), and G4ITStepProcessor::PushSecondaries().

AddTrackID()

void G4ITTrackHolder::AddTrackID ( G4Track * track )

protected

Definition at line 376 of file G4ITTrackHolder.cc.

{
  //if(fNbTracks == 0) fNbTracks = -1;
  track->SetTrackID(fNbTracks);
  fNbTracks--;
}

Referenced by _PushTrack().

AddWatcher()

bool G4ITTrackHolder::AddWatcher	(	int	id,
		G4TrackList::Watcher *	watcher,
		PriorityList::Type	type = PriorityList::MainList )

Definition at line 782 of file G4ITTrackHolder.cc.

{
  auto it = fLists.find(id);
  if (it == fLists.end()) return false;
 
  G4TrackList* trackList = it->second->Get(type);
  if (trackList == nullptr) return false;
  trackList->AddWatcher(watcher);
  return true;
}

AddWatcherForKillList()

void G4ITTrackHolder::AddWatcherForKillList

(

G4TrackList::Watcher *

watcher

)

Definition at line 800 of file G4ITTrackHolder.cc.

{
  watcher->Watch(&fToBeKilledList);
}

AddWatcherForMainList()

void G4ITTrackHolder::AddWatcherForMainList

(

G4TrackList::Watcher *

watcher

)

Definition at line 795 of file G4ITTrackHolder.cc.

{
  fAllMainList.AddGlobalWatcher(watcher);
}

CheckMapIsNOTEmpty()

bool G4ITTrackHolder::CheckMapIsNOTEmpty	(	MapOfPriorityLists &	mapOfLists,
		PriorityList::Type	type )

Definition at line 879 of file G4ITTrackHolder.cc.

{
  auto it = mapOfLists.begin();
  auto end = mapOfLists.end();
  for (; it != end; it++)
  {
    if (PriorityList* lists = it->second)
    {
      if (G4TrackList* trackList = lists->Get(type))
      {
        if (!(trackList->empty())) return true;
      }
    }
  }
  return false;
}

Referenced by MainListsNOTEmpty(), and SecondaryListsNOTEmpty().

Clear()

void G4ITTrackHolder::Clear

(

)

Definition at line 725 of file G4ITTrackHolder.cc.

{
  fAllMainList.ClearLists();
  fAllSecondariesList.ClearLists();
//  fAllMainList.RemoveLists();
//  fAllSecondariesList.RemoveLists();
 
  auto it = fLists.begin();
 
  for (; it != fLists.end(); it++)
  {
    delete it->second;
    it->second = 0;
  }
  fLists.clear();
 
  auto it1 = fDelayedList.begin();
 
  for (; it1 != fDelayedList.end(); it1++)
  {
    auto it2 = it1->second.begin();
 
    for (; it2 != it1->second.end(); it2++)
    {
      delete it2->second;
      it2->second = 0;
    }
  }
 
  fDelayedList.clear();
 
//  fAllMainList.ClearLists();
//  fAllSecondariesList.ClearLists();
  fAllMainList.RemoveLists();
  fAllSecondariesList.RemoveLists();
  KillTracks();
 
  fNbTracks = -1;
}

Referenced by G4Scheduler::ClearList().

DelayListsNOTEmpty()

bool G4ITTrackHolder::DelayListsNOTEmpty

(

)

Definition at line 856 of file G4ITTrackHolder.cc.

{
  auto __it = fDelayedList.begin();
  auto __end = fDelayedList.end();
  for (; __it != __end; __it++)
  {
    std::map<Key, G4TrackList*>& mapOfLists = __it->second;
    if (!mapOfLists.empty())
    {
      auto it = mapOfLists.begin();
      auto end = mapOfLists.end();
      for (; it != end; it++)
      {
        if (G4TrackList* mainList = it->second)
        {
          if (!(mainList->empty())) return true;
        }
      }
    }
  }
  return false;
}

Referenced by G4Scheduler::Process().

GetDelayedLists()

MapOfDelayedLists & G4ITTrackHolder::GetDelayedLists ( )

inline

Definition at line 206 of file G4ITTrackHolder.hh.

  {
    return fDelayedList;
  }

GetKillList()

G4TrackList * G4ITTrackHolder::GetKillList ( )

inline

Definition at line 235 of file G4ITTrackHolder.hh.

  {
    return &fToBeKilledList;
  }

GetLists()

MapOfPriorityLists & G4ITTrackHolder::GetLists ( )

inline

Definition at line 192 of file G4ITTrackHolder.hh.

  { return fLists;}

GetMainList() [1/2]

G4TrackManyList * G4ITTrackHolder::GetMainList ( )

inline

Definition at line 196 of file G4ITTrackHolder.hh.

  {
    return &fAllMainList;
  }

GetMainList() [2/2]

G4TrackList * G4ITTrackHolder::GetMainList

(

Key

i

)

Definition at line 772 of file G4ITTrackHolder.cc.

{
  PriorityList* priorityList = GetPriorityList(i);
  if (priorityList != nullptr)
  {
    return priorityList->GetMainList();
  }
  return nullptr;
}

Referenced by G4DNAIndependentReactionTimeStepper::CalculateMinTimeStep(), G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAMoleculeEncounterStepper::CalculateMinTimeStep(), G4ITStepProcessor::ComputeInteractionLength(), G4ITStepProcessor::DoIt(), G4Scheduler::EndTracking(), G4DNAIRT::Initialize(), G4DNAIRT::IRTSampling(), G4DNAIRT::SpaceBinning(), and G4DNAEventScheduler::Voxelizing().

GetNextTime()

double G4ITTrackHolder::GetNextTime ( )

inline

Definition at line 152 of file G4ITTrackHolder.hh.

  {
    if (fDelayedList.empty()) return DBL_MAX;
    return fDelayedList.begin()->first;
  }

Referenced by G4Scheduler::Process(), and G4Scheduler::SynchronizeTracks().

GetNTracks()

size_t G4ITTrackHolder::GetNTracks ( )

overridevirtual

Reimplemented from G4VITTrackHolder.

Definition at line 814 of file G4ITTrackHolder.cc.

{
  size_t nTracks(0);
  nTracks += fAllMainList.size();
  nTracks += fAllSecondariesList.size();
 
  //    G4cout << "nTracks = " << nTracks << G4endl;
 
  auto delayedmap_it = fDelayedList.begin();
  auto delayedmap_end = fDelayedList.end();
 
  for (; delayedmap_it != delayedmap_end; delayedmap_it++)
  {
    auto it = delayedmap_it->second.begin();
    auto end = delayedmap_it->second.end();
 
    for (; it != end; it++)
    {
      if (it->second != nullptr) nTracks += it->second->size();
    }
  }
 
  //    G4cout << "nTracks = " << nTracks << G4endl;
 
  return nTracks;
}

Referenced by G4Scheduler::GetNTracks().

GetPriorityList()

PriorityList * G4ITTrackHolder::GetPriorityList

(

Key

i

)

Definition at line 765 of file G4ITTrackHolder.cc.

{
  auto it = fLists.find(i);
  if (it == fLists.end()) return nullptr;
  return it->second;
}

Referenced by GetMainList().

GetSecondariesList()

G4TrackManyList * G4ITTrackHolder::GetSecondariesList ( )

inline

Definition at line 201 of file G4ITTrackHolder.hh.

  {
    return &fAllSecondariesList;
  }

Referenced by G4Scheduler::EndTracking().

Instance()

G4ITTrackHolder * G4ITTrackHolder::Instance ( )

static

Definition at line 196 of file G4ITTrackHolder.cc.

{
  if (fgInstance == nullptr)
  {
    fgInstance = new G4ITTrackHolder();
    if(G4Threading::IsMasterThread() ||
       !G4Threading::IsMultithreadedApplication() 
    ) 
    {
      fgMasterInstance = fgInstance;
    }
    
  }
  return fgInstance;
}

Referenced by G4ITTrackingManager::EndTracking(), G4DNAIRTMoleculeEncounterStepper::G4DNAIRTMoleculeEncounterStepper(), G4DNAMoleculeEncounterStepper::G4DNAMoleculeEncounterStepper(), G4DNAIRT::Initialize(), G4ITModelProcessor::Initialize(), G4ITStepProcessor::Initialize(), G4DNAMakeReaction::MakeReaction(), G4DNAMolecularReaction::MakeReaction(), G4DNAScavengerProcess::PostStepDoIt(), G4DNAChemistryManager::PushTrack(), and G4DNAEventScheduler::Voxelizing().

KillTracks()

void G4ITTrackHolder::KillTracks

(

)

Definition at line 695 of file G4ITTrackHolder.cc.

{
  if (fToBeKilledList.empty()) return;
#ifdef G4VERBOSE
  if (fVerbose > 1)
  {
    G4cout << "*** G4ITTrackHolder::KillTracks , step #"
           << G4VScheduler::Instance()->GetNbSteps()
           << " ***" << G4endl;
    G4cout << "Nb of tracks to kill "<< fToBeKilledList.size() << G4endl;
    G4cout << setw(25) << left << "#Name"
           << setw(25) << "track ID"<< G4endl;
 
    G4TrackList::iterator it = fToBeKilledList.begin();
    for(; it != fToBeKilledList.end();)
    {
      G4Track* toBeErased = *it;
 
      G4cout << setw(25) << GetIT(toBeErased)->GetName()
      << setw(25) << toBeErased->GetTrackID()
      << G4endl;
 
      it = fToBeKilledList.erase(toBeErased);
    }
  }
  else
#endif
  fToBeKilledList.erase(fToBeKilledList.begin(), fToBeKilledList.end());
}

Referenced by Clear(), G4ITModelProcessor::ComputeTrackReaction(), and G4ITStepProcessor::DoIt().

MainListsNOTEmpty()

bool G4ITTrackHolder::MainListsNOTEmpty ( )

inline

Definition at line 215 of file G4ITTrackHolder.hh.

  {
    return CheckMapIsNOTEmpty(fLists, PriorityList::MainList);
  }

Referenced by G4Scheduler::DoProcess(), G4Scheduler::EndTracking(), and G4Scheduler::PrintWhyDoYouStop().

MasterInstance()

G4ITTrackHolder * G4ITTrackHolder::MasterInstance ( )

static

Definition at line 212 of file G4ITTrackHolder.cc.

{
  G4AutoLock lock(&creationOfTheMasterInstance);
  if (fgMasterInstance == nullptr)
  {
    fgMasterInstance = new G4ITTrackHolder();
  }
  lock.unlock();
  return fgMasterInstance;
}

Referenced by PushToMaster().

MergeNextTimeToMainList()

bool G4ITTrackHolder::MergeNextTimeToMainList

(

double &

time

)

Definition at line 288 of file G4ITTrackHolder.cc.

{
//  G4cout << "G4ITTrackHolder::MergeNextTimeToMainList" << G4endl;
  if (fDelayedList.empty())
  {
    return false;
  }
 
//  G4cout << "fDelayedList.size = " << fDelayedList.size() <<G4endl;
 
  auto it =
      fDelayedList.begin()->second.begin();
  auto end =
      fDelayedList.begin()->second.end();
  if (it == end) return false;
 
  bool output = false;
  for (; it != end; it++)
  {
    PriorityList* right_listUnion(nullptr);
 
    auto it_listUnion = fLists.find(
        it->first);
    if (it_listUnion == fLists.end())
    {
      right_listUnion = (fLists[it->first] = new PriorityList());
    }
    else
    {
      if (it_listUnion->second == 0)
      {
        it_listUnion->second = new PriorityList();
      }
      right_listUnion = it_listUnion->second;
    }
 
    if (it->second == 0) continue;
 
    /*
     if (right_listUnion->GetMainList() == 0)
     {
     //      right_listUnion->fpMainList = new G4TrackList();
     //      if(it->second)
     //      {
     right_listUnion->NewMainList(it->second, fAllMainList);
     //      }
     }
     else
     {
     right_listUnion->TransferToMainList(it->second);
     delete it->second;
     }*/
 
    right_listUnion->TransferToMainList(it->second, fAllMainList);
 
    if (!output)
    {
      if (static_cast<int>(!right_listUnion->GetMainList()->empty()) != 0)
      {
        output = true;
      }
    }
    it->second = 0;
  }
 
  if (output) time = fDelayedList.begin()->first;
  fDelayedList.erase(fDelayedList.begin());
  return output;
}

Referenced by G4Scheduler::SynchronizeTracks().

MergeSecondariesWithMainList()

void G4ITTrackHolder::MergeSecondariesWithMainList

(

)

Definition at line 358 of file G4ITTrackHolder.cc.

{
  auto it = fLists.begin();
  auto end = fLists.end();
 
  for (; it != end; it++)
  {
    if (it->second->GetMainList() == nullptr)
    {
      it->second->NewMainList(fAllMainList);
    }
 
    it->second->TransferSecondariesToMainList();
  }
}

Referenced by G4ITModelProcessor::ComputeTrackReaction(), G4ITStepProcessor::DoIt(), G4Scheduler::EndTracking(), and G4DNAIRT::MakeReaction().

MoveMainToWaitingList()

void G4ITTrackHolder::MoveMainToWaitingList

(

)

Definition at line 841 of file G4ITTrackHolder.cc.

{
  auto it = fLists.begin();
  auto end = fLists.end();
  for (; it != end; it++)
  {
    if (PriorityList* lists = it->second)
    {
      lists->SetWaitingList(lists->GetMainList());
      //TODO
    }
  }
  fAllMainList.RemoveLists();
}

Push()

void G4ITTrackHolder::Push ( G4Track * track )

overridevirtual

Reimplemented from G4VITTrackHolder.

Definition at line 385 of file G4ITTrackHolder.cc.

{
//  if (G4VScheduler::Instance()->IsRunning())
//  {
//    G4ExceptionDescription exceptionDescription;
//    exceptionDescription
//        << "G4ITTrackHolder::PushTrack : You are trying to push tracks while the "
//        "ITStepManager is running";
//    G4Exception("G4ITTrackHolder::PushTrack", "ITStepManager012",
//                FatalErrorInArgument, exceptionDescription);
//  }
  _PushTrack(track);
 
//  G4MIConstituent::NotifyEntityAdded(track);
}

Referenced by G4DNAIRT::MakeReaction(), G4DNAMakeReaction::MakeReaction(), G4DNAMolecularReaction::MakeReaction(), G4DNAScavengerProcess::PostStepDoIt(), G4DNAChemistryManager::PushTrack(), and G4DNAIRT::Sampling().

PushDelayed()

void G4ITTrackHolder::PushDelayed ( G4Track * track )

protected

Definition at line 620 of file G4ITTrackHolder.cc.

{
#ifdef G4VERBOSE
  if (fVerbose != 0)
  {
    G4cout << "\t" << ">> Pushing a delayed track" << G4endl;
  }
#endif
 
  int moleculeID = GetIT(track)->GetITSubType();
  //  std::map<int, PriorityList>::iterator it = fLists.find(moleculeID);
 
  G4double globalTime = track->GetGlobalTime();
 
  auto it_delayed =
  fDelayedList.find(globalTime);
 
  if (it_delayed == fDelayedList.end())
  {
    (fDelayedList[globalTime][moleculeID] = new G4TrackList())->push_back(
        track);
  }
  else
  {
    auto it_trackList =
    it_delayed->second.find(moleculeID);
 
    if (it_trackList == it_delayed->second.end())
    {
      (it_delayed->second[moleculeID] = new G4TrackList())->push_back(track);
    }
    else
    {
      if (it_trackList->second != 0)
      {
        it_trackList->second->push_back(track);
      }
    }
  }
 
  //  fDelayedList[globalTime][moleculeID]
 
  /*
   std::map<double,std::map<int, G4TrackList* > >::iterator it_delayed =
   fDelayedList.begin();
 
   std::map<double,std::map<int, G4TrackList* > >::iterator end_delayed =
   fDelayedList.end();
 
   for(it_delayed != end_delayed ; it_delayed++)
   {
   std::map<int, G4TrackList*> & trackListMap = it->second;
 
 
   }
   */
  /*
   std::map<double,G4TrackList* > :: iterator
   fDelayedList_i = fDelayedList.find(globalTime) ;
 
   if(fDelayedList_i == fDelayedList.end())
   {
 
   G4TrackList* newList = new G4TrackList ;
   newList -> push_back(track);
   fDelayedList[globalTime] = newList ;
   }
   else
   {
   fDelayedList_i->second-> push_back(track);
   }
   */
}

Referenced by _PushTrack(), and PushToMaster().

PushTo()

void G4ITTrackHolder::PushTo ( G4Track * track, PriorityList::Type type )

protected

Definition at line 401 of file G4ITTrackHolder.cc.

{
  int moleculeID = GetIT(track)->GetITSubType();
  auto it = fLists.find(moleculeID);
 
  PriorityList* priorityList(nullptr);
 
  if (it == fLists.end())
  {
    priorityList = new PriorityList(fAllMainList);
    fLists[moleculeID] = priorityList;
  }
  else
  {
    priorityList = it->second;
  }
 
  switch (type)
  {
    case PriorityList::MainList:
    {
      priorityList->PushToMainList(track, fAllMainList);
      break;
    }
    case PriorityList::SecondariesList:
    {
      priorityList->PushToListOfSecondaries(track, fAllSecondariesList);
      break;
    }
    case PriorityList::WaitingList:
    {
      priorityList->PushToWaitingList(track);
      return;
      break;
    }
 
    default:
    {
      return;
      break;
    }
  }
}

Referenced by _PushTrack().

PushToKill()

void G4ITTrackHolder::PushToKill ( G4Track * track )

inline

Definition at line 164 of file G4ITTrackHolder.hh.

  {
    G4TrackList::Pop(track);
    fToBeKilledList.push_back(track);
    
    if(track->GetTrackStatus() != fKillTrackAndSecondaries){
      track->SetTrackStatus(fStopAndKill);
    }
  }

Referenced by G4ITTrackingManager::EndTracking().

PushToMaster()

void G4ITTrackHolder::PushToMaster ( G4Track * track )

static

Definition at line 805 of file G4ITTrackHolder.cc.

{
  G4ITTrackHolder* trackHolder = MasterInstance();
 
  G4AutoLock lock(&pushToTheMasterInstance);
  trackHolder->PushDelayed(track);
  lock.unlock();
}

SecondaryListsNOTEmpty()

bool G4ITTrackHolder::SecondaryListsNOTEmpty ( )

inline

Definition at line 220 of file G4ITTrackHolder.hh.

  {
    return CheckMapIsNOTEmpty(fLists, PriorityList::SecondariesList);
  }

Referenced by G4Scheduler::EndTracking().

SetVerbose()

void G4ITTrackHolder::SetVerbose ( int verbose )

inline

Definition at line 230 of file G4ITTrackHolder.hh.

  {
    fVerbose = verbose;
  }

Friends And Related Symbol Documentation

G4ITModelProcessor

friend class G4ITModelProcessor

friend

Definition at line 134 of file G4ITTrackHolder.hh.

G4ITStepProcessor

friend class G4ITStepProcessor

friend

Definition at line 133 of file G4ITTrackHolder.hh.

G4Scheduler

friend class G4Scheduler

friend

Definition at line 132 of file G4ITTrackHolder.hh.

Member Data Documentation

fAllMainList

G4TrackManyList G4ITTrackHolder::fAllMainList

protected

Definition at line 257 of file G4ITTrackHolder.hh.

Referenced by AddWatcherForMainList(), Clear(), GetMainList(), GetNTracks(), MergeNextTimeToMainList(), MergeSecondariesWithMainList(), MoveMainToWaitingList(), PushTo(), and ~G4ITTrackHolder().

fAllSecondariesList

G4TrackManyList G4ITTrackHolder::fAllSecondariesList

protected

Definition at line 258 of file G4ITTrackHolder.hh.

Referenced by Clear(), GetNTracks(), GetSecondariesList(), PushTo(), and ~G4ITTrackHolder().

fDelayedList

MapOfDelayedLists G4ITTrackHolder::fDelayedList

protected

Definition at line 248 of file G4ITTrackHolder.hh.

Referenced by Clear(), DelayListsNOTEmpty(), GetDelayedLists(), GetNextTime(), GetNTracks(), MergeNextTimeToMainList(), PushDelayed(), and ~G4ITTrackHolder().

fLists

std::map<Key, PriorityList*> G4ITTrackHolder::fLists

protected

Definition at line 247 of file G4ITTrackHolder.hh.

Referenced by AddWatcher(), Clear(), GetLists(), GetPriorityList(), MainListsNOTEmpty(), MergeNextTimeToMainList(), MergeSecondariesWithMainList(), MoveMainToWaitingList(), PushTo(), SecondaryListsNOTEmpty(), and ~G4ITTrackHolder().

fMainListHaveBeenSet

bool G4ITTrackHolder::fMainListHaveBeenSet

protected

Definition at line 250 of file G4ITTrackHolder.hh.

Referenced by _PushTrack(), and G4ITTrackHolder().

fNbTracks

int G4ITTrackHolder::fNbTracks

protected

Definition at line 252 of file G4ITTrackHolder.hh.

Referenced by AddTrackID(), Clear(), G4ITTrackHolder(), and ~G4ITTrackHolder().

fPostActivityGlobalTime

double G4ITTrackHolder::fPostActivityGlobalTime

protected

Definition at line 254 of file G4ITTrackHolder.hh.

Referenced by G4ITTrackHolder().

fToBeKilledList

G4TrackList G4ITTrackHolder::fToBeKilledList

protected

Definition at line 249 of file G4ITTrackHolder.hh.

Referenced by AddWatcherForKillList(), GetKillList(), KillTracks(), and PushToKill().

fVerbose

int G4ITTrackHolder::fVerbose

protected

Definition at line 251 of file G4ITTrackHolder.hh.

Referenced by _PushTrack(), G4ITTrackHolder(), KillTracks(), PushDelayed(), and SetVerbose().

---

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

• G4ITTrackHolder.hh
• G4ITTrackHolder.cc