include/Geant4/G4Region.icc

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 // G4Region inline implementation
0027 //
0028 // 19.09.02, G.Cosmo - Created
0029 // --------------------------------------------------------------------
0030
0031 // ********************************************************************
0032 // Equality operator, defined by address only
0033 // ********************************************************************
0034 //
0035 inline
0036 G4bool G4Region::operator==(const G4Region& rg) const
0037 {
0038   return this==&rg;
0039 }
0040
0041 // ********************************************************************
0042 // GetInstanceID
0043 // ********************************************************************
0044 //
0045 inline
0046 G4int G4Region::GetInstanceID() const
0047 {
0048   return instanceID;
0049 }
0050
0051 // ********************************************************************
0052 // GetName
0053 // ********************************************************************
0054 //
0055 inline
0056 const G4String& G4Region::GetName() const
0057 {
0058   return fName;
0059 }
0060
0061 // ********************************************************************
0062 // RegionModified
0063 // ********************************************************************
0064 //
0065 inline
0066 void G4Region::RegionModified(G4bool flag)
0067 {
0068   fRegionMod = flag;
0069 }
0070
0071 // ********************************************************************
0072 // IsModified
0073 // ********************************************************************
0074 //
0075 inline
0076 G4bool G4Region::IsModified() const
0077 {
0078   return fRegionMod;
0079 }
0080
0081 // ********************************************************************
0082 // SetProductionCuts
0083 // ********************************************************************
0084 //
0085 inline
0086 void G4Region::SetProductionCuts(G4ProductionCuts* cut)
0087 {
0088   fCut = cut;
0089   fRegionMod = true;
0090 }
0091
0092 // ********************************************************************
0093 // GetProductionCuts
0094 // ********************************************************************
0095 //
0096 inline
0097 G4ProductionCuts* G4Region::GetProductionCuts() const
0098 {
0099   return fCut;
0100 }
0101
0102 // ********************************************************************
0103 // GetLogicalVolumeIterator
0104 // ********************************************************************
0105 //
0106 inline
0107 std::vector<G4LogicalVolume*>::iterator
0108 G4Region::GetRootLogicalVolumeIterator()
0109 {
0110   return G4RootLVList::iterator(fRootVolumes.begin());
0111 }
0112
0113 // ********************************************************************
0114 // GetMaterialIterator
0115 // ********************************************************************
0116 //
0117 inline
0118 std::vector<G4Material*>::const_iterator
0119 G4Region::GetMaterialIterator() const
0120 {
0121   return fMaterials.cbegin();
0122 }
0123
0124 // ********************************************************************
0125 // GetNumberOfMaterials
0126 // ********************************************************************
0127 //
0128 inline
0129 size_t G4Region::GetNumberOfMaterials() const
0130 {
0131   return fMaterials.size();
0132 }
0133
0134 // ********************************************************************
0135 // GetNumberOfRootVolumes
0136 // ********************************************************************
0137 //
0138 inline
0139 size_t G4Region::GetNumberOfRootVolumes() const
0140 {
0141   return fRootVolumes.size();
0142 }
0143
0144 // ********************************************************************
0145 // SetUserInformation
0146 // ********************************************************************
0147 //
0148 inline
0149 void G4Region::SetUserInformation(G4VUserRegionInformation* ui)
0150 {
0151   fUserInfo = ui;
0152 }
0153
0154 // ********************************************************************
0155 // GetUserInformation
0156 // ********************************************************************
0157 //
0158 inline
0159 G4VUserRegionInformation* G4Region::GetUserInformation() const
0160 {
0161   return fUserInfo;
0162 }
0163
0164 // ********************************************************************
0165 // SetUserLimits
0166 // ********************************************************************
0167 //
0168 inline
0169 void G4Region::SetUserLimits(G4UserLimits* ul)
0170 {
0171   fUserLimits = ul;
0172 }
0173
0174 // ********************************************************************
0175 // GetUserLimits
0176 // ********************************************************************
0177 //
0178 inline
0179 G4UserLimits* G4Region::GetUserLimits() const
0180 {
0181   return fUserLimits;
0182 }
0183
0184 // ********************************************************************
0185 // ClearMap
0186 // ********************************************************************
0187 //
0188 inline
0189 void G4Region::ClearMap()
0190 {
0191   if(!(fMaterialCoupleMap.empty()))
0192   {
0193     auto b = fMaterialCoupleMap.cbegin();
0194     auto e = fMaterialCoupleMap.cend();
0195     fMaterialCoupleMap.erase(b,e);
0196   }
0197 }
0198
0199 // ********************************************************************
0200 // RegisterMateralCouplePair
0201 // ********************************************************************
0202 //
0203 inline
0204 void G4Region::RegisterMaterialCouplePair(G4Material* mat,
0205                                           G4MaterialCutsCouple* couple)
0206 {
0207   fMaterialCoupleMap.insert(G4MaterialCouplePair(mat,couple));
0208 }
0209
0210 // ********************************************************************
0211 // FindCouple
0212 // ********************************************************************
0213 //
0214 inline
0215 G4MaterialCutsCouple* G4Region::FindCouple(G4Material* mat)
0216 {
0217   auto c = fMaterialCoupleMap.find(mat);
0218   G4MaterialCutsCouple* couple = nullptr;
0219   if(c!=fMaterialCoupleMap.cend()) couple = (*c).second;
0220   return couple;
0221 }
0222
0223 // ********************************************************************
0224 // GetFieldManager
0225 // ********************************************************************
0226 //
0227 inline
0228 G4FieldManager* G4Region::GetFieldManager() const
0229 {
0230   return fFieldManager;
0231 }
0232
0233 // ********************************************************************
0234 // SetFieldManager
0235 // ********************************************************************
0236 //
0237 inline
0238 void G4Region::SetFieldManager(G4FieldManager* fm)
0239 {
0240   fFieldManager = fm;
0241 }
0242
0243 // ********************************************************************
0244 // GetWorldPhysical
0245 // ********************************************************************
0246 //
0247 inline
0248 G4VPhysicalVolume* G4Region::GetWorldPhysical() const
0249 {
0250   return fWorldPhys;
0251 }
0252
0253 // ********************************************************************
0254 // AddMaterial
0255 // ********************************************************************
0256 //
0257 inline
0258 void G4Region::AddMaterial(G4Material* aMaterial)
0259 {
0260   auto pos = std::find(fMaterials.cbegin(),fMaterials.cend(),aMaterial);
0261   if (pos == fMaterials.cend())
0262   {
0263     fMaterials.push_back(aMaterial);
0264     fRegionMod = true;
0265   }
0266 }
0267
0268 // ********************************************************************
0269 // UsedInMassGeometry
0270 // ********************************************************************
0271 //
0272 inline
0273 void G4Region::UsedInMassGeometry(G4bool val)
0274 {
0275   fInMassGeometry = val;
0276 }
0277
0278 // ********************************************************************
0279 // UsedInParallelGeometry
0280 // ********************************************************************
0281 //
0282 inline
0283 void G4Region::UsedInParallelGeometry(G4bool val)
0284 {
0285   fInParallelGeometry = val;
0286 }
0287
0288 // ********************************************************************
0289 // IsInMassGeometry
0290 // ********************************************************************
0291 //
0292 inline
0293 G4bool G4Region::IsInMassGeometry() const
0294 {
0295   return fInMassGeometry;
0296 }
0297
0298 // ********************************************************************
0299 // IsInParallelGeometry
0300 // ********************************************************************
0301 //
0302 inline
0303 G4bool G4Region::IsInParallelGeometry() const
0304 {
0305   return fInParallelGeometry;
0306 }