ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ITTrackHolder.hh
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4ITTrackHolder.hh
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 
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 
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:
116  // to merge with fpMainList
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 
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_ */