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