Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/g3tog4/src/G4gsposp.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /g3tog4/src/G4gsposp.cc (Version 11.3.0) and /g3tog4/src/G4gsposp.cc (Version 9.0.p2)


  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-03-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