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: G4Region.cc 81594 2014-06-03 14:05:18Z gcosmo $ >> 28 // 25 // 29 // 26 // G4Region class implementation << 30 // class G4Region Implementation 27 // 31 // 28 // 18.09.02, G.Cosmo - Initial version << 29 // ------------------------------------------- 32 // -------------------------------------------------------------------- 30 33 31 #include "G4Region.hh" 34 #include "G4Region.hh" 32 #include "G4RegionStore.hh" 35 #include "G4RegionStore.hh" 33 #include "G4LogicalVolume.hh" 36 #include "G4LogicalVolume.hh" 34 #include "G4VPhysicalVolume.hh" 37 #include "G4VPhysicalVolume.hh" 35 #include "G4LogicalVolumeStore.hh" 38 #include "G4LogicalVolumeStore.hh" 36 #include "G4VNestedParameterisation.hh" 39 #include "G4VNestedParameterisation.hh" 37 #include "G4VUserRegionInformation.hh" 40 #include "G4VUserRegionInformation.hh" 38 #include "G4Material.hh" 41 #include "G4Material.hh" 39 42 40 // These macros changes the references to fiel << 43 // This static member is thread local. For each thread, it points to the 41 // in the class G4RegionData. << 44 // array of G4RegionData instances. 42 // 45 // 43 #define G4MT_fsmanager ((subInstanceManager.of << 46 template <class G4RegionData> G4ThreadLocal 44 #define G4MT_rsaction ((subInstanceManager.off << 47 G4RegionData* G4GeomSplitter<G4RegionData>::offset = 0; 45 48 46 // This new field helps to use the class G4Reg 49 // This new field helps to use the class G4RegionManager 47 // 50 // 48 G4RegionManager G4Region::subInstanceManager; 51 G4RegionManager G4Region::subInstanceManager; 49 52 50 // ******************************************* 53 // ******************************************************************* 51 // GetSubInstanceManager: 54 // GetSubInstanceManager: 52 // - Returns the private data instance manage 55 // - Returns the private data instance manager. 53 // ******************************************* 56 // ******************************************************************* 54 // 57 // 55 const G4RegionManager& G4Region::GetSubInstanc 58 const G4RegionManager& G4Region::GetSubInstanceManager() 56 { 59 { 57 return subInstanceManager; 60 return subInstanceManager; 58 } 61 } 59 62 60 // ******************************************* 63 // ******************************************************************* 61 // Constructor: 64 // Constructor: 62 // - Adds self to region Store 65 // - Adds self to region Store 63 // ******************************************* 66 // ******************************************************************* 64 // 67 // 65 G4Region::G4Region(const G4String& pName) 68 G4Region::G4Region(const G4String& pName) 66 : fName(pName) << 69 : fName(pName), fRegionMod(true), fCut(0), fUserInfo(0), fUserLimits(0), >> 70 fFieldManager(0), fWorldPhys(0), >> 71 fInMassGeometry(false), fInParallelGeometry(false) 67 { 72 { 68 73 69 instanceID = subInstanceManager.CreateSubIns 74 instanceID = subInstanceManager.CreateSubInstance(); 70 G4MT_fsmanager = nullptr; << 75 G4MT_fsmanager = 0; 71 G4MT_rsaction = nullptr; << 76 G4MT_rsaction = 0; 72 77 73 G4RegionStore* rStore = G4RegionStore::GetIn 78 G4RegionStore* rStore = G4RegionStore::GetInstance(); 74 if (rStore->GetRegion(pName, false) != nullp << 79 if (rStore->GetRegion(pName,false)) 75 { 80 { 76 std::ostringstream message; 81 std::ostringstream message; 77 message << "The region has NOT been regist 82 message << "The region has NOT been registered !" << G4endl 78 << " Region " << pName << 83 << " Region " << pName << " already existing in store !" 79 << G4endl; 84 << G4endl; 80 G4Exception("G4Region::G4Region()", "GeomM 85 G4Exception("G4Region::G4Region()", "GeomMgt1001", 81 JustWarning, message); 86 JustWarning, message); 82 } 87 } 83 else 88 else 84 { 89 { 85 rStore->Register(this); 90 rStore->Register(this); 86 } 91 } 87 } 92 } 88 93 89 // ******************************************* 94 // ******************************************************************** 90 // Fake default constructor - sets only member 95 // Fake default constructor - sets only member data and allocates memory 91 // for usage restri 96 // for usage restricted to object persistency. 92 // ******************************************* 97 // ******************************************************************** 93 // 98 // 94 G4Region::G4Region( __void__& ) 99 G4Region::G4Region( __void__& ) 95 : fName("") << 100 : fName(""), fRegionMod(true), fCut(0), fUserInfo(0), fUserLimits(0), >> 101 fFieldManager(0), fWorldPhys(0), >> 102 fInMassGeometry(false), fInParallelGeometry(false) 96 { 103 { 97 instanceID = subInstanceManager.CreateSubIns 104 instanceID = subInstanceManager.CreateSubInstance(); 98 G4MT_fsmanager = nullptr; << 105 G4MT_fsmanager = 0; 99 G4MT_rsaction = nullptr; << 106 G4MT_rsaction = 0; 100 107 101 // Register to store 108 // Register to store 102 // 109 // 103 G4RegionStore::GetInstance()->Register(this) 110 G4RegionStore::GetInstance()->Register(this); 104 } 111 } 105 112 106 // ******************************************* 113 // ******************************************************************* 107 // Destructor: 114 // Destructor: 108 // - Removes self from region Store 115 // - Removes self from region Store 109 // ******************************************* 116 // ******************************************************************* 110 // 117 // 111 G4Region::~G4Region() 118 G4Region::~G4Region() 112 { 119 { 113 G4RegionStore::GetInstance()->DeRegister(thi 120 G4RegionStore::GetInstance()->DeRegister(this); 114 delete fUserInfo; << 121 if(fUserInfo) delete fUserInfo; 115 } << 116 << 117 // ******************************************* << 118 // SetName - Set region name and notify store << 119 // ******************************************* << 120 // << 121 void G4Region::SetName(const G4String& pName) << 122 { << 123 fName = pName; << 124 G4RegionStore::GetInstance()->SetMapValid(fa << 125 } << 126 << 127 // ******************************************* << 128 // SetFastSimulationManager << 129 // ******************************************* << 130 // << 131 void G4Region::SetFastSimulationManager(G4Fast << 132 { << 133 G4MT_fsmanager = fsm; << 134 } << 135 << 136 // ******************************************* << 137 // GetFastSimulationManager << 138 // ******************************************* << 139 // << 140 G4FastSimulationManager* G4Region::GetFastSimu << 141 { << 142 return G4MT_fsmanager; << 143 } << 144 << 145 // ******************************************* << 146 // SetRegionalSteppingAction << 147 // ******************************************* << 148 // << 149 void G4Region::SetRegionalSteppingAction(G4Use << 150 { << 151 G4MT_rsaction = rusa; << 152 } << 153 << 154 // ******************************************* << 155 // GetRegionalSteppingAction << 156 // ******************************************* << 157 // << 158 G4UserSteppingAction* G4Region::GetRegionalSte << 159 { << 160 return G4MT_rsaction; << 161 } 122 } 162 123 163 // ******************************************* 124 // ******************************************************************* 164 // ScanVolumeTree: 125 // ScanVolumeTree: 165 // - Scans recursively the 'lv' logical volum 126 // - Scans recursively the 'lv' logical volume tree, retrieves 166 // and places all materials in the list. 127 // and places all materials in the list. 167 // - The boolean flag 'region' identifies if 128 // - The boolean flag 'region' identifies if the volume tree must 168 // have region reset (false) or if the curr 129 // have region reset (false) or if the current region must be 169 // associated to the logical volume 'lv' an 130 // associated to the logical volume 'lv' and its tree (true). 170 // ******************************************* 131 // ******************************************************************* 171 // 132 // 172 void G4Region::ScanVolumeTree(G4LogicalVolume* 133 void G4Region::ScanVolumeTree(G4LogicalVolume* lv, G4bool region) 173 { 134 { 174 // If logical volume is going to become a re 135 // If logical volume is going to become a region, add 175 // its material to the list if not already p 136 // its material to the list if not already present 176 // 137 // 177 G4Region* currentRegion = nullptr; << 138 G4Region* currentRegion = 0; 178 std::size_t noDaughters = lv->GetNoDaughters << 139 size_t noDaughters = lv->GetNoDaughters(); 179 G4Material* volMat = lv->GetMaterial(); 140 G4Material* volMat = lv->GetMaterial(); 180 if((volMat == nullptr) && fInMassGeometry) << 141 if(!volMat && fInMassGeometry) 181 { 142 { 182 std::ostringstream message; 143 std::ostringstream message; 183 message << "Logical volume <" << lv->GetNa 144 message << "Logical volume <" << lv->GetName() << ">" << G4endl 184 << "does not have a valid material 145 << "does not have a valid material pointer." << G4endl 185 << "A logical volume belonging to 146 << "A logical volume belonging to the (tracking) world volume " 186 << "must have a valid material."; 147 << "must have a valid material."; 187 G4Exception("G4Region::ScanVolumeTree()", 148 G4Exception("G4Region::ScanVolumeTree()", "GeomMgt0002", 188 FatalException, message, "Chec 149 FatalException, message, "Check your geometry construction."); 189 } 150 } 190 if (region) 151 if (region) 191 { 152 { 192 currentRegion = this; 153 currentRegion = this; 193 if (volMat != nullptr) << 154 if (volMat) 194 { 155 { 195 AddMaterial(volMat); 156 AddMaterial(volMat); 196 auto baseMat = const_cast<G4Material*>( << 157 G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial()); 197 if (baseMat != nullptr) { AddMaterial(ba << 158 if (baseMat) { AddMaterial(baseMat); } 198 } 159 } 199 } 160 } 200 161 201 // Set the LV region to be either the curren 162 // Set the LV region to be either the current region or NULL, 202 // according to the boolean selector 163 // according to the boolean selector 203 // 164 // 204 lv->SetRegion(currentRegion); 165 lv->SetRegion(currentRegion); 205 166 206 // Stop recursion here if no further daughte 167 // Stop recursion here if no further daughters are involved 207 // 168 // 208 if(noDaughters==0) return; 169 if(noDaughters==0) return; 209 170 210 G4VPhysicalVolume* daughterPVol = lv->GetDau 171 G4VPhysicalVolume* daughterPVol = lv->GetDaughter(0); 211 if (daughterPVol->IsParameterised()) 172 if (daughterPVol->IsParameterised()) 212 { 173 { 213 // Adopt special treatment in case of para 174 // Adopt special treatment in case of parameterised volumes, 214 // where parameterisation involves a new m 175 // where parameterisation involves a new material scan 215 // 176 // 216 G4VPVParameterisation* pParam = daughterPV 177 G4VPVParameterisation* pParam = daughterPVol->GetParameterisation(); 217 178 218 if (pParam->GetMaterialScanner() != nullpt << 179 if (pParam->GetMaterialScanner()) 219 { 180 { 220 std::size_t matNo = pParam->GetMaterialS << 181 size_t matNo = pParam->GetMaterialScanner()->GetNumberOfMaterials(); 221 for (std::size_t mat=0; mat<matNo; ++mat << 182 for (size_t mat=0; mat<matNo; mat++) 222 { 183 { 223 volMat = pParam->GetMaterialScanner()- << 184 volMat = pParam->GetMaterialScanner()->GetMaterial(mat); 224 if((volMat == nullptr) && fInMassGeome << 185 if(!volMat && fInMassGeometry) 225 { 186 { 226 std::ostringstream message; 187 std::ostringstream message; 227 message << "The parameterisation for 188 message << "The parameterisation for the physical volume <" 228 << daughterPVol->GetName() < 189 << daughterPVol->GetName() << ">" << G4endl 229 << "does not return a valid 190 << "does not return a valid material pointer." << G4endl 230 << "A volume belonging to th 191 << "A volume belonging to the (tracking) world volume must " 231 << "have a valid material."; 192 << "have a valid material."; 232 G4Exception("G4Region::ScanVolumeTre 193 G4Exception("G4Region::ScanVolumeTree()", "GeomMgt0002", 233 FatalException, message, 194 FatalException, message, "Check your parameterisation."); 234 } 195 } 235 if (volMat != nullptr) << 196 if (volMat) 236 { 197 { 237 AddMaterial(volMat); 198 AddMaterial(volMat); 238 auto baseMat = const_cast<G4Materia << 199 G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial()); 239 if (baseMat != nullptr) { AddMateria << 200 if (baseMat) { AddMaterial(baseMat); } 240 } 201 } 241 } 202 } 242 } 203 } 243 else 204 else 244 { 205 { 245 std::size_t repNo = daughterPVol->GetMul << 206 size_t repNo = daughterPVol->GetMultiplicity(); 246 for (std::size_t rep=0; rep<repNo; ++rep << 207 for (size_t rep=0; rep<repNo; rep++) 247 { 208 { 248 volMat = pParam->ComputeMaterial((G4in << 209 volMat = pParam->ComputeMaterial(rep, daughterPVol); 249 if((volMat == nullptr) && fInMassGeome << 210 if(!volMat && fInMassGeometry) 250 { 211 { 251 std::ostringstream message; 212 std::ostringstream message; 252 message << "The parameterisation for 213 message << "The parameterisation for the physical volume <" 253 << daughterPVol->GetName() < 214 << daughterPVol->GetName() << ">" << G4endl 254 << "does not return a valid 215 << "does not return a valid material pointer." << G4endl 255 << "A volume belonging to th 216 << "A volume belonging to the (tracking) world volume must " 256 << "have a valid material."; 217 << "have a valid material."; 257 G4Exception("G4Region::ScanVolumeTre 218 G4Exception("G4Region::ScanVolumeTree()", "GeomMgt0002", 258 FatalException, message, 219 FatalException, message, "Check your parameterisation."); 259 } 220 } 260 if(volMat != nullptr) << 221 if(volMat) 261 { 222 { 262 AddMaterial(volMat); 223 AddMaterial(volMat); 263 auto baseMat = const_cast<G4Materia << 224 G4Material* baseMat = const_cast<G4Material*>(volMat->GetBaseMaterial()); 264 if (baseMat != nullptr) { AddMateria << 225 if (baseMat) { AddMaterial(baseMat); } 265 } 226 } 266 } 227 } 267 } 228 } 268 G4LogicalVolume* daughterLVol = daughterPV 229 G4LogicalVolume* daughterLVol = daughterPVol->GetLogicalVolume(); 269 ScanVolumeTree(daughterLVol, region); 230 ScanVolumeTree(daughterLVol, region); 270 } 231 } 271 else 232 else 272 { 233 { 273 for (std::size_t i=0; i<noDaughters; ++i) << 234 for (size_t i=0; i<noDaughters; i++) 274 { 235 { 275 G4LogicalVolume* daughterLVol = lv->GetD 236 G4LogicalVolume* daughterLVol = lv->GetDaughter(i)->GetLogicalVolume(); 276 if (!daughterLVol->IsRootRegion()) 237 if (!daughterLVol->IsRootRegion()) 277 { 238 { 278 // Set daughter's LV to be a region an 239 // Set daughter's LV to be a region and store materials in 279 // the materials list, if the LV is no 240 // the materials list, if the LV is not already a root region 280 // 241 // 281 ScanVolumeTree(daughterLVol, region); 242 ScanVolumeTree(daughterLVol, region); 282 } 243 } 283 } 244 } 284 } 245 } 285 } 246 } 286 247 287 // ******************************************* 248 // ******************************************************************* 288 // AddRootLogicalVolume: 249 // AddRootLogicalVolume: 289 // - Adds a root logical volume and sets its 250 // - Adds a root logical volume and sets its daughters flags as 290 // regions. It also recomputes the material 251 // regions. It also recomputes the materials list for the region. 291 // ******************************************* 252 // ******************************************************************* 292 // 253 // 293 void G4Region::AddRootLogicalVolume(G4LogicalV << 254 void G4Region::AddRootLogicalVolume(G4LogicalVolume* lv) 294 { 255 { 295 // Check if logical volume is already belong << 296 // << 297 if ((lv->IsRootRegion()) && (lv->GetRegion() << 298 { << 299 std::ostringstream message; << 300 message << "Logical volume <" << lv->GetNa << 301 << "root for region <" << lv->GetR << 302 << "It cannot be root logical volu << 303 << ">" << G4endl; << 304 G4Exception("G4Region::AddRootLogicalVolum << 305 message, "A logical volume can << 306 return; << 307 } << 308 << 309 // Check the logical volume is not already i 256 // Check the logical volume is not already in the list 310 // 257 // 311 if (search) << 258 G4RootLVList::iterator pos; >> 259 pos = std::find(fRootVolumes.begin(),fRootVolumes.end(),lv); >> 260 if (pos == fRootVolumes.end()) 312 { 261 { 313 auto pos = std::find(fRootVolumes.cbegin() << 262 // Insert the root volume in the list and set it as root region 314 if (pos == fRootVolumes.cend()) << 263 // 315 { << 316 // Insert the root volume in the list an << 317 // << 318 fRootVolumes.push_back(lv); << 319 lv->SetRegionRootFlag(true); << 320 } << 321 } << 322 else // WARNING: user *MUST* guarantee lv i << 323 { // Providing speedup for very complex << 324 fRootVolumes.push_back(lv); 264 fRootVolumes.push_back(lv); 325 lv->SetRegionRootFlag(true); 265 lv->SetRegionRootFlag(true); 326 } 266 } >> 267 327 // Scan recursively the tree of daugther vol 268 // Scan recursively the tree of daugther volumes and set regions 328 // 269 // 329 ScanVolumeTree(lv, true); 270 ScanVolumeTree(lv, true); 330 271 331 // Set region as modified 272 // Set region as modified 332 // 273 // 333 fRegionMod = true; 274 fRegionMod = true; 334 } 275 } 335 276 336 // ******************************************* 277 // ******************************************************************* 337 // RemoveRootLogicalVolume: 278 // RemoveRootLogicalVolume: 338 // - Removes a root logical volume and resets 279 // - Removes a root logical volume and resets its daughters flags as 339 // regions. It also recomputes the material 280 // regions. It also recomputes the materials list for the region. 340 // ******************************************* 281 // ******************************************************************* 341 // 282 // 342 void G4Region::RemoveRootLogicalVolume(G4Logic 283 void G4Region::RemoveRootLogicalVolume(G4LogicalVolume* lv, G4bool scan) 343 { 284 { 344 // Find and remove logical volume from the l 285 // Find and remove logical volume from the list 345 // 286 // 346 auto pos = std::find(fRootVolumes.cbegin(),f << 287 G4RootLVList::iterator pos; 347 if (pos != fRootVolumes.cend()) << 288 pos = std::find(fRootVolumes.begin(),fRootVolumes.end(),lv); >> 289 if (pos != fRootVolumes.end()) 348 { 290 { 349 if (fRootVolumes.size() != 1) // Avoid re 291 if (fRootVolumes.size() != 1) // Avoid resetting flag for world since 350 { // volume m 292 { // volume may be already deleted ! 351 lv->SetRegionRootFlag(false); 293 lv->SetRegionRootFlag(false); 352 } 294 } 353 fRootVolumes.erase(pos); 295 fRootVolumes.erase(pos); 354 } 296 } 355 297 356 if (scan) // Update the materials list 298 if (scan) // Update the materials list 357 { 299 { 358 UpdateMaterialList(); 300 UpdateMaterialList(); 359 } 301 } 360 302 361 // Set region as modified 303 // Set region as modified 362 // 304 // 363 fRegionMod = true; 305 fRegionMod = true; 364 } 306 } 365 307 366 // ******************************************* << 367 // Clean << 368 // ******************************************* << 369 // << 370 void G4Region::Clean() << 371 { << 372 subInstanceManager.FreeSlave(); << 373 } << 374 << 375 // ******************************************* 308 // ******************************************************************* 376 // ClearMaterialList: 309 // ClearMaterialList: 377 // - Clears the material list. 310 // - Clears the material list. 378 // ******************************************* 311 // ******************************************************************* 379 // 312 // 380 void G4Region::ClearMaterialList() 313 void G4Region::ClearMaterialList() 381 { 314 { 382 fMaterials.clear(); 315 fMaterials.clear(); 383 } 316 } 384 317 385 // ******************************************* 318 // ******************************************************************* 386 // UpdateMaterialList: 319 // UpdateMaterialList: 387 // - computes material list looping through 320 // - computes material list looping through 388 // each root logical volume in the region. 321 // each root logical volume in the region. 389 // ******************************************* 322 // ******************************************************************* 390 // 323 // 391 void G4Region::UpdateMaterialList() 324 void G4Region::UpdateMaterialList() 392 { 325 { 393 // Reset the materials list 326 // Reset the materials list 394 // 327 // 395 ClearMaterialList(); 328 ClearMaterialList(); 396 329 397 // Loop over the root logical volumes and re 330 // Loop over the root logical volumes and rebuild the list 398 // of materials from scratch 331 // of materials from scratch 399 // 332 // 400 for (auto pLV=fRootVolumes.cbegin(); pLV!=fR << 333 G4RootLVList::iterator pLV; >> 334 for (pLV=fRootVolumes.begin(); pLV!=fRootVolumes.end(); pLV++) 401 { 335 { 402 ScanVolumeTree(*pLV, true); 336 ScanVolumeTree(*pLV, true); 403 } 337 } 404 } 338 } 405 339 406 // ******************************************* 340 // ******************************************************************* 407 // SetWorld: 341 // SetWorld: 408 // - Set the world physical volume if this re 342 // - Set the world physical volume if this region belongs to this 409 // world. If the given pointer is null, res 343 // world. If the given pointer is null, reset the pointer. 410 // ******************************************* 344 // ******************************************************************* 411 // 345 // 412 void G4Region::SetWorld(G4VPhysicalVolume* wp) 346 void G4Region::SetWorld(G4VPhysicalVolume* wp) 413 { 347 { 414 if(wp == nullptr) << 348 if(!wp) 415 { fWorldPhys = nullptr; } << 349 { fWorldPhys = 0; } 416 else 350 else 417 { if(BelongsTo(wp)) fWorldPhys = wp; } 351 { if(BelongsTo(wp)) fWorldPhys = wp; } 418 352 419 return; 353 return; 420 } 354 } 421 355 422 // ******************************************* 356 // ******************************************************************* 423 // BelongsTo: 357 // BelongsTo: 424 // - Returns whether this region belongs to t 358 // - Returns whether this region belongs to the given physical volume 425 // (recursively scanned to the bottom of th 359 // (recursively scanned to the bottom of the hierarchy) 426 // ******************************************* 360 // ******************************************************************* 427 // 361 // 428 G4bool G4Region::BelongsTo(G4VPhysicalVolume* 362 G4bool G4Region::BelongsTo(G4VPhysicalVolume* thePhys) const 429 { 363 { 430 G4LogicalVolume* currLog = thePhys->GetLogic 364 G4LogicalVolume* currLog = thePhys->GetLogicalVolume(); 431 if (currLog->GetRegion()==this) {return true 365 if (currLog->GetRegion()==this) {return true;} 432 366 433 std::size_t nDaughters = currLog->GetNoDaugh << 367 G4int nDaughters = currLog->GetNoDaughters(); 434 while ((nDaughters--) != 0) // Loop checkin << 368 while (nDaughters--) 435 { 369 { 436 if (BelongsTo(currLog->GetDaughter(nDaught 370 if (BelongsTo(currLog->GetDaughter(nDaughters))) {return true;} 437 } 371 } 438 372 439 return false; 373 return false; 440 } 374 } 441 375 442 // ******************************************* 376 // ******************************************************************* 443 // ClearFastSimulationManager: 377 // ClearFastSimulationManager: 444 // - Set G4FastSimulationManager pointer to t 378 // - Set G4FastSimulationManager pointer to the one for the parent region 445 // if it exists. Otherwise set to null. 379 // if it exists. Otherwise set to null. 446 // ******************************************* 380 // ******************************************************************* 447 // 381 // 448 void G4Region::ClearFastSimulationManager() 382 void G4Region::ClearFastSimulationManager() 449 { 383 { 450 G4bool isUnique; 384 G4bool isUnique; 451 G4Region* parent = GetParentRegion(isUnique) 385 G4Region* parent = GetParentRegion(isUnique); 452 if(parent != nullptr) << 386 if(parent) 453 { 387 { 454 if (isUnique) 388 if (isUnique) 455 { 389 { 456 G4MT_fsmanager = parent->GetFastSimulati 390 G4MT_fsmanager = parent->GetFastSimulationManager(); 457 } 391 } 458 else 392 else 459 { 393 { 460 std::ostringstream message; 394 std::ostringstream message; 461 message << "Region <" << fName << "> bel 395 message << "Region <" << fName << "> belongs to more than" 462 << " one parent region !" << G4e 396 << " one parent region !" << G4endl 463 << "A region cannot belong to mo 397 << "A region cannot belong to more than one direct parent region," 464 << G4endl 398 << G4endl 465 << "to have fast-simulation assi 399 << "to have fast-simulation assigned."; 466 G4Exception("G4Region::ClearFastSimulati 400 G4Exception("G4Region::ClearFastSimulationManager()", 467 "GeomMgt1002", JustWarning, 401 "GeomMgt1002", JustWarning, message); 468 G4MT_fsmanager = nullptr; << 402 G4MT_fsmanager = 0; 469 } 403 } 470 } 404 } 471 else 405 else 472 { 406 { 473 G4MT_fsmanager = nullptr; << 407 G4MT_fsmanager = 0; 474 } 408 } 475 } 409 } 476 410 477 // ******************************************* 411 // ******************************************************************* 478 // GetParentRegion: 412 // GetParentRegion: 479 // - Returns a region that contains this regi 413 // - Returns a region that contains this region. 480 // Otherwise null is returned. 414 // Otherwise null is returned. 481 // ******************************************* 415 // ******************************************************************* 482 // 416 // 483 G4Region* G4Region::GetParentRegion(G4bool& un 417 G4Region* G4Region::GetParentRegion(G4bool& unique) const 484 { 418 { 485 G4Region* parent = nullptr; unique = true; << 419 G4Region* parent = 0; unique = true; 486 G4LogicalVolumeStore* lvStore = G4LogicalVol 420 G4LogicalVolumeStore* lvStore = G4LogicalVolumeStore::GetInstance(); >> 421 G4LogicalVolumeStore::iterator lvItr; 487 422 488 // Loop over all logical volumes in the stor 423 // Loop over all logical volumes in the store 489 // 424 // 490 for(auto lvItr=lvStore->cbegin(); lvItr!=lvS << 425 for(lvItr=lvStore->begin(); lvItr!=lvStore->end(); lvItr++) 491 { 426 { 492 std::size_t nD = (*lvItr)->GetNoDaughters( << 427 G4int nD = (*lvItr)->GetNoDaughters(); 493 G4Region* aR = (*lvItr)->GetRegion(); 428 G4Region* aR = (*lvItr)->GetRegion(); 494 429 495 // Loop over all daughters of each logical 430 // Loop over all daughters of each logical volume 496 // 431 // 497 for(std::size_t iD=0; iD<nD; ++iD) << 432 for(G4int iD=0; iD<nD; iD++) 498 { 433 { 499 if((*lvItr)->GetDaughter(iD)->GetLogical 434 if((*lvItr)->GetDaughter(iD)->GetLogicalVolume()->GetRegion()==this) 500 { 435 { 501 if(parent != nullptr) << 436 if(parent) 502 { 437 { 503 if(parent!=aR) { unique = false; } 438 if(parent!=aR) { unique = false; } 504 } 439 } 505 else // Cache LV parent region which 440 else // Cache LV parent region which includes a daughter volume 506 // with the same associated regi 441 // with the same associated region as the current one 507 { 442 { 508 parent = aR; 443 parent = aR; 509 } 444 } 510 } 445 } 511 } 446 } 512 } 447 } 513 return parent; 448 return parent; 514 } 449 } 515 450