| 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 //
>> 26 //
>> 27 // $Id: G4LogicalVolume.cc 78050 2013-12-03 08:17:33Z gcosmo $
>> 28 //
25 // 29 //
26 // class G4LogicalVolume implementation << 30 // class G4LogicalVolume Implementation
27 // 31 //
>> 32 // History:
28 // 15.01.13 G.Cosmo, A.Dotti: Modified for thr 33 // 15.01.13 G.Cosmo, A.Dotti: Modified for thread-safety for MT
29 // 01.03.05 G.Santin: Added flag for optional 34 // 01.03.05 G.Santin: Added flag for optional propagation of GetMass()
30 // 17.05.02 G.Cosmo: Added flag for optional o 35 // 17.05.02 G.Cosmo: Added flag for optional optimisation
31 // 12.02.99 S.Giani: Default initialization of 36 // 12.02.99 S.Giani: Default initialization of voxelization quality
32 // 04.08.97 P.M.DeFreitas: Added methods for p 37 // 04.08.97 P.M.DeFreitas: Added methods for parameterised simulation
>> 38 // 19.08.96 P.Kent: Modified for G4VSensitive Detector
33 // 11.07.95 P.Kent: Initial version 39 // 11.07.95 P.Kent: Initial version
34 // ------------------------------------------- 40 // --------------------------------------------------------------------
35 41
36 #include "G4LogicalVolume.hh" 42 #include "G4LogicalVolume.hh"
>> 43 #ifdef NO_INLINE
>> 44 #define inline
>> 45 #include "G4LogicalVolume.icc"
>> 46 #undef inline
>> 47 #endif
>> 48
37 #include "G4LogicalVolumeStore.hh" 49 #include "G4LogicalVolumeStore.hh"
38 #include "G4VSolid.hh" 50 #include "G4VSolid.hh"
39 #include "G4Material.hh" 51 #include "G4Material.hh"
40 #include "G4VPVParameterisation.hh" 52 #include "G4VPVParameterisation.hh"
41 #include "G4VisAttributes.hh" 53 #include "G4VisAttributes.hh"
42 54
43 #include "G4UnitsTable.hh" 55 #include "G4UnitsTable.hh"
44 56
45 G4LVData::G4LVData() {;} << 57 // This static member is thread local. For each thread, it points to the
46 << 58 // array of G4LVData instances.
47 // This new field helps to use the class G4LVM <<
48 // <<
49 G4LVManager G4LogicalVolume::subInstanceManage <<
50 <<
51 // These macros change the references to field <<
52 // in the class G4LVData. <<
53 // 59 //
54 #define G4MT_solid ((subInstanceManager.of << 60 template <class G4LVData> G4ThreadLocal
55 #define G4MT_sdetector ((subInstanceManager.of << 61 G4LVData* G4GeomSplitter<G4LVData>::offset = 0;
56 #define G4MT_fmanager ((subInstanceManager.of <<
57 #define G4MT_material ((subInstanceManager.of <<
58 #define G4MT_mass ((subInstanceManager.of <<
59 #define G4MT_ccouple ((subInstanceManager.of <<
60 #define G4MT_instance (subInstanceManager.off <<
61 <<
62 // ******************************************* <<
63 // Constructor - sets member data and adds to <<
64 // voxel pointer for optimisatio <<
65 // Initialises daughter vector t <<
66 // ******************************************* <<
67 // <<
68 G4LogicalVolume::G4LogicalVolume( G4VSolid* pS <<
69 G4Material* <<
70 const G4String& na <<
71 G4FieldManag <<
72 G4VSensitive <<
73 G4UserLimits <<
74 G4bool optim <<
75 : fDaughters(0,(G4VPhysicalVolume*)nullptr), <<
76 fOptimise(optimise) <<
77 { <<
78 // Initialize 'Shadow'/master pointers - for <<
79 // <<
80 fSolid = pSolid; <<
81 fSensitiveDetector = pSDetector; <<
82 fFieldManager = pFieldMgr; <<
83 62
84 instanceID = subInstanceManager.CreateSubIns << 63 G4LVData::G4LVData()
85 AssignFieldManager(pFieldMgr); << 64 : fSolid(0),fSensitiveDetector(0),fFieldManager(0),
86 << 65 fMaterial(0),fMass(0.),fCutsCouple(0)
87 G4MT_mass = 0.; << 66 {;}
88 G4MT_ccouple = nullptr; <<
89 67
90 SetSolid(pSolid); << 68 // This new field helps to use the class G4LVManager
91 SetMaterial(pMaterial); <<
92 SetName(name); <<
93 SetSensitiveDetector(pSDetector); <<
94 SetUserLimits(pULimits); <<
95 <<
96 // Initialize 'Shadow' data structure - for <<
97 // <<
98 lvdata = new G4LVData(); <<
99 lvdata->fSolid = pSolid; <<
100 lvdata->fMaterial = pMaterial; <<
101 <<
102 // <<
103 // Add to store <<
104 // <<
105 G4LogicalVolumeStore::Register(this); <<
106 } <<
107 <<
108 // ******************************************* <<
109 // Fake default constructor - sets only member <<
110 // for usage restri <<
111 // ******************************************* <<
112 // <<
113 G4LogicalVolume::G4LogicalVolume( __void__& ) <<
114 : fDaughters(0,(G4VPhysicalVolume*)nullptr), <<
115 { <<
116 instanceID = subInstanceManager.CreateSubIns <<
117 <<
118 SetSensitiveDetector(nullptr); // G4MT_sd <<
119 SetFieldManager(nullptr, false); // G4MT_fm <<
120 <<
121 G4MT_mass = 0.; <<
122 G4MT_ccouple = nullptr; <<
123 <<
124 // Add to store <<
125 // <<
126 G4LogicalVolumeStore::Register(this); <<
127 } <<
128 <<
129 // ******************************************* <<
130 // Destructor - Removes itself from solid Stor <<
131 // NOTE: Not virtual <<
132 // ******************************************* <<
133 // <<
134 G4LogicalVolume::~G4LogicalVolume() <<
135 { <<
136 if (!fLock && fRootRegion) // De-register r <<
137 { // and flagged a <<
138 fRegion->RemoveRootLogicalVolume(this, tru <<
139 } <<
140 delete lvdata; <<
141 G4LogicalVolumeStore::DeRegister(this); <<
142 } <<
143 <<
144 // ******************************************* <<
145 // SetName - Set volume name and notify store <<
146 // ******************************************* <<
147 // 69 //
148 void G4LogicalVolume::SetName(const G4String& << 70 G4LVManager G4LogicalVolume::subInstanceManager;
149 { <<
150 fName = pName; <<
151 G4LogicalVolumeStore::GetInstance()->SetMapV <<
152 } <<
153 71
154 // ******************************************* 72 // ********************************************************************
155 // InitialiseWorker 73 // InitialiseWorker
156 // 74 //
157 // This method is similar to the constructor. 75 // This method is similar to the constructor. It is used by each worker
158 // thread to achieve the same effect as that o 76 // thread to achieve the same effect as that of the master thread exept
159 // to register the new created instance. This 77 // to register the new created instance. This method is invoked explicitly.
160 // It does not create a new G4LogicalVolume in 78 // It does not create a new G4LogicalVolume instance. It only assign the value
161 // for the fields encapsulated by the class G4 79 // for the fields encapsulated by the class G4LVData.
162 // ******************************************* 80 // ********************************************************************
163 // 81 //
164 void G4LogicalVolume:: 82 void G4LogicalVolume::
165 InitialiseWorker( G4LogicalVolume* /*pMasterOb 83 InitialiseWorker( G4LogicalVolume* /*pMasterObject*/,
166 G4VSolid* pSolid, 84 G4VSolid* pSolid,
167 G4VSensitiveDetector* pSDete 85 G4VSensitiveDetector* pSDetector)
168 { 86 {
169 subInstanceManager.SlaveCopySubInstanceArray 87 subInstanceManager.SlaveCopySubInstanceArray();
170 88
171 SetSolid(pSolid); 89 SetSolid(pSolid);
172 SetSensitiveDetector(pSDetector); // How th 90 SetSensitiveDetector(pSDetector); // How this object is available now ?
173 AssignFieldManager(fFieldManager); << 91 AssignFieldManager(fFieldManager); // Should be set - but a per-thread copy is not available yet
174 // Should be set - but a per-thread copy is << 92 // G4MT_fmanager= fFieldManager;
175 // Must not call SetFieldManager(), which p << 93 // Must not call SetFieldManager(fFieldManager, false); which propagates FieldMgr
176 94
177 #ifdef CLONE_FIELD_MGR 95 #ifdef CLONE_FIELD_MGR
178 // Create a field FieldManager by cloning 96 // Create a field FieldManager by cloning
179 // << 97 G4FieldManager workerFldMgr= fFieldManager->GetWorkerClone(G4bool* created);
180 G4FieldManager workerFldMgr = fFieldManager- << 98 if( created || (GetFieldManager()!=workerFldMgr) )
181 if( created || (GetFieldManager() != workerF <<
182 { 99 {
183 SetFieldManager(fFieldManager, false); // 100 SetFieldManager(fFieldManager, false); // which propagates FieldMgr
184 } << 101 }else{
185 else <<
186 { <<
187 // Field manager existed and is equal to c 102 // Field manager existed and is equal to current one
188 // <<
189 AssignFieldManager(workerFldMgr); 103 AssignFieldManager(workerFldMgr);
190 } 104 }
191 #endif 105 #endif
192 } 106 }
193 107
194 // ******************************************* 108 // ********************************************************************
195 // Clean <<
196 // ******************************************* <<
197 // <<
198 void G4LogicalVolume::Clean() <<
199 { <<
200 subInstanceManager.FreeSlave(); <<
201 } <<
202 <<
203 // ******************************************* <<
204 // TerminateWorker 109 // TerminateWorker
205 // 110 //
206 // This method is similar to the destructor. I 111 // This method is similar to the destructor. It is used by each worker
207 // thread to achieve the partial effect as tha 112 // thread to achieve the partial effect as that of the master thread.
208 // For G4LogicalVolume instances, nothing more 113 // For G4LogicalVolume instances, nothing more to do here.
209 // ******************************************* 114 // ********************************************************************
210 // 115 //
211 void G4LogicalVolume:: 116 void G4LogicalVolume::
212 TerminateWorker( G4LogicalVolume* /*pMasterObj 117 TerminateWorker( G4LogicalVolume* /*pMasterObject*/)
213 { 118 {
214 } 119 }
215 120
216 // ******************************************* 121 // ********************************************************************
217 // GetSubInstanceManager 122 // GetSubInstanceManager
218 // 123 //
219 // Returns the private data instance manager. 124 // Returns the private data instance manager.
220 // ******************************************* 125 // ********************************************************************
221 // 126 //
222 const G4LVManager& G4LogicalVolume::GetSubInst 127 const G4LVManager& G4LogicalVolume::GetSubInstanceManager()
223 { 128 {
224 return subInstanceManager; 129 return subInstanceManager;
225 } 130 }
226 131
227 // ******************************************* 132 // ********************************************************************
228 // GetFieldManager << 133 // Constructor - sets member data and adds to logical Store,
>> 134 // voxel pointer for optimisation set to 0 by default.
>> 135 // Initialises daughter vector to 0 length.
229 // ******************************************* 136 // ********************************************************************
230 // 137 //
231 G4FieldManager* G4LogicalVolume::GetFieldManag << 138 G4LogicalVolume::G4LogicalVolume( G4VSolid* pSolid,
>> 139 G4Material* pMaterial,
>> 140 const G4String& name,
>> 141 G4FieldManager* pFieldMgr,
>> 142 G4VSensitiveDetector* pSDetector,
>> 143 G4UserLimits* pULimits,
>> 144 G4bool optimise )
>> 145 : fDaughters(0,(G4VPhysicalVolume*)0),
>> 146 fVoxel(0), fOptimise(optimise), fRootRegion(false), fLock(false),
>> 147 fSmartless(2.), fVisAttributes(0), fRegion(0)
232 { 148 {
233 return G4MT_fmanager; << 149 // Initialize 'Shadow'/master pointers - for use in copying to workers
>> 150 fSolid = pSolid;
>> 151 fSensitiveDetector = pSDetector;
>> 152 fFieldManager = pFieldMgr;
>> 153
>> 154 instanceID = subInstanceManager.CreateSubInstance();
>> 155 AssignFieldManager(pFieldMgr); // G4MT_fmanager = pFieldMgr;
>> 156
>> 157 // fMasterFieldMgr= pFieldMgr;
>> 158 G4MT_mass = 0.;
>> 159 G4MT_ccouple = 0;
>> 160
>> 161 SetSolid(pSolid);
>> 162 SetMaterial(pMaterial);
>> 163 SetName(name);
>> 164 SetSensitiveDetector(pSDetector);
>> 165 SetUserLimits(pULimits);
>> 166 //
>> 167 // Add to store
>> 168 //
>> 169 G4LogicalVolumeStore::Register(this);
234 } 170 }
235 171
236 // ******************************************* 172 // ********************************************************************
237 // AssignFieldManager << 173 // Fake default constructor - sets only member data and allocates memory
>> 174 // for usage restricted to object persistency.
238 // ******************************************* 175 // ********************************************************************
239 // 176 //
240 void G4LogicalVolume::AssignFieldManager( G4Fi << 177 G4LogicalVolume::G4LogicalVolume( __void__& )
>> 178 : fDaughters(0,(G4VPhysicalVolume*)0),
>> 179 fName(""), fUserLimits(0),
>> 180 fVoxel(0), fOptimise(true), fRootRegion(false), fLock(false),
>> 181 fSmartless(2.), fVisAttributes(0), fRegion(0), fBiasWeight(0.),
>> 182 fSolid(0), fSensitiveDetector(0), fFieldManager(0)
241 { 183 {
242 G4MT_fmanager= fldMgr; << 184 instanceID = subInstanceManager.CreateSubInstance();
243 if(G4Threading::IsMasterThread()) { fFieldM << 185
>> 186 // G4MT_solid = 0,
>> 187 SetSolid(0);
>> 188 SetSensitiveDetector(0); // G4MT_sdetector = 0;
>> 189 SetFieldManager(0, false); // G4MT_fmanager = 0;
>> 190 SetMaterial(0); // G4MT_material = 0;
>> 191 // this->SetMass(0); //
>> 192 G4MT_mass = 0.;
>> 193 // this->SetCutsCouple(0);
>> 194 G4MT_ccouple = 0;
>> 195
>> 196 // Add to store
>> 197 //
>> 198 G4LogicalVolumeStore::Register(this);
244 } 199 }
245 200
246 // ******************************************* 201 // ********************************************************************
247 // IsExtended << 202 // Destructor - Removes itself from solid Store
>> 203 // NOTE: Not virtual
248 // ******************************************* 204 // ********************************************************************
249 // 205 //
250 G4bool G4LogicalVolume::IsExtended() const << 206 G4LogicalVolume::~G4LogicalVolume()
251 { 207 {
252 return false; << 208 if (!fLock && fRootRegion) // De-register root region first if not locked
>> 209 { // and flagged as root logical-volume
>> 210 fRegion->RemoveRootLogicalVolume(this, true);
>> 211 }
>> 212 G4LogicalVolumeStore::DeRegister(this);
253 } 213 }
254 214
255 // ******************************************* 215 // ********************************************************************
256 // SetFieldManager 216 // SetFieldManager
257 // ******************************************* 217 // ********************************************************************
258 // 218 //
259 void 219 void
260 G4LogicalVolume::SetFieldManager(G4FieldManage 220 G4LogicalVolume::SetFieldManager(G4FieldManager* pNewFieldMgr,
261 G4bool 221 G4bool forceAllDaughters)
262 { 222 {
>> 223 // G4MT_fmanager = pNewFieldMgr;
263 AssignFieldManager(pNewFieldMgr); 224 AssignFieldManager(pNewFieldMgr);
264 225
265 auto NoDaughters = GetNoDaughters(); << 226 G4int NoDaughters = GetNoDaughters();
266 while ( (NoDaughters--)>0 ) 227 while ( (NoDaughters--)>0 )
267 { 228 {
268 G4LogicalVolume* DaughterLogVol; 229 G4LogicalVolume* DaughterLogVol;
269 DaughterLogVol = GetDaughter(NoDaughters)- 230 DaughterLogVol = GetDaughter(NoDaughters)->GetLogicalVolume();
270 if ( forceAllDaughters || (DaughterLogVol- << 231 if ( forceAllDaughters || (DaughterLogVol->GetFieldManager() == 0) )
271 { 232 {
272 DaughterLogVol->SetFieldManager(pNewFiel 233 DaughterLogVol->SetFieldManager(pNewFieldMgr, forceAllDaughters);
273 } 234 }
274 } 235 }
275 } 236 }
276 237
277 // ******************************************* <<
278 // AddDaughter <<
279 // ******************************************* <<
280 // <<
281 void G4LogicalVolume::AddDaughter(G4VPhysicalV <<
282 { <<
283 EVolume daughterType = pNewDaughter->VolumeT <<
284 <<
285 // The type of the navigation needed is dete <<
286 // <<
287 if( fDaughters.empty() ) <<
288 { <<
289 fDaughtersVolumeType = daughterType; <<
290 } <<
291 else <<
292 { <<
293 // Check consistency of detector descripti <<
294 <<
295 // 1. A replica or parameterised volume ca <<
296 // <<
297 if( fDaughters[0]->IsReplicated() ) <<
298 { <<
299 std::ostringstream message; <<
300 message << "ERROR - Attempt to place a v <<
301 << G4endl <<
302 << " already containing a repli <<
303 << " A volume can either contai <<
304 << " or a unique replica or par <<
305 << " Mother logical volume: <<
306 << " Placing volume: " << pN <<
307 << G4endl; <<
308 G4Exception("G4LogicalVolume::AddDaughte <<
309 FatalException, message, <<
310 "Replica or parameterised vo <<
311 } <<
312 else <<
313 { <<
314 // 2. Ensure that Placement and External <<
315 // <<
316 if( daughterType != fDaughtersVolumeTyp <<
317 { <<
318 std::ostringstream message; <<
319 message << "ERROR - Attempt to place a <<
320 << G4endl <<
321 << " already containing a dif <<
322 << " A volume can either cont <<
323 << " - one or more placements <<
324 << " - one or more 'external' <<
325 << " Mother logical volume: <<
326 << " Volume being placed: " <<
327 << G4endl; <<
328 G4Exception("G4LogicalVolume::AddDaugh <<
329 FatalException, message, <<
330 "Cannot mix placements and <<
331 } <<
332 } <<
333 } <<
334 <<
335 // Invalidate previous calculation of mass - <<
336 // <<
337 G4MT_mass = 0.; <<
338 fDaughters.push_back(pNewDaughter); <<
339 <<
340 G4LogicalVolume* pDaughterLogical = pNewDaug <<
341 <<
342 // Propagate the Field Manager, if the daugh <<
343 // <<
344 G4FieldManager* pDaughterFieldManager = pDau <<
345 <<
346 // Avoid propagating the fieldManager pointe <<
347 // and daughter's one is null as well... <<
348 // <<
349 if( (G4MT_fmanager != nullptr ) && (pDaughte <<
350 { <<
351 pDaughterLogical->SetFieldManager(G4MT_fma <<
352 } <<
353 if (fRegion != nullptr) <<
354 { <<
355 PropagateRegion(); <<
356 fRegion->RegionModified(true); <<
357 } <<
358 } <<
359 <<
360 // ******************************************* <<
361 // RemoveDaughter <<
362 // ******************************************* <<
363 // <<
364 void G4LogicalVolume::RemoveDaughter(const G4V <<
365 { <<
366 for (auto i=fDaughters.cbegin(); i!=fDaughte <<
367 { <<
368 if (**i==*p) <<
369 { <<
370 fDaughters.erase(i); <<
371 break; <<
372 } <<
373 } <<
374 if (fRegion != nullptr) <<
375 { <<
376 fRegion->RegionModified(true); <<
377 } <<
378 G4MT_mass = 0.; <<
379 } <<
380 <<
381 // ******************************************* <<
382 // ClearDaughters <<
383 // ******************************************* <<
384 // <<
385 void G4LogicalVolume::ClearDaughters() <<
386 { <<
387 fDaughters.erase(fDaughters.cbegin(), fDaugh <<
388 if (fRegion != nullptr) <<
389 { <<
390 fRegion->RegionModified(true); <<
391 } <<
392 G4MT_mass = 0.; <<
393 } <<
394 <<
395 // ******************************************* <<
396 // ResetMass <<
397 // ******************************************* <<
398 // <<
399 void G4LogicalVolume::ResetMass() <<
400 { <<
401 G4MT_mass= 0.0; <<
402 } <<
403 <<
404 // ******************************************* <<
405 // GetSolid <<
406 // ******************************************* <<
407 // <<
408 G4VSolid* G4LogicalVolume::GetSolid(G4LVData & <<
409 { <<
410 return instLVdata.fSolid; <<
411 } <<
412 <<
413 G4VSolid* G4LogicalVolume::GetSolid() const <<
414 { <<
415 return this->GetSolid( subInstanceManager.of <<
416 } <<
417 <<
418 // ******************************************* <<
419 // SetSolid <<
420 // ******************************************* <<
421 // <<
422 void G4LogicalVolume::SetSolid(G4VSolid *pSoli <<
423 { <<
424 <<
425 G4MT_solid = pSolid; <<
426 this->ResetMass(); <<
427 } <<
428 <<
429 void G4LogicalVolume::SetSolid(G4LVData& instL <<
430 { <<
431 instLVdata.fSolid = pSolid; <<
432 instLVdata.fMass = 0.0; <<
433 } <<
434 <<
435 // ******************************************* <<
436 // GetMaterial <<
437 // ******************************************* <<
438 // <<
439 G4Material* G4LogicalVolume::GetMaterial() con <<
440 { <<
441 return G4MT_material; <<
442 } <<
443 <<
444 // ******************************************* <<
445 // SetMaterial <<
446 // ******************************************* <<
447 // <<
448 void G4LogicalVolume::SetMaterial(G4Material* <<
449 { <<
450 G4MT_material = pMaterial; <<
451 G4MT_mass = 0.0; <<
452 } <<
453 <<
454 // ******************************************* <<
455 // UpdateMaterial <<
456 // ******************************************* <<
457 // <<
458 void G4LogicalVolume::UpdateMaterial(G4Materia <<
459 { <<
460 G4MT_material=pMaterial; <<
461 if (fRegion != nullptr) { G4MT_ccouple = fRe <<
462 G4MT_mass = 0.0; <<
463 } <<
464 <<
465 // ******************************************* <<
466 // GetSensitiveDetector <<
467 // ******************************************* <<
468 // <<
469 G4VSensitiveDetector* G4LogicalVolume::GetSens <<
470 { <<
471 return G4MT_sdetector; <<
472 } <<
473 <<
474 // ******************************************* <<
475 // SetSensitiveDetector <<
476 // ******************************************* <<
477 // <<
478 void G4LogicalVolume::SetSensitiveDetector(G4V <<
479 { <<
480 G4MT_sdetector = pSDetector; <<
481 if (G4Threading::IsMasterThread()) { fSensi <<
482 } <<
483 <<
484 // ******************************************* <<
485 // GetMaterialCutsCouple <<
486 // ******************************************* <<
487 // <<
488 const G4MaterialCutsCouple* G4LogicalVolume::G <<
489 { <<
490 return G4MT_ccouple; <<
491 } <<
492 <<
493 // ******************************************* <<
494 // SetMaterialCutsCouple <<
495 // ******************************************* <<
496 // <<
497 void G4LogicalVolume::SetMaterialCutsCouple(G4 <<
498 { <<
499 G4MT_ccouple = cuts; <<
500 } <<
501 238
502 // ******************************************* 239 // ********************************************************************
503 // IsAncestor 240 // IsAncestor
504 // 241 //
505 // Finds out if the current logical volume is 242 // Finds out if the current logical volume is an ancestor of a given
506 // physical volume 243 // physical volume
507 // ******************************************* 244 // ********************************************************************
508 // 245 //
509 G4bool 246 G4bool
510 G4LogicalVolume::IsAncestor(const G4VPhysicalV 247 G4LogicalVolume::IsAncestor(const G4VPhysicalVolume* aVolume) const
511 { 248 {
512 G4bool isDaughter = IsDaughter(aVolume); 249 G4bool isDaughter = IsDaughter(aVolume);
513 if (!isDaughter) 250 if (!isDaughter)
514 { 251 {
515 for (auto itDau = fDaughters.cbegin(); itD << 252 for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
>> 253 itDau != fDaughters.end(); itDau++)
516 { 254 {
517 isDaughter = (*itDau)->GetLogicalVolume( 255 isDaughter = (*itDau)->GetLogicalVolume()->IsAncestor(aVolume);
518 if (isDaughter) break; 256 if (isDaughter) break;
519 } 257 }
520 } 258 }
521 return isDaughter; 259 return isDaughter;
522 } 260 }
523 261
524 // ******************************************* 262 // ********************************************************************
525 // TotalVolumeEntities 263 // TotalVolumeEntities
526 // 264 //
527 // Returns the total number of physical volume 265 // Returns the total number of physical volumes (replicated or placed)
528 // in the tree represented by the current logi 266 // in the tree represented by the current logical volume.
529 // ******************************************* 267 // ********************************************************************
530 // 268 //
531 G4int G4LogicalVolume::TotalVolumeEntities() c 269 G4int G4LogicalVolume::TotalVolumeEntities() const
532 { 270 {
533 G4int vols = 1; 271 G4int vols = 1;
534 for (auto itDau = fDaughters.cbegin(); itDau << 272 for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
>> 273 itDau != fDaughters.end(); itDau++)
535 { 274 {
536 G4VPhysicalVolume* physDaughter = (*itDau) 275 G4VPhysicalVolume* physDaughter = (*itDau);
537 vols += physDaughter->GetMultiplicity() 276 vols += physDaughter->GetMultiplicity()
538 *physDaughter->GetLogicalVolume()-> 277 *physDaughter->GetLogicalVolume()->TotalVolumeEntities();
539 } 278 }
540 return vols; 279 return vols;
541 } 280 }
542 281
543 // ******************************************* 282 // ********************************************************************
544 // GetMass 283 // GetMass
545 // 284 //
546 // Returns the mass of the logical volume tree 285 // Returns the mass of the logical volume tree computed from the
547 // estimated geometrical volume of each solid 286 // estimated geometrical volume of each solid and material associated
548 // to the logical volume and its daughters. 287 // to the logical volume and its daughters.
549 // NOTE: the computation may require considera 288 // NOTE: the computation may require considerable amount of time,
550 // depending from the complexity of the 289 // depending from the complexity of the geometry tree.
551 // The returned value is cached and can 290 // The returned value is cached and can be used for successive
552 // calls (default), unless recomputation 291 // calls (default), unless recomputation is forced by providing
553 // 'true' for the boolean argument in in 292 // 'true' for the boolean argument in input. Computation should
554 // be forced if the geometry setup has c 293 // be forced if the geometry setup has changed after the previous
555 // call. By setting the 'propagate' bool 294 // call. By setting the 'propagate' boolean flag to 'false' the
556 // method returns the mass of the presen 295 // method returns the mass of the present logical volume only
557 // (subtracted for the volume occupied b 296 // (subtracted for the volume occupied by the daughter volumes).
558 // The extra argument 'parMaterial' is i 297 // The extra argument 'parMaterial' is internally used to
559 // consider cases of geometrical paramet 298 // consider cases of geometrical parameterisations by material.
560 // ******************************************* 299 // ********************************************************************
561 // 300 //
562 G4double G4LogicalVolume::GetMass(G4bool force 301 G4double G4LogicalVolume::GetMass(G4bool forced,
563 G4bool propa 302 G4bool propagate,
564 G4Material* 303 G4Material* parMaterial)
565 { 304 {
566 // Return the cached non-zero value, if not 305 // Return the cached non-zero value, if not forced
567 // 306 //
568 if ( ((G4MT_mass) != 0.0) && (!forced) ) { << 307 if ( (G4MT_mass) && (!forced) ) return G4MT_mass;
569 308
570 // Global density and computed mass associat 309 // Global density and computed mass associated to the logical
571 // volume without considering its daughters 310 // volume without considering its daughters
572 // 311 //
573 G4Material* logMaterial = parMaterial != nul << 312 G4Material* logMaterial = parMaterial ? parMaterial : GetMaterial(); // G4MT_material;
574 if (logMaterial == nullptr) << 313 if (!logMaterial)
575 { 314 {
576 std::ostringstream message; 315 std::ostringstream message;
577 message << "No material associated to the << 316 message << "No material associated to the logical volume: " << fName << " !"
578 << fName << " !" << G4endl << 317 << G4endl
579 << "Sorry, cannot compute the mass 318 << "Sorry, cannot compute the mass ...";
580 G4Exception("G4LogicalVolume::GetMass()", 319 G4Exception("G4LogicalVolume::GetMass()", "GeomMgt0002",
581 FatalException, message); 320 FatalException, message);
582 return 0.0; << 321 return 0;
583 } 322 }
584 if ( GetSolid() == nullptr ) << 323 if (! GetSolid() ) // !G4MT_solid)
585 { 324 {
586 std::ostringstream message; 325 std::ostringstream message;
587 message << "No solid is associated to the << 326 message << "No solid is associated to the logical volume: " << fName << " !"
588 << fName << " !" << G4endl << 327 << G4endl
589 << "Sorry, cannot compute the mass 328 << "Sorry, cannot compute the mass ...";
590 G4Exception("G4LogicalVolume::GetMass()", 329 G4Exception("G4LogicalVolume::GetMass()", "GeomMgt0002",
591 FatalException, message); 330 FatalException, message);
592 return 0.0; << 331 return 0;
593 } 332 }
594 G4double globalDensity = logMaterial->GetDen 333 G4double globalDensity = logMaterial->GetDensity();
595 G4double motherMass = GetSolid()->GetCubicVo << 334 G4double motherMass= GetSolid()->GetCubicVolume() * globalDensity;
596 G4double massSum = motherMass; << 335
>> 336 // G4MT_mass =
>> 337 // SetMass( motherMmass );
>> 338 G4double massSum= motherMass;
597 339
598 // For each daughter in the tree, subtract t 340 // For each daughter in the tree, subtract the mass occupied
599 // and if required by the propagate flag, ad 341 // and if required by the propagate flag, add the real daughter's
600 // one computed recursively 342 // one computed recursively
601 343
602 for (auto itDau = fDaughters.cbegin(); itDau << 344 for (G4PhysicalVolumeList::const_iterator itDau = fDaughters.begin();
>> 345 itDau != fDaughters.end(); itDau++)
603 { 346 {
604 G4VPhysicalVolume* physDaughter = (*itDau) 347 G4VPhysicalVolume* physDaughter = (*itDau);
605 G4LogicalVolume* logDaughter = physDaughte 348 G4LogicalVolume* logDaughter = physDaughter->GetLogicalVolume();
606 G4double subMass = 0.0; << 349 G4double subMass=0.;
607 G4VSolid* daughterSolid = nullptr; << 350 G4VSolid* daughterSolid = 0;
608 G4Material* daughterMaterial = nullptr; << 351 G4Material* daughterMaterial = 0;
609 352
610 // Compute the mass to subtract and to add 353 // Compute the mass to subtract and to add for each daughter
611 // considering its multiplicity (i.e. repl 354 // considering its multiplicity (i.e. replicated or not) and
612 // eventually its parameterisation (by sol 355 // eventually its parameterisation (by solid and/or by material)
613 // 356 //
614 for (auto i=0; i<physDaughter->GetMultipli << 357 for (G4int i=0; i<physDaughter->GetMultiplicity(); i++)
615 { 358 {
616 G4VPVParameterisation* physParam = physD << 359 G4VPVParameterisation*
617 if (physParam != nullptr) << 360 physParam = physDaughter->GetParameterisation();
>> 361 if (physParam)
618 { 362 {
619 daughterSolid = physParam->ComputeSoli 363 daughterSolid = physParam->ComputeSolid(i, physDaughter);
620 daughterSolid->ComputeDimensions(physP 364 daughterSolid->ComputeDimensions(physParam, i, physDaughter);
621 daughterMaterial = physParam->ComputeM 365 daughterMaterial = physParam->ComputeMaterial(i, physDaughter);
622 } 366 }
623 else 367 else
624 { 368 {
625 daughterSolid = logDaughter->GetSolid( 369 daughterSolid = logDaughter->GetSolid();
626 daughterMaterial = logDaughter->GetMat 370 daughterMaterial = logDaughter->GetMaterial();
627 } 371 }
628 subMass = daughterSolid->GetCubicVolume( 372 subMass = daughterSolid->GetCubicVolume() * globalDensity;
629 373
630 // Subtract the daughter's portion for t 374 // Subtract the daughter's portion for the mass and, if required,
631 // add the real daughter's mass computed 375 // add the real daughter's mass computed recursively
632 // 376 //
633 massSum -= subMass; 377 massSum -= subMass;
634 if (propagate) 378 if (propagate)
635 { 379 {
636 massSum += logDaughter->GetMass(true, 380 massSum += logDaughter->GetMass(true, true, daughterMaterial);
637 } 381 }
638 } 382 }
639 } 383 }
640 G4MT_mass = massSum; << 384 G4MT_mass= massSum;
641 return massSum; 385 return massSum;
642 } 386 }
643 387
644 // ******************************************* <<
645 // Change the daughters volume type -- checkin <<
646 // <<
647 // Undertakes primitive checking, to ensure t <<
648 // are made: <<
649 // - any type to 'external' ( user respons <<
650 // - the type proposed is checked against t <<
651 // (for potential switch back to 'intern <<
652 // Returns success (true) or failure (false) <<
653 // <<
654 G4bool G4LogicalVolume::ChangeDaughtersType(EV <<
655 { <<
656 G4bool works = false; <<
657 if( aType == kExternal ) <<
658 { <<
659 // It is the responsibility of External Na <<
660 // <<
661 fDaughtersVolumeType = aType; <<
662 works = true; <<
663 } <<
664 else <<
665 { <<
666 EVolume expectedVType = DeduceDaughtersTyp <<
667 works = (expectedVType == aType); <<
668 if ( works ) <<
669 { <<
670 fDaughtersVolumeType = aType; <<
671 } <<
672 } <<
673 return works; <<
674 } <<
675 <<
676 // ******************************************* <<
677 // SetVisAttributes - copy version <<
678 // ******************************************* <<
679 // <<
680 void G4LogicalVolume::SetVisAttributes (const 388 void G4LogicalVolume::SetVisAttributes (const G4VisAttributes& VA)
681 { 389 {
682 if (G4Threading::IsWorkerThread()) return; << 390 fVisAttributes = new G4VisAttributes(VA);
683 fVisAttributes = std::make_shared<const G4Vi <<
684 } <<
685 <<
686 // ******************************************* <<
687 // SetVisAttributes <<
688 // ******************************************* <<
689 // <<
690 void G4LogicalVolume::SetVisAttributes (const <<
691 { <<
692 if (G4Threading::IsWorkerThread()) return; <<
693 fVisAttributes = std::shared_ptr<const G4Vis <<
694 } 391 }
695 392