| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 /* 26 /*
27 * G4MIMolecularTracks.cc 27 * G4MIMolecularTracks.cc
28 * 28 *
29 * Created on: 17 sept. 2014 29 * Created on: 17 sept. 2014
30 * Author: kara 30 * Author: kara
31 */ 31 */
32 32
33 #include <G4Scheduler.hh> 33 #include <G4Scheduler.hh>
34 #include <G4VScheduler.hh> 34 #include <G4VScheduler.hh>
35 #include "G4ITTrackHolder.hh" 35 #include "G4ITTrackHolder.hh"
36 #include "G4IT.hh" 36 #include "G4IT.hh"
37 #include "G4Track.hh" 37 #include "G4Track.hh"
38 #include "G4UnitsTable.hh" 38 #include "G4UnitsTable.hh"
39 #include "G4AutoLock.hh" 39 #include "G4AutoLock.hh"
40 #include "G4Threading.hh" 40 #include "G4Threading.hh"
41 41
42 using namespace std; 42 using namespace std;
43 43
44 PriorityList::PriorityList() : 44 PriorityList::PriorityList() :
45 fpMainList(nullptr), fpWaitingList(nullpt << 45 G4TrackList::Watcher(), fpMainList(0), fpWaitingList(0)
46 { 46 {
47 } 47 }
48 48
49 PriorityList::PriorityList(G4TrackManyList& al <<
50 fpMainList(nullptr), fpWaitingList(nullpt <<
51 { <<
52 NewMainList(allMainList); <<
53 } <<
54 <<
55 PriorityList::PriorityList(const PriorityList& 49 PriorityList::PriorityList(const PriorityList& right) :
56 << 50 G4TrackList::Watcher(),
57 fpMainList(right.fpMainList), 51 fpMainList(right.fpMainList),
58 fpWaitingList(right.fpWaitingList) 52 fpWaitingList(right.fpWaitingList)
59 { 53 {
60 } 54 }
61 55
62 PriorityList::~PriorityList() 56 PriorityList::~PriorityList()
63 { 57 {
64 if (fpMainList != nullptr) << 58 if (fpMainList)
65 { 59 {
66 delete fpMainList; 60 delete fpMainList;
67 fpMainList = nullptr; << 61 fpMainList = 0;
68 } 62 }
69 if (fpWaitingList != nullptr) << 63 if (fpWaitingList)
70 { 64 {
71 delete fpWaitingList; 65 delete fpWaitingList;
72 fpWaitingList = nullptr; << 66 fpWaitingList = 0;
73 } 67 }
74 } 68 }
75 69
76 void PriorityList::NotifyDeletingList(G4TrackL 70 void PriorityList::NotifyDeletingList(G4TrackList* __list)
77 { 71 {
78 if (__list == fpMainList) 72 if (__list == fpMainList)
79 { 73 {
80 // StopWatching(fpMainList); << 74 fpMainList = 0;
81 fpMainList = nullptr; << 75 StopWatching(fpMainList);
82 } 76 }
83 else if (__list == fpWaitingList) 77 else if (__list == fpWaitingList)
84 { 78 {
85 // StopWatching(fpWaitingList); << 79 fpWaitingList = 0;
86 fpWaitingList = nullptr; << 80 StopWatching(fpWaitingList);
87 } 81 }
88 } 82 }
89 83
90 void PriorityList::NewMainList(G4TrackList* __ 84 void PriorityList::NewMainList(G4TrackList* __list,
91 G4TrackManyList 85 G4TrackManyList& allMainList)
92 { 86 {
93 fpMainList = __list; 87 fpMainList = __list;
94 allMainList.Add(__list); 88 allMainList.Add(__list);
95 Watch(fpMainList); 89 Watch(fpMainList);
96 } 90 }
97 91
98 G4TrackList* PriorityList::NewMainList(G4Track 92 G4TrackList* PriorityList::NewMainList(G4TrackManyList& allMainList)
99 { 93 {
100 auto trackList = new G4TrackList(); << 94 G4TrackList* trackList = new G4TrackList();
101 NewMainList(trackList, allMainList); 95 NewMainList(trackList, allMainList);
102 return fpMainList; 96 return fpMainList;
103 } 97 }
104 98
105 void PriorityList::PushToMainList(G4Track* __t 99 void PriorityList::PushToMainList(G4Track* __track,
106 G4TrackManyL 100 G4TrackManyList& allMainList)
107 { 101 {
108 if (fpMainList == nullptr) << 102 if (fpMainList == 0)
109 { 103 {
110 NewMainList(allMainList); 104 NewMainList(allMainList);
111 } 105 }
112 fpMainList->push_back(__track); 106 fpMainList->push_back(__track);
113 } 107 }
114 108
115 void PriorityList::TransferToMainList(G4TrackL 109 void PriorityList::TransferToMainList(G4TrackList*& __list,
116 G4TrackM 110 G4TrackManyList& allMainList)
117 { 111 {
118 if (fpMainList != nullptr) << 112 if (fpMainList)
119 { 113 {
120 __list->transferTo(fpMainList); 114 __list->transferTo(fpMainList);
121 delete __list; 115 delete __list;
122 __list = nullptr; << 116 __list = 0;
123 } 117 }
124 else 118 else
125 { 119 {
126 NewMainList(__list, allMainList); 120 NewMainList(__list, allMainList);
127 } 121 }
128 } 122 }
129 123
130 void PriorityList::PushToListOfSecondaries(G4T 124 void PriorityList::PushToListOfSecondaries(G4Track* __track,
131 G4T 125 G4TrackManyList& listOfAllSecondaries)
132 { 126 {
133 // if (priorityList->fSecondaries.empty 127 // if (priorityList->fSecondaries.empty())
134 if (fSecondaries.GetListNode() != nullptr) << 128 if (fSecondaries.GetListNode())
135 { 129 {
136 listOfAllSecondaries.Add(&fSecondaries); 130 listOfAllSecondaries.Add(&fSecondaries);
137 } 131 }
138 fSecondaries.push_back(__track); 132 fSecondaries.push_back(__track);
139 } 133 }
140 134
141 void PriorityList::PushToWaitingList(G4Track* 135 void PriorityList::PushToWaitingList(G4Track* __track)
142 { 136 {
143 if (fpWaitingList == nullptr) << 137 if (fpWaitingList == 0)
144 { 138 {
145 fpWaitingList = new G4TrackList(); 139 fpWaitingList = new G4TrackList();
146 } 140 }
147 fpWaitingList->push_back(__track); 141 fpWaitingList->push_back(__track);
148 } 142 }
149 143
150 void PriorityList::TransferSecondariesToMainLi 144 void PriorityList::TransferSecondariesToMainList()
151 { 145 {
152 fSecondaries.transferTo(fpMainList); 146 fSecondaries.transferTo(fpMainList);
153 } 147 }
154 148
155 void PriorityList::PushToMainList(G4Track* tra 149 void PriorityList::PushToMainList(G4Track* track)
156 { 150 {
157 if (fpMainList == nullptr) fpMainList = new << 151 if (fpMainList == 0) fpMainList = new G4TrackList();
158 fpMainList->push_back(track); 152 fpMainList->push_back(track);
159 } 153 }
160 154
161 void PriorityList::MergeWithMainList(G4TrackLi 155 void PriorityList::MergeWithMainList(G4TrackList* trackList)
162 { 156 {
163 if (fpMainList == nullptr) fpMainList = new << 157 if (fpMainList == 0) fpMainList = new G4TrackList();
164 trackList->transferTo(trackList); 158 trackList->transferTo(trackList);
165 } 159 }
166 160
167 int PriorityList::GetNTracks() 161 int PriorityList::GetNTracks()
168 { 162 {
169 int nTracks = 0; 163 int nTracks = 0;
170 164
171 if (fpMainList != nullptr) << 165 if (fpMainList)
172 { 166 {
173 nTracks += fpMainList->size(); 167 nTracks += fpMainList->size();
174 } 168 }
175 169
176 if (fpWaitingList != nullptr) << 170 if (fpWaitingList)
177 { 171 {
178 nTracks += fpWaitingList->size(); 172 nTracks += fpWaitingList->size();
179 } 173 }
180 174
181 nTracks += fSecondaries.size(); 175 nTracks += fSecondaries.size();
182 176
183 return nTracks; 177 return nTracks;
184 } 178 }
185 179
186 //============================================ 180 //=============================================================================
187 // G4ITTrackHolder 181 // G4ITTrackHolder
188 //============================================ 182 //=============================================================================
189 183
190 G4ThreadLocal G4ITTrackHolder* G4ITTrackHolder << 184 G4ThreadLocal G4ITTrackHolder* G4ITTrackHolder::fgInstance(0);
191 G4ITTrackHolder* G4ITTrackHolder::fgMasterInst << 185 G4ITTrackHolder* G4ITTrackHolder::fgMasterInstance(0);
192 186
193 G4Mutex creationOfTheMasterInstance; 187 G4Mutex creationOfTheMasterInstance;
194 G4Mutex pushToTheMasterInstance; 188 G4Mutex pushToTheMasterInstance;
195 189
196 G4ITTrackHolder* G4ITTrackHolder::Instance() 190 G4ITTrackHolder* G4ITTrackHolder::Instance()
197 { 191 {
198 if (fgInstance == nullptr) << 192 if (fgInstance == 0)
199 { 193 {
200 fgInstance = new G4ITTrackHolder(); 194 fgInstance = new G4ITTrackHolder();
201 if(G4Threading::IsMasterThread() || << 195 if(G4Threading::IsWorkerThread() == false ||
202 !G4Threading::IsMultithreadedApplicatio << 196 G4Threading::IsMultithreadedApplication() == false
203 ) 197 )
204 { 198 {
205 fgMasterInstance = fgInstance; 199 fgMasterInstance = fgInstance;
206 } 200 }
207 201
208 } 202 }
209 return fgInstance; 203 return fgInstance;
210 } 204 }
211 205
212 G4ITTrackHolder* G4ITTrackHolder::MasterInstan 206 G4ITTrackHolder* G4ITTrackHolder::MasterInstance()
213 { 207 {
214 G4AutoLock lock(&creationOfTheMasterInstance 208 G4AutoLock lock(&creationOfTheMasterInstance);
215 if (fgMasterInstance == nullptr) << 209 if (fgMasterInstance == 0)
216 { 210 {
217 fgMasterInstance = new G4ITTrackHolder(); 211 fgMasterInstance = new G4ITTrackHolder();
218 } 212 }
219 lock.unlock(); 213 lock.unlock();
220 return fgMasterInstance; 214 return fgMasterInstance;
221 } 215 }
222 216
223 G4ITTrackHolder::G4ITTrackHolder() << 217 G4ITTrackHolder::G4ITTrackHolder() :
>> 218 G4VITTrackHolder()
224 { 219 {
225 fNbTracks = -1; 220 fNbTracks = -1;
226 fMainListHaveBeenSet = false; 221 fMainListHaveBeenSet = false;
227 fVerbose = 0; 222 fVerbose = 0;
228 223
229 fPostActivityGlobalTime = -1; 224 fPostActivityGlobalTime = -1;
230 // fPreActivityGlobalTime = -1; 225 // fPreActivityGlobalTime = -1;
231 } 226 }
232 227
233 G4ITTrackHolder::~G4ITTrackHolder() 228 G4ITTrackHolder::~G4ITTrackHolder()
234 { 229 {
235 auto end = fLists.end(); << 230 std::map<Key, PriorityList*>::iterator end = fLists.end();
236 231
237 for (auto it = fLists.begin(); it != end; << 232 for (std::map<Key, PriorityList*>::iterator it = fLists.begin(); it != end;
238 it++) 233 it++)
239 { 234 {
240 delete it->second; 235 delete it->second;
241 it->second = 0; 236 it->second = 0;
242 } 237 }
243 238
244 if (!fDelayedList.empty()) 239 if (!fDelayedList.empty())
245 { 240 {
246 auto fDelayedList_i = fDelayedList.begin() << 241 MapOfDelayedLists::iterator fDelayedList_i = fDelayedList.begin();
247 auto fDelayedList_end = fDelayedList.end() << 242 MapOfDelayedLists::iterator fDelayedList_end = fDelayedList.end();
248 243
249 for (; fDelayedList_i != fDelayedList_end; 244 for (; fDelayedList_i != fDelayedList_end; fDelayedList_i++)
250 { 245 {
251 auto it = fDelayedList_i->second.begin() << 246 std::map<Key, G4TrackList*>::iterator it = fDelayedList_i->second.begin();
252 auto __end = << 247 std::map<Key, G4TrackList*>::iterator __end =
253 fDelayedList_i->second.end(); 248 fDelayedList_i->second.end();
254 249
255 for (; it != __end; it++) 250 for (; it != __end; it++)
256 { 251 {
257 delete (it->second); << 252 if (it->second) delete (it->second);
258 it->second = 0; 253 it->second = 0;
259 } 254 }
260 } 255 }
261 fDelayedList.clear(); 256 fDelayedList.clear();
262 } 257 }
263 258
264 fAllMainList.RemoveLists(); 259 fAllMainList.RemoveLists();
265 fAllSecondariesList.RemoveLists(); 260 fAllSecondariesList.RemoveLists();
266 fNbTracks = -1; 261 fNbTracks = -1;
267 } 262 }
268 263
269 /* 264 /*
270 void G4MIMolecularTracks::Decide() 265 void G4MIMolecularTracks::Decide()
271 { 266 {
272 cout << "G4MIMolecularTracks::Decide" << endl 267 cout << "G4MIMolecularTracks::Decide" << endl;
273 268
274 if (fDelayedList.empty()) 269 if (fDelayedList.empty())
275 { 270 {
276 cout << "fDelayedList.empty()" << endl; 271 cout << "fDelayedList.empty()" << endl;
277 return; 272 return;
278 } 273 }
279 fPostActivityGlobalTime = GetNextTime(); 274 fPostActivityGlobalTime = GetNextTime();
280 // PushActivity(workspace->GetScheduler(), t 275 // PushActivity(workspace->GetScheduler(), this);
281 } 276 }
282 */ 277 */
283 278
284 /* 279 /*
285 * param time = time of the merged list 280 * param time = time of the merged list
286 * returned = was there actually merged data ? 281 * returned = was there actually merged data ?
287 */ 282 */
288 bool G4ITTrackHolder::MergeNextTimeToMainList( 283 bool G4ITTrackHolder::MergeNextTimeToMainList(double& time)
289 { 284 {
290 // G4cout << "G4ITTrackHolder::MergeNextTimeT 285 // G4cout << "G4ITTrackHolder::MergeNextTimeToMainList" << G4endl;
291 if (fDelayedList.empty()) 286 if (fDelayedList.empty())
292 { 287 {
293 return false; 288 return false;
294 } 289 }
295 290
296 // G4cout << "fDelayedList.size = " << fDelay 291 // G4cout << "fDelayedList.size = " << fDelayedList.size() <<G4endl;
297 292
298 auto it = << 293 std::map<Key, G4TrackList*>::iterator it =
299 fDelayedList.begin()->second.begin(); 294 fDelayedList.begin()->second.begin();
300 auto end = << 295 std::map<Key, G4TrackList*>::iterator end =
301 fDelayedList.begin()->second.end(); 296 fDelayedList.begin()->second.end();
302 if (it == end) return false; 297 if (it == end) return false;
303 298
304 bool output = false; 299 bool output = false;
305 for (; it != end; it++) 300 for (; it != end; it++)
306 { 301 {
307 PriorityList* right_listUnion(nullptr); << 302 PriorityList* right_listUnion(0);
308 303
309 auto it_listUnion = fLists.find( << 304 std::map<Key, PriorityList*>::iterator it_listUnion = fLists.find(
310 it->first); 305 it->first);
311 if (it_listUnion == fLists.end()) 306 if (it_listUnion == fLists.end())
312 { 307 {
313 right_listUnion = (fLists[it->first] = n 308 right_listUnion = (fLists[it->first] = new PriorityList());
314 } 309 }
315 else 310 else
316 { 311 {
317 if (it_listUnion->second == 0) 312 if (it_listUnion->second == 0)
318 { 313 {
319 it_listUnion->second = new PriorityLis 314 it_listUnion->second = new PriorityList();
320 } 315 }
321 right_listUnion = it_listUnion->second; 316 right_listUnion = it_listUnion->second;
322 } 317 }
323 318
324 if (it->second == 0) continue; 319 if (it->second == 0) continue;
325 320
326 /* 321 /*
327 if (right_listUnion->GetMainList() == 0) 322 if (right_listUnion->GetMainList() == 0)
328 { 323 {
329 // right_listUnion->fpMainList = new 324 // right_listUnion->fpMainList = new G4TrackList();
330 // if(it->second) 325 // if(it->second)
331 // { 326 // {
332 right_listUnion->NewMainList(it->second, 327 right_listUnion->NewMainList(it->second, fAllMainList);
333 // } 328 // }
334 } 329 }
335 else 330 else
336 { 331 {
337 right_listUnion->TransferToMainList(it->s 332 right_listUnion->TransferToMainList(it->second);
338 delete it->second; 333 delete it->second;
339 }*/ 334 }*/
340 335
341 right_listUnion->TransferToMainList(it->se 336 right_listUnion->TransferToMainList(it->second, fAllMainList);
342 337
343 if (!output) << 338 if (output == false)
344 { 339 {
345 if (static_cast<int>(!right_listUnion->G << 340 if (right_listUnion->GetMainList()->size())
346 { 341 {
347 output = true; 342 output = true;
348 } 343 }
349 } 344 }
350 it->second = 0; 345 it->second = 0;
351 } 346 }
352 347
353 if (output) time = fDelayedList.begin()->fir 348 if (output) time = fDelayedList.begin()->first;
354 fDelayedList.erase(fDelayedList.begin()); 349 fDelayedList.erase(fDelayedList.begin());
355 return output; 350 return output;
356 } 351 }
357 352
358 void G4ITTrackHolder::MergeSecondariesWithMain 353 void G4ITTrackHolder::MergeSecondariesWithMainList()
359 { 354 {
360 auto it = fLists.begin(); << 355 std::map<Key, PriorityList*>::iterator it = fLists.begin();
361 auto end = fLists.end(); << 356 std::map<Key, PriorityList*>::iterator end = fLists.end();
362 357
363 for (; it != end; it++) 358 for (; it != end; it++)
364 { 359 {
365 if (it->second->GetMainList() == nullptr) << 360 if (it->second->GetMainList() == 0)
366 { 361 {
367 it->second->NewMainList(fAllMainList); 362 it->second->NewMainList(fAllMainList);
368 } 363 }
369 364
370 it->second->TransferSecondariesToMainList( 365 it->second->TransferSecondariesToMainList();
371 } 366 }
372 } 367 }
373 368
374 //____________________________________________ 369 //_________________________________________________________________________
375 370
376 void G4ITTrackHolder::AddTrackID(G4Track* trac 371 void G4ITTrackHolder::AddTrackID(G4Track* track)
377 { 372 {
378 //if(fNbTracks == 0) fNbTracks = -1; 373 //if(fNbTracks == 0) fNbTracks = -1;
379 track->SetTrackID(fNbTracks); 374 track->SetTrackID(fNbTracks);
380 fNbTracks--; 375 fNbTracks--;
381 } 376 }
382 377
383 //____________________________________________ 378 //_________________________________________________________________________
384 379
385 void G4ITTrackHolder::Push(G4Track* track) 380 void G4ITTrackHolder::Push(G4Track* track)
386 { 381 {
387 // if (G4VScheduler::Instance()->IsRunning()) << 382 if (G4VScheduler::Instance()->IsRunning())
388 // { << 383 {
389 // G4ExceptionDescription exceptionDescript << 384 G4ExceptionDescription exceptionDescription;
390 // exceptionDescription << 385 exceptionDescription
391 // << "G4ITTrackHolder::PushTrack : You << 386 << "G4ITTrackHolder::PushTrack : You are trying to push tracks while the "
392 // "ITStepManager is running"; << 387 "ITStepManager is running";
393 // G4Exception("G4ITTrackHolder::PushTrack" << 388 G4Exception("G4ITTrackHolder::PushTrack", "ITStepManager012",
394 // FatalErrorInArgument, except << 389 FatalErrorInArgument, exceptionDescription);
395 // } << 390 }
396 _PushTrack(track); 391 _PushTrack(track);
397 392
398 // G4MIConstituent::NotifyEntityAdded(track); 393 // G4MIConstituent::NotifyEntityAdded(track);
399 } 394 }
400 //____________________________________________ 395 //_________________________________________________________________________
401 void G4ITTrackHolder::PushTo(G4Track* track, P 396 void G4ITTrackHolder::PushTo(G4Track* track, PriorityList::Type type)
402 { 397 {
403 int moleculeID = GetIT(track)->GetITSubType( 398 int moleculeID = GetIT(track)->GetITSubType();
404 auto it = fLists.find(moleculeID); << 399 std::map<Key, PriorityList*>::iterator it = fLists.find(moleculeID);
405 400
406 PriorityList* priorityList(nullptr); << 401 PriorityList* priorityList(0);
407 402
408 if (it == fLists.end()) 403 if (it == fLists.end())
409 { 404 {
410 priorityList = new PriorityList(fAllMainLi << 405 priorityList = new PriorityList();
411 fLists[moleculeID] = priorityList; 406 fLists[moleculeID] = priorityList;
412 } 407 }
413 else 408 else
414 { 409 {
415 priorityList = it->second; 410 priorityList = it->second;
416 } 411 }
417 412
418 switch (type) 413 switch (type)
419 { 414 {
420 case PriorityList::MainList: 415 case PriorityList::MainList:
421 { 416 {
422 priorityList->PushToMainList(track, fAll 417 priorityList->PushToMainList(track, fAllMainList);
423 break; 418 break;
424 } 419 }
425 case PriorityList::SecondariesList: 420 case PriorityList::SecondariesList:
426 { 421 {
427 priorityList->PushToListOfSecondaries(tr 422 priorityList->PushToListOfSecondaries(track, fAllSecondariesList);
428 break; 423 break;
429 } 424 }
430 case PriorityList::WaitingList: 425 case PriorityList::WaitingList:
431 { 426 {
432 priorityList->PushToWaitingList(track); 427 priorityList->PushToWaitingList(track);
433 return; 428 return;
434 break; 429 break;
435 } 430 }
436 431
437 default: 432 default:
438 { 433 {
439 return; 434 return;
440 break; 435 break;
441 } 436 }
442 } 437 }
443 } 438 }
444 //____________________________________________ 439 //_________________________________________________________________________
445 440
446 void G4ITTrackHolder::_PushTrack(G4Track* trac 441 void G4ITTrackHolder::_PushTrack(G4Track* track)
447 { 442 {
448 if (track == nullptr) << 443 if (track == 0)
449 { 444 {
450 G4ExceptionDescription exceptionDescriptio 445 G4ExceptionDescription exceptionDescription;
451 exceptionDescription 446 exceptionDescription
452 << "You are trying to push a non-exist 447 << "You are trying to push a non-existing track (track pointer is null)"
453 << G4endl; 448 << G4endl;
454 449
455 G4Exception("G4ITTrackHolder::_PushTrack", 450 G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager014",
456 FatalErrorInArgument, exceptio 451 FatalErrorInArgument, exceptionDescription);
457 } 452 }
458 453
459 G4double globalTime = track->GetGlobalTime() 454 G4double globalTime = track->GetGlobalTime();
460 455
461 if (track->GetTrackID() == 0) 456 if (track->GetTrackID() == 0)
462 { 457 {
463 // Set track ID 458 // Set track ID
464 AddTrackID(track); 459 AddTrackID(track);
465 } 460 }
466 461
467 double currentGlobalTime = G4Scheduler::Inst 462 double currentGlobalTime = G4Scheduler::Instance()->GetGlobalTime();
468 463
469 #ifdef G4VERBOSE 464 #ifdef G4VERBOSE
470 if (fVerbose != 0) << 465 if (fVerbose > 5)
471 { 466 {
472 G4cout << G4endl; 467 G4cout << G4endl;
473 G4cout << "\t"<< ">> Pushing a track --> 468 G4cout << "\t"<< ">> Pushing a track --> ";
474 G4cout << GetIT(track)->GetName() << " (" 469 G4cout << GetIT(track)->GetName() << " (" << track->GetTrackID() <<")"
475 << " -- "; 470 << " -- ";
476 G4cout << "Global current time: " << G4Bes 471 G4cout << "Global current time: " << G4BestUnit(currentGlobalTime,"Time")
477 << "\t"; 472 << "\t";
478 G4cout << "Track's time: " << G4BestUnit(t 473 G4cout << "Track's time: " << G4BestUnit(track->GetGlobalTime(),"Time")
479 << G4endl; 474 << G4endl;
480 } 475 }
481 #endif 476 #endif
482 477
483 if (!G4Scheduler::Instance()->IsRunning()) << 478 if (G4Scheduler::Instance()->IsRunning() == false)
484 { 479 {
485 if (globalTime < currentGlobalTime) 480 if (globalTime < currentGlobalTime)
486 { 481 {
487 G4ExceptionDescription exceptionDescript 482 G4ExceptionDescription exceptionDescription;
488 exceptionDescription 483 exceptionDescription
489 << "You are trying to push a track w 484 << "You are trying to push a track with a global time"
490 << " inferior to the current simulat 485 << " inferior to the current simulation time." << G4endl<< "The time is going back : " << G4endl
491 << "The time in the step manager : " 486 << "The time in the step manager : "
492 << G4BestUnit(currentGlobalTime,"Time") 487 << G4BestUnit(currentGlobalTime,"Time")
493 << G4endl 488 << G4endl
494 << "The time of the track : " 489 << "The time of the track : "
495 << G4BestUnit(globalTime,"Time") 490 << G4BestUnit(globalTime,"Time")
496 << G4endl 491 << G4endl
497 << "(ITStepManager is not yet running)" 492 << "(ITStepManager is not yet running)"
498 << G4endl; 493 << G4endl;
499 494
500 G4Exception("G4ITTrackHolder::_PushTrack 495 G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager014",
501 FatalErrorInArgument, except 496 FatalErrorInArgument, exceptionDescription);
502 } 497 }
503 498
504 // Push the track to the rigth track list 499 // Push the track to the rigth track list :
505 // If the track time is the same as the ma 500 // If the track time is the same as the main track list,
506 // it will be push to the main track list 501 // it will be push to the main track list
507 // otherwise, it will be pushed to the del 502 // otherwise, it will be pushed to the delayed track list.
508 if (!fMainListHaveBeenSet) << 503 if (fMainListHaveBeenSet == false)
509 { 504 {
510 PushDelayed(track); 505 PushDelayed(track);
511 } 506 }
512 else 507 else
513 { 508 {
514 if (globalTime == currentGlobalTime) 509 if (globalTime == currentGlobalTime)
515 { 510 {
516 #ifdef G4VERBOSE <<
517 if (fVerbose != 0) <<
518 { <<
519 G4cout << G4endl; <<
520 G4cout << "\t"<< ">> Pushing to *m <<
521 G4cout << GetIT(track)->GetName() <<
522 << " -- "; <<
523 G4cout << "Global current time: " <<
524 << "\t"; <<
525 G4cout << "Track's time: " << G4Be <<
526 << G4endl; <<
527 } <<
528 #endif <<
529 PushTo(track, PriorityList::MainList); 511 PushTo(track, PriorityList::MainList);
530 } 512 }
531 else 513 else
532 { 514 {
533 // if(currentGlobalTime > 1*CLHEP::pic <<
534 #ifdef G4VERBOSE <<
535 if (fVerbose != 0) <<
536 { <<
537 G4cout << G4endl; <<
538 G4cout << "\t"<< ">> Pushing to *d <<
539 G4cout << GetIT(track)->GetName() <<
540 << " -- "; <<
541 G4cout << "Global current time: " <<
542 << "\t"; <<
543 G4cout << "Track's time: " << G4Be <<
544 << G4endl; <<
545 } <<
546 #endif <<
547 PushDelayed(track); 515 PushDelayed(track);
548 } 516 }
549 } 517 }
550 } 518 }
551 else // Is running 519 else // Is running
552 { 520 {
553 double timeDifference = globalTime - curre 521 double timeDifference = globalTime - currentGlobalTime;
554 double timeTolerance = G4Scheduler::Instan 522 double timeTolerance = G4Scheduler::Instance()->GetTimeTolerance();
555 523
556 if (timeDifference < -1 * timeTolerance) 524 if (timeDifference < -1 * timeTolerance)
557 { 525 {
558 G4ExceptionDescription exceptionDescript 526 G4ExceptionDescription exceptionDescription;
559 exceptionDescription 527 exceptionDescription
560 << "You are trying to push a track w 528 << "You are trying to push a track with a global time"
561 << " inferior to the current simulat 529 << " inferior to the current simulation time." << G4endl<< "The time is going back : "
562 << G4endl 530 << G4endl
563 << "The time in the step manager : " 531 << "The time in the step manager : "
564 << G4BestUnit(timeDifference,"Time") 532 << G4BestUnit(timeDifference,"Time")
565 << G4endl 533 << G4endl
566 << "The time of the track : " << G4BestU 534 << "The time of the track : " << G4BestUnit(globalTime,"Time")
567 << G4endl 535 << G4endl
568 << "(ITStepManager is running)" 536 << "(ITStepManager is running)"
569 << G4endl; 537 << G4endl;
570 538
571 G4Exception("G4ITTrackHolder::_PushTrack 539 G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager015",
572 FatalErrorInArgument, except 540 FatalErrorInArgument, exceptionDescription);
573 } 541 }
574 542
575 // Push the track to the rigth track list 543 // Push the track to the rigth track list :
576 // If the track time is the same as the ma 544 // If the track time is the same as the main track list,
577 // it will be push to the secondary list 545 // it will be push to the secondary list
578 // otherwise, it will be pushed to the del 546 // otherwise, it will be pushed to the delayed track list.
579 if (fabs(timeDifference) < timeTolerance) 547 if (fabs(timeDifference) < timeTolerance)
580 { 548 {
581 // G4cout << "Is pushing " << GetIT(track 549 // G4cout << "Is pushing " << GetIT(track)->GetName() << G4endl;
582 550
583 #ifdef G4VERBOSE <<
584 if (fVerbose != 0) <<
585 { <<
586 G4cout << G4endl; <<
587 G4cout << "\t"<< ">> Pushing to *sec <<
588 G4cout << GetIT(track)->GetName() << <<
589 << " -- "; <<
590 G4cout << "Global current time: " << <<
591 << "\t"; <<
592 G4cout << "Track's time: " << G4Best <<
593 << G4endl; <<
594 } <<
595 #endif <<
596 PushTo(track, PriorityList::SecondariesL 551 PushTo(track, PriorityList::SecondariesList);
597 } 552 }
598 else // globalTime < fGlobalTime already t 553 else // globalTime < fGlobalTime already taken into account above
599 { 554 {
600 G4ExceptionDescription exceptionDescript 555 G4ExceptionDescription exceptionDescription;
601 exceptionDescription 556 exceptionDescription
602 << "While running you cannot push a 557 << "While running you cannot push a track"
603 << " with a bigger global time than 558 << " with a bigger global time than the current global time" << G4endl<< "The time in the step manager : "
604 << G4BestUnit(currentGlobalTime,"Time") 559 << G4BestUnit(currentGlobalTime,"Time")
605 << G4endl 560 << G4endl
606 << "The time of the track : " << G4BestU 561 << "The time of the track : " << G4BestUnit(globalTime,"Time")
607 << G4endl 562 << G4endl
608 << "(ITStepManager is running)" 563 << "(ITStepManager is running)"
609 << G4endl; 564 << G4endl;
610 565
611 G4Exception("G4ITTrackHolder::_PushTrack 566 G4Exception("G4ITTrackHolder::_PushTrack", "ITStepManager016",
612 FatalErrorInArgument, except 567 FatalErrorInArgument, exceptionDescription);
613 // PushDelayed(track, globalTime); 568 // PushDelayed(track, globalTime);
614 } 569 }
615 } 570 }
616 } 571 }
617 572
618 //____________________________________________ 573 //_________________________________________________________________________
619 574
620 void G4ITTrackHolder::PushDelayed(G4Track* tra 575 void G4ITTrackHolder::PushDelayed(G4Track* track)
621 { 576 {
622 #ifdef G4VERBOSE 577 #ifdef G4VERBOSE
623 if (fVerbose != 0) << 578 if (fVerbose > 5)
624 { 579 {
625 G4cout << "\t" << ">> Pushing a delayed tr 580 G4cout << "\t" << ">> Pushing a delayed track" << G4endl;
626 } 581 }
627 #endif 582 #endif
628 583
629 int moleculeID = GetIT(track)->GetITSubType( 584 int moleculeID = GetIT(track)->GetITSubType();
630 // std::map<int, PriorityList>::iterator it 585 // std::map<int, PriorityList>::iterator it = fLists.find(moleculeID);
631 586
632 G4double globalTime = track->GetGlobalTime() 587 G4double globalTime = track->GetGlobalTime();
633 588
634 auto it_delayed = << 589 std::map<double, std::map<Key, G4TrackList*> >::iterator it_delayed =
635 fDelayedList.find(globalTime); 590 fDelayedList.find(globalTime);
636 591
637 if (it_delayed == fDelayedList.end()) 592 if (it_delayed == fDelayedList.end())
638 { 593 {
639 (fDelayedList[globalTime][moleculeID] = ne 594 (fDelayedList[globalTime][moleculeID] = new G4TrackList())->push_back(
640 track); 595 track);
641 } 596 }
642 else 597 else
643 { 598 {
644 auto it_trackList = << 599 std::map<Key, G4TrackList*>::iterator it_trackList =
645 it_delayed->second.find(moleculeID); 600 it_delayed->second.find(moleculeID);
646 601
647 if (it_trackList == it_delayed->second.end 602 if (it_trackList == it_delayed->second.end())
648 { 603 {
649 (it_delayed->second[moleculeID] = new G4 604 (it_delayed->second[moleculeID] = new G4TrackList())->push_back(track);
650 } 605 }
651 else 606 else
652 { 607 {
653 if (it_trackList->second != 0) 608 if (it_trackList->second != 0)
654 { 609 {
655 it_trackList->second->push_back(track) 610 it_trackList->second->push_back(track);
656 } 611 }
657 } 612 }
658 } 613 }
659 614
660 // fDelayedList[globalTime][moleculeID] 615 // fDelayedList[globalTime][moleculeID]
661 616
662 /* 617 /*
663 std::map<double,std::map<int, G4TrackList* 618 std::map<double,std::map<int, G4TrackList* > >::iterator it_delayed =
664 fDelayedList.begin(); 619 fDelayedList.begin();
665 620
666 std::map<double,std::map<int, G4TrackList* 621 std::map<double,std::map<int, G4TrackList* > >::iterator end_delayed =
667 fDelayedList.end(); 622 fDelayedList.end();
668 623
669 for(it_delayed != end_delayed ; it_delayed+ 624 for(it_delayed != end_delayed ; it_delayed++)
670 { 625 {
671 std::map<int, G4TrackList*> & trackListMap 626 std::map<int, G4TrackList*> & trackListMap = it->second;
672 627
673 628
674 } 629 }
675 */ 630 */
676 /* 631 /*
677 std::map<double,G4TrackList* > :: iterator 632 std::map<double,G4TrackList* > :: iterator
678 fDelayedList_i = fDelayedList.find(globalTi 633 fDelayedList_i = fDelayedList.find(globalTime) ;
679 634
680 if(fDelayedList_i == fDelayedList.end()) 635 if(fDelayedList_i == fDelayedList.end())
681 { 636 {
682 637
683 G4TrackList* newList = new G4TrackList ; 638 G4TrackList* newList = new G4TrackList ;
684 newList -> push_back(track); 639 newList -> push_back(track);
685 fDelayedList[globalTime] = newList ; 640 fDelayedList[globalTime] = newList ;
686 } 641 }
687 else 642 else
688 { 643 {
689 fDelayedList_i->second-> push_back(track); 644 fDelayedList_i->second-> push_back(track);
690 } 645 }
691 */ 646 */
692 } 647 }
693 //____________________________________________ 648 //______________________________________________________________________________
694 649
695 void G4ITTrackHolder::KillTracks() 650 void G4ITTrackHolder::KillTracks()
696 { 651 {
697 if (fToBeKilledList.empty()) return; << 652 if (fToBeKilledList.size() == 0) return;
698 #ifdef G4VERBOSE 653 #ifdef G4VERBOSE
699 if (fVerbose > 1) << 654 if (fVerbose > 5)
700 { 655 {
701 G4cout << "*** G4ITTrackHolder::KillTracks 656 G4cout << "*** G4ITTrackHolder::KillTracks , step #"
702 << G4VScheduler::Instance()->GetNbS << 657 // << G4MIWorldEngine::Instance()->GetScheduler()->GetNbSteps()
703 << " ***" << G4endl; << 658 << G4VScheduler::Instance()->GetNbSteps() << " ***" << G4endl;
704 G4cout << "Nb of tracks to kill "<< fToBeK 659 G4cout << "Nb of tracks to kill "<< fToBeKilledList.size() << G4endl;
705 G4cout << setw(25) << left << "#Name" 660 G4cout << setw(25) << left << "#Name"
706 << setw(25) << "track ID"<< G4endl; << 661 << setw(25) << "track ID"<< G4endl;
707 662
708 G4TrackList::iterator it = fToBeKilledList 663 G4TrackList::iterator it = fToBeKilledList.begin();
709 for(; it != fToBeKilledList.end();) 664 for(; it != fToBeKilledList.end();)
710 { 665 {
711 G4Track* toBeErased = *it; 666 G4Track* toBeErased = *it;
712 667
713 G4cout << setw(25) << GetIT(toBeErased)- 668 G4cout << setw(25) << GetIT(toBeErased)->GetName()
714 << setw(25) << toBeErased->GetTrackID() 669 << setw(25) << toBeErased->GetTrackID()
715 << G4endl; 670 << G4endl;
716 671
717 it = fToBeKilledList.erase(toBeErased); 672 it = fToBeKilledList.erase(toBeErased);
718 } 673 }
719 } 674 }
720 else 675 else
721 #endif 676 #endif
722 fToBeKilledList.erase(fToBeKilledList.begin( 677 fToBeKilledList.erase(fToBeKilledList.begin(), fToBeKilledList.end());
723 } 678 }
724 679
725 void G4ITTrackHolder::Clear() 680 void G4ITTrackHolder::Clear()
726 { 681 {
727 fAllMainList.ClearLists(); 682 fAllMainList.ClearLists();
728 fAllSecondariesList.ClearLists(); 683 fAllSecondariesList.ClearLists();
729 // fAllMainList.RemoveLists(); 684 // fAllMainList.RemoveLists();
730 // fAllSecondariesList.RemoveLists(); 685 // fAllSecondariesList.RemoveLists();
731 686
732 auto it = fLists.begin(); << 687 std::map<Key, PriorityList*>::iterator it = fLists.begin();
733 688
734 for (; it != fLists.end(); it++) 689 for (; it != fLists.end(); it++)
735 { 690 {
736 delete it->second; << 691 if (it->second) delete it->second;
737 it->second = 0; 692 it->second = 0;
738 } 693 }
739 fLists.clear(); 694 fLists.clear();
740 695
741 auto it1 = fDelayedList.begin(); << 696 MapOfDelayedLists::iterator it1 = fDelayedList.begin();
742 697
743 for (; it1 != fDelayedList.end(); it1++) 698 for (; it1 != fDelayedList.end(); it1++)
744 { 699 {
745 auto it2 = it1->second.begin(); << 700 std::map<Key, G4TrackList*>::iterator it2 = it1->second.begin();
746 701
747 for (; it2 != it1->second.end(); it2++) 702 for (; it2 != it1->second.end(); it2++)
748 { 703 {
749 delete it2->second; << 704 if (it2->second) delete it2->second;
750 it2->second = 0; 705 it2->second = 0;
751 } 706 }
752 } 707 }
753 708
754 fDelayedList.clear(); 709 fDelayedList.clear();
755 710
756 // fAllMainList.ClearLists(); 711 // fAllMainList.ClearLists();
757 // fAllSecondariesList.ClearLists(); 712 // fAllSecondariesList.ClearLists();
758 fAllMainList.RemoveLists(); 713 fAllMainList.RemoveLists();
759 fAllSecondariesList.RemoveLists(); 714 fAllSecondariesList.RemoveLists();
760 KillTracks(); 715 KillTracks();
761 716
762 fNbTracks = -1; 717 fNbTracks = -1;
763 } 718 }
764 719
765 PriorityList* G4ITTrackHolder::GetPriorityList 720 PriorityList* G4ITTrackHolder::GetPriorityList(Key i)
766 { 721 {
767 auto it = fLists.find(i); << 722 std::map<Key, PriorityList*>::iterator it = fLists.find(i);
768 if (it == fLists.end()) return nullptr; << 723 if (it == fLists.end()) return 0;
769 return it->second; 724 return it->second;
770 } 725 }
771 726
772 G4TrackList* G4ITTrackHolder::GetMainList(G4in 727 G4TrackList* G4ITTrackHolder::GetMainList(G4int i)
773 { 728 {
774 PriorityList* priorityList = GetPriorityList 729 PriorityList* priorityList = GetPriorityList(i);
775 if (priorityList != nullptr) << 730 if (priorityList)
776 { 731 {
777 return priorityList->GetMainList(); 732 return priorityList->GetMainList();
778 } 733 }
779 return nullptr; << 734 return 0;
780 } 735 }
781 736
782 bool G4ITTrackHolder::AddWatcher(Key id, 737 bool G4ITTrackHolder::AddWatcher(Key id,
783 G4TrackList:: 738 G4TrackList::Watcher* watcher,
784 PriorityList: 739 PriorityList::Type type)
785 { 740 {
786 auto it = fLists.find(id); << 741 std::map<Key, PriorityList*>::iterator it = fLists.find(id);
787 if (it == fLists.end()) return false; 742 if (it == fLists.end()) return false;
788 743
789 G4TrackList* trackList = it->second->Get(typ 744 G4TrackList* trackList = it->second->Get(type);
790 if (trackList == nullptr) return false; << 745 if (trackList == 0) return false;
791 trackList->AddWatcher(watcher); 746 trackList->AddWatcher(watcher);
792 return true; 747 return true;
793 } 748 }
794 749
795 void G4ITTrackHolder::AddWatcherForMainList(G4 <<
796 { <<
797 fAllMainList.AddGlobalWatcher(watcher); <<
798 } <<
799 <<
800 void G4ITTrackHolder::AddWatcherForKillList(G4 <<
801 { <<
802 watcher->Watch(&fToBeKilledList); <<
803 } <<
804 <<
805 void G4ITTrackHolder::PushToMaster(G4Track* tr 750 void G4ITTrackHolder::PushToMaster(G4Track* track)
806 { 751 {
807 G4ITTrackHolder* trackHolder = MasterInstanc 752 G4ITTrackHolder* trackHolder = MasterInstance();
808 753
809 G4AutoLock lock(&pushToTheMasterInstance); 754 G4AutoLock lock(&pushToTheMasterInstance);
810 trackHolder->PushDelayed(track); 755 trackHolder->PushDelayed(track);
811 lock.unlock(); 756 lock.unlock();
812 } 757 }
813 758
814 size_t G4ITTrackHolder::GetNTracks() 759 size_t G4ITTrackHolder::GetNTracks()
815 { 760 {
816 size_t nTracks(0); 761 size_t nTracks(0);
817 nTracks += fAllMainList.size(); 762 nTracks += fAllMainList.size();
818 nTracks += fAllSecondariesList.size(); 763 nTracks += fAllSecondariesList.size();
819 764
820 // G4cout << "nTracks = " << nTracks << G 765 // G4cout << "nTracks = " << nTracks << G4endl;
821 766
822 auto delayedmap_it = fDelayedList.begin(); << 767 MapOfDelayedLists::iterator delayedmap_it = fDelayedList.begin();
823 auto delayedmap_end = fDelayedList.end(); << 768 MapOfDelayedLists::iterator delayedmap_end = fDelayedList.end();
824 769
825 for (; delayedmap_it != delayedmap_end; dela 770 for (; delayedmap_it != delayedmap_end; delayedmap_it++)
826 { 771 {
827 auto it = delayedmap_it->second.begin(); << 772 std::map<Key, G4TrackList*>::iterator it = delayedmap_it->second.begin();
828 auto end = delayedmap_it->second.end(); << 773 std::map<Key, G4TrackList*>::iterator end = delayedmap_it->second.end();
829 774
830 for (; it != end; it++) 775 for (; it != end; it++)
831 { 776 {
832 if (it->second != nullptr) nTracks += it << 777 if (it->second) nTracks += it->second->size();
833 } 778 }
834 } 779 }
835 780
836 // G4cout << "nTracks = " << nTracks << G 781 // G4cout << "nTracks = " << nTracks << G4endl;
837 782
838 return nTracks; 783 return nTracks;
839 } 784 }
840 785
841 void G4ITTrackHolder::MoveMainToWaitingList() 786 void G4ITTrackHolder::MoveMainToWaitingList()
842 { 787 {
843 auto it = fLists.begin(); << 788 MapOfPriorityLists::iterator it = fLists.begin();
844 auto end = fLists.end(); << 789 MapOfPriorityLists::iterator end = fLists.end();
845 for (; it != end; it++) 790 for (; it != end; it++)
846 { 791 {
847 if (PriorityList* lists = it->second) 792 if (PriorityList* lists = it->second)
848 { 793 {
849 lists->SetWaitingList(lists->GetMainList 794 lists->SetWaitingList(lists->GetMainList());
850 //TODO 795 //TODO
851 } 796 }
852 } 797 }
853 fAllMainList.RemoveLists(); 798 fAllMainList.RemoveLists();
854 } 799 }
855 800
856 bool G4ITTrackHolder::DelayListsNOTEmpty() 801 bool G4ITTrackHolder::DelayListsNOTEmpty()
857 { 802 {
858 auto __it = fDelayedList.begin(); << 803 MapOfDelayedLists::iterator __it = fDelayedList.begin();
859 auto __end = fDelayedList.end(); << 804 MapOfDelayedLists::iterator __end = fDelayedList.end();
860 for (; __it != __end; __it++) 805 for (; __it != __end; __it++)
861 { 806 {
862 std::map<Key, G4TrackList*>& mapOfLists = 807 std::map<Key, G4TrackList*>& mapOfLists = __it->second;
863 if (!mapOfLists.empty()) << 808 if (mapOfLists.empty() == false)
864 { 809 {
865 auto it = mapOfLists.begin(); << 810 std::map<Key, G4TrackList*>::iterator it = mapOfLists.begin();
866 auto end = mapOfLists.end(); << 811 std::map<Key, G4TrackList*>::iterator end = mapOfLists.end();
867 for (; it != end; it++) 812 for (; it != end; it++)
868 { 813 {
869 if (G4TrackList* mainList = it->second 814 if (G4TrackList* mainList = it->second)
870 { 815 {
871 if (!(mainList->empty())) return tru 816 if (!(mainList->empty())) return true;
872 } 817 }
873 } 818 }
874 } 819 }
875 } 820 }
876 return false; 821 return false;
877 } 822 }
878 823
879 bool G4ITTrackHolder::CheckMapIsNOTEmpty(MapOf 824 bool G4ITTrackHolder::CheckMapIsNOTEmpty(MapOfPriorityLists& mapOfLists,
880 Prior 825 PriorityList::Type type)
881 { 826 {
882 auto it = mapOfLists.begin(); << 827 MapOfPriorityLists::iterator it = mapOfLists.begin();
883 auto end = mapOfLists.end(); << 828 MapOfPriorityLists::iterator end = mapOfLists.end();
884 for (; it != end; it++) 829 for (; it != end; it++)
885 { 830 {
886 if (PriorityList* lists = it->second) 831 if (PriorityList* lists = it->second)
887 { 832 {
888 if (G4TrackList* trackList = lists->Get( 833 if (G4TrackList* trackList = lists->Get(type))
889 { 834 {
890 if (!(trackList->empty())) return true 835 if (!(trackList->empty())) return true;
891 } 836 }
892 } 837 }
893 } 838 }
894 return false; 839 return false;
895 } 840 }
896 841