| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // G4tgrLineProcessor
27 //
28 // Author: P.Arce, CIEMAT (November 2007)
29 // --------------------------------------------------------------------
30
31 #include "G4tgrLineProcessor.hh"
32
33 #include "G4SystemOfUnits.hh"
34 #include "G4tgrParameterMgr.hh"
35 #include "G4tgrFileIn.hh"
36 #include "G4tgrElementSimple.hh"
37 #include "G4tgrElementFromIsotopes.hh"
38 #include "G4tgrVolume.hh"
39 #include "G4tgrVolumeDivision.hh"
40 #include "G4tgrVolumeAssembly.hh"
41 #include "G4tgrPlaceDivRep.hh"
42 #include "G4tgrPlaceParameterisation.hh"
43 #include "G4tgrVolumeMgr.hh"
44 #include "G4tgrUtils.hh"
45 #include "G4tgrMaterialFactory.hh"
46 #include "G4tgrRotationMatrixFactory.hh"
47 #include "G4tgrMessenger.hh"
48
49 // --------------------------------------------------------------------
50 G4tgrLineProcessor::G4tgrLineProcessor()
51 {
52 volmgr = G4tgrVolumeMgr::GetInstance();
53 }
54
55 // --------------------------------------------------------------------
56 G4tgrLineProcessor::~G4tgrLineProcessor()
57 {
58 }
59
60 // --------------------------------------------------------------------
61 G4bool G4tgrLineProcessor::ProcessLine(const std::vector<G4String>& wl)
62 {
63 #ifdef G4VERBOSE
64 if(G4tgrMessenger::GetVerboseLevel() >= 1)
65 {
66 G4tgrUtils::DumpVS(wl, "@@@ Processing input line");
67 }
68 #endif
69
70 G4String wl0 = wl[0];
71 for(G4int ii = 0; ii < (G4int)wl0.length(); ++ii)
72 {
73 wl0[ii] = (char)std::toupper(wl0[ii]);
74 }
75
76 //------------------------------- parameter number
77 if(wl0 == ":P")
78 {
79 G4tgrParameterMgr::GetInstance()->AddParameterNumber(wl);
80
81 //------------------------------- parameter string
82 }
83 else if(wl0 == ":PS")
84 {
85 G4tgrParameterMgr::GetInstance()->AddParameterString(wl);
86
87 //------------------------------- isotope
88 }
89 else if(wl0 == ":ISOT")
90 {
91 G4tgrIsotope* isot = G4tgrMaterialFactory::GetInstance()->AddIsotope(wl);
92 volmgr->RegisterMe(isot);
93
94 //------------------------------- element
95 }
96 else if(wl0 == ":ELEM")
97 {
98 G4tgrElementSimple* elem =
99 G4tgrMaterialFactory::GetInstance()->AddElementSimple(wl);
100 volmgr->RegisterMe(elem);
101
102 //------------------------------- element from isotopes
103 }
104 else if(wl0 == ":ELEM_FROM_ISOT")
105 {
106 //:ELEM_FROM_ISOT NAME SYMBOL N_ISOT (ISOT_NAME ISOT_ABUNDANCE)
107 G4tgrElementFromIsotopes* elem =
108 G4tgrMaterialFactory::GetInstance()->AddElementFromIsotopes(wl);
109 volmgr->RegisterMe(elem);
110
111 //------------------------------- material
112 }
113 else if(wl0 == ":MATE")
114 {
115 G4tgrMaterialSimple* mate =
116 G4tgrMaterialFactory::GetInstance()->AddMaterialSimple(wl);
117 volmgr->RegisterMe(mate);
118
119 //------------------------------- material mixtures & by weight
120 }
121 else if((wl0 == ":MIXT") || (wl0 == ":MIXT_BY_WEIGHT"))
122 {
123 G4tgrMaterialMixture* mate =
124 G4tgrMaterialFactory::GetInstance()->AddMaterialMixture(
125 wl, "MaterialMixtureByWeight");
126 volmgr->RegisterMe(mate);
127
128 //------------------------------- material mixture by number of atoms
129 }
130 else if(wl0 == ":MIXT_BY_NATOMS")
131 {
132 G4tgrMaterialMixture* mate =
133 G4tgrMaterialFactory::GetInstance()->AddMaterialMixture(
134 wl, "MaterialMixtureByNoAtoms");
135 volmgr->RegisterMe(mate);
136
137 //------------------------------- material mixture by volume
138 }
139 else if(wl0 == ":MIXT_BY_VOLUME")
140 {
141 G4tgrMaterialMixture* mate =
142 G4tgrMaterialFactory::GetInstance()->AddMaterialMixture(
143 wl, "MaterialMixtureByVolume");
144 volmgr->RegisterMe(mate);
145
146 //------------------------------- material Mean Excitation Energy of
147 // Ionisation Potential
148 }
149 else if(wl0 == ":MATE_MEE")
150 {
151 G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
152 G4tgrUtils::GetString(wl[1]));
153 if(mate == 0)
154 {
155 G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
156 FatalException, G4tgrUtils::GetString(wl[1]));
157 return false;
158 }
159 mate->SetIonisationMeanExcitationEnergy(G4tgrUtils::GetDouble(wl[2]));
160
161 //------------------------------- material
162 }
163 else if(wl0 == ":MATE_STATE")
164 {
165 G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
166 G4tgrUtils::GetString(wl[1]));
167 if(mate == 0)
168 {
169 G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
170 FatalException, wl[1]);
171 }
172 mate->SetState(wl[2]);
173
174 //------------------------------- material
175 }
176 else if(wl0 == ":MATE_TEMPERATURE")
177 {
178 G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
179 G4tgrUtils::GetString(wl[1]));
180 if(mate == 0)
181 {
182 G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
183 FatalException, wl[1]);
184 }
185 mate->SetTemperature(G4tgrUtils::GetDouble(wl[2], kelvin));
186
187 //------------------------------- material
188 }
189 else if(wl0 == ":MATE_PRESSURE")
190 {
191 G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
192 G4tgrUtils::GetString(wl[1]));
193 if(mate == 0)
194 {
195 G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
196 FatalException, wl[1]);
197 }
198 mate->SetPressure(G4tgrUtils::GetDouble(wl[2], atmosphere));
199
200 //------------------------------- solid
201 }
202 else if(wl0 == ":SOLID")
203 { // called from here or from G4tgrVolume::G4tgrVolume
204 volmgr->CreateSolid(wl, 0);
205
206 //------------------------------- volume
207 }
208 else if(wl0 == ":VOLU")
209 {
210 G4tgrVolume* vol = new G4tgrVolume(wl);
211 volmgr->RegisterMe(vol);
212
213 //--------------------------------- single placement
214 }
215 else if(wl0 == ":PLACE")
216 {
217 G4tgrVolume* vol = FindVolume(G4tgrUtils::GetString(wl[1]));
218 G4tgrPlace* vpl = vol->AddPlace(wl);
219 volmgr->RegisterMe(vpl);
220
221 //--------------------------------- parameterisation
222 }
223 else if(wl0 == ":PLACE_PARAM")
224 {
225 G4tgrVolume* vol = FindVolume(G4tgrUtils::GetString(wl[1]));
226 G4tgrPlaceParameterisation* vpl = vol->AddPlaceParam(wl);
227 volmgr->RegisterMe(vpl);
228
229 //--------------------------------- division
230 }
231 else if((wl0 == ":DIV_NDIV") || (wl0 == ":DIV_WIDTH") ||
232 (wl0 == ":DIV_NDIV_WIDTH"))
233 {
234 //---------- Create G4tgrVolumeDivision and fill the volume params
235 G4tgrVolumeDivision* vol = new G4tgrVolumeDivision(wl);
236 volmgr->RegisterMe(vol);
237
238 //--------------------------------- replica
239 }
240 else if(wl0 == ":REPL")
241 {
242 G4tgrVolume* vol = FindVolume(G4tgrUtils::GetString(wl[1]));
243 G4tgrPlaceDivRep* vpl = vol->AddPlaceReplica(wl);
244 volmgr->RegisterMe(vpl);
245
246 //----------------------------- assembly volume: definition of components
247 }
248 else if(wl0 == ":VOLU_ASSEMBLY")
249 {
250 G4tgrVolumeAssembly* vol = new G4tgrVolumeAssembly(wl);
251 volmgr->RegisterMe(vol);
252
253 //----------------------------- assembly volume: definition of components
254 }
255 else if(wl0 == ":PLACE_ASSEMBLY")
256 {
257 G4tgrVolume* vol = FindVolume(G4tgrUtils::GetString(wl[1]));
258 G4tgrPlace* vpl = vol->AddPlace(wl);
259 volmgr->RegisterMe(vpl);
260
261 //--------------------------------- rotation matrix
262 }
263 else if(wl0 == ":ROTM")
264 {
265 //---------- When second word is ':NEXT/:MNXT' it is used for defining a
266 // rotation matrix that will be used for the next placement/s
267 G4tgrRotationMatrix* rm =
268 G4tgrRotationMatrixFactory::GetInstance()->AddRotMatrix(wl);
269 volmgr->RegisterMe(rm);
270
271 //------------------------------- visualisation
272 }
273 else if(wl0 == ":VIS")
274 {
275 std::vector<G4tgrVolume*> vols =
276 volmgr->FindVolumes(G4tgrUtils::GetString(wl[1]), 1);
277 for(std::size_t ii = 0; ii < vols.size(); ++ii)
278 {
279 vols[ii]->AddVisibility(wl);
280 }
281
282 //--------------------------------- colour
283 }
284 else if((wl0 == ":COLOUR") || (wl0 == ":COLOR"))
285 {
286 std::vector<G4tgrVolume*> vols =
287 volmgr->FindVolumes(G4tgrUtils::GetString(wl[1]), 1);
288 for(std::size_t ii = 0; ii < vols.size(); ++ii)
289 {
290 vols[ii]->AddRGBColour(wl);
291 }
292
293 //--------------------------------- check overlaps
294 }
295 else if(wl0 == ":CHECK_OVERLAPS")
296 {
297 std::vector<G4tgrVolume*> vols =
298 volmgr->FindVolumes(G4tgrUtils::GetString(wl[1]), 1);
299 for(std::size_t ii = 0; ii < vols.size(); ++ii)
300 {
301 vols[ii]->AddCheckOverlaps(wl);
302 }
303 //--------------------------------- ERROR
304 }
305 else
306 {
307 return false;
308 }
309
310 return true;
311 }
312
313 // --------------------------------------------------------------------
314 G4tgrVolume* G4tgrLineProcessor::FindVolume(const G4String& volname)
315 {
316 G4tgrVolume* vol = volmgr->FindVolume(volname, 1);
317
318 if(vol->GetType() == "VOLDivision")
319 {
320 G4Exception("G4tgrLineProcessor::FindVolume()", "InvalidSetup",
321 FatalException,
322 "Using 'PLACE' for a volume created by a division !");
323 }
324
325 return vol;
326 }
327