Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ITTrackHolder.hh
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 /*
27  * G4ITTrackHolder.hh
28  *
29  * Created on: 17 sept. 2014
30  * Author: kara
31  */
32 
33 #ifndef G4ITTRACKHOLDER_HH
34 #define G4ITTRACKHOLDER_HH
35 
36 #include "G4TrackList.hh"
37 #include "G4VITTrackHolder.hh"
38 #include <iostream>
39 
40 class PriorityList : public G4TrackList::Watcher
41 {
42 public:
43  enum Type
44  {
45  MainList = 0,
48  Undefined = -1
49  };
50 
51  PriorityList();
52  PriorityList(G4TrackManyList& allMainList);
54  virtual ~PriorityList();
55 
56  virtual void NotifyDeletingList(G4TrackList* __list);
57 
58  void NewMainList(G4TrackList* __list, G4TrackManyList& allMainList);
59 
61 
62  void PushToMainList(G4Track* __track, G4TrackManyList& allMainList);
63 
64  void TransferToMainList(G4TrackList*& __list, G4TrackManyList& allMainList);
65 
66  void PushToListOfSecondaries(G4Track* __track,
67  G4TrackManyList& listOfAllSecondaries);
68 
69  void PushToWaitingList(G4Track* __track);
70 
72 
73  void PushToMainList(G4Track* track);
74 
75  void MergeWithMainList(G4TrackList* trackList);
76 
78  {
79  return fpMainList;
80  }
81 
83  {
84  return &fSecondaries;
85  }
86 
87  inline void SetWaitingList(G4TrackList* __list)
88  {
89  fpWaitingList = __list;
90  }
91 
92  inline G4TrackList* Get(Type type)
93  {
94  switch (type)
95  {
96  case MainList:
97  return fpMainList;
98  break;
99  case SecondariesList:
100  return &fSecondaries;
101  break;
102  case WaitingList:
103  return fpWaitingList;
104  break;
105  case Undefined:
106  return 0;
107  }
108  return 0;
109  }
110 
111  int GetNTracks();
112 
113 private:
114  G4TrackList* fpMainList;
115  G4TrackList fSecondaries;
116  // to merge with fpMainList
117  G4TrackList* fpWaitingList;
118  // Waiting queue of currentList
119 };
120 
122 {
123  /* UR:
124  * Push on time
125  * Push delayed
126  * Exception when going back
127  * Get all tracks
128  */
129 
130  static G4ThreadLocal G4ITTrackHolder* fgInstance;
131  static G4ITTrackHolder* fgMasterInstance;
132  friend class G4Scheduler;
133  friend class G4ITStepProcessor;
134  friend class G4ITModelProcessor;
135 
136 public:
137  //----- typedefs -----
138  typedef int Key; //TODO
139  typedef std::map<Key, PriorityList*> MapOfPriorityLists;
140  typedef std::map<double, std::map<Key, G4TrackList*> > MapOfDelayedLists;
141 
142  //----- Access singletons + constructors/destructors-----
143 
144  static G4ITTrackHolder* Instance();
146 
147  G4ITTrackHolder();
148  virtual
150 
151  //----- Time of the next set of tracks -----
152  inline double GetNextTime()
153  {
154  if (fDelayedList.empty()) return DBL_MAX;
155  return fDelayedList.begin()->first;
156  }
157 
158  //----- Add new tracks to the list -----
159  virtual void Push(G4Track*);
160  static void PushToMaster(G4Track*);
161 
162  //----- Operations between lists -----
163 
164  inline void PushToKill(G4Track* track)
165  {
166  G4TrackList::Pop(track);
167  fToBeKilledList.push_back(track);
168 
171  }
172  }
173 
174  bool MergeNextTimeToMainList(double& time);
176  void MoveMainToWaitingList();
177 
178  // ----- To call at the end of the step -----
179  void KillTracks();
180  void Clear();
181 
182  // ----- Add a watcher to a specific track list -----
183  // comment: to stop watching, just call StopWatching from your watcher class
184  bool AddWatcher(int,
185  G4TrackList::Watcher*,
187 
188  void AddWatcherForMainList(G4TrackList::Watcher*);
189  void AddWatcherForKillList(G4TrackList::Watcher*);
190 
191  // ----- Access track lists -----
193  { return fLists;}
197  {
198  return &fAllMainList;
199  }
200 
202  {
203  return &fAllSecondariesList;
204  }
205 
207  {
208  return fDelayedList;
209  }
210 
211  virtual size_t GetNTracks();
212 
213  // ----- Check track lists are NOT empty -----
214  // comment: checking NOT empty faster than checking IS empty
215  inline bool MainListsNOTEmpty()
216  {
218  }
219 
221  {
223  }
224 
225  bool DelayListsNOTEmpty();
226 
227  bool CheckMapIsNOTEmpty(MapOfPriorityLists& mapOfLists,
228  PriorityList::Type type);
229 
230  inline void SetVerbose(int verbose)
231  {
232  fVerbose = verbose;
233  }
234 
236  {
237  return &fToBeKilledList;
238  }
239 
240 protected:
241  void AddTrackID(G4Track* track);
242  void _PushTrack(G4Track* track);
244  void PushDelayed(G4Track* track);
245 
246 protected:
247  std::map<Key, PriorityList*> fLists;
251  int fVerbose;
253 
255  // double fPreActivityGlobalTime ;
256 
259 };
260 
261 #endif /* G4MIMOLECULARTRACKS_HH_ */
G4TrackList * Get(Type type)
G4TrackList fToBeKilledList
void SetTrackStatus(const G4TrackStatus aTrackStatus)
G4TrackManyList * GetMainList()
virtual void Push(G4Track *)
void MergeSecondariesWithMainList()
bool CheckMapIsNOTEmpty(MapOfPriorityLists &mapOfLists, PriorityList::Type type)
G4TrackManyList * GetSecondariesList()
void AddTrackID(G4Track *track)
std::map< Key, PriorityList * > fLists
double fPostActivityGlobalTime
std::map< double, std::map< Key, G4TrackList * > > MapOfDelayedLists
void PushDelayed(G4Track *track)
G4TrackStatus GetTrackStatus() const
void MoveMainToWaitingList()
G4TrackList * GetKillList()
virtual void NotifyDeletingList(G4TrackList *__list)
G4TrackList * GetSecondariesList()
G4TrackList * GetMainList()
void SetVerbose(int verbose)
#define G4ThreadLocal
Definition: tls.hh:89
void PushToMainList(G4Track *__track, G4TrackManyList &allMainList)
MapOfPriorityLists & GetLists()
void PushToWaitingList(G4Track *__track)
static void Pop(G4Track *)
void MergeWithMainList(G4TrackList *trackList)
void AddWatcherForMainList(G4TrackList::Watcher *)
void AddWatcherForKillList(G4TrackList::Watcher *)
void _PushTrack(G4Track *track)
virtual ~PriorityList()
void PushTo(G4Track *, PriorityList::Type)
bool MergeNextTimeToMainList(double &time)
void SetWaitingList(G4TrackList *__list)
bool SecondaryListsNOTEmpty()
void PushToKill(G4Track *track)
G4TrackManyList fAllMainList
virtual size_t GetNTracks()
void TransferToMainList(G4TrackList *&__list, G4TrackManyList &allMainList)
static G4ITTrackHolder * MasterInstance()
PriorityList * GetPriorityList(Key)
void push_back(OBJECT *__track)
MapOfDelayedLists fDelayedList
std::map< Key, PriorityList * > MapOfPriorityLists
static void PushToMaster(G4Track *)
void PushToListOfSecondaries(G4Track *__track, G4TrackManyList &listOfAllSecondaries)
static G4ITTrackHolder * Instance()
virtual ~G4ITTrackHolder()
MapOfDelayedLists & GetDelayedLists()
void NewMainList(G4TrackList *__list, G4TrackManyList &allMainList)
void TransferSecondariesToMainList()
G4TrackManyList fAllSecondariesList
#define DBL_MAX
Definition: templates.hh:83
bool AddWatcher(int, G4TrackList::Watcher *, PriorityList::Type=PriorityList::MainList)