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