Geant4  10.00.p02
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 78050 2013-12-03 08:17:33Z 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 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::IsWorkerThread()) 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  // Do not fChangedState= 1;
270 }
271 
272 // ********************************************************************
273 // GetSolid
274 // ********************************************************************
275 //
276 inline
277 G4VSolid* G4LogicalVolume::GetSolid(G4LVData &instLVdata) // const
278 {
279  return instLVdata.fSolid;
280 }
281 
282 inline
283 G4VSolid* G4LogicalVolume::GetSolid() const
284 {
285  // return G4MT_solid;
286  // return ((subInstanceManager.offset[instanceID]).fSolid);
287  return this->GetSolid( subInstanceManager.offset[instanceID] );
288 }
289 
290 // ********************************************************************
291 // GetMasterSolid
292 // ********************************************************************
293 //
294 inline
295 G4VSolid* G4LogicalVolume::GetMasterSolid() const
296 {
297  return fSolid;
298 }
299 
300 // ********************************************************************
301 // SetSolid
302 // ********************************************************************
303 //
304 inline
305 void G4LogicalVolume::SetSolid(G4VSolid *pSolid)
306 {
307 
308  // ((subInstanceManager.offset[instanceID]).fSolid) = pSolid;
309  G4MT_solid=pSolid;
310  // G4MT_mass = 0.;
311  this->ResetMass();
312 }
313 
314 inline
315 void G4LogicalVolume::SetSolid(G4LVData &instLVdata, G4VSolid *pSolid)
316 {
317  instLVdata.fSolid = pSolid;
318  // G4MT_solid=pSolid;
319  instLVdata.fMass= 0;
320  // A fast way to reset the mass ... ie G4MT_mass = 0.;
321 }
322 
323 // ********************************************************************
324 // GetMaterial
325 // ********************************************************************
326 //
327 inline
328 G4Material* G4LogicalVolume::GetMaterial() const
329 {
330  return G4MT_material;
331 }
332 
333 // ********************************************************************
334 // SetMaterial
335 // ********************************************************************
336 //
337 inline
338 void G4LogicalVolume::SetMaterial(G4Material *pMaterial)
339 {
340  G4MT_material=pMaterial;
341  G4MT_mass = 0.;
342 }
343 
344 // ********************************************************************
345 // UpdateMaterial
346 // ********************************************************************
347 //
348 inline
349 void G4LogicalVolume::UpdateMaterial(G4Material *pMaterial)
350 {
351  G4MT_material=pMaterial;
352  if(fRegion) { G4MT_ccouple = fRegion->FindCouple(pMaterial); }
353  G4MT_mass = 0.;
354 }
355 
356 // ********************************************************************
357 // GetSensitiveDetector
358 // ********************************************************************
359 //
360 inline
361 G4VSensitiveDetector* G4LogicalVolume::GetSensitiveDetector() const
362 {
363  return G4MT_sdetector;
364 }
365 
366 // ********************************************************************
367 // GetMasterSensitiveDetector
368 // ********************************************************************
369 //
370 inline
371 G4VSensitiveDetector* G4LogicalVolume::GetMasterSensitiveDetector() const
372 {
373  return fSensitiveDetector;
374 }
375 
376 // ********************************************************************
377 // SetSensitiveDetector
378 // ********************************************************************
379 //
380 inline
381 void G4LogicalVolume::SetSensitiveDetector(G4VSensitiveDetector* pSDetector)
382 {
383  G4MT_sdetector = pSDetector;
384  if(!G4Threading::IsWorkerThread()) fSensitiveDetector = pSDetector;
385 }
386 
387 // ********************************************************************
388 // GetUserLimits
389 // ********************************************************************
390 //
391 inline
392 G4UserLimits* G4LogicalVolume::GetUserLimits() const
393 {
394  if(fUserLimits) return fUserLimits;
395  if(fRegion) return fRegion->GetUserLimits();
396  return 0;
397 }
398 
399 // ********************************************************************
400 // SetUserLimits
401 // ********************************************************************
402 //
403 inline
404 void G4LogicalVolume::SetUserLimits(G4UserLimits* pULimits)
405 {
406  fUserLimits = pULimits;
407 }
408 
409 // ********************************************************************
410 // GetVoxelHeader
411 // ********************************************************************
412 //
413 inline
414 G4SmartVoxelHeader* G4LogicalVolume::GetVoxelHeader() const
415 {
416  return fVoxel;
417 }
418 
419 // ********************************************************************
420 // SetVoxelHeader
421 // ********************************************************************
422 //
423 inline
424 void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader* pVoxel)
425 {
426  fVoxel = pVoxel;
427 }
428 
429 // ********************************************************************
430 // GetSmartless
431 // ********************************************************************
432 //
433 inline
434 G4double G4LogicalVolume::GetSmartless() const
435 {
436  return fSmartless;
437 }
438 
439 // ********************************************************************
440 // SetSmartless
441 // ********************************************************************
442 //
443 inline
444 void G4LogicalVolume::SetSmartless(G4double smt)
445 {
446  fSmartless = smt;
447 }
448 
449 // ********************************************************************
450 // IsToOptimise
451 // ********************************************************************
452 //
453 inline
454 G4bool G4LogicalVolume::IsToOptimise() const
455 {
456  return fOptimise;
457 }
458 
459 // ********************************************************************
460 // SetOptimisation
461 // ********************************************************************
462 //
463 inline
464 void G4LogicalVolume::SetOptimisation(G4bool optim)
465 {
466  fOptimise = optim;
467 }
468 
469 // ********************************************************************
470 // IsRootRegion
471 // ********************************************************************
472 //
473 inline
474 G4bool G4LogicalVolume::IsRootRegion() const
475 {
476  return fRootRegion;
477 }
478 
479 // ********************************************************************
480 // SetRegionRootFlag
481 // ********************************************************************
482 //
483 inline
484 void G4LogicalVolume::SetRegionRootFlag(G4bool rreg)
485 {
486  fRootRegion = rreg;
487 }
488 
489 // ********************************************************************
490 // IsRegion
491 // ********************************************************************
492 //
493 inline
494 G4bool G4LogicalVolume::IsRegion() const
495 {
496  G4bool reg = false;
497  if (fRegion) reg = true;
498  return reg;
499 }
500 
501 // ********************************************************************
502 // SetRegion
503 // ********************************************************************
504 //
505 inline
506 void G4LogicalVolume::SetRegion(G4Region* reg)
507 {
508  fRegion = reg;
509 }
510 
511 // ********************************************************************
512 // GetRegion
513 // ********************************************************************
514 //
515 inline
516 G4Region* G4LogicalVolume::GetRegion() const
517 {
518  return fRegion;
519 }
520 
521 // ********************************************************************
522 // PropagateRegion
523 // ********************************************************************
524 //
525 inline
526 void G4LogicalVolume::PropagateRegion()
527 {
528  fRegion->ScanVolumeTree(this, true);
529 }
530 
531 // ********************************************************************
532 // GetMaterialCutsCouple
533 // ********************************************************************
534 //
535 inline
536 const G4MaterialCutsCouple* G4LogicalVolume::GetMaterialCutsCouple() const
537 {
538  return G4MT_ccouple;
539 }
540 
541 // ********************************************************************
542 // SetMaterialCutsCouple
543 // ********************************************************************
544 //
545 inline
546 void G4LogicalVolume::SetMaterialCutsCouple(G4MaterialCutsCouple* cuts)
547 {
548  G4MT_ccouple = cuts;
549 }
550 
551 // ********************************************************************
552 // Lock
553 // ********************************************************************
554 //
555 inline
556 void G4LogicalVolume::Lock()
557 {
558  fLock = true;
559 }
560 
561 // ********************************************************************
562 // Operator ==
563 // ********************************************************************
564 //
565 inline
566 G4bool G4LogicalVolume::operator == ( const G4LogicalVolume& lv) const
567 {
568  return (this==&lv) ? true : false;
569 }
570 
571 // ********************************************************************
572 // GetVisAttributes
573 // ********************************************************************
574 //
575 inline
576 const G4VisAttributes* G4LogicalVolume::GetVisAttributes () const
577 {
578  return fVisAttributes;
579 }
580 
581 // ********************************************************************
582 // SetVisAttributes
583 // ********************************************************************
584 //
585 inline
586 void G4LogicalVolume::SetVisAttributes (const G4VisAttributes* pVA)
587 {
588  fVisAttributes = pVA;
589 }
590 
591 // ********************************************************************
592 // SetBiasWeight
593 // ********************************************************************
594 //
595 inline
596 void G4LogicalVolume::SetBiasWeight(G4double weight)
597 {
598  fBiasWeight = weight;
599 }
600 
601 // ********************************************************************
602 // GetBiasWeight
603 // ********************************************************************
604 //
605 inline
606 G4double G4LogicalVolume::GetBiasWeight() const
607 {
608  return fBiasWeight;
609 }
610 #undef G4MT_solid
611 #undef G4MT_sdetector
612 #undef G4MT_fmanager
613 #undef G4MT_material
614 // #undef G4MT_mass
615 // #undef G4MT_ccouple
616 #undef G4MT_instance