ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ITTransportationManager.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4ITTransportationManager.cc
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 //
30 //
31 // History:
32 // -----------
33 //
34 // -------------------------------------------------------------------
35 
38 #include "G4ITNavigator.hh"
39 #include "G4ITSafetyHelper.hh"
40 #include "G4PVPlacement.hh"
41 
44 
46 {
47  Initialize();
48 }
49 
51 {
53  if (fpSafetyHelper) delete fpSafetyHelper;
54 }
55 
57 {
58  if (fpInstance)
59  {
60  delete fpInstance;
61  fpInstance = 0;
62  }
63 }
64 
65 // ----------------------------------------------------------------------------
66 // ClearNavigators()
67 //
68 // Clear collection of navigators and delete allocated objects.
69 // Called only by the class destructor.
70 //
72 {
73  std::vector<G4ITNavigator*>::iterator pNav;
74  for (pNav = fNavigators.begin(); pNav != fNavigators.end(); pNav++)
75  {
76  delete *pNav;
77  }
78  fNavigators.clear();
79  fActiveNavigators.clear();
80  fWorlds.clear();
81 }
82 
84 {
85  // Create the navigator for tracking and activate it; add to collections
86  //
87  G4ITNavigator* trackingNavigator = new G4ITNavigator();
88  trackingNavigator->Activate(true);
89  G4Navigator* navForTracking =
92  G4VPhysicalVolume* world = navForTracking->GetWorldVolume();
93  trackingNavigator->SetWorldVolume(world);
94  fNavigators.push_back(trackingNavigator);
95  fActiveNavigators.push_back(trackingNavigator);
96  //fWorlds.push_back(world); // NULL registered
97 
99  ->GetNoWorlds();
100  std::vector<G4VPhysicalVolume*>::iterator it =
102 
103  for (size_t i = 0; i < n_worlds; i++, it++)
104  {
105  fWorlds.push_back(*it);
106  }
108 }
109 
111 {
113  return fpInstance;
114 }
115 
116 // ----------------------------------------------------------------------------
117 // GetParallelWorld()
118 //
119 // Provided the name of a world volume, returns the associated world pointer.
120 // If not existing, create (allocate) and register it in the collection.
121 //
124 {
125  G4VPhysicalVolume* wPV = IsWorldExisting(worldName);
126  if (!wPV)
127  {
128  wPV = GetNavigatorForTracking()->GetWorldVolume();
129  G4LogicalVolume* wLV = wPV->GetLogicalVolume();
130  wLV = new G4LogicalVolume(wLV->GetSolid(), 0, worldName);
131  wPV = new G4PVPlacement(wPV->GetRotation(), wPV->GetTranslation(), wLV,
132  worldName, 0, false, 0);
133  RegisterWorld(wPV);
134  }
135  return wPV;
136 }
137 
138 // ----------------------------------------------------------------------------
139 // GetNavigator()
140 //
141 // Provided the name of a world volume, returns the associated navigator.
142 // If not existing, create it and register it in the collection, throw an
143 // exception if the associated parallel world does not exist.
144 //
145 G4ITNavigator* G4ITTransportationManager::GetNavigator(const G4String& worldName)
146 {
147  // If already existing, return the stored pointer to the navigator
148  //
149  std::vector<G4ITNavigator*>::iterator pNav;
150  for (pNav = fNavigators.begin(); pNav != fNavigators.end(); pNav++)
151  {
152  if ((*pNav)->GetWorldVolume()->GetName() == worldName)
153  {
154  return *pNav;
155  }
156  }
157 
158  // Check if world of that name already exists,
159  // create a navigator and register it
160  //
161  G4ITNavigator* aNavigator = 0;
162  G4VPhysicalVolume* aWorld = IsWorldExisting(worldName);
163  if (aWorld)
164  {
165  aNavigator = new G4ITNavigator();
166  aNavigator->SetWorldVolume(aWorld);
167  fNavigators.push_back(aNavigator);
168  }
169  else
170  {
171  G4String message = "World volume with name -"
172  + worldName
173  + "- does not exist. Create it first by GetParallelWorld() method!";
174  G4Exception("G4ITTransportationManager::GetNavigator(name)", "GeomNav0002",
175  FatalException, message);
176  }
177 
178  return aNavigator;
179 }
180 
181 // ----------------------------------------------------------------------------
182 // GetNavigator()
183 //
184 // Provided a pointer to a world volume, returns the associated navigator.
185 // Create it in case not existing and add it to the collection.
186 // If world volume not existing, issue an exception.
187 //
189 {
190  std::vector<G4ITNavigator*>::iterator pNav;
191  for (pNav = fNavigators.begin(); pNav != fNavigators.end(); pNav++)
192  {
193  if ((*pNav)->GetWorldVolume() == aWorld)
194  {
195  return *pNav;
196  }
197  }
198  G4ITNavigator* aNavigator = 0;
199  std::vector<G4VPhysicalVolume*>::iterator pWorld = std::find(fWorlds.begin(),
200  fWorlds.end(),
201  aWorld);
202  if (pWorld != fWorlds.end())
203  {
204  aNavigator = new G4ITNavigator();
205  aNavigator->SetWorldVolume(aWorld);
206  fNavigators.push_back(aNavigator);
207  }
208  else
209  {
210  G4String message = "World volume with name -"
211  + aWorld->GetName()
212  + "- does not exist. Create it first by GetParallelWorld() method!";
213  G4Exception("G4ITTransportationManager::GetNavigator(pointer)",
214  "GeomNav0002", FatalException, message);
215  }
216 
217  return aNavigator;
218 }
219 
220 // ----------------------------------------------------------------------------
221 // DeRegisterNavigator()
222 //
223 // Provided a pointer to an already allocated navigator object, removes the
224 // associated entry in the navigators collection (remove pair) but does not
225 // delete the actual pointed object, which is still owned by the caller.
226 // The navigator for tracking -cannot- be deregistered.
227 //
228 void G4ITTransportationManager::DeRegisterNavigator(G4ITNavigator* aNavigator)
229 {
230  if (aNavigator == fNavigators[0])
231  {
232  G4Exception("G4ITTransportationManager::DeRegisterNavigator()",
233  "GeomNav0003", FatalException,
234  "The navigator for tracking CANNOT be deregistered!");
235  }
236  std::vector<G4ITNavigator*>::iterator pNav = std::find(fNavigators.begin(),
237  fNavigators.end(),
238  aNavigator);
239  if (pNav != fNavigators.end())
240  {
241  // Deregister associated world volume
242  //
243  DeRegisterWorld((*pNav)->GetWorldVolume());
244 
245  // Deregister the navigator
246  //
247  fNavigators.erase(pNav);
248  }
249  else
250  {
251  G4String message = "Navigator for volume -"
252  + aNavigator->GetWorldVolume()->GetName() + "- not found in memory!";
253  G4Exception("G4ITTransportationManager::DeRegisterNavigator()",
254  "GeomNav1002", JustWarning, message);
255  }
256 }
257 
258 // ----------------------------------------------------------------------------
259 // ActivateNavigator()
260 //
261 // Provided a pointer to an already allocated navigator object, set to 'true'
262 // the associated activation flag for the navigator in the collection.
263 // If the provided navigator is not already registered, issue a warning
264 // Return the index of the activated navigator. This index should be used for
265 // ComputeStep() method of G4PathFinder.
266 //
268 {
269  std::vector<G4ITNavigator*>::iterator pNav = std::find(fNavigators.begin(),
270  fNavigators.end(),
271  aNavigator);
272  if (pNav == fNavigators.end())
273  {
274  G4String message = "Navigator for volume -"
275  + aNavigator->GetWorldVolume()->GetName() + "- not found in memory!";
276  G4Exception("G4ITTransportationManager::ActivateNavigator()", "GeomNav1002",
277  JustWarning, message);
278  return -1;
279  }
280 
281  aNavigator->Activate(true);
282  G4int id = 0;
283  std::vector<G4ITNavigator*>::iterator pActiveNav;
284  for (pActiveNav = fActiveNavigators.begin();
285  pActiveNav != fActiveNavigators.end(); pActiveNav++)
286  {
287  if (*pActiveNav == aNavigator)
288  {
289  return id;
290  }
291  id++;
292  }
293 
294  fActiveNavigators.push_back(aNavigator);
295  return id;
296 }
297 
298 // ----------------------------------------------------------------------------
299 // DeActivateNavigator()
300 //
301 // Provided a pointer to an already allocated navigator object, set to 'false'
302 // the associated activation flag in the navigators collection.
303 // If the provided navigator is not already registered, issue a warning.
304 //
305 void G4ITTransportationManager::DeActivateNavigator(G4ITNavigator* aNavigator)
306 {
307  std::vector<G4ITNavigator*>::iterator pNav = std::find(fNavigators.begin(),
308  fNavigators.end(),
309  aNavigator);
310  if (pNav != fNavigators.end())
311  {
312  (*pNav)->Activate(false);
313  }
314  else
315  {
316  G4String message = "Navigator for volume -"
317  + aNavigator->GetWorldVolume()->GetName() + "- not found in memory!";
318  G4Exception("G4ITTransportationManager::DeActivateNavigator()",
319  "GeomNav1002", JustWarning, message);
320  }
321 
322  std::vector<G4ITNavigator*>::iterator pActiveNav = std::find(
323  fActiveNavigators.begin(), fActiveNavigators.end(), aNavigator);
324  if (pActiveNav != fActiveNavigators.end())
325  {
326  fActiveNavigators.erase(pActiveNav);
327  }
328 }
329 
330 // ----------------------------------------------------------------------------
331 // InactivateAll()
332 //
333 // Inactivate all the navigators except for the tracking one, and clear the
334 // store of active navigators.
335 //
337 {
338  std::vector<G4ITNavigator*>::iterator pNav;
339  for (pNav = fActiveNavigators.begin(); pNav != fActiveNavigators.end();
340  pNav++)
341  {
342  (*pNav)->Activate(false);
343  }
344  fActiveNavigators.clear();
345 
346  // Restore status for the navigator for tracking
347  //
348  fNavigators[0]->Activate(true);
349  fActiveNavigators.push_back(fNavigators[0]);
350 }
351 
352 // ----------------------------------------------------------------------------
353 // IsWorldExisting()
354 //
355 // Verify existance or not of an istance of the world volume with
356 // same name in the collection. Return the world pointer if existing.
357 //
360 {
361  std::vector<G4VPhysicalVolume*>::iterator pWorld = fWorlds.begin();
362  if (*pWorld == 0)
363  {
364  *pWorld = fNavigators[0]->GetWorldVolume();
365  }
366 
367  for (pWorld = fWorlds.begin(); pWorld != fWorlds.end(); pWorld++)
368  {
369  if ((*pWorld)->GetName() == name)
370  {
371  return *pWorld;
372  }
373  }
374  return 0;
375 }
376 
377 // ----------------------------------------------------------------------------
378 // RegisterWorld()
379 //
380 // Provided a pointer to an already allocated world object, check and add the
381 // associated entry in the worlds collection. Return 'true' if registration
382 // succeeds and the new entry is created.
383 //
385 {
386  G4bool done = false;
387 
388  std::vector<G4VPhysicalVolume*>::iterator pWorld = std::find(fWorlds.begin(),
389  fWorlds.end(),
390  aWorld);
391  if (pWorld == fWorlds.end())
392  {
393  fWorlds.push_back(aWorld);
394  done = true;
395  }
396  return done;
397 }
398 
399 // ----------------------------------------------------------------------------
400 // DeRegisterWorld()
401 //
402 // Provided a pointer to an already allocated world object, removes the
403 // associated entry in the worlds collection but does not delete the actual
404 // pointed object, which is still owned by the caller.
405 //
407 {
408  std::vector<G4VPhysicalVolume*>::iterator pWorld = std::find(fWorlds.begin(),
409  fWorlds.end(),
410  aWorld);
411  if (pWorld != fWorlds.end())
412  {
413  fWorlds.erase(pWorld);
414  }
415  else
416  {
417  G4String message = "World volume -" + aWorld->GetName()
418  + "- not found in memory!";
419  G4Exception("G4ITTransportationManager::DeRegisterWorld()", "GeomNav1002",
420  JustWarning, message);
421  }
422 }