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 // 25 // 26 // G4SolidStore implementation << 27 // 26 // 28 // 10.07.95, P.Kent, G.Cosmo << 27 // $Id: G4SolidStore.cc,v 1.17 2007/04/10 10:13:50 gcosmo Exp $ >> 28 // GEANT4 tag $Name: geant4-09-03-patch-02 $ >> 29 // >> 30 // G4SolidStore >> 31 // >> 32 // Implementation for singleton container >> 33 // >> 34 // History: >> 35 // 10.07.95 P.Kent Initial version 29 // ------------------------------------------- 36 // -------------------------------------------------------------------- 30 37 31 #include "globals.hh" 38 #include "globals.hh" 32 #include "G4SolidStore.hh" 39 #include "G4SolidStore.hh" 33 #include "G4GeometryManager.hh" 40 #include "G4GeometryManager.hh" 34 41 35 #include "G4AutoLock.hh" << 36 << 37 namespace << 38 { << 39 G4Mutex mapMutex = G4MUTEX_INITIALIZER; << 40 } << 41 << 42 // ******************************************* 42 // *************************************************************************** 43 // Static class variables 43 // Static class variables 44 // ******************************************* 44 // *************************************************************************** 45 // 45 // 46 G4SolidStore* G4SolidStore::fgInstance = nullp << 46 G4SolidStore* G4SolidStore::fgInstance = 0; 47 G4ThreadLocal G4VStoreNotifier* G4SolidStore:: << 47 G4VStoreNotifier* G4SolidStore::fgNotifier = 0; 48 G4ThreadLocal G4bool G4SolidStore::locked = fa << 48 G4bool G4SolidStore::locked = false; 49 49 50 // ******************************************* 50 // *************************************************************************** 51 // Protected constructor: Construct underlying 51 // Protected constructor: Construct underlying container with 52 // initial size of 100 entries 52 // initial size of 100 entries 53 // ******************************************* 53 // *************************************************************************** 54 // 54 // 55 G4SolidStore::G4SolidStore() 55 G4SolidStore::G4SolidStore() 56 << 56 : std::vector<G4VSolid*>() 57 { 57 { 58 reserve(100); 58 reserve(100); 59 } 59 } 60 60 61 // ******************************************* 61 // *************************************************************************** 62 // Destructor 62 // Destructor 63 // ******************************************* 63 // *************************************************************************** 64 // 64 // 65 G4SolidStore::~G4SolidStore() 65 G4SolidStore::~G4SolidStore() 66 { 66 { 67 Clean(); 67 Clean(); 68 } 68 } 69 69 70 // ******************************************* 70 // *************************************************************************** 71 // Delete all elements from the store 71 // Delete all elements from the store 72 // ******************************************* 72 // *************************************************************************** 73 // 73 // 74 void G4SolidStore::Clean() 74 void G4SolidStore::Clean() 75 { 75 { 76 // Do nothing if geometry is closed 76 // Do nothing if geometry is closed 77 // 77 // 78 if (G4GeometryManager::GetInstance()->IsGeom 78 if (G4GeometryManager::GetInstance()->IsGeometryClosed()) 79 { 79 { 80 G4cout << "WARNING - Attempt to delete the 80 G4cout << "WARNING - Attempt to delete the solid store" 81 << " while geometry closed !" << G4 81 << " while geometry closed !" << G4endl; 82 return; 82 return; 83 } 83 } 84 84 85 // Locks store for deletion of solids. De-re 85 // Locks store for deletion of solids. De-registration will be 86 // performed at this stage. G4VSolids will n 86 // performed at this stage. G4VSolids will not de-register themselves. 87 // 87 // 88 locked = true; 88 locked = true; 89 89 >> 90 size_t i=0; 90 G4SolidStore* store = GetInstance(); 91 G4SolidStore* store = GetInstance(); 91 92 92 for(auto pos=store->cbegin(); pos!=store->ce << 93 #ifdef G4GEOMETRY_VOXELDEBUG >> 94 G4cout << "Deleting Solids ... "; >> 95 #endif >> 96 >> 97 for(iterator pos=store->begin(); pos!=store->end(); pos++) 93 { 98 { 94 if (fgNotifier != nullptr) { fgNotifier->N << 99 if (fgNotifier) { fgNotifier->NotifyDeRegistration(); } 95 delete *pos; << 100 if (*pos) { delete *pos; } >> 101 i++; 96 } 102 } 97 103 98 store->bmap.clear(); store->mvalid = false; << 104 #ifdef G4GEOMETRY_VOXELDEBUG >> 105 if (store->size() < i-1) >> 106 { G4cout << "No solids deleted. Already deleted by user ?" << G4endl; } >> 107 else >> 108 { G4cout << i-1 << " solids deleted !" << G4endl; } >> 109 #endif >> 110 99 locked = false; 111 locked = false; 100 store->clear(); 112 store->clear(); 101 } 113 } 102 114 103 // ******************************************* 115 // *************************************************************************** 104 // Associate user notifier to the store 116 // Associate user notifier to the store 105 // ******************************************* 117 // *************************************************************************** 106 // 118 // 107 void G4SolidStore::SetNotifier(G4VStoreNotifie 119 void G4SolidStore::SetNotifier(G4VStoreNotifier* pNotifier) 108 { 120 { 109 GetInstance(); 121 GetInstance(); 110 fgNotifier = pNotifier; 122 fgNotifier = pNotifier; 111 } 123 } 112 124 113 // ******************************************* 125 // *************************************************************************** 114 // Bring contents of internal map up to date a << 115 // ******************************************* << 116 // << 117 void G4SolidStore::UpdateMap() << 118 { << 119 G4AutoLock l(&mapMutex); // to avoid thread << 120 if (mvalid) return; << 121 bmap.clear(); << 122 for(auto pos=GetInstance()->cbegin(); pos!=G << 123 { << 124 const G4String& sol_name = (*pos)->GetName << 125 auto it = bmap.find(sol_name); << 126 if (it != bmap.cend()) << 127 { << 128 it->second.push_back(*pos); << 129 } << 130 else << 131 { << 132 std::vector<G4VSolid*> sol_vec { *pos }; << 133 bmap.insert(std::make_pair(sol_name, sol << 134 } << 135 } << 136 mvalid = true; << 137 l.unlock(); << 138 } << 139 << 140 // ******************************************* << 141 // Add Solid to container 126 // Add Solid to container 142 // ******************************************* 127 // *************************************************************************** 143 // 128 // 144 void G4SolidStore::Register(G4VSolid* pSolid) 129 void G4SolidStore::Register(G4VSolid* pSolid) 145 { 130 { 146 G4SolidStore* store = GetInstance(); << 131 GetInstance()->push_back(pSolid); 147 store->push_back(pSolid); << 132 if (fgNotifier) { fgNotifier->NotifyRegistration(); } 148 const G4String& sol_name = pSolid->GetName() << 149 auto it = store->bmap.find(sol_name); << 150 if (it != store->bmap.cend()) << 151 { << 152 it->second.push_back(pSolid); << 153 } << 154 else << 155 { << 156 std::vector<G4VSolid*> sol_vec { pSolid }; << 157 store->bmap.insert(std::make_pair(sol_name << 158 } << 159 if (fgNotifier != nullptr) { fgNotifier->Not << 160 store->mvalid = true; << 161 } 133 } 162 134 163 // ******************************************* 135 // *************************************************************************** 164 // Remove Solid from container 136 // Remove Solid from container 165 // ******************************************* 137 // *************************************************************************** 166 // 138 // 167 void G4SolidStore::DeRegister(G4VSolid* pSolid 139 void G4SolidStore::DeRegister(G4VSolid* pSolid) 168 { 140 { 169 G4SolidStore* store = GetInstance(); << 170 if (!locked) // Do not de-register if loc 141 if (!locked) // Do not de-register if locked ! 171 { 142 { 172 if (fgNotifier != nullptr) { fgNotifier->N << 143 if (fgNotifier) { fgNotifier->NotifyDeRegistration(); } 173 for (auto i=store->crbegin(); i!=store->cr << 144 for (iterator i=GetInstance()->begin(); i!=GetInstance()->end(); i++) 174 { 145 { 175 if (**i==*pSolid) 146 if (**i==*pSolid) 176 { 147 { 177 store->erase(std::next(i).base()); << 148 GetInstance()->erase(i); 178 store->mvalid = false; << 179 break; 149 break; 180 } 150 } 181 } 151 } 182 const G4String& sol_name = pSolid->GetName << 183 auto it = store->bmap.find(sol_name); << 184 if (it != store->bmap.cend()) << 185 { << 186 if (it->second.size() > 1) << 187 { << 188 for (auto i=it->second.cbegin(); i!=it << 189 { << 190 if (**i==*pSolid) << 191 { << 192 it->second.erase(i); << 193 break; << 194 } << 195 } << 196 } << 197 else << 198 { << 199 store->bmap.erase(it); << 200 } << 201 } << 202 } 152 } 203 } 153 } 204 154 205 // ******************************************* 155 // *************************************************************************** 206 // Retrieve the first or last solid pointer in << 156 // Retrieve the first solid pointer in the container having that name 207 // ******************************************* 157 // *************************************************************************** 208 // 158 // 209 G4VSolid* G4SolidStore::GetSolid(const G4Strin << 159 G4VSolid* G4SolidStore::GetSolid(const G4String& name, G4bool verbose) const 210 G4bool revers << 211 { 160 { 212 G4SolidStore* store = GetInstance(); << 161 for (iterator i=GetInstance()->begin(); i!=GetInstance()->end(); i++) 213 if (!store->mvalid) { store->UpdateMap(); } << 214 auto pos = store->bmap.find(name); << 215 if(pos != store->bmap.cend()) << 216 { 162 { 217 if ((verbose) && (pos->second.size()>1)) << 163 if ((*i)->GetName() == name) { return *i; } 218 { << 219 std::ostringstream message; << 220 message << "There exists more than ONE s << 221 << name << "!" << G4endl << 222 << "Returning the first found."; << 223 G4Exception("G4SolidStore::GetSolid()", << 224 "GeomMgt1001", JustWarning, << 225 } << 226 if(reverseSearch) << 227 { << 228 return pos->second[pos->second.size()-1] << 229 } << 230 else << 231 { << 232 return pos->second[0]; << 233 } << 234 } 164 } 235 if (verbose) 165 if (verbose) 236 { 166 { 237 std::ostringstream message; << 167 G4cerr << "ERROR - G4SolidStore::GetSolid()" << G4endl 238 message << "Solid " << name << " not found << 168 << " Solid " << name << " not found in store !" << G4endl 239 << "Returning NULL pointer."; << 169 << " Returning NULL pointer." << G4endl; 240 G4Exception("G4SolidStore::GetSolid()", << 170 G4Exception("G4SolidStore::GetSolid()", "InvalidQuery", 241 "GeomMgt1001", JustWarning, me << 171 JustWarning, "Solid NOT found in store !"); 242 } 172 } 243 return nullptr; << 173 return 0; 244 } 174 } 245 175 246 // ******************************************* 176 // *************************************************************************** 247 // Return ptr to Store, setting if necessary 177 // Return ptr to Store, setting if necessary 248 // ******************************************* 178 // *************************************************************************** 249 // 179 // 250 G4SolidStore* G4SolidStore::GetInstance() 180 G4SolidStore* G4SolidStore::GetInstance() 251 { 181 { 252 static G4SolidStore worldStore; 182 static G4SolidStore worldStore; 253 if (fgInstance == nullptr) << 183 if (!fgInstance) 254 { 184 { 255 fgInstance = &worldStore; 185 fgInstance = &worldStore; 256 } 186 } 257 return fgInstance; 187 return fgInstance; 258 } 188 } 259 189