EIC code displayed by LXR |
|
|
|
|||
File indexing completed on 2025-01-18 09:58:38
0001 // 0002 // ******************************************************************** 0003 // * License and Disclaimer * 0004 // * * 0005 // * The Geant4 software is copyright of the Copyright Holders of * 0006 // * the Geant4 Collaboration. It is provided under the terms and * 0007 // * conditions of the Geant4 Software License, included in the file * 0008 // * LICENSE and available at http://cern.ch/geant4/license . These * 0009 // * include a list of copyright holders. * 0010 // * * 0011 // * Neither the authors of this software system, nor their employing * 0012 // * institutes,nor the agencies providing financial support for this * 0013 // * work make any representation or warranty, express or implied, * 0014 // * regarding this software system or assume any liability for its * 0015 // * use. Please see the license in the file LICENSE and URL above * 0016 // * for the full disclaimer and the limitation of liability. * 0017 // * * 0018 // * This code implementation is the result of the scientific and * 0019 // * technical work of the GEANT4 collaboration. * 0020 // * By using, copying, modifying or distributing the software (or * 0021 // * any work based on the software) you agree to acknowledge its * 0022 // * use in resulting scientific publications, and indicate your * 0023 // * acceptance of all terms of the Geant4 Software license. * 0024 // ******************************************************************** 0025 // 0026 // class G4LogicalVolume inline implementation 0027 // 0028 // 15.01.13 - G.Cosmo, A.Dotti: Modified for thread-safety for MT 0029 // 10.20.97 - P. MoraDeFreitas : Added SetFastSimulation method 0030 // 05.11.98 - M. Verderi: Add Get/Set methods for fBiasWeight 0031 // 09.11.98 - J.Apostolakis: Changed MagneticField to FieldManager 0032 // 12.02.99 - S.Giani: Added set/get methods for voxelization quality 0033 // 18.04.01 - G.Cosmo: Migrated to STL vector 0034 // 17.05.02 - G.Cosmo: Added IsToOptimise() method 0035 // -------------------------------------------------------------------- 0036 0037 // ******************************************************************** 0038 // GetName 0039 // ******************************************************************** 0040 // 0041 inline 0042 const G4String& G4LogicalVolume::GetName() const 0043 { 0044 return fName; 0045 } 0046 0047 // ******************************************************************** 0048 // GetInstanceID 0049 // ******************************************************************** 0050 // 0051 inline 0052 G4int G4LogicalVolume::GetInstanceID() const 0053 { 0054 return instanceID; 0055 } 0056 0057 // ******************************************************************** 0058 // GetMasterFieldManager 0059 // ******************************************************************** 0060 // 0061 inline 0062 G4FieldManager* G4LogicalVolume::GetMasterFieldManager() const 0063 { 0064 return fFieldManager; 0065 } 0066 0067 // ******************************************************************** 0068 // GetNoDaughters 0069 // ******************************************************************** 0070 // 0071 inline 0072 std::size_t G4LogicalVolume::GetNoDaughters() const 0073 { 0074 return fDaughters.size(); 0075 } 0076 0077 // ******************************************************************** 0078 // GetDaughter 0079 // ******************************************************************** 0080 // 0081 inline 0082 G4VPhysicalVolume* G4LogicalVolume::GetDaughter(const std::size_t i) const 0083 { 0084 return fDaughters[i]; 0085 } 0086 0087 // ******************************************************************** 0088 // GetFastSimulationManager 0089 // ******************************************************************** 0090 // 0091 inline 0092 G4FastSimulationManager* G4LogicalVolume::GetFastSimulationManager () const 0093 { 0094 G4FastSimulationManager* fFSM = nullptr; 0095 if(fRegion != nullptr) fFSM = fRegion->GetFastSimulationManager(); 0096 return fFSM; 0097 } 0098 0099 // ******************************************************************** 0100 // IsDaughter 0101 // ******************************************************************** 0102 // 0103 inline 0104 G4bool G4LogicalVolume::IsDaughter(const G4VPhysicalVolume* p) const 0105 { 0106 for (const auto & daughter : fDaughters) 0107 { 0108 if (*daughter==*p) return true; 0109 } 0110 return false; 0111 } 0112 0113 // ******************************************************************** 0114 // CharacteriseDaughters 0115 // ******************************************************************** 0116 // 0117 inline 0118 EVolume G4LogicalVolume::CharacteriseDaughters() const 0119 { 0120 return fDaughtersVolumeType; 0121 } 0122 0123 // ******************************************************************** 0124 // DeduceDaughtersType 0125 // ******************************************************************** 0126 // 0127 inline 0128 EVolume G4LogicalVolume::DeduceDaughtersType() const 0129 { 0130 EVolume type= kNormal; 0131 G4VPhysicalVolume* pVol; 0132 0133 if ( GetNoDaughters() >= 1 ) 0134 { 0135 pVol = GetDaughter(0); 0136 type = pVol->VolumeType(); 0137 } 0138 return type; 0139 } 0140 0141 // ******************************************************************** 0142 // GetMasterSolid 0143 // ******************************************************************** 0144 // 0145 inline 0146 G4VSolid* G4LogicalVolume::GetMasterSolid() const 0147 { 0148 return fSolid; 0149 } 0150 0151 // ******************************************************************** 0152 // GetMasterSensitiveDetector 0153 // ******************************************************************** 0154 // 0155 inline 0156 G4VSensitiveDetector* G4LogicalVolume::GetMasterSensitiveDetector() const 0157 { 0158 return fSensitiveDetector; 0159 } 0160 0161 // ******************************************************************** 0162 // GetUserLimits 0163 // ******************************************************************** 0164 // 0165 inline 0166 G4UserLimits* G4LogicalVolume::GetUserLimits() const 0167 { 0168 if(fUserLimits != nullptr) return fUserLimits; 0169 if(fRegion != nullptr) return fRegion->GetUserLimits(); 0170 return nullptr; 0171 } 0172 0173 // ******************************************************************** 0174 // SetUserLimits 0175 // ******************************************************************** 0176 // 0177 inline 0178 void G4LogicalVolume::SetUserLimits(G4UserLimits* pULimits) 0179 { 0180 fUserLimits = pULimits; 0181 } 0182 0183 // ******************************************************************** 0184 // GetVoxelHeader 0185 // ******************************************************************** 0186 // 0187 inline 0188 G4SmartVoxelHeader* G4LogicalVolume::GetVoxelHeader() const 0189 { 0190 return fVoxel; 0191 } 0192 0193 // ******************************************************************** 0194 // SetVoxelHeader 0195 // ******************************************************************** 0196 // 0197 inline 0198 void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader* pVoxel) 0199 { 0200 fVoxel = pVoxel; 0201 } 0202 0203 // ******************************************************************** 0204 // GetSmartless 0205 // ******************************************************************** 0206 // 0207 inline 0208 G4double G4LogicalVolume::GetSmartless() const 0209 { 0210 return fSmartless; 0211 } 0212 0213 // ******************************************************************** 0214 // SetSmartless 0215 // ******************************************************************** 0216 // 0217 inline 0218 void G4LogicalVolume::SetSmartless(G4double smt) 0219 { 0220 fSmartless = smt; 0221 } 0222 0223 // ******************************************************************** 0224 // IsToOptimise 0225 // ******************************************************************** 0226 // 0227 inline 0228 G4bool G4LogicalVolume::IsToOptimise() const 0229 { 0230 return fOptimise; 0231 } 0232 0233 // ******************************************************************** 0234 // SetOptimisation 0235 // ******************************************************************** 0236 // 0237 inline 0238 void G4LogicalVolume::SetOptimisation(G4bool optim) 0239 { 0240 fOptimise = optim; 0241 } 0242 0243 // ******************************************************************** 0244 // IsRootRegion 0245 // ******************************************************************** 0246 // 0247 inline 0248 G4bool G4LogicalVolume::IsRootRegion() const 0249 { 0250 return fRootRegion; 0251 } 0252 0253 // ******************************************************************** 0254 // SetRegionRootFlag 0255 // ******************************************************************** 0256 // 0257 inline 0258 void G4LogicalVolume::SetRegionRootFlag(G4bool rreg) 0259 { 0260 fRootRegion = rreg; 0261 } 0262 0263 // ******************************************************************** 0264 // IsRegion 0265 // ******************************************************************** 0266 // 0267 inline 0268 G4bool G4LogicalVolume::IsRegion() const 0269 { 0270 G4bool reg = false; 0271 if (fRegion != nullptr) reg = true; 0272 return reg; 0273 } 0274 0275 // ******************************************************************** 0276 // SetRegion 0277 // ******************************************************************** 0278 // 0279 inline 0280 void G4LogicalVolume::SetRegion(G4Region* reg) 0281 { 0282 fRegion = reg; 0283 } 0284 0285 // ******************************************************************** 0286 // GetRegion 0287 // ******************************************************************** 0288 // 0289 inline 0290 G4Region* G4LogicalVolume::GetRegion() const 0291 { 0292 return fRegion; 0293 } 0294 0295 // ******************************************************************** 0296 // PropagateRegion 0297 // ******************************************************************** 0298 // 0299 inline 0300 void G4LogicalVolume::PropagateRegion() 0301 { 0302 fRegion->ScanVolumeTree(this, true); 0303 } 0304 0305 // ******************************************************************** 0306 // Lock 0307 // ******************************************************************** 0308 // 0309 inline 0310 void G4LogicalVolume::Lock() 0311 { 0312 fLock = true; 0313 } 0314 0315 // ******************************************************************** 0316 // Operator == 0317 // ******************************************************************** 0318 // 0319 inline 0320 G4bool G4LogicalVolume::operator == ( const G4LogicalVolume& lv) const 0321 { 0322 return this==&lv; 0323 } 0324 0325 // ******************************************************************** 0326 // SetBiasWeight 0327 // ******************************************************************** 0328 // 0329 inline 0330 void G4LogicalVolume::SetBiasWeight(G4double weight) 0331 { 0332 fBiasWeight = weight; 0333 } 0334 0335 // ******************************************************************** 0336 // GetBiasWeight 0337 // ******************************************************************** 0338 // 0339 inline 0340 G4double G4LogicalVolume::GetBiasWeight() const 0341 { 0342 return fBiasWeight; 0343 } 0344 0345 // ******************************************************************** 0346 // GetVisAttributes 0347 // ******************************************************************** 0348 // 0349 inline 0350 const G4VisAttributes* G4LogicalVolume::GetVisAttributes () const 0351 { 0352 return fVisAttributes.get(); 0353 }
| [ Source navigation ] | [ Diff markup ] | [ Identifier search ] | [ general search ] |
|
This page was automatically generated by the 2.3.7 LXR engine. The LXR team |
|