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 67975 2013-03-13 10:19:44Z gcosmo $ >> 28 // >> 29 // G4SolidStore >> 30 // >> 31 // Implementation for singleton container >> 32 // >> 33 // History: >> 34 // 10.07.95 P.Kent Initial version 29 // ------------------------------------------- 35 // -------------------------------------------------------------------- 30 36 31 #include "globals.hh" 37 #include "globals.hh" 32 #include "G4SolidStore.hh" 38 #include "G4SolidStore.hh" 33 #include "G4GeometryManager.hh" 39 #include "G4GeometryManager.hh" 34 40 35 #include "G4AutoLock.hh" << 36 << 37 namespace << 38 { << 39 G4Mutex mapMutex = G4MUTEX_INITIALIZER; << 40 } << 41 << 42 // ******************************************* 41 // *************************************************************************** 43 // Static class variables 42 // Static class variables 44 // ******************************************* 43 // *************************************************************************** 45 // 44 // 46 G4SolidStore* G4SolidStore::fgInstance = nullp << 45 G4SolidStore* G4SolidStore::fgInstance = 0; 47 G4ThreadLocal G4VStoreNotifier* G4SolidStore:: << 46 G4ThreadLocal G4VStoreNotifier* G4SolidStore::fgNotifier = 0; 48 G4ThreadLocal G4bool G4SolidStore::locked = fa 47 G4ThreadLocal G4bool G4SolidStore::locked = false; 49 48 50 // ******************************************* 49 // *************************************************************************** 51 // Protected constructor: Construct underlying 50 // Protected constructor: Construct underlying container with 52 // initial size of 100 entries 51 // initial size of 100 entries 53 // ******************************************* 52 // *************************************************************************** 54 // 53 // 55 G4SolidStore::G4SolidStore() 54 G4SolidStore::G4SolidStore() 56 << 55 : std::vector<G4VSolid*>() 57 { 56 { 58 reserve(100); 57 reserve(100); 59 } 58 } 60 59 61 // ******************************************* 60 // *************************************************************************** 62 // Destructor 61 // Destructor 63 // ******************************************* 62 // *************************************************************************** 64 // 63 // 65 G4SolidStore::~G4SolidStore() 64 G4SolidStore::~G4SolidStore() 66 { 65 { >> 66 // In multi-threaded mode, since parameterised solids are replicated >> 67 // by threads, the master thread can not free them when thread private >> 68 // malloc library is used. May let the master thread to replicate. >> 69 >> 70 #ifndef G4MULTITHREADED 67 Clean(); 71 Clean(); >> 72 #endif 68 } 73 } 69 74 70 // ******************************************* 75 // *************************************************************************** 71 // Delete all elements from the store 76 // Delete all elements from the store 72 // ******************************************* 77 // *************************************************************************** 73 // 78 // 74 void G4SolidStore::Clean() 79 void G4SolidStore::Clean() 75 { 80 { 76 // Do nothing if geometry is closed 81 // Do nothing if geometry is closed 77 // 82 // 78 if (G4GeometryManager::GetInstance()->IsGeom 83 if (G4GeometryManager::GetInstance()->IsGeometryClosed()) 79 { 84 { 80 G4cout << "WARNING - Attempt to delete the 85 G4cout << "WARNING - Attempt to delete the solid store" 81 << " while geometry closed !" << G4 86 << " while geometry closed !" << G4endl; 82 return; 87 return; 83 } 88 } 84 89 85 // Locks store for deletion of solids. De-re 90 // Locks store for deletion of solids. De-registration will be 86 // performed at this stage. G4VSolids will n 91 // performed at this stage. G4VSolids will not de-register themselves. 87 // 92 // 88 locked = true; 93 locked = true; 89 94 >> 95 size_t i=0; 90 G4SolidStore* store = GetInstance(); 96 G4SolidStore* store = GetInstance(); 91 97 92 for(auto pos=store->cbegin(); pos!=store->ce << 98 #ifdef G4GEOMETRY_VOXELDEBUG >> 99 G4cout << "Deleting Solids ... "; >> 100 #endif >> 101 >> 102 for(iterator pos=store->begin(); pos!=store->end(); pos++) 93 { 103 { 94 if (fgNotifier != nullptr) { fgNotifier->N << 104 if (fgNotifier) { fgNotifier->NotifyDeRegistration(); } 95 delete *pos; << 105 if (*pos) { delete *pos; } >> 106 i++; 96 } 107 } 97 108 98 store->bmap.clear(); store->mvalid = false; << 109 #ifdef G4GEOMETRY_VOXELDEBUG >> 110 if (store->size() < i-1) >> 111 { G4cout << "No solids deleted. Already deleted by user ?" << G4endl; } >> 112 else >> 113 { G4cout << i-1 << " solids deleted !" << G4endl; } >> 114 #endif >> 115 99 locked = false; 116 locked = false; 100 store->clear(); 117 store->clear(); 101 } 118 } 102 119 103 // ******************************************* 120 // *************************************************************************** 104 // Associate user notifier to the store 121 // Associate user notifier to the store 105 // ******************************************* 122 // *************************************************************************** 106 // 123 // 107 void G4SolidStore::SetNotifier(G4VStoreNotifie 124 void G4SolidStore::SetNotifier(G4VStoreNotifier* pNotifier) 108 { 125 { 109 GetInstance(); 126 GetInstance(); 110 fgNotifier = pNotifier; 127 fgNotifier = pNotifier; 111 } 128 } 112 129 113 // ******************************************* 130 // *************************************************************************** 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 131 // Add Solid to container 142 // ******************************************* 132 // *************************************************************************** 143 // 133 // 144 void G4SolidStore::Register(G4VSolid* pSolid) 134 void G4SolidStore::Register(G4VSolid* pSolid) 145 { 135 { 146 G4SolidStore* store = GetInstance(); << 136 GetInstance()->push_back(pSolid); 147 store->push_back(pSolid); << 137 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 } 138 } 162 139 163 // ******************************************* 140 // *************************************************************************** 164 // Remove Solid from container 141 // Remove Solid from container 165 // ******************************************* 142 // *************************************************************************** 166 // 143 // 167 void G4SolidStore::DeRegister(G4VSolid* pSolid 144 void G4SolidStore::DeRegister(G4VSolid* pSolid) 168 { 145 { 169 G4SolidStore* store = GetInstance(); << 170 if (!locked) // Do not de-register if loc 146 if (!locked) // Do not de-register if locked ! 171 { 147 { 172 if (fgNotifier != nullptr) { fgNotifier->N << 148 if (fgNotifier) { fgNotifier->NotifyDeRegistration(); } 173 for (auto i=store->crbegin(); i!=store->cr << 149 for (iterator i=GetInstance()->begin(); i!=GetInstance()->end(); i++) 174 { 150 { 175 if (**i==*pSolid) 151 if (**i==*pSolid) 176 { 152 { 177 store->erase(std::next(i).base()); << 153 GetInstance()->erase(i); 178 store->mvalid = false; << 179 break; 154 break; 180 } 155 } 181 } 156 } 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 } 157 } 203 } 158 } 204 159 205 // ******************************************* 160 // *************************************************************************** 206 // Retrieve the first or last solid pointer in << 161 // Retrieve the first solid pointer in the container having that name 207 // ******************************************* 162 // *************************************************************************** 208 // 163 // 209 G4VSolid* G4SolidStore::GetSolid(const G4Strin << 164 G4VSolid* G4SolidStore::GetSolid(const G4String& name, G4bool verbose) const 210 G4bool revers << 211 { 165 { 212 G4SolidStore* store = GetInstance(); << 166 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 { 167 { 217 if ((verbose) && (pos->second.size()>1)) << 168 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 } 169 } 235 if (verbose) 170 if (verbose) 236 { 171 { 237 std::ostringstream message; << 172 std::ostringstream message; 238 message << "Solid " << name << " not found << 173 message << "Solid " << name << " not found in store !" << G4endl 239 << "Returning NULL pointer."; << 174 << "Returning NULL pointer."; 240 G4Exception("G4SolidStore::GetSolid()", << 175 G4Exception("G4SolidStore::GetSolid()", 241 "GeomMgt1001", JustWarning, me << 176 "GeomMgt1001", JustWarning, message); 242 } 177 } 243 return nullptr; << 178 return 0; 244 } 179 } 245 180 246 // ******************************************* 181 // *************************************************************************** 247 // Return ptr to Store, setting if necessary 182 // Return ptr to Store, setting if necessary 248 // ******************************************* 183 // *************************************************************************** 249 // 184 // 250 G4SolidStore* G4SolidStore::GetInstance() 185 G4SolidStore* G4SolidStore::GetInstance() 251 { 186 { 252 static G4SolidStore worldStore; 187 static G4SolidStore worldStore; 253 if (fgInstance == nullptr) << 188 if (!fgInstance) 254 { 189 { 255 fgInstance = &worldStore; 190 fgInstance = &worldStore; 256 } 191 } 257 return fgInstance; 192 return fgInstance; 258 } 193 } 259 194