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