#include <G4ITTrackHolder.hh>

Inheritance diagram for G4ITTrackHolder:

Public Types
typedef int	Key

typedef std::map< double, std::map< Key, G4TrackList * > >	MapOfDelayedLists

typedef std::map< Key, PriorityList * >	MapOfPriorityLists

Public Member Functions
bool	AddWatcher (int, G4TrackList::Watcher *, PriorityList::Type=PriorityList::MainList)

void	AddWatcherForKillList (G4TrackList::Watcher *)

void	AddWatcherForMainList (G4TrackList::Watcher *)

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

void	Clear ()

bool	DelayListsNOTEmpty ()

	G4ITTrackHolder ()

MapOfDelayedLists &	GetDelayedLists ()

G4TrackList *	GetKillList ()

MapOfPriorityLists &	GetLists ()

G4TrackManyList *	GetMainList ()

G4TrackList *	GetMainList (Key)

double	GetNextTime ()

virtual size_t	GetNTracks ()

PriorityList *	GetPriorityList (Key)

G4TrackManyList *	GetSecondariesList ()

void	KillTracks ()

bool	MainListsNOTEmpty ()

bool	MergeNextTimeToMainList (double &time)

void	MergeSecondariesWithMainList ()

void	MoveMainToWaitingList ()

virtual void	Push (G4Track *)

void	PushToKill (G4Track *track)

bool	SecondaryListsNOTEmpty ()

void	SetVerbose (int verbose)

virtual	~G4ITTrackHolder ()

Static Public Member Functions
static G4ITTrackHolder *	Instance ()

static G4ITTrackHolder *	MasterInstance ()

static void	PushToMaster (G4Track *)

Protected Member Functions
void	_PushTrack (G4Track *track)

void	AddTrackID (G4Track *track)

void	PushDelayed (G4Track *track)

void	PushTo (G4Track *, PriorityList::Type)

Protected Attributes
G4TrackManyList	fAllMainList

G4TrackManyList	fAllSecondariesList

MapOfDelayedLists	fDelayedList

std::map< Key, PriorityList * >	fLists

bool	fMainListHaveBeenSet

int	fNbTracks

double	fPostActivityGlobalTime

G4TrackList	fToBeKilledList

int	fVerbose

Static Protected Attributes
static G4ThreadLocal G4VITTrackHolder *	fInstance

Static Private Attributes
static G4ThreadLocal G4ITTrackHolder *	fgInstance

static G4ITTrackHolder *	fgMasterInstance

Friends
class	G4ITModelProcessor

class	G4ITStepProcessor

class	G4Scheduler

Detailed Description

Definition at line 121 of file G4ITTrackHolder.hh.

Member Typedef Documentation

◆ Key

typedef int G4ITTrackHolder::Key

Definition at line 138 of file G4ITTrackHolder.hh.

◆ MapOfDelayedLists

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

Definition at line 140 of file G4ITTrackHolder.hh.

◆ MapOfPriorityLists

typedef std::map<Key, PriorityList*> G4ITTrackHolder::MapOfPriorityLists

Definition at line 139 of file G4ITTrackHolder.hh.

Constructor & Destructor Documentation

◆ G4ITTrackHolder()

G4ITTrackHolder::G4ITTrackHolder ( )

Definition at line 223 of file G4ITTrackHolder.cc.

                                 :
    G4VITTrackHolder()
{
  fNbTracks = -1;
  fMainListHaveBeenSet = false;
  fVerbose = 0;
 
  fPostActivityGlobalTime = -1;
//  fPreActivityGlobalTime = -1;
}

References fMainListHaveBeenSet, fNbTracks, fPostActivityGlobalTime, and fVerbose.

Referenced by Instance(), and MasterInstance().

◆ ~G4ITTrackHolder()

G4ITTrackHolder::~G4ITTrackHolder ( )

virtual

Definition at line 234 of file G4ITTrackHolder.cc.

{
  std::map<Key, PriorityList*>::iterator end = fLists.end();
 
  for (std::map<Key, PriorityList*>::iterator it = fLists.begin(); it != end;
      it++)
  {
    delete it->second;
    it->second = 0;
  }
 
  if (!fDelayedList.empty())
  {
    MapOfDelayedLists::iterator fDelayedList_i = fDelayedList.begin();
    MapOfDelayedLists::iterator fDelayedList_end = fDelayedList.end();
 
    for (; fDelayedList_i != fDelayedList_end; fDelayedList_i++)
    {
      std::map<Key, G4TrackList*>::iterator it = fDelayedList_i->second.begin();
      std::map<Key, G4TrackList*>::iterator __end =
          fDelayedList_i->second.end();
 
      for (; it != __end; it++)
      {
        if (it->second) delete (it->second);
        it->second = 0;
      }
    }
    fDelayedList.clear();
  }
 
  fAllMainList.RemoveLists();
  fAllSecondariesList.RemoveLists();
  fNbTracks = -1;
}

References fAllMainList, fAllSecondariesList, fDelayedList, fLists, fNbTracks, and G4ManyFastLists< OBJECT >::RemoveLists().

Member Function Documentation

◆ _PushTrack()

void G4ITTrackHolder::_PushTrack ( G4Track * track )

protected

Definition at line 447 of file G4ITTrackHolder.cc.

{
  if (track == 0)
  {
    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)
  {
    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() == false)
  {
    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 == false)
    {
      PushDelayed(track);
    }
    else
    {
      if (globalTime == currentGlobalTime)
      {
        #ifdef G4VERBOSE
          if (fVerbose)
          {
            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)
          {
            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)
        {
          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);
    }
  }
}

References AddTrackID(), FatalErrorInArgument, fMainListHaveBeenSet, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), G4Scheduler::GetGlobalTime(), G4Track::GetGlobalTime(), GetIT(), G4IT::GetName(), G4Scheduler::GetTimeTolerance(), G4Track::GetTrackID(), G4Scheduler::Instance(), PriorityList::MainList, PushDelayed(), PushTo(), and PriorityList::SecondariesList.

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

◆ AddTrackID()

void G4ITTrackHolder::AddTrackID ( G4Track * track )

protected

Definition at line 377 of file G4ITTrackHolder.cc.

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

References fNbTracks, and G4Track::SetTrackID().

Referenced by _PushTrack().

◆ AddWatcher()

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

Definition at line 783 of file G4ITTrackHolder.cc.

{
  std::map<Key, PriorityList*>::iterator it = fLists.find(id);
  if (it == fLists.end()) return false;
 
  G4TrackList* trackList = it->second->Get(type);
  if (trackList == 0) return false;
  trackList->AddWatcher(watcher);
  return true;
}

References G4FastList< OBJECT >::AddWatcher(), and fLists.

◆ AddWatcherForKillList()

void G4ITTrackHolder::AddWatcherForKillList ( G4TrackList::Watcher * watcher )

Definition at line 801 of file G4ITTrackHolder.cc.

{
  watcher->Watch(&fToBeKilledList);
}

References fToBeKilledList.

◆ AddWatcherForMainList()

void G4ITTrackHolder::AddWatcherForMainList ( G4TrackList::Watcher * watcher )

Definition at line 796 of file G4ITTrackHolder.cc.

{
  fAllMainList.AddGlobalWatcher(watcher);
}

References G4ManyFastLists< OBJECT >::AddGlobalWatcher(), and fAllMainList.

◆ CheckMapIsNOTEmpty()

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

Definition at line 880 of file G4ITTrackHolder.cc.

{
  MapOfPriorityLists::iterator it = mapOfLists.begin();
  MapOfPriorityLists::iterator 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 726 of file G4ITTrackHolder.cc.

{
  fAllMainList.ClearLists();
  fAllSecondariesList.ClearLists();
//  fAllMainList.RemoveLists();
//  fAllSecondariesList.RemoveLists();
 
  std::map<Key, PriorityList*>::iterator it = fLists.begin();
 
  for (; it != fLists.end(); it++)
  {
    if (it->second) delete it->second;
    it->second = 0;
  }
  fLists.clear();
 
  MapOfDelayedLists::iterator it1 = fDelayedList.begin();
 
  for (; it1 != fDelayedList.end(); it1++)
  {
    std::map<Key, G4TrackList*>::iterator it2 = it1->second.begin();
 
    for (; it2 != it1->second.end(); it2++)
    {
      if (it2->second) delete it2->second;
      it2->second = 0;
    }
  }
 
  fDelayedList.clear();
 
//  fAllMainList.ClearLists();
//  fAllSecondariesList.ClearLists();
  fAllMainList.RemoveLists();
  fAllSecondariesList.RemoveLists();
  KillTracks();
 
  fNbTracks = -1;
}

References G4ManyFastLists< OBJECT >::ClearLists(), fAllMainList, fAllSecondariesList, fDelayedList, fLists, fNbTracks, KillTracks(), and G4ManyFastLists< OBJECT >::RemoveLists().

Referenced by G4Scheduler::ClearList().

◆ DelayListsNOTEmpty()

bool G4ITTrackHolder::DelayListsNOTEmpty ( )

Definition at line 857 of file G4ITTrackHolder.cc.

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

References fDelayedList.

Referenced by G4Scheduler::Process().

◆ GetDelayedLists()

MapOfDelayedLists & G4ITTrackHolder::GetDelayedLists ( )

inline

Definition at line 206 of file G4ITTrackHolder.hh.

  {
    return fDelayedList;
  }

References fDelayedList.

◆ GetKillList()

G4TrackList * G4ITTrackHolder::GetKillList ( )

inline

Definition at line 235 of file G4ITTrackHolder.hh.

  {
    return &fToBeKilledList;
  }

References fToBeKilledList.

◆ GetLists()

MapOfPriorityLists & G4ITTrackHolder::GetLists ( )

inline

Definition at line 192 of file G4ITTrackHolder.hh.

193 { return fLists;}

References fLists.

◆ GetMainList() [1/2]

G4TrackManyList * G4ITTrackHolder::GetMainList ( )

inline

Definition at line 196 of file G4ITTrackHolder.hh.

  {
    return &fAllMainList;
  }

References fAllMainList.

◆ GetMainList() [2/2]

G4TrackList * G4ITTrackHolder::GetMainList ( Key i )

Definition at line 773 of file G4ITTrackHolder.cc.

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

References PriorityList::GetMainList(), and GetPriorityList().

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAIndependentReactionTimeStepper::CalculateMinTimeStep(), G4ITStepProcessor::ComputeInteractionLength(), G4ITStepProcessor::DoIt(), G4Scheduler::EndTracking(), G4DNAIRT_geometries::Initialize(), G4DNAIRT::IRTSampling(), G4DNAIRT_geometries::IRTSampling(), G4DNAIRT::SpaceBinning(), G4DNAIRT_geometries::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;
  }

References DBL_MAX, and fDelayedList.

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

◆ GetNTracks()

size_t G4ITTrackHolder::GetNTracks ( )

virtual

Reimplemented from G4VITTrackHolder.

Definition at line 815 of file G4ITTrackHolder.cc.

{
  size_t nTracks(0);
  nTracks += fAllMainList.size();
  nTracks += fAllSecondariesList.size();
 
  //    G4cout << "nTracks = " << nTracks << G4endl;
 
  MapOfDelayedLists::iterator delayedmap_it = fDelayedList.begin();
  MapOfDelayedLists::iterator delayedmap_end = fDelayedList.end();
 
  for (; delayedmap_it != delayedmap_end; delayedmap_it++)
  {
    std::map<Key, G4TrackList*>::iterator it = delayedmap_it->second.begin();
    std::map<Key, G4TrackList*>::iterator end = delayedmap_it->second.end();
 
    for (; it != end; it++)
    {
      if (it->second) nTracks += it->second->size();
    }
  }
 
  //    G4cout << "nTracks = " << nTracks << G4endl;
 
  return nTracks;
}

References fAllMainList, fAllSecondariesList, fDelayedList, and G4ManyFastLists< OBJECT >::size().

Referenced by G4Scheduler::GetNTracks().

◆ GetPriorityList()

PriorityList * G4ITTrackHolder::GetPriorityList ( Key i )

Definition at line 766 of file G4ITTrackHolder.cc.

{
  std::map<Key, PriorityList*>::iterator it = fLists.find(i);
  if (it == fLists.end()) return 0;
  return it->second;
}

References fLists.

Referenced by GetMainList().

◆ GetSecondariesList()

G4TrackManyList * G4ITTrackHolder::GetSecondariesList ( )

inline

Definition at line 201 of file G4ITTrackHolder.hh.

  {
    return &fAllSecondariesList;
  }

References fAllSecondariesList.

Referenced by G4Scheduler::EndTracking().

◆ Instance()

G4ITTrackHolder * G4ITTrackHolder::Instance ( )

static

Definition at line 196 of file G4ITTrackHolder.cc.

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

References fgInstance, fgMasterInstance, G4ITTrackHolder(), G4Threading::IsMasterThread(), and G4Threading::IsMultithreadedApplication().

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

◆ KillTracks()

void G4ITTrackHolder::KillTracks ( )

Definition at line 696 of file G4ITTrackHolder.cc.

{
  if (fToBeKilledList.size() == 0) 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());
}

References G4FastList< OBJECT >::begin(), G4FastList< OBJECT >::end(), G4FastList< OBJECT >::erase(), fToBeKilledList, fVerbose, G4cout, G4endl, GetIT(), G4IT::GetName(), G4VScheduler::GetNbSteps(), G4Track::GetTrackID(), G4VScheduler::Instance(), and G4FastList< OBJECT >::size().

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);
  }

References CheckMapIsNOTEmpty(), fLists, and 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 == 0)
  {
    fgMasterInstance = new G4ITTrackHolder();
  }
  lock.unlock();
  return fgMasterInstance;
}

References creationOfTheMasterInstance, fgMasterInstance, G4ITTrackHolder(), and G4TemplateAutoLock< _Mutex_t >::unlock().

Referenced by PushToMaster().

◆ MergeNextTimeToMainList()

bool G4ITTrackHolder::MergeNextTimeToMainList ( double & time )

Definition at line 289 of file G4ITTrackHolder.cc.

{
//  G4cout << "G4ITTrackHolder::MergeNextTimeToMainList" << G4endl;
  if (fDelayedList.empty())
  {
    return false;
  }
 
//  G4cout << "fDelayedList.size = " << fDelayedList.size() <<G4endl;
 
  std::map<Key, G4TrackList*>::iterator it =
      fDelayedList.begin()->second.begin();
  std::map<Key, G4TrackList*>::iterator end =
      fDelayedList.begin()->second.end();
  if (it == end) return false;
 
  bool output = false;
  for (; it != end; it++)
  {
    PriorityList* right_listUnion(0);
 
    std::map<Key, PriorityList*>::iterator 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 == false)
    {
      if (right_listUnion->GetMainList()->size())
      {
        output = true;
      }
    }
    it->second = 0;
  }
 
  if (output) time = fDelayedList.begin()->first;
  fDelayedList.erase(fDelayedList.begin());
  return output;
}

References fAllMainList, fDelayedList, fLists, PriorityList::GetMainList(), G4FastList< OBJECT >::size(), and PriorityList::TransferToMainList().

Referenced by G4Scheduler::SynchronizeTracks().

◆ MergeSecondariesWithMainList()

void G4ITTrackHolder::MergeSecondariesWithMainList ( )

Definition at line 359 of file G4ITTrackHolder.cc.

{
  std::map<Key, PriorityList*>::iterator it = fLists.begin();
  std::map<Key, PriorityList*>::iterator end = fLists.end();
 
  for (; it != end; it++)
  {
    if (it->second->GetMainList() == 0)
    {
      it->second->NewMainList(fAllMainList);
    }
 
    it->second->TransferSecondariesToMainList();
  }
}

References fAllMainList, and fLists.

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

◆ MoveMainToWaitingList()

void G4ITTrackHolder::MoveMainToWaitingList ( )

Definition at line 842 of file G4ITTrackHolder.cc.

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

References fAllMainList, fLists, and G4ManyFastLists< OBJECT >::RemoveLists().

◆ Push()

void G4ITTrackHolder::Push ( G4Track * track )

virtual

Reimplemented from G4VITTrackHolder.

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

References _PushTrack().

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

◆ PushDelayed()

void G4ITTrackHolder::PushDelayed ( G4Track * track )

protected

Definition at line 621 of file G4ITTrackHolder.cc.

{
#ifdef G4VERBOSE
  if (fVerbose)
  {
    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();
 
  std::map<double, std::map<Key, G4TrackList*> >::iterator it_delayed =
  fDelayedList.find(globalTime);
 
  if (it_delayed == fDelayedList.end())
  {
    (fDelayedList[globalTime][moleculeID] = new G4TrackList())->push_back(
        track);
  }
  else
  {
    std::map<Key, G4TrackList*>::iterator 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);
   }
   */
}

References fDelayedList, fVerbose, G4cout, G4endl, G4Track::GetGlobalTime(), GetIT(), and G4IT::GetITSubType().

Referenced by _PushTrack(), and PushToMaster().

◆ PushTo()

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

protected

Definition at line 402 of file G4ITTrackHolder.cc.

{
  int moleculeID = GetIT(track)->GetITSubType();
  std::map<Key, PriorityList*>::iterator it = fLists.find(moleculeID);
 
  PriorityList* priorityList(0);
 
  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;
    }
  }
}

References fAllMainList, fAllSecondariesList, fLists, GetIT(), G4IT::GetITSubType(), PriorityList::MainList, PriorityList::PushToListOfSecondaries(), PriorityList::PushToMainList(), PriorityList::PushToWaitingList(), PriorityList::SecondariesList, and PriorityList::WaitingList.

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);
    }
  }

References fKillTrackAndSecondaries, fStopAndKill, fToBeKilledList, G4Track::GetTrackStatus(), G4FastList< G4Track >::Pop(), G4FastList< OBJECT >::push_back(), and G4Track::SetTrackStatus().

Referenced by G4ITTrackingManager::EndTracking().

◆ PushToMaster()

void G4ITTrackHolder::PushToMaster ( G4Track * track )

static

Definition at line 806 of file G4ITTrackHolder.cc.

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

References MasterInstance(), PushDelayed(), pushToTheMasterInstance, and G4TemplateAutoLock< _Mutex_t >::unlock().

◆ SecondaryListsNOTEmpty()

bool G4ITTrackHolder::SecondaryListsNOTEmpty ( )

inline

Definition at line 220 of file G4ITTrackHolder.hh.

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

References CheckMapIsNOTEmpty(), fLists, and PriorityList::SecondariesList.

Referenced by G4Scheduler::EndTracking().

◆ SetVerbose()

void G4ITTrackHolder::SetVerbose ( int verbose )

inline

Definition at line 230 of file G4ITTrackHolder.hh.

  {
    fVerbose = verbose;
  }

References fVerbose.

Friends And Related Function 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.

Field 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().

◆ fgInstance

G4ThreadLocal G4ITTrackHolder * G4ITTrackHolder::fgInstance

staticprivate

Definition at line 130 of file G4ITTrackHolder.hh.

Referenced by Instance().

◆ fgMasterInstance

G4ITTrackHolder * G4ITTrackHolder::fgMasterInstance

staticprivate

Definition at line 131 of file G4ITTrackHolder.hh.

Referenced by Instance(), and MasterInstance().

◆ fInstance

G4ThreadLocal G4VITTrackHolder * G4VITTrackHolder::fInstance

staticprotectedinherited

Definition at line 65 of file G4VITTrackHolder.hh.

Referenced by G4VITTrackHolder::G4VITTrackHolder(), G4VITTrackHolder::Instance(), and G4VITTrackHolder::~G4VITTrackHolder().

◆ 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:

source/processes/electromagnetic/dna/management/include/G4ITTrackHolder.hh
source/processes/electromagnetic/dna/management/src/G4ITTrackHolder.cc

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Static Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ Key

◆ MapOfDelayedLists

◆ MapOfPriorityLists

Constructor & Destructor Documentation

◆ G4ITTrackHolder()

◆ ~G4ITTrackHolder()

Member Function Documentation

◆ _PushTrack()

◆ AddTrackID()

◆ AddWatcher()

◆ AddWatcherForKillList()

◆ AddWatcherForMainList()

◆ CheckMapIsNOTEmpty()

◆ Clear()

◆ DelayListsNOTEmpty()

◆ GetDelayedLists()

◆ GetKillList()

◆ GetLists()

◆ GetMainList() [1/2]

◆ GetMainList() [2/2]

◆ GetNextTime()

◆ GetNTracks()

◆ GetPriorityList()

◆ GetSecondariesList()

◆ Instance()

◆ KillTracks()

◆ MainListsNOTEmpty()

◆ MasterInstance()

◆ MergeNextTimeToMainList()

◆ MergeSecondariesWithMainList()

◆ MoveMainToWaitingList()

◆ Push()

◆ PushDelayed()

◆ PushTo()

◆ PushToKill()

◆ PushToMaster()

◆ SecondaryListsNOTEmpty()

◆ SetVerbose()

Friends And Related Function Documentation

◆ G4ITModelProcessor

◆ G4ITStepProcessor

◆ G4Scheduler

Field Documentation

◆ fAllMainList

◆ fAllSecondariesList

◆ fDelayedList

◆ fgInstance

◆ fgMasterInstance

◆ fInstance

◆ fLists

◆ fMainListHaveBeenSet

◆ fNbTracks

◆ fPostActivityGlobalTime

◆ fToBeKilledList

◆ fVerbose