G4ITTrackHolder Class Reference

#include <G4ITTrackHolder.hh>

Inheritance diagram for G4ITTrackHolder:

Collaboration 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 ()

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

Static Private Attributes
static G4ThreadLocal G4ITTrackHolder *	fgInstance
static G4ITTrackHolder *	fgMasterInstance

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

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

AddTrackID()

void G4ITTrackHolder::AddTrackID ( G4Track *  track )

protected

Definition at line 377 of file G4ITTrackHolder.cc.

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

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

GetDelayedLists()

MapOfDelayedLists& G4ITTrackHolder::GetDelayedLists ( )

inline

Definition at line 201 of file G4ITTrackHolder.hh.

  {
    return fDelayedList;
  }

Here is the call graph for this function:

GetKillList()

G4TrackList* G4ITTrackHolder::GetKillList ( )

inline

Definition at line 230 of file G4ITTrackHolder.hh.

  {
    return &fToBeKilledList;
  }

GetLists()

MapOfPriorityLists& G4ITTrackHolder::GetLists ( )

inline

Definition at line 187 of file G4ITTrackHolder.hh.

  { return fLists;}

Here is the call graph for this function:

GetMainList() [1/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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMainList() [2/2]

G4TrackManyList* G4ITTrackHolder::GetMainList ( )

inline

Definition at line 191 of file G4ITTrackHolder.hh.

  {
    return &fAllMainList;
  }

GetNextTime()

double G4ITTrackHolder::GetNextTime ( )

inline

Definition at line 152 of file G4ITTrackHolder.hh.

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

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

GetSecondariesList()

G4TrackManyList* G4ITTrackHolder::GetSecondariesList ( )

inline

Definition at line 196 of file G4ITTrackHolder.hh.

  {
    return &fAllSecondariesList;
  }

Here is the caller graph for this function:

Instance()

G4ITTrackHolder * G4ITTrackHolder::Instance ( void  )

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

MainListsNOTEmpty()

bool G4ITTrackHolder::MainListsNOTEmpty ( )

inline

Definition at line 210 of file G4ITTrackHolder.hh.

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

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the caller graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

Here is the caller graph for this function:

PushToKill()

void G4ITTrackHolder::PushToKill ( G4Track *  track )

inline

Definition at line 164 of file G4ITTrackHolder.hh.

  {
    fToBeKilledList.push_back(track);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Here is the call graph for this function:

SecondaryListsNOTEmpty()

bool G4ITTrackHolder::SecondaryListsNOTEmpty ( )

inline

Definition at line 215 of file G4ITTrackHolder.hh.

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

Here is the caller graph for this function:

SetVerbose()

void G4ITTrackHolder::SetVerbose ( int  verbose )

inline

Definition at line 225 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 252 of file G4ITTrackHolder.hh.

fAllSecondariesList

G4TrackManyList G4ITTrackHolder::fAllSecondariesList

protected

Definition at line 253 of file G4ITTrackHolder.hh.

fDelayedList

MapOfDelayedLists G4ITTrackHolder::fDelayedList

protected

Definition at line 243 of file G4ITTrackHolder.hh.

fgInstance

G4ThreadLocal G4ITTrackHolder * G4ITTrackHolder::fgInstance

staticprivate

Definition at line 130 of file G4ITTrackHolder.hh.

fgMasterInstance

G4ITTrackHolder * G4ITTrackHolder::fgMasterInstance

staticprivate

Definition at line 131 of file G4ITTrackHolder.hh.

fLists

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

protected

Definition at line 242 of file G4ITTrackHolder.hh.

fMainListHaveBeenSet

bool G4ITTrackHolder::fMainListHaveBeenSet

protected

Definition at line 245 of file G4ITTrackHolder.hh.

fNbTracks

int G4ITTrackHolder::fNbTracks

protected

Definition at line 247 of file G4ITTrackHolder.hh.

fPostActivityGlobalTime

double G4ITTrackHolder::fPostActivityGlobalTime

protected

Definition at line 249 of file G4ITTrackHolder.hh.

fToBeKilledList

G4TrackList G4ITTrackHolder::fToBeKilledList

protected

Definition at line 244 of file G4ITTrackHolder.hh.

fVerbose

int G4ITTrackHolder::fVerbose

protected

Definition at line 246 of file G4ITTrackHolder.hh.

---

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

• G4ITTrackHolder.hh
• G4ITTrackHolder.cc