G4ITTrackHolder Class Reference

#include <G4ITTrackHolder.hh>

Inheritance diagram for G4ITTrackHolder:

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

Public Member Functions
	G4ITTrackHolder ()
virtual	~G4ITTrackHolder ()
double	GetNextTime ()
virtual void	Push (G4Track *)
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 ()
virtual size_t	GetNTracks ()
bool	MainListsNOTEmpty ()
bool	SecondaryListsNOTEmpty ()
bool	DelayListsNOTEmpty ()
bool	CheckMapIsNOTEmpty (MapOfPriorityLists &mapOfLists, PriorityList::Type type)
void	SetVerbose (int verbose)
G4TrackList *	GetKillList ()
virtual void	Push (G4Track *)
virtual size_t	GetNTracks ()

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

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

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

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

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

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

AddWatcherForKillList()

void G4ITTrackHolder::AddWatcherForKillList

(

G4TrackList::Watcher *

watcher

)

Definition at line 801 of file G4ITTrackHolder.cc.

{
  watcher->Watch(&fToBeKilledList);
}

AddWatcherForMainList()

void G4ITTrackHolder::AddWatcherForMainList

(

G4TrackList::Watcher *

watcher

)

Definition at line 796 of file G4ITTrackHolder.cc.

{
  fAllMainList.AddGlobalWatcher(watcher);
}

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

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

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 773 of file G4ITTrackHolder.cc.

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

Referenced by G4DNAIRTMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAMoleculeEncounterStepper::CalculateMinTimeStep(), G4DNAIndependentReactionTimeStepper::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 ( )

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

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

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 == 0)
  {
    fgInstance = new G4ITTrackHolder();
    if(G4Threading::IsMasterThread() ||
       G4Threading::IsMultithreadedApplication() == false 
    ) 
    {
      fgMasterInstance = fgInstance;
    }
    
  }
  return fgInstance;
}

Referenced by G4ITTrackingManager::EndTracking(), G4DNAIRTMoleculeEncounterStepper::G4DNAIRTMoleculeEncounterStepper(), G4DNAMoleculeEncounterStepper::G4DNAMoleculeEncounterStepper(), G4ITModelProcessor::Initialize(), G4ITStepProcessor::Initialize(), G4DNAIRT::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());
}

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

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

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

Referenced by G4ITModelProcessor::ComputeTrackReaction(), G4ITStepProcessor::DoIt(), G4Scheduler::EndTracking(), and G4DNAIRT::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();
}

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

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

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

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 806 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 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.

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