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