| 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 // 26 //
>> 27 // $Id: clparse.cc,v 1.19 2008-11-17 08:33:57 gcosmo Exp $
>> 28 // GEANT4 tag $Name: not supported by cvs2svn $
27 // 29 //
28 // modified by I.Hrivnacova 30 // modified by I.Hrivnacova
29 // added G3SensVol 31 // added G3SensVol
30 32
31 #include "globals.hh" 33 #include "globals.hh"
32 #include <fstream> 34 #include <fstream>
33 #include "G4Tokenizer.hh" 35 #include "G4Tokenizer.hh"
34 #include "G3toG4.hh" 36 #include "G3toG4.hh"
35 #include "G3EleTable.hh" 37 #include "G3EleTable.hh"
36 #include "G3VolTable.hh" 38 #include "G3VolTable.hh"
37 #include "G3MatTable.hh" 39 #include "G3MatTable.hh"
38 #include "G3MedTable.hh" 40 #include "G3MedTable.hh"
39 #include "G3RotTable.hh" 41 #include "G3RotTable.hh"
40 #include "G3PartTable.hh" 42 #include "G3PartTable.hh"
41 #include "G3DetTable.hh" 43 #include "G3DetTable.hh"
42 #include "G3SensVolVector.hh" 44 #include "G3SensVolVector.hh"
43 45
44 std::ofstream ofile; 46 std::ofstream ofile;
45 47
46 extern "C" 48 extern "C"
47 { 49 {
48 #include <stdlib.h> 50 #include <stdlib.h>
49 } 51 }
50 52
51 extern std::ofstream ofile; 53 extern std::ofstream ofile;
52 54
53 G3VolTable G3Vol; 55 G3VolTable G3Vol;
54 G3MatTable G3Mat; // material G3 ID <-> G4 p 56 G3MatTable G3Mat; // material G3 ID <-> G4 pointer table
55 G3MedTable G3Med; // trk media G3 ID <-> G4 57 G3MedTable G3Med; // trk media G3 ID <-> G4 pointer table
56 G3RotTable G3Rot; // rotation ID <-> G4 tran 58 G3RotTable G3Rot; // rotation ID <-> G4 transform object table
57 G3PartTable G3Part; // particle ID <-> Particl 59 G3PartTable G3Part; // particle ID <-> ParticleDefinition pointer
58 G3DetTable G3Det; // sensitive detector name 60 G3DetTable G3Det; // sensitive detector name <-> pointer
59 G3EleTable G3Ele; // element names table 61 G3EleTable G3Ele; // element names table
60 G3SensVolVector G3SensVol; // vector of sensit 62 G3SensVolVector G3SensVol; // vector of sensitive logical volumes
61 char gSeparator('_'); 63 char gSeparator('_');
62 64
63 G4int narray; 65 G4int narray;
64 66
65 G4int Ipar[1000]; 67 G4int Ipar[1000];
66 G4double Rpar[1000]; 68 G4double Rpar[1000];
67 G4String Spar[1000]; 69 G4String Spar[1000];
68 70
69 G4int G3CLTokens(G4String *line, G4String *tok 71 G4int G3CLTokens(G4String *line, G4String *tokens);
70 void G3CLEval(G4String *tokens, char *select); 72 void G3CLEval(G4String *tokens, char *select);
71 73
72 // front-end decoders for G3 routines 74 // front-end decoders for G3 routines
73 // 75 //
74 void PG4gsvolu(G4String *tokens); 76 void PG4gsvolu(G4String *tokens);
75 void PG4gspos (G4String *tokens); 77 void PG4gspos (G4String *tokens);
76 void PG4gsposp(G4String *tokens); 78 void PG4gsposp(G4String *tokens);
77 void PG4gsatt (G4String *tokens); 79 void PG4gsatt (G4String *tokens);
78 void PG4gsrotm(G4String *tokens); 80 void PG4gsrotm(G4String *tokens);
79 void PG4gsdvn (G4String *tokens); 81 void PG4gsdvn (G4String *tokens);
80 void PG4gsdvt (G4String *tokens); 82 void PG4gsdvt (G4String *tokens);
81 void PG4gsdvx (G4String *tokens); 83 void PG4gsdvx (G4String *tokens);
82 void PG4gsdvn2(G4String *tokens); 84 void PG4gsdvn2(G4String *tokens);
83 void PG4gsdvt2(G4String *tokens); 85 void PG4gsdvt2(G4String *tokens);
84 void PG4gsmate(G4String *tokens); 86 void PG4gsmate(G4String *tokens);
85 void PG4gsmixt(G4String *tokens); 87 void PG4gsmixt(G4String *tokens);
86 void PG4gstmed(G4String *tokens); 88 void PG4gstmed(G4String *tokens);
87 void PG4gstpar(G4String *tokens); 89 void PG4gstpar(G4String *tokens);
88 void PG4gspart(G4String *tokens); 90 void PG4gspart(G4String *tokens);
89 void PG4gsdk (G4String *tokens); 91 void PG4gsdk (G4String *tokens);
90 void PG4gsdet (G4String *tokens); 92 void PG4gsdet (G4String *tokens);
91 void PG4gsdetv(G4String *tokens); 93 void PG4gsdetv(G4String *tokens);
92 void PG4gsdeta(G4String *tokens); 94 void PG4gsdeta(G4String *tokens);
93 void PG4gsdeth(G4String *tokens); 95 void PG4gsdeth(G4String *tokens);
94 void PG4gsdetd(G4String *tokens); 96 void PG4gsdetd(G4String *tokens);
95 void PG4gsdetu(G4String *tokens); 97 void PG4gsdetu(G4String *tokens);
96 void PG4ggclos(); 98 void PG4ggclos();
97 99
98 void G3CLRead(G4String & fname, char *select = 100 void G3CLRead(G4String & fname, char *select = 0)
99 { 101 {
100 // 102 //
101 // G3CLRead 103 // G3CLRead
102 // Read the call List file, parse the token 104 // Read the call List file, parse the tokens, and pass the token
103 // List to the Geant4 interpreter 105 // List to the Geant4 interpreter
104 // 106 //
105 // fname: call List filename 107 // fname: call List filename
106 108
107 G4String line; 109 G4String line;
108 G4String tokens[1000]; 110 G4String tokens[1000];
109 111
110 const char* ofname = "clparse.out"; 112 const char* ofname = "clparse.out";
111 ofile.open(ofname); 113 ofile.open(ofname);
112 ofile << "Output file open\n"; 114 ofile << "Output file open\n";
113 115
>> 116 G4int count = 0;
114 G4int ntokens = 0; 117 G4int ntokens = 0;
115 std::ifstream istr(fname); 118 std::ifstream istr(fname);
116 119
117 while (G4StrUtil::readline(istr, line) && << 120 while (line.readLine(istr) && ! istr.eof())
118 { 121 {
>> 122 count++;
119 ntokens = G3CLTokens(&line,tokens); / 123 ntokens = G3CLTokens(&line,tokens); // tokenize the line
120 for (G4int i=0; i < ntokens; i++) 124 for (G4int i=0; i < ntokens; i++)
121 { 125 {
122 ofile << tokens[i] << G4endl; 126 ofile << tokens[i] << G4endl;
123 } 127 }
124 128
125 // interpret the line as a Geant call 129 // interpret the line as a Geant call
126 // 130 //
127 G3CLEval(tokens, select); 131 G3CLEval(tokens, select);
128 } 132 }
129 } 133 }
130 134
131 135
132 G4int G3CLTokens(G4String *line, G4String toke 136 G4int G3CLTokens(G4String *line, G4String tokens[])
133 { 137 {
134 // 138 //
135 // G3CLTokens 139 // G3CLTokens
136 // 140 //
137 // Tokenize line, returning tokens in tokens 141 // Tokenize line, returning tokens in tokens[]. Items in ".."
138 // are extracted as single tokens, despite e 142 // are extracted as single tokens, despite embedded spaces.
139 143
140 G4Tokenizer next(*line); 144 G4Tokenizer next(*line);
141 145
142 // first tokenize using " to identify stri 146 // first tokenize using " to identify strings
143 // 147 //
144 G4int itok = 0; 148 G4int itok = 0;
145 G4int ntokens = 0; 149 G4int ntokens = 0;
146 G4String token1, token2; 150 G4String token1, token2;
147 while (!(token1=next("\"")).empty()) << 151 while (!(token1=next("\"")).isNull())
148 { 152 {
149 itok++; 153 itok++;
150 if (itok%2 == 0 ) // even: inside a st 154 if (itok%2 == 0 ) // even: inside a string
151 { 155 {
152 tokens[ntokens++] = token1; 156 tokens[ntokens++] = token1;
153 } 157 }
154 else // not in a quoted s 158 else // not in a quoted string: finish tokenization
155 { 159 {
156 G4Tokenizer lev2(token1); 160 G4Tokenizer lev2(token1);
157 while (!(token2=lev2()).empty()) << 161 while (!(token2=lev2()).isNull())
158 { 162 {
159 tokens[ntokens] = token2; 163 tokens[ntokens] = token2;
160 ntokens++; 164 ntokens++;
161 } 165 }
162 } 166 }
163 } 167 }
164 return ntokens; 168 return ntokens;
165 } 169 }
166 170
167 171
168 void G3CLEval(G4String tokens[], char *select) 172 void G3CLEval(G4String tokens[], char *select)
169 { 173 {
170 // 174 //
171 // G3CLEval 175 // G3CLEval
172 // 176 //
173 // Evaluate the token List as a Geant3 call, 177 // Evaluate the token List as a Geant3 call, and execute it as
174 // a Geant4 call. 178 // a Geant4 call.
175 179
176 const char* context = tokens[0]; 180 const char* context = tokens[0];
177 const char* routine = tokens[1]; 181 const char* routine = tokens[1];
178 const char* wcard = "*"; 182 const char* wcard = "*";
179 183
180 // If context is selected, return unless c 184 // If context is selected, return unless context matches
181 // 185 //
182 if ((select != 0) && (select != wcard)) 186 if ((select != 0) && (select != wcard))
183 { 187 {
184 if ( strcmp(select,context) ) { return; 188 if ( strcmp(select,context) ) { return; }
185 } 189 }
186 190
187 // Branch on Geant3 routine name 191 // Branch on Geant3 routine name
188 // 192 //
189 ofile << "Do routine " << routine << " in 193 ofile << "Do routine " << routine << " in context " << context << G4endl;
190 194
191 if ( !strcmp(routine,"GSVOLU") ) { PG4gsvo 195 if ( !strcmp(routine,"GSVOLU") ) { PG4gsvolu(&tokens[2]); return;}
192 if ( !strcmp(routine,"GSPOS") ) { PG4gspo 196 if ( !strcmp(routine,"GSPOS") ) { PG4gspos (&tokens[2]); return;}
193 if ( !strcmp(routine,"GSPOSP") ) { PG4gspo 197 if ( !strcmp(routine,"GSPOSP") ) { PG4gsposp(&tokens[2]); return;}
194 if ( !strcmp(routine,"GSATT") ) { PG4gsat 198 if ( !strcmp(routine,"GSATT") ) { PG4gsatt (&tokens[2]); return;}
195 if ( !strcmp(routine,"GSROTM") ) { PG4gsro 199 if ( !strcmp(routine,"GSROTM") ) { PG4gsrotm(&tokens[2]); return;}
196 if ( !strcmp(routine,"GSDVN") ) { PG4gsdv 200 if ( !strcmp(routine,"GSDVN") ) { PG4gsdvn (&tokens[2]); return;}
197 if ( !strcmp(routine,"GSDVT") ) { PG4gsdv 201 if ( !strcmp(routine,"GSDVT") ) { PG4gsdvt (&tokens[2]); return;}
198 if ( !strcmp(routine,"GSDVX") ) { PG4gsdv 202 if ( !strcmp(routine,"GSDVX") ) { PG4gsdvx (&tokens[2]); return;}
199 if ( !strcmp(routine,"GSDVN2") ) { PG4gsdv 203 if ( !strcmp(routine,"GSDVN2") ) { PG4gsdvn2(&tokens[2]); return;}
200 if ( !strcmp(routine,"GSDVT2") ) { PG4gsdv 204 if ( !strcmp(routine,"GSDVT2") ) { PG4gsdvt2(&tokens[2]); return;}
201 if ( !strcmp(routine,"GSMATE") ) { PG4gsma 205 if ( !strcmp(routine,"GSMATE") ) { PG4gsmate(&tokens[2]); return;}
202 if ( !strcmp(routine,"GSMIXT") ) { PG4gsmi 206 if ( !strcmp(routine,"GSMIXT") ) { PG4gsmixt(&tokens[2]); return;}
203 if ( !strcmp(routine,"GSTMED") ) { PG4gstm 207 if ( !strcmp(routine,"GSTMED") ) { PG4gstmed(&tokens[2]); return;}
204 if ( !strcmp(routine,"GSTPAR") ) { PG4gstp 208 if ( !strcmp(routine,"GSTPAR") ) { PG4gstpar(&tokens[2]); return;}
205 if ( !strcmp(routine,"GSPART") ) { PG4gspa 209 if ( !strcmp(routine,"GSPART") ) { PG4gspart(&tokens[2]); return;}
206 if ( !strcmp(routine,"GSDK") ) { PG4gsdk 210 if ( !strcmp(routine,"GSDK") ) { PG4gsdk (&tokens[2]); return;}
207 if ( !strcmp(routine,"GSDET") ) { PG4gsde 211 if ( !strcmp(routine,"GSDET") ) { PG4gsdet (&tokens[2]); return;}
208 if ( !strcmp(routine,"GSDETV") ) { PG4gsde 212 if ( !strcmp(routine,"GSDETV") ) { PG4gsdetv(&tokens[2]); return;}
209 if ( !strcmp(routine,"GSDETA") ) { PG4gsde 213 if ( !strcmp(routine,"GSDETA") ) { PG4gsdeta(&tokens[2]); return;}
210 if ( !strcmp(routine,"GSDETH") ) { PG4gsde 214 if ( !strcmp(routine,"GSDETH") ) { PG4gsdeth(&tokens[2]); return;}
211 if ( !strcmp(routine,"GSDETD") ) { PG4gsde 215 if ( !strcmp(routine,"GSDETD") ) { PG4gsdetd(&tokens[2]); return;}
212 if ( !strcmp(routine,"GSDETU") ) { PG4gsde 216 if ( !strcmp(routine,"GSDETU") ) { PG4gsdetu(&tokens[2]); return;}
213 if ( !strcmp(routine,"GGCLOS") ) { PG4ggcl 217 if ( !strcmp(routine,"GGCLOS") ) { PG4ggclos(); return;}
214 } 218 }
215 219
216 void G3fillParams(G4String *tokens, const char 220 void G3fillParams(G4String *tokens, const char *ptypes)
217 { 221 {
218 // 222 //
219 // G3fillParams 223 // G3fillParams
220 // 224 //
221 // Interpret tokens to fill call parameters, 225 // Interpret tokens to fill call parameters, based on parameter types ptypes
222 226
223 // loop over ptypes 227 // loop over ptypes
224 // 228 //
225 G4int i =0, ipt = 0, k = 0; 229 G4int i =0, ipt = 0, k = 0;
226 G4int ni =0, nr = 0, nq = 0; << 230 G4int ni =0, nr = 0, ns = 0;
227 while (ptypes[i] != '\0') 231 while (ptypes[i] != '\0')
228 { 232 {
229 switch (ptypes[i]) 233 switch (ptypes[i])
230 { 234 {
231 case 'i': 235 case 'i':
232 Ipar[ni] = atoi(tokens[ipt].da 236 Ipar[ni] = atoi(tokens[ipt].data());
233 narray = Ipar[ni]; 237 narray = Ipar[ni];
234 ni++; ipt++; 238 ni++; ipt++;
235 break; 239 break;
236 case 'r': 240 case 'r':
237 Rpar[nr] = atof(tokens[ipt].da 241 Rpar[nr] = atof(tokens[ipt].data());
238 nr++; ipt++; 242 nr++; ipt++;
239 break; 243 break;
240 case 's': 244 case 's':
241 Spar[nq] = tokens[ipt]; << 245 Spar[ns] = tokens[ipt];
242 nq++; ipt++; << 246 ns++; ipt++;
243 break; 247 break;
244 case 'I': 248 case 'I':
245 for (k=0; k < narray; k++) 249 for (k=0; k < narray; k++)
246 { 250 {
247 Ipar[ni] = atoi(tokens[ipt 251 Ipar[ni] = atoi(tokens[ipt].data());
248 ni++; ipt++; 252 ni++; ipt++;
249 } 253 }
250 break; 254 break;
251 case 'R': 255 case 'R':
252 for (k=0; k < narray; k++) 256 for (k=0; k < narray; k++)
253 { 257 {
254 Rpar[nr] = atof(tokens[ipt 258 Rpar[nr] = atof(tokens[ipt].data());
255 nr++; ipt++; 259 nr++; ipt++;
256 } 260 }
257 break; 261 break;
258 case 'Q': 262 case 'Q':
259 // special case of reading thr 263 // special case of reading three successive R arrays
260 // into one (used in gsmixt) 264 // into one (used in gsmixt)
261 // 265 //
262 narray = 3 * std::abs(narray); 266 narray = 3 * std::abs(narray);
263 for (k=0; k < narray; k++) 267 for (k=0; k < narray; k++)
264 { 268 {
265 Rpar[nr] = atof(tokens[ipt 269 Rpar[nr] = atof(tokens[ipt].data());
266 nr++; ipt++; 270 nr++; ipt++;
267 } 271 }
268 break; 272 break;
269 case 'S': 273 case 'S':
270 for (k=0; k < narray; k++) 274 for (k=0; k < narray; k++)
271 { 275 {
272 Spar[nq] = tokens[ipt]; << 276 Spar[ns] = tokens[ipt];
273 nq++; ipt++; << 277 ns++; ipt++;
274 } 278 }
275 break; 279 break;
276 default: 280 default:
277 ofile << "unidentified ptype ' 281 ofile << "unidentified ptype '" << ptypes[i] << G4endl;
278 }; 282 };
279 i++; 283 i++;
280 } 284 }
281 } 285 }
282 286