| 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: G4gsposp.cc,v 1.16 2006/06/29 18:14:44 gunter Exp $
>> 28 // GEANT4 tag $Name: geant4-08-01-patch-01 $
27 // 29 //
28 // by I.Hrivnacova, 13.10.99 30 // by I.Hrivnacova, 13.10.99
29 31
30 #include "G3G4Interface.hh" 32 #include "G3G4Interface.hh"
31 #include "G3toG4.hh" 33 #include "G3toG4.hh"
32 #include "G3VolTable.hh" 34 #include "G3VolTable.hh"
33 #include "G3toG4MakeSolid.hh" 35 #include "G3toG4MakeSolid.hh"
34 #include "G3Division.hh" 36 #include "G3Division.hh"
35 #include "G4SystemOfUnits.hh" <<
36 #include "G4VSolid.hh" 37 #include "G4VSolid.hh"
37 38
38 G4bool G3NegVolPars(G4double pars[], G4int *np 39 G4bool G3NegVolPars(G4double pars[], G4int *nparpt,
39 G3VolTableEntry* vte, G3VolTableEntr 40 G3VolTableEntry* vte, G3VolTableEntry* mvte, const char routine[]);
40 41
41 void PG4gsposp(G4String *tokens){ << 42 void PG4gsposp(G4String tokens[]){
42 // fill the parameter containers 43 // fill the parameter containers
43 G3fillParams(tokens,PTgsposp); 44 G3fillParams(tokens,PTgsposp);
44 45
45 // interpret the parameters 46 // interpret the parameters
46 G4String name = Spar[0]; 47 G4String name = Spar[0];
47 G4String moth = Spar[1]; 48 G4String moth = Spar[1];
48 G4String only = Spar[2]; 49 G4String only = Spar[2];
49 G4int num = Ipar[0]; 50 G4int num = Ipar[0];
50 G4int irot = Ipar[1]; 51 G4int irot = Ipar[1];
51 G4int npar = Ipar[2]; 52 G4int npar = Ipar[2];
52 // all parameters are passed to G4gsxxx meth 53 // all parameters are passed to G4gsxxx methods
53 // in G3 default units 54 // in G3 default units
54 //G4double x = Rpar[0]*cm; 55 //G4double x = Rpar[0]*cm;
55 //G4double y = Rpar[1]*cm; 56 //G4double y = Rpar[1]*cm;
56 //G4double z = Rpar[2]*cm; 57 //G4double z = Rpar[2]*cm;
57 G4double x = Rpar[0]; 58 G4double x = Rpar[0];
58 G4double y = Rpar[1]; 59 G4double y = Rpar[1];
59 G4double z = Rpar[2]; 60 G4double z = Rpar[2];
60 G4double *pars = &Rpar[3]; 61 G4double *pars = &Rpar[3];
61 62
62 G4gsposp(name, num, moth, x, y, z, irot, onl 63 G4gsposp(name, num, moth, x, y, z, irot, only, pars, npar);
63 } 64 }
64 65
65 void G4ProcessDaughters(G3VolTableEntry* vte) 66 void G4ProcessDaughters(G3VolTableEntry* vte)
66 // restore negative volume parameters and crea 67 // restore negative volume parameters and create solid for all
67 // vte daughters 68 // vte daughters
68 { 69 {
69 if (vte->HasNegPars()) { 70 if (vte->HasNegPars()) {
70 G4cerr << " Warning:" << G4endl; 71 G4cerr << " Warning:" << G4endl;
71 G4cerr << " G4ProcessDaughters: Ignored (v 72 G4cerr << " G4ProcessDaughters: Ignored (vte has negative parameters)."
72 << G4endl; 73 << G4endl;
73 } 74 }
74 else { 75 else {
75 for (G4int i=0; i<vte->GetNoDaughters(); i 76 for (G4int i=0; i<vte->GetNoDaughters(); i++) {
76 77
77 G3VolTableEntry* dvte = vte->GetDaughter 78 G3VolTableEntry* dvte = vte->GetDaughter(i);
78 79
79 if (dvte->HasNegPars()) { 80 if (dvte->HasNegPars()) {
80 if (dvte->GetDivision()) { 81 if (dvte->GetDivision()) {
81 // call division method for creatin 82 // call division method for creating solid and updating
82 // dvte parameters 83 // dvte parameters
83 dvte->GetDivision()->UpdateVTE(); 84 dvte->GetDivision()->UpdateVTE();
84 } 85 }
85 else { 86 else {
86 // update negative parameters 87 // update negative parameters
87 G4double* pars = dvte->GetRpar(); 88 G4double* pars = dvte->GetRpar();
88 G4int npar = dvte->GetNpar(); 89 G4int npar = dvte->GetNpar();
89 G4bool negpars 90 G4bool negpars
90 = G3NegVolPars(pars,&npar, dvte, vte, "G 91 = G3NegVolPars(pars,&npar, dvte, vte, "GSPOS");
91 92
92 if (negpars) { 93 if (negpars) {
93 G4String text = "G3NegVolPars stil << 94 G4String text = " G4ProcessDaughter:\n";
94 G4Exception("G4ProcessDaughters()" << 95 text = text + " G3NegVolPars still returns negative parameters!";
95 FatalException, text); << 96 G4Exception(text);
96 return; <<
97 } 97 }
98 98
99 // create solid 99 // create solid
100 G4bool hasNegPars; 100 G4bool hasNegPars;
101 G4bool deferred; 101 G4bool deferred;
102 G4bool okAxis[3]; 102 G4bool okAxis[3];
103 G4VSolid* solid 103 G4VSolid* solid
104 = G3toG4MakeSolid(dvte->GetName(), 104 = G3toG4MakeSolid(dvte->GetName(), dvte->GetShape(), pars, npar,
105 hasNegPars, deferred, 105 hasNegPars, deferred, okAxis);
106 if (hasNegPars) { 106 if (hasNegPars) {
107 G4String text = "G3toG4MakeSolid s << 107 G4String text = " G4ProcessDaughter:\n";
108 G4Exception("G4ProcessDaughters()" << 108 text = text + " G3toG4MakeSolid still returns negative parameters!";
109 FatalException, text); << 109 G4Exception(text);
110 return; <<
111 } 110 }
112 111
113 // update dvte 112 // update dvte
114 dvte->SetNRpar(npar, pars); 113 dvte->SetNRpar(npar, pars);
115 dvte->SetSolid(solid); 114 dvte->SetSolid(solid);
116 dvte->SetHasNegPars(hasNegPars); 115 dvte->SetHasNegPars(hasNegPars);
117 } 116 }
118 117
119 // process daughters 118 // process daughters
120 G4ProcessDaughters(dvte); 119 G4ProcessDaughters(dvte);
121 } 120 }
122 } 121 }
123 } 122 }
124 } 123 }
125 124
126 void G4CloneDaughters(G3VolTableEntry* vte, G3 125 void G4CloneDaughters(G3VolTableEntry* vte, G3VolTableEntry* vteClone)
127 // copy vte daughters to vteClone 126 // copy vte daughters to vteClone
128 // (in case of daughters with negative paramet 127 // (in case of daughters with negative parameters
129 // or with divisions new clone copies have to 128 // or with divisions new clone copies have to be created)
130 { 129 {
131 G4int nofDaughters = vte->GetNoDaughters(); 130 G4int nofDaughters = vte->GetNoDaughters();
132 if (nofDaughters>0) 131 if (nofDaughters>0)
133 for (G4int id=0; id<nofDaughters; id++) { 132 for (G4int id=0; id<nofDaughters; id++) {
134 G3VolTableEntry* dvte = vte->GetDaughter 133 G3VolTableEntry* dvte = vte->GetDaughter(id);
135 134
136 if (dvte->HasNegPars() || dvte->GetDivis 135 if (dvte->HasNegPars() || dvte->GetDivision()){
137 // create new dvteClone with Position/ 136 // create new dvteClone with Position/Division
138 // and set it to vteClone 137 // and set it to vteClone
139 138
140 // get master of dvte 139 // get master of dvte
141 G3VolTableEntry* dvteMaster = dvte->Ge 140 G3VolTableEntry* dvteMaster = dvte->GetMasterClone();
142 141
143 // generate vteClone name 142 // generate vteClone name
144 G4int cloneNo = dvteMaster->GetNoClone 143 G4int cloneNo = dvteMaster->GetNoClones();
>> 144 char index[5]; sprintf(index,"%d",cloneNo);
145 G4String newName = dvteMaster->GetName 145 G4String newName = dvteMaster->GetName();
146 newName += gSeparator; << 146 newName.append(gSeparator); newName = newName + index;
147 newName = newName + std::to_string(clo <<
148 147
149 // create dvteClone 148 // create dvteClone
150 G4String dvteShape = dvte->GetShape() 149 G4String dvteShape = dvte->GetShape();
151 G4double* dvteRpar = dvte->GetRpar(); 150 G4double* dvteRpar = dvte->GetRpar();
152 G4int dvteNpar = dvte->GetNpar(); 151 G4int dvteNpar = dvte->GetNpar();
153 G4int dvteNmed = dvte->GetNmed(); 152 G4int dvteNmed = dvte->GetNmed();
154 G4bool hasNegPars = dvte->HasNegPars(); 153 G4bool hasNegPars = dvte->HasNegPars();
155 G3VolTableEntry* dvteClone 154 G3VolTableEntry* dvteClone
156 = new G3VolTableEntry(newName, dvteS 155 = new G3VolTableEntry(newName, dvteShape, dvteRpar, dvteNpar,
157 dvteNmed, 0, hasNeg 156 dvteNmed, 0, hasNegPars);
158 157
159 // let dvte master and vol table know 158 // let dvte master and vol table know about it
160 G3Vol.PutVTE(dvteClone); 159 G3Vol.PutVTE(dvteClone);
161 dvteMaster->AddClone(dvteClone); 160 dvteMaster->AddClone(dvteClone);
162 161
163 // set mother daughter 162 // set mother daughter
164 vteClone->AddDaughter(dvteClone); 163 vteClone->AddDaughter(dvteClone);
165 dvteClone->AddMother(vteClone); 164 dvteClone->AddMother(vteClone);
166 165
167 // copy positions 166 // copy positions
168 G4int nofPositions = dvte->NPCopies(); 167 G4int nofPositions = dvte->NPCopies();
169 for (G4int ip=0; ip<nofPositions; ip++) 168 for (G4int ip=0; ip<nofPositions; ip++)
170 dvteClone->AddG3Pos(dvte->GetG3PosCopy(ip) 169 dvteClone->AddG3Pos(dvte->GetG3PosCopy(ip));
171 170
172 // copy division 171 // copy division
173 G3Division* dvteDivision = dvte->GetDivision 172 G3Division* dvteDivision = dvte->GetDivision();
174 if (dvteDivision) { 173 if (dvteDivision) {
175 G3Division* dvteCloneDivision 174 G3Division* dvteCloneDivision
176 = new G3Division(dvteClone, vteClone, *d 175 = new G3Division(dvteClone, vteClone, *dvteDivision);
177 dvteClone->SetDivision(dvteCloneDivi 176 dvteClone->SetDivision(dvteCloneDivision);
178 dvteCloneDivision->UpdateVTE(); 177 dvteCloneDivision->UpdateVTE();
179 } 178 }
180 179
181 // clone daughters recursively 180 // clone daughters recursively
182 G4CloneDaughters(dvte, dvteClone); 181 G4CloneDaughters(dvte, dvteClone);
183 } 182 }
184 else { 183 else {
185 // set dvte to vteClone 184 // set dvte to vteClone
186 vteClone->AddDaughter(dvte); 185 vteClone->AddDaughter(dvte);
187 dvte->AddMother(vteClone); 186 dvte->AddMother(vteClone);
188 } 187 }
189 } 188 }
190 } 189 }
191 190
192 void G4CreateCloneVTE(G3VolTableEntry* vte, G3 191 void G4CreateCloneVTE(G3VolTableEntry* vte, G3VolTableEntry* mvte,
193 G4double pars[], G4int npar, G4i 192 G4double pars[], G4int npar, G4int num,
194 G4double x, G4double y, G4double 193 G4double x, G4double y, G4double z, G4int irot, G4String vonly)
195 // 194 //
196 // create a new vte clone copy for each mother 195 // create a new vte clone copy for each mother
197 // and derive its parameters from the mother i 196 // and derive its parameters from the mother if possible
198 { 197 {
199 // create a G3Pos 198 // create a G3Pos
200 G4ThreeVector* offset = new G4ThreeVector(x 199 G4ThreeVector* offset = new G4ThreeVector(x*cm, y*cm, z*cm);
201 G3Pos* aG3Pos = new G3Pos(mvte->GetName(), 200 G3Pos* aG3Pos = new G3Pos(mvte->GetName(), num, offset, irot, vonly);
202 201
203 // loop over all mothers 202 // loop over all mothers
204 for (G4int i=0; i<mvte->GetNoClones(); i++) 203 for (G4int i=0; i<mvte->GetNoClones(); i++) {
205 // mvte was retrieved from 204 // mvte was retrieved from its "master" name
206 // -> there is no need to 205 // -> there is no need to call GetMasterClone()
207 G3VolTableEntry* mvteClone = mvte->GetCl 206 G3VolTableEntry* mvteClone = mvte->GetClone(i);
208 207
209 G4String tmpName = "TRY"; 208 G4String tmpName = "TRY";
210 G4String vteShape = vte->GetShape(); 209 G4String vteShape = vte->GetShape();
211 G3VolTableEntry* vteClone 210 G3VolTableEntry* vteClone
212 = new G3VolTableEntry(tmpName, vteShap 211 = new G3VolTableEntry(tmpName, vteShape, pars, npar, vte->GetNmed(),
213 0, true); 212 0, true);
214 213
215 // negative parameters will be updated o 214 // negative parameters will be updated only
216 // for vteClone, pars are unchanged 215 // for vteClone, pars are unchanged
217 G4double* clonePars = vteClone->GetRpar( 216 G4double* clonePars = vteClone->GetRpar();
218 G4int cloneNpar = vteClone->GetNpar( 217 G4int cloneNpar = vteClone->GetNpar();
219 G4bool negpars 218 G4bool negpars
220 = G3NegVolPars(clonePars, &cloneNpar, 219 = G3NegVolPars(clonePars, &cloneNpar, vteClone, mvteClone, "GSPOS");
221 vteClone->SetHasNegPars(negpars); 220 vteClone->SetHasNegPars(negpars);
222 221
223 G3VolTableEntry* vteSameClone = 0; 222 G3VolTableEntry* vteSameClone = 0;
224 G4VSolid* solid = 0; 223 G4VSolid* solid = 0;
225 if (!negpars) { 224 if (!negpars) {
226 // check if vteClone with the same par 225 // check if vteClone with the same parameters exist
227 for (G4int ic=0; ic<vte->GetNoClones() 226 for (G4int ic=0; ic<vte->GetNoClones(); ic++) {
228 G3VolTableEntry* checkClone = vte->G 227 G3VolTableEntry* checkClone = vte->GetClone(ic);
229 G4int checkNpar = checkClone->GetNpar(); 228 G4int checkNpar = checkClone->GetNpar();
230 G4double* checkPars = checkClone->GetRpar( 229 G4double* checkPars = checkClone->GetRpar();
231 230
232 G4bool isSame; 231 G4bool isSame;
233 if (checkNpar != cloneNpar) 232 if (checkNpar != cloneNpar)
234 isSame = false; 233 isSame = false;
235 else { 234 else {
236 isSame = true; 235 isSame = true;
237 for (G4int ip=0; ip<cloneNpar; ip++) 236 for (G4int ip=0; ip<cloneNpar; ip++)
238 if (checkPars[ip] != clonePars[ip]) { 237 if (checkPars[ip] != clonePars[ip]) {
239 isSame = false; 238 isSame = false;
240 break; 239 break;
241 } 240 }
242 } 241 }
243 if (isSame) { vteSameClone = checkClone; b << 242 if (isSame) vteSameClone = checkClone;
>> 243 break;
244 } 244 }
245 245
246 if (vteSameClone) { 246 if (vteSameClone) {
247 delete vteClone; 247 delete vteClone;
248 248
249 // add aG3Pos to the vteClone 249 // add aG3Pos to the vteClone
250 vteSameClone->AddG3Pos(aG3Pos); 250 vteSameClone->AddG3Pos(aG3Pos);
251 mvteClone->AddDaughter(vteSameClone) 251 mvteClone->AddDaughter(vteSameClone);
252 vteSameClone->AddMother(mvteClone); 252 vteSameClone->AddMother(mvteClone);
253 } 253 }
254 else { 254 else {
255 // create the solid 255 // create the solid
256 G4bool hasNegPars; 256 G4bool hasNegPars;
257 G4bool deferred; 257 G4bool deferred;
258 G4bool okAxis[3]; 258 G4bool okAxis[3];
259 G4String vteName = vte->GetName(); 259 G4String vteName = vte->GetName();
260 G4String cloneShape = vteClone->GetS 260 G4String cloneShape = vteClone->GetShape();
261 solid = G3toG4MakeSolid(vteName, clo 261 solid = G3toG4MakeSolid(vteName, cloneShape, clonePars, cloneNpar,
262 hasNegPars, 262 hasNegPars, deferred, okAxis);
263 } 263 }
264 } 264 }
265 265
266 if ( negpars || !(vteSameClone)) { 266 if ( negpars || !(vteSameClone)) {
267 // generate vteClone name 267 // generate vteClone name
268 G4int cloneNo = vte->GetNoClones(); 268 G4int cloneNo = vte->GetNoClones();
>> 269 char index[5]; sprintf(index,"%d",cloneNo);
269 G4String newName = vte->GetName(); 270 G4String newName = vte->GetName();
270 newName += gSeparator; << 271 newName.append(gSeparator); newName = newName + index;
271 newName = newName + std::to_string(clo <<
272 272
273 // update vteClone 273 // update vteClone
274 vteClone->SetName(newName); 274 vteClone->SetName(newName);
275 vteClone->SetSolid(solid); 275 vteClone->SetSolid(solid);
276 vteClone->SetHasNegPars(negpars); 276 vteClone->SetHasNegPars(negpars);
277 277
278 // let vte and vol table know about it 278 // let vte and vol table know about it
279 G3Vol.PutVTE(vteClone); 279 G3Vol.PutVTE(vteClone);
280 vte->AddClone(vteClone); 280 vte->AddClone(vteClone);
281 281
282 // add aG3Pos to the vteClone 282 // add aG3Pos to the vteClone
283 vteClone->AddG3Pos(aG3Pos); 283 vteClone->AddG3Pos(aG3Pos);
284 mvteClone->AddDaughter(vteClone); 284 mvteClone->AddDaughter(vteClone);
285 vteClone->AddMother(mvteClone); 285 vteClone->AddMother(mvteClone);
286 286
287 // copy all daughters 287 // copy all daughters
288 G4CloneDaughters(vte, vteClone); 288 G4CloneDaughters(vte, vteClone);
289 289
290 // retrieve daughters parameters 290 // retrieve daughters parameters
291 if (!negpars) G4ProcessDaughters(vteCl 291 if (!negpars) G4ProcessDaughters(vteClone);
292 } 292 }
293 } 293 }
294 } 294 }
295 295
296 void G4gsposp(G4String vname, G4int num, G4Str 296 void G4gsposp(G4String vname, G4int num, G4String vmoth, G4double x,
297 G4double y, G4double z, G4int ir 297 G4double y, G4double z, G4int irot, G4String vonly,
298 G4double pars[], G4int npar) 298 G4double pars[], G4int npar)
299 { 299 {
300 // find VTEs 300 // find VTEs
301 G3VolTableEntry* vte = G3Vol.GetVTE(vname); 301 G3VolTableEntry* vte = G3Vol.GetVTE(vname);
302 G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth); 302 G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
303 303
304 if (vte == 0) { 304 if (vte == 0) {
305 G4String err_message1 = "G4gsposp: '" + vn << 305 G4Exception("G4gsposp: '" + vname + "' has no VolTableEntry");
306 G4Exception("G4psposp()", "G3toG40021", Fa <<
307 return; <<
308 } 306 }
309 if (mvte == 0) { 307 if (mvte == 0) {
310 G4String err_message2 = "G4gsposp: '" + vm << 308 G4Exception("G4gsposp: '" + vmoth + "' has no VolTableEntry");
311 G4Exception("G4psposp()", "G3toG40022", Fa <<
312 return; <<
313 } 309 }
314 else { 310 else {
315 // a new vte clone copy is created for eac 311 // a new vte clone copy is created for each mother (clone copy)
316 // and its parameters are derived from it 312 // and its parameters are derived from it if possible
317 313
318 G4CreateCloneVTE(vte, mvte, pars, npar, nu 314 G4CreateCloneVTE(vte, mvte, pars, npar, num, x, y, z, irot, vonly);
319 } 315 }
320 } 316 }
321 317