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