| 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 // G4GDMLParser implementation
27 //
28 // Author: Zoltan Torzsok, November 2007
29 // -------------------------------------------
30
31 #include "G4GDMLParser.hh"
32
33 #include "G4UnitsTable.hh"
34 #include "G4LogicalVolumeStore.hh"
35 #include "G4RegionStore.hh"
36 #include "G4UserLimits.hh"
37 #include "G4ProductionCuts.hh"
38 #include "G4ReflectionFactory.hh"
39 #include "G4Track.hh"
40
41 // -------------------------------------------
42 G4GDMLParser::G4GDMLParser()
43 : strip(true)
44 {
45 reader = new G4GDMLReadStructure;
46 writer = new G4GDMLWriteStructure;
47 messenger = new G4GDMLMessenger(this);
48
49 xercesc::XMLPlatformUtils::Initialize();
50 }
51
52 // -------------------------------------------
53 G4GDMLParser::G4GDMLParser(G4GDMLReadStructure
54 : urcode(true), strip(true)
55 {
56 reader = extr;
57 writer = new G4GDMLWriteStructure;
58 messenger = new G4GDMLMessenger(this);
59
60 xercesc::XMLPlatformUtils::Initialize();
61 }
62
63 // -------------------------------------------
64 G4GDMLParser::G4GDMLParser(G4GDMLReadStructure
65 G4GDMLWriteStructur
66 : urcode(true), uwcode(true), strip(true)
67 {
68 reader = extr;
69 writer = extw;
70 messenger = new G4GDMLMessenger(this);
71
72 xercesc::XMLPlatformUtils::Initialize();
73 }
74
75 // -------------------------------------------
76 G4GDMLParser::~G4GDMLParser()
77 {
78 xercesc::XMLPlatformUtils::Terminate();
79 if(!urcode)
80 {
81 delete reader;
82 }
83 if(!uwcode)
84 {
85 delete writer;
86 }
87 delete ullist;
88 delete rlist;
89
90 delete messenger;
91 }
92
93 // -------------------------------------------
94 void G4GDMLParser::ImportRegions()
95 {
96 G4ReflectionFactory* reflFactory = G4Ref
97 const G4GDMLAuxListType* auxInfoList = GetAu
98 for(auto iaux = auxInfoList->cbegin(); iaux
99 {
100 if(iaux->type != "Region")
101 continue;
102
103 G4String name = iaux->value;
104 if(strip)
105 {
106 reader->StripName(name);
107 }
108 if(G4StrUtil::contains(name, "DefaultRegio
109 continue;
110
111 if(!iaux->auxList)
112 {
113 G4Exception("G4GDMLParser::ImportRegions
114 "Invalid definition of geome
115 }
116 else // Create region and loop over all r
117 {
118 G4Region* aRegion = new G4Region(n
119 G4ProductionCuts* pcuts = new G4Producti
120 aRegion->SetProductionCuts(pcuts);
121 for(auto raux = iaux->auxList->cbegin();
122 raux != iaux->auxList->cend();
123 {
124 const G4String& tag = raux->type;
125 if(tag == "volume")
126 {
127 G4String volname = raux->value;
128 if(strip)
129 {
130 reader->StripName(volname);
131 }
132 G4LogicalVolumeStore* store = G4Logi
133 auto pos = store->GetMap().find(voln
134 if(pos != store->GetMap().cend())
135 {
136 // Scan for all possible volumes w
137 // and set them as root logical vo
138 // Issue a notification in case mo
139 // with same name exist and get se
140 //
141 if (pos->second.size()>1)
142 {
143 std::ostringstream message;
144 message << "There exists more th
145 << "in store named: " <<
146 << "NOTE: assigning all
147 << "volumes for region:
148 G4Exception("G4GDMLParser::Impor
149 "Notification", Just
150 }
151 for (auto vpos = pos->second.cbegi
152 vpos != pos->second.cend
153 {
154 aRegion->AddRootLogicalVolume(*v
155 if(reflFactory->IsConstituent(*v
156 aRegion->AddRootLogicalVolume(
157 }
158 }
159 else
160 {
161 std::ostringstream message;
162 message << "Volume NOT found in st
163 << " Volume " << vo
164 << G4endl
165 << " No region is b
166 G4Exception("G4GDMLParser::ImportR
167 "InvalidSetup", JustWa
168 }
169 }
170 else if(tag == "pcut")
171 {
172 const G4String& cvalue = raux->value
173 const G4String& cunit = raux->unit;
174 if(G4UnitDefinition::GetCategory(cun
175 {
176 G4Exception("G4GDMLParser::ImportR
177 FatalException, "Inval
178 }
179 G4double cut =
180 eval.Evaluate(cvalue) * G4UnitDefi
181 pcuts->SetProductionCut(cut, "proton
182 }
183 else if(tag == "ecut")
184 {
185 const G4String& cvalue = raux->value
186 const G4String& cunit = raux->unit;
187 if(G4UnitDefinition::GetCategory(cun
188 {
189 G4Exception("G4GDMLParser::ImportR
190 FatalException, "Inval
191 }
192 G4double cut =
193 eval.Evaluate(cvalue) * G4UnitDefi
194 pcuts->SetProductionCut(cut, "e-");
195 }
196 else if(tag == "poscut")
197 {
198 const G4String& cvalue = raux->value
199 const G4String& cunit = raux->unit;
200 if(G4UnitDefinition::GetCategory(cun
201 {
202 G4Exception("G4GDMLParser::ImportR
203 FatalException, "Inval
204 }
205 G4double cut =
206 eval.Evaluate(cvalue) * G4UnitDefi
207 pcuts->SetProductionCut(cut, "e+");
208 }
209 else if(tag == "gamcut")
210 {
211 const G4String& cvalue = raux->value
212 const G4String& cunit = raux->unit;
213 if(G4UnitDefinition::GetCategory(cun
214 {
215 G4Exception("G4GDMLParser::ImportR
216 FatalException, "Inval
217 }
218 G4double cut =
219 eval.Evaluate(cvalue) * G4UnitDefi
220 pcuts->SetProductionCut(cut, "gamma"
221 }
222 else if(tag == "ulimits")
223 {
224 G4double ustepMax = DBL_MAX, utrakMa
225 G4double uekinMin = 0., urangMin = 0
226 const G4String& ulname = raux->value
227 for(auto uaux = raux->auxList->cbegi
228 uaux != raux->auxList->cend
229 {
230 const G4String& ultag = uaux->typ
231 const G4String& uvalue = uaux->val
232 const G4String& uunit = uaux->uni
233 G4double ulvalue = eval.Evaluate(u
234 if(ultag == "ustepMax")
235 {
236 ustepMax = ulvalue;
237 }
238 else if(ultag == "utrakMax")
239 {
240 utrakMax = ulvalue;
241 }
242 else if(ultag == "utimeMax")
243 {
244 utimeMax = ulvalue;
245 }
246 else if(ultag == "uekinMin")
247 {
248 uekinMin = ulvalue;
249 }
250 else if(ultag == "urangMin")
251 {
252 urangMin = ulvalue;
253 }
254 else
255 {
256 G4Exception("G4GDMLParser::Impor
257 FatalException, "Inv
258 }
259 }
260 G4UserLimits* ulimits = new G4UserLi
261 ulname, ustepMax, utrakMax, utimeM
262 aRegion->SetUserLimits(ulimits);
263 }
264 else
265 continue; // Ignore unknown tags
266 }
267 }
268 }
269 }
270
271 // -------------------------------------------
272 void G4GDMLParser::ExportRegions(G4bool storeR
273 {
274 G4RegionStore* rstore = G4RegionS
275 G4ReflectionFactory* reflFactory = G4Reflect
276 for(std::size_t i = 0; i < rstore->size(); +
277 // Skip default regions associated to wor
278 {
279 const G4String& tname = (*rstore)[i]->GetN
280 if(G4StrUtil::contains(tname, "DefaultRegi
281 continue;
282 const G4String& rname = writer->Generat
283 rlist = new G4GDMLAuxLi
284 G4GDMLAuxStructType raux = { "Region", rna
285 auto rlvol_iter = (*rstore)[i]->GetRootLog
286 for(std::size_t j = 0; j < (*rstore)[i]->G
287 {
288 G4LogicalVolume* rlvol = *rlvol_iter;
289 if(reflFactory->IsReflected(rlvol))
290 continue;
291 G4String vname = writer->GenerateName(rl
292 if(!storeReferences)
293 {
294 reader->StripName(vname);
295 }
296 G4GDMLAuxStructType rsubaux = { "volume"
297 rlist->push_back(rsubaux);
298 ++rlvol_iter;
299 }
300 G4double gam_cut
301 = (*rstore)[i]->GetProductionCuts()->Get
302 G4GDMLAuxStructType caux1
303 = { "gamcut", eval.ConvertToString(gam_c
304 rlist->push_back(caux1);
305 G4double e_cut = (*rstore)[i]->GetProducti
306 G4GDMLAuxStructType caux2
307 = { "ecut", eval.ConvertToString(e_cut),
308 rlist->push_back(caux2);
309 G4double pos_cut
310 = (*rstore)[i]->GetProductionCuts()->Get
311 G4GDMLAuxStructType caux3
312 = { "poscut", eval.ConvertToString(pos_c
313 rlist->push_back(caux3);
314 G4double p_cut
315 = (*rstore)[i]->GetProductionCuts()->Get
316 G4GDMLAuxStructType caux4
317 = { "pcut", eval.ConvertToString(p_cut),
318 rlist->push_back(caux4);
319 if((*rstore)[i]->GetUserLimits())
320 {
321 const G4Track fake_trk;
322 ullist = new G4GDMLAux
323 const G4String& utype = (*rstore)[i]-
324 G4GDMLAuxStructType uaux = { "ulimits",
325 G4double max_step
326 = (*rstore)[i]->GetUserLimits()->GetMa
327 G4GDMLAuxStructType ulaux1
328 = { "ustepMax", eval.ConvertToString(m
329 ullist->push_back(ulaux1);
330 G4double max_trk
331 = (*rstore)[i]->GetUserLimits()->GetUs
332 G4GDMLAuxStructType ulaux2
333 = { "utrakMax", eval.ConvertToString(m
334 ullist->push_back(ulaux2);
335 G4double max_time
336 = (*rstore)[i]->GetUserLimits()->GetUs
337 G4GDMLAuxStructType ulaux3
338 = { "utimeMax", eval.ConvertToString(m
339 ullist->push_back(ulaux3);
340 G4double min_ekin
341 = (*rstore)[i]->GetUserLimits()->GetUs
342 G4GDMLAuxStructType ulaux4
343 = { "uekinMin", eval.ConvertToString(m
344 ullist->push_back(ulaux4);
345 G4double min_rng
346 = (*rstore)[i]->GetUserLimits()->GetUs
347 G4GDMLAuxStructType ulaux5
348 = { "urangMin", eval.ConvertToString(m
349 ullist->push_back(ulaux5);
350 rlist->push_back(uaux);
351 }
352 AddAuxiliary(raux);
353 }
354 }
355