| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // G4IStore implementation
27 //
28 // Author: Michael Dressel (CERN), 2002
29 // Modified: Alex Howard (CERN), 2013 - Change
30 // -------------------------------------------
31
32 #include "G4IStore.hh"
33 #include "G4VPhysicalVolume.hh"
34 #include "G4GeometryCell.hh"
35 #include "G4GeometryCellStepStream.hh"
36 #include "G4LogicalVolume.hh"
37 #include "G4TransportationManager.hh"
38
39 #include "G4AutoLock.hh"
40
41 namespace
42 {
43 G4Mutex IStoreMutex = G4MUTEX_INITIALIZER;
44 }
45
46 // *******************************************
47 // Static class variable: ptr to single instan
48 // *******************************************
49 G4ThreadLocal G4IStore* G4IStore::fInstance =
50
51 G4IStore::G4IStore()
52 : fWorldVolume(G4TransportationManager::GetT
53 ->GetNavigatorForTracking()->
54 {
55 }
56
57 G4IStore::G4IStore(const G4String& ParallelWor
58 : fWorldVolume(G4TransportationManager::GetT
59 ->GetParallelWorld(ParallelWo
60 {
61 #ifdef G4VERBOSE
62 G4cout << " G4IStore:: ParallelWorldName = "
63 << ParallelWorldName << G4endl;
64 G4cout << " G4IStore:: fParallelWorldVolume
65 << fWorldVolume->GetName() << G4endl;
66 #endif
67 }
68
69 G4IStore::~G4IStore() = default;
70
71 void G4IStore::Clear()
72 {
73 fGeometryCelli.clear();
74 }
75
76 void G4IStore::SetWorldVolume()
77 {
78 G4cout << " G4IStore:: SetWorldVolume " << G
79 fWorldVolume = G4TransportationManager::GetT
80 ->GetNavigatorForTracking()->
81 G4cout << " World volume is: " << fWorldVolu
82 // fGeometryCelli = new G4GeometryCellImport
83 }
84
85 void G4IStore::SetParallelWorldVolume(const G4
86 {
87 G4cout << " G4IStore:: SetParallelWorldVolum
88 fWorldVolume = G4TransportationManager::GetT
89 ->GetParallelWorld(paraName);
90 G4cout << " ParallelWorld volume is: " << fW
91 // fGeometryCelli = new G4GeometryCellImport
92 }
93
94 const G4VPhysicalVolume& G4IStore::GetWorldVol
95 {
96 return *fWorldVolume;
97 }
98
99 const G4VPhysicalVolume* G4IStore::GetParallel
100 {
101 return fWorldVolume;
102 }
103
104 void G4IStore::SetInternalIterator(const G4Geo
105 {
106 fCurrentIterator = fGeometryCelli.find(gCell
107 }
108
109 void G4IStore::AddImportanceGeometryCell(G4dou
110 const
111 {
112 if (importance < 0 )
113 {
114 Error("AddImportanceGeometryCell() - Inval
115 }
116 if (!IsInWorld(gCell.GetPhysicalVolume()) )
117 {
118 Error("AddImportanceGeometryCell() - Physi
119 }
120 SetInternalIterator(gCell);
121 if (fCurrentIterator != fGeometryCelli.cend(
122 {
123 Error("AddImportanceGeometryCell() - Regio
124 }
125 fGeometryCelli[gCell] = importance;
126 }
127
128 void G4IStore::AddImportanceGeometryCell(G4dou
129 const
130 G4int
131 {
132 AddImportanceGeometryCell(importance, G4Geom
133 }
134
135 void G4IStore::ChangeImportance(G4double impor
136 const G4Geomet
137 {
138 if (importance < 0 )
139 {
140 Error("ChangeImportance() - Invalid import
141 }
142 if (!IsInWorld(gCell.GetPhysicalVolume()))
143 {
144 Error("ChangeImportance() - Physical volum
145 }
146 SetInternalIterator(gCell);
147 if (fCurrentIterator == fGeometryCelli.cend(
148 {
149 Error("ChangeImportance() - Region does no
150 }
151 fGeometryCelli[gCell] = importance;
152
153 }
154
155 void G4IStore::ChangeImportance(G4double impor
156 const G4VPhysi
157 G4int aRepNum)
158 {
159 ChangeImportance(importance, G4GeometryCell(
160 }
161
162 G4double G4IStore::GetImportance(const G4VPhys
163 G4int aRepNum
164 {
165 G4AutoLock l(&IStoreMutex);
166 SetInternalIterator(G4GeometryCell(aVolume,
167 auto gCellIterator = fCurrentIterator;
168 if (gCellIterator == fGeometryCelli.cend())
169 {
170 Error("GetImportance() - Region does not e
171 return 0.;
172 }
173 G4double importance_value = (*fCurrentIterat
174 l.unlock();
175
176 return importance_value;
177 }
178
179 G4double G4IStore::GetImportance(const G4Geome
180 {
181 G4AutoLock l(&IStoreMutex);
182 SetInternalIterator(gCell);
183 auto gCellIterator = fCurrentIterator;
184 if (gCellIterator == fGeometryCelli.cend())
185 {
186 std::ostringstream err_mess;
187 err_mess << "GetImportance() - Region does
188 << "Geometry cell, " << gCell
189 << ", not found in: " << fGeometr
190 Error(err_mess.str());
191 return 0.;
192 }
193 G4double importance_value = (*fCurrentIterat
194 l.unlock();
195
196 return importance_value;
197 }
198
199 G4bool G4IStore::IsKnown(const G4GeometryCell&
200 {
201 G4AutoLock l(&IStoreMutex);
202 G4bool inWorldKnown(IsInWorld(gCell.GetPhysi
203
204 if ( inWorldKnown )
205 {
206 SetInternalIterator(gCell);
207 inWorldKnown = (fCurrentIterator != fGeome
208 }
209 l.unlock();
210
211 return inWorldKnown;
212 }
213
214 G4bool G4IStore::IsInWorld(const G4VPhysicalVo
215 {
216 G4bool isIn(true);
217 if (!(aVolume == *fWorldVolume))
218 {
219 isIn = fWorldVolume->GetLogicalVolume()->I
220 }
221 return isIn;
222 }
223
224 void G4IStore::Error(const G4String& msg) cons
225 {
226 G4Exception("G4IStore::Error()", "GeomBias00
227 }
228
229 // *******************************************
230 // Returns the instance of the singleton.
231 // Creates it in case it's called for the firs
232 // *******************************************
233 //
234 G4IStore* G4IStore::GetInstance()
235 {
236 if (fInstance == nullptr)
237 {
238 #ifdef G4VERBOSE
239 G4cout << "G4IStore:: Creating new MASS IS
240 #endif
241 fInstance = new G4IStore();
242 }
243 return fInstance;
244 }
245
246 // *******************************************
247 // Returns the instance of the singleton.
248 // Creates it in case it's called for the firs
249 // *******************************************
250 //
251 G4IStore* G4IStore::GetInstance(const G4String
252 {
253 if (fInstance == nullptr)
254 {
255 #ifdef G4VERBOSE
256 G4cout << "G4IStore:: Creating new Paralle
257 << ParallelWorldName << G4endl;
258 #endif
259 fInstance = new G4IStore(ParallelWorldName
260 }
261 return fInstance;
262 }
263