Geant4  10.02
G4LogicalVolume.icc
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 // $Id: G4LogicalVolume.icc 91010 2015-06-15 09:55:26Z gcosmo $
28 //
29 //
30 // class G4LogicalVolume Inline Implementation file
31 //
32 // 15.01.13 - G.Cosmo, A.Dotti: Modified for thread-safety for MT
33 // 10.20.97 - P. MoraDeFreitas : Added SetFastSimulation method
34 // 05.11.98 - M. Verderi: Add Get/Set methods for fBiasWeight
35 // 09.11.98 - J. Apostolakis: Changed MagneticField to FieldManager
36 // 12.02.99 - S.Giani: Added set/get methods for voxelization quality
37 // 18.04.01 - G.Cosmo: Migrated to STL vector
38 // 17.05.02 - G.Cosmo: Added IsToOptimise() method
39 // --------------------------------------------------------------------
40 
41 
42 // These macros change the references to fields that are now encapsulated
43 // in the class G4LVData.
44 //
45 #define G4MT_solid ((subInstanceManager.offset[instanceID]).fSolid)
46 #define G4MT_sdetector ((subInstanceManager.offset[instanceID]).fSensitiveDetector)
47 #define G4MT_fmanager ((subInstanceManager.offset[instanceID]).fFieldManager)
48 #define G4MT_material ((subInstanceManager.offset[instanceID]).fMaterial)
49 #define G4MT_mass ((subInstanceManager.offset[instanceID]).fMass)
50 #define G4MT_ccouple ((subInstanceManager.offset[instanceID]).fCutsCouple)
51 #define G4MT_instance (subInstanceManager.offset[instanceID])
52 
53 #include "G4Threading.hh"
54 // ********************************************************************
55 // GetName
56 // ********************************************************************
57 //
58 inline
59 const G4String& G4LogicalVolume::GetName() const
60 {
61  return fName;
62 }
63 
64 // ********************************************************************
65 // SetName
66 // ********************************************************************
67 //
68 inline
69 void G4LogicalVolume::SetName(const G4String& pName)
70 {
71  fName = pName;
72 }
73 
74 // ********************************************************************
75 // GetInstanceID
76 // ********************************************************************
77 //
78 inline
79 G4int G4LogicalVolume::GetInstanceID() const
80 {
81  return instanceID;
82 }
83 
84 // ********************************************************************
85 // GetFieldManager
86 // ********************************************************************
87 //
88 inline
89 G4FieldManager* G4LogicalVolume::GetFieldManager() const
90 {
91  return G4MT_fmanager;
92 }
93 
94 inline void G4LogicalVolume::AssignFieldManager( G4FieldManager *fldMgr)
95 {
96  G4MT_fmanager= fldMgr;
97  if(G4Threading::IsMasterThread()) fFieldManager = fldMgr;
98 }
99 
100 
101 // ********************************************************************
102 // GetMasterFieldManager
103 // ********************************************************************
104 //
105 inline
106 G4FieldManager* G4LogicalVolume::GetMasterFieldManager() const
107 {
108  return fFieldManager;
109 }
110 
111 // ********************************************************************
112 // GetNoDaughters
113 // ********************************************************************
114 //
115 inline
116 G4int G4LogicalVolume::GetNoDaughters() const
117 {
118  return fDaughters.size();
119 }
120 
121 // ********************************************************************
122 // GetDaughter
123 // ********************************************************************
124 //
125 inline
126 G4VPhysicalVolume* G4LogicalVolume::GetDaughter(const G4int i) const
127 {
128  return fDaughters[i];
129 }
130 
131 // ********************************************************************
132 // GetFastSimulationManager
133 // ********************************************************************
134 //
135 inline
136 G4FastSimulationManager* G4LogicalVolume::GetFastSimulationManager () const
137 {
138  G4FastSimulationManager* fFSM = 0;
139  if(fRegion) fFSM = fRegion->GetFastSimulationManager();
140  return fFSM;
141 }
142 
143 // ********************************************************************
144 // AddDaughter
145 // ********************************************************************
146 //
147 inline
148 void G4LogicalVolume::AddDaughter(G4VPhysicalVolume* pNewDaughter)
149 {
150  if( !fDaughters.empty() && fDaughters[0]->IsReplicated() )
151  {
152  std::ostringstream message;
153  message << "ERROR - Attempt to place a volume in a mother volume" << G4endl
154  << " already containing a replicated volume." << G4endl
155  << " A volume can either contain several placements" << G4endl
156  << " or a unique replica or parameterised volume !" << G4endl
157  << " Mother logical volume: " << GetName() << G4endl
158  << " Placing volume: " << pNewDaughter->GetName() << G4endl;
159  G4Exception("G4LogicalVolume::AddDaughter()", "GeomMgt0002",
160  FatalException, message,
161  "Replica or parameterised volume must be the only daughter !");
162  }
163 
164  // Invalidate previous calculation of mass - if any - for all threads
165  G4MT_mass = 0.;
166  // SignalVolumeChange(); // fVolumeChanged= true;
167  fDaughters.push_back(pNewDaughter);
168 
169  G4LogicalVolume* pDaughterLogical = pNewDaughter->GetLogicalVolume();
170 
171  // Propagate the Field Manager, if the daughter has no field Manager.
172  //
173  G4FieldManager* pDaughterFieldManager = pDaughterLogical->GetFieldManager();
174 
175  if( pDaughterFieldManager == 0 )
176  {
177  pDaughterLogical->SetFieldManager(G4MT_fmanager, false);
178  }
179  if (fRegion)
180  {
181  PropagateRegion();
182  fRegion->RegionModified(true);
183  }
184 }
185 
186 // ********************************************************************
187 // IsDaughter
188 // ********************************************************************
189 //
190 inline
191 G4bool G4LogicalVolume::IsDaughter(const G4VPhysicalVolume* p) const
192 {
193  G4PhysicalVolumeList::const_iterator i;
194  for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i )
195  {
196  if (**i==*p) return true;
197  }
198  return false;
199 }
200 
201 // ********************************************************************
202 // RemoveDaughter
203 // ********************************************************************
204 //
205 inline
206 void G4LogicalVolume::RemoveDaughter(const G4VPhysicalVolume* p)
207 {
208  G4PhysicalVolumeList::iterator i;
209  for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i )
210  {
211  if (**i==*p)
212  {
213  fDaughters.erase(i);
214  break;
215  }
216  }
217  if (fRegion)
218  {
219  fRegion->RegionModified(true);
220  }
221  G4MT_mass = 0.;
222 }
223 
224 // ********************************************************************
225 // ClearDaughters
226 // ********************************************************************
227 //
228 inline
229 void G4LogicalVolume::ClearDaughters()
230 {
231  G4PhysicalVolumeList::iterator i;
232  for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i )
233  {
234  fDaughters.erase(i);
235  }
236  if (fRegion)
237  {
238  fRegion->RegionModified(true);
239  }
240  G4MT_mass = 0.;
241 }
242 
243 // ********************************************************************
244 // CharacteriseDaughters
245 // ********************************************************************
246 //
247 inline
248 EVolume G4LogicalVolume::CharacteriseDaughters() const
249 {
250  EVolume type;
251  G4VPhysicalVolume *pVol;
252 
253  if ( GetNoDaughters()==1 )
254  {
255  pVol = GetDaughter(0);
256  type = pVol->VolumeType();
257  }
258  else
259  {
260  type = kNormal;
261  }
262  return type;
263 }
264 
265 inline
266 void G4LogicalVolume::ResetMass()
267 {
268  G4MT_mass= 0.0;
269 }
270 
271 // ********************************************************************
272 // GetSolid
273 // ********************************************************************
274 //
275 inline
276 G4VSolid* G4LogicalVolume::GetSolid(G4LVData &instLVdata) // const
277 {
278  return instLVdata.fSolid;
279 }
280 
281 inline
282 G4VSolid* G4LogicalVolume::GetSolid() const
283 {
284  // return G4MT_solid;
285  // return ((subInstanceManager.offset[instanceID]).fSolid);
286  return this->GetSolid( subInstanceManager.offset[instanceID] );
287 }
288 
289 // ********************************************************************
290 // GetMasterSolid
291 // ********************************************************************
292 //
293 inline
294 G4VSolid* G4LogicalVolume::GetMasterSolid() const
295 {
296  return fSolid;
297 }
298 
299 // ********************************************************************
300 // SetSolid
301 // ********************************************************************
302 //
303 inline
304 void G4LogicalVolume::SetSolid(G4VSolid *pSolid)
305 {
306 
307  // ((subInstanceManager.offset[instanceID]).fSolid) = pSolid;
308  G4MT_solid=pSolid;
309  // G4MT_mass = 0.;
310  this->ResetMass();
311 }
312 
313 inline
314 void G4LogicalVolume::SetSolid(G4LVData &instLVdata, G4VSolid *pSolid)
315 {
316  instLVdata.fSolid = pSolid;
317  // G4MT_solid=pSolid;
318  instLVdata.fMass= 0;
319  // A fast way to reset the mass ... ie G4MT_mass = 0.;
320 }
321 
322 // ********************************************************************
323 // GetMaterial
324 // ********************************************************************
325 //
326 inline
327 G4Material* G4LogicalVolume::GetMaterial() const
328 {
329  return G4MT_material;
330 }
331 
332 // ********************************************************************
333 // SetMaterial
334 // ********************************************************************
335 //
336 inline
337 void G4LogicalVolume::SetMaterial(G4Material *pMaterial)
338 {
339  G4MT_material=pMaterial;
340  G4MT_mass = 0.;
341 }
342 
343 // ********************************************************************
344 // UpdateMaterial
345 // ********************************************************************
346 //
347 inline
348 void G4LogicalVolume::UpdateMaterial(G4Material *pMaterial)
349 {
350  G4MT_material=pMaterial;
351  if(fRegion) { G4MT_ccouple = fRegion->FindCouple(pMaterial); }
352  G4MT_mass = 0.;
353 }
354 
355 // ********************************************************************
356 // GetSensitiveDetector
357 // ********************************************************************
358 //
359 inline
360 G4VSensitiveDetector* G4LogicalVolume::GetSensitiveDetector() const
361 {
362  return G4MT_sdetector;
363 }
364 
365 // ********************************************************************
366 // GetMasterSensitiveDetector
367 // ********************************************************************
368 //
369 inline
370 G4VSensitiveDetector* G4LogicalVolume::GetMasterSensitiveDetector() const
371 {
372  return fSensitiveDetector;
373 }
374 
375 // ********************************************************************
376 // SetSensitiveDetector
377 // ********************************************************************
378 //
379 inline
380 void G4LogicalVolume::SetSensitiveDetector(G4VSensitiveDetector* pSDetector)
381 {
382  G4MT_sdetector = pSDetector;
383  if(G4Threading::IsMasterThread()) fSensitiveDetector = pSDetector;
384 }
385 
386 // ********************************************************************
387 // GetUserLimits
388 // ********************************************************************
389 //
390 inline
391 G4UserLimits* G4LogicalVolume::GetUserLimits() const
392 {
393  if(fUserLimits) return fUserLimits;
394  if(fRegion) return fRegion->GetUserLimits();
395  return 0;
396 }
397 
398 // ********************************************************************
399 // SetUserLimits
400 // ********************************************************************
401 //
402 inline
403 void G4LogicalVolume::SetUserLimits(G4UserLimits* pULimits)
404 {
405  fUserLimits = pULimits;
406 }
407 
408 // ********************************************************************
409 // GetVoxelHeader
410 // ********************************************************************
411 //
412 inline
413 G4SmartVoxelHeader* G4LogicalVolume::GetVoxelHeader() const
414 {
415  return fVoxel;
416 }
417 
418 // ********************************************************************
419 // SetVoxelHeader
420 // ********************************************************************
421 //
422 inline
423 void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader* pVoxel)
424 {
425  fVoxel = pVoxel;
426 }
427 
428 // ********************************************************************
429 // GetSmartless
430 // ********************************************************************
431 //
432 inline
433 G4double G4LogicalVolume::GetSmartless() const
434 {
435  return fSmartless;
436 }
437 
438 // ********************************************************************
439 // SetSmartless
440 // ********************************************************************
441 //
442 inline
443 void G4LogicalVolume::SetSmartless(G4double smt)
444 {
445  fSmartless = smt;
446 }
447 
448 // ********************************************************************
449 // IsToOptimise
450 // ********************************************************************
451 //
452 inline
453 G4bool G4LogicalVolume::IsToOptimise() const
454 {
455  return fOptimise;
456 }
457 
458 // ********************************************************************
459 // SetOptimisation
460 // ********************************************************************
461 //
462 inline
463 void G4LogicalVolume::SetOptimisation(G4bool optim)
464 {
465  fOptimise = optim;
466 }
467 
468 // ********************************************************************
469 // IsRootRegion
470 // ********************************************************************
471 //
472 inline
473 G4bool G4LogicalVolume::IsRootRegion() const
474 {
475  return fRootRegion;
476 }
477 
478 // ********************************************************************
479 // SetRegionRootFlag
480 // ********************************************************************
481 //
482 inline
483 void G4LogicalVolume::SetRegionRootFlag(G4bool rreg)
484 {
485  fRootRegion = rreg;
486 }
487 
488 // ********************************************************************
489 // IsRegion
490 // ********************************************************************
491 //
492 inline
493 G4bool G4LogicalVolume::IsRegion() const
494 {
495  G4bool reg = false;
496  if (fRegion) reg = true;
497  return reg;
498 }
499 
500 // ********************************************************************
501 // SetRegion
502 // ********************************************************************
503 //
504 inline
505 void G4LogicalVolume::SetRegion(G4Region* reg)
506 {
507  fRegion = reg;
508 }
509 
510 // ********************************************************************
511 // GetRegion
512 // ********************************************************************
513 //
514 inline
515 G4Region* G4LogicalVolume::GetRegion() const
516 {
517  return fRegion;
518 }
519 
520 // ********************************************************************
521 // PropagateRegion
522 // ********************************************************************
523 //
524 inline
525 void G4LogicalVolume::PropagateRegion()
526 {
527  fRegion->ScanVolumeTree(this, true);
528 }
529 
530 // ********************************************************************
531 // GetMaterialCutsCouple
532 // ********************************************************************
533 //
534 inline
535 const G4MaterialCutsCouple* G4LogicalVolume::GetMaterialCutsCouple() const
536 {
537  return G4MT_ccouple;
538 }
539 
540 // ********************************************************************
541 // SetMaterialCutsCouple
542 // ********************************************************************
543 //
544 inline
545 void G4LogicalVolume::SetMaterialCutsCouple(G4MaterialCutsCouple* cuts)
546 {
547  G4MT_ccouple = cuts;
548 }
549 
550 // ********************************************************************
551 // Lock
552 // ********************************************************************
553 //
554 inline
555 void G4LogicalVolume::Lock()
556 {
557  fLock = true;
558 }
559 
560 // ********************************************************************
561 // Operator ==
562 // ********************************************************************
563 //
564 inline
565 G4bool G4LogicalVolume::operator == ( const G4LogicalVolume& lv) const
566 {
567  return (this==&lv) ? true : false;
568 }
569 
570 // ********************************************************************
571 // GetVisAttributes
572 // ********************************************************************
573 //
574 inline
575 const G4VisAttributes* G4LogicalVolume::GetVisAttributes () const
576 {
577  return fVisAttributes;
578 }
579 
580 // ********************************************************************
581 // SetVisAttributes
582 // ********************************************************************
583 //
584 inline
585 void G4LogicalVolume::SetVisAttributes (const G4VisAttributes* pVA)
586 {
587  fVisAttributes = pVA;
588 }
589 
590 // ********************************************************************
591 // SetBiasWeight
592 // ********************************************************************
593 //
594 inline
595 void G4LogicalVolume::SetBiasWeight(G4double weight)
596 {
597  fBiasWeight = weight;
598 }
599 
600 // ********************************************************************
601 // GetBiasWeight
602 // ********************************************************************
603 //
604 inline
605 G4double G4LogicalVolume::GetBiasWeight() const
606 {
607  return fBiasWeight;
608 }
609 #undef G4MT_solid
610 #undef G4MT_sdetector
611 #undef G4MT_fmanager
612 #undef G4MT_material
613 // #undef G4MT_mass
614 // #undef G4MT_ccouple
615 #undef G4MT_instance