G4gspos.cc File Reference

#include "G3G4Interface.hh"
#include "G3VolTable.hh"
#include "G3toG4.hh"
#include "G3Pos.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"

Go to the source code of this file.

Functions

void G4CreateCloneVTE (G3VolTableEntry *vte, G3VolTableEntry *mvte, G4double pars[], G4int npar, G4int num, G4double x, G4double y, G4double z, G4int irot, G4String vonly)
void PG4gspos (G4String *tokens)
void G4gspos (G4String vname, G4int num, G4String vmoth, G4double x, G4double y, G4double z, G4int irot, G4String vonly)


Function Documentation

void G4CreateCloneVTE ( G3VolTableEntry vte,
G3VolTableEntry mvte,
G4double  pars[],
G4int  npar,
G4int  num,
G4double  x,
G4double  y,
G4double  z,
G4int  irot,
G4String  vonly 
)

Definition at line 193 of file G4gsposp.cc.

References G3VolTableEntry::AddClone(), G3VolTableEntry::AddG3Pos(), G3VolTableEntry::AddMother(), G4String::append(), G3NegVolPars(), G3toG4MakeSolid(), G3Vol, G4CloneDaughters(), G4ProcessDaughters(), G3VolTableEntry::GetClone(), G3VolTableEntry::GetName(), G3VolTableEntry::GetNmed(), G3VolTableEntry::GetNoClones(), G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTableEntry::GetShape(), gSeparator, G3VolTable::PutVTE(), G3VolTableEntry::SetHasNegPars(), G3VolTableEntry::SetName(), and G3VolTableEntry::SetSolid().

Referenced by G4gspos(), and G4gsposp().

00199 {
00200    // create a G3Pos
00201    G4ThreeVector* offset = new G4ThreeVector(x*cm, y*cm, z*cm);
00202    G3Pos* aG3Pos = new G3Pos(mvte->GetName(), num, offset, irot, vonly);
00203             
00204    // loop over all mothers
00205    for (G4int i=0; i<mvte->GetNoClones(); i++) {
00206                     // mvte was retrieved from its "master" name
00207                     // -> there is no need to call GetMasterClone()
00208       G3VolTableEntry* mvteClone = mvte->GetClone(i);
00209         
00210       G4String tmpName = "TRY";
00211       G4String vteShape = vte->GetShape();
00212       G3VolTableEntry* vteClone
00213         = new G3VolTableEntry(tmpName, vteShape, pars, npar, vte->GetNmed(),
00214                                0, true);
00215           
00216       // negative parameters will be updated only 
00217       // for vteClone, pars are unchanged
00218       G4double* clonePars = vteClone->GetRpar();
00219       G4int     cloneNpar = vteClone->GetNpar();
00220       G4bool negpars
00221         = G3NegVolPars(clonePars, &cloneNpar, vteClone, mvteClone, "GSPOS");
00222       vteClone->SetHasNegPars(negpars);
00223 
00224       G3VolTableEntry* vteSameClone = 0;
00225       G4VSolid* solid = 0;
00226       if (!negpars) {
00227         // check if vteClone with the same parameters exist
00228         for (G4int ic=0; ic<vte->GetNoClones(); ic++) {
00229           G3VolTableEntry* checkClone = vte->GetClone(ic);
00230           G4int checkNpar = checkClone->GetNpar();
00231           G4double* checkPars = checkClone->GetRpar();
00232           
00233           G4bool isSame;
00234           if (checkNpar != cloneNpar) 
00235             isSame = false;
00236           else {  
00237             isSame = true;
00238             for (G4int ip=0; ip<cloneNpar; ip++) 
00239               if (checkPars[ip] != clonePars[ip]) {
00240                 isSame = false;
00241                 break;  
00242               }
00243           } 
00244           if (isSame) { vteSameClone = checkClone; break; }
00245         }
00246        
00247         if (vteSameClone) {
00248           delete vteClone;
00249           
00250           // add aG3Pos to the vteClone  
00251           vteSameClone->AddG3Pos(aG3Pos);
00252           mvteClone->AddDaughter(vteSameClone);  
00253           vteSameClone->AddMother(mvteClone);
00254         }
00255         else {
00256           // create the solid
00257           G4bool hasNegPars;
00258           G4bool deferred;
00259           G4bool okAxis[3];
00260           G4String vteName = vte->GetName();
00261           G4String cloneShape = vteClone->GetShape();
00262           solid = G3toG4MakeSolid(vteName, cloneShape, clonePars, cloneNpar,
00263                                   hasNegPars, deferred, okAxis);
00264         }                                 
00265       }
00266    
00267       if ( negpars || !(vteSameClone)) {
00268         // generate vteClone name         
00269         G4int cloneNo = vte->GetNoClones();
00270         char index[5]; sprintf(index,"%d",cloneNo);
00271         G4String newName = vte->GetName();
00272         newName.append(gSeparator); newName = newName + index;
00273         
00274         // update vteClone
00275         vteClone->SetName(newName);
00276         vteClone->SetSolid(solid);
00277         vteClone->SetHasNegPars(negpars);
00278                                 
00279         // let vte and vol table know about it
00280         G3Vol.PutVTE(vteClone);
00281         vte->AddClone(vteClone);
00282           
00283         // add aG3Pos to the vteClone  
00284         vteClone->AddG3Pos(aG3Pos);
00285         mvteClone->AddDaughter(vteClone);
00286         vteClone->AddMother(mvteClone);
00287            
00288         // copy all daughters
00289         G4CloneDaughters(vte, vteClone);
00290 
00291         // retrieve daughters parameters
00292         if (!negpars) G4ProcessDaughters(vteClone);
00293       }
00294   }
00295 }

void G4gspos ( G4String  vname,
G4int  num,
G4String  vmoth,
G4double  x,
G4double  y,
G4double  z,
G4int  irot,
G4String  vonly 
)

Definition at line 65 of file G4gspos.cc.

References G3VolTableEntry::AddG3Pos(), G3VolTableEntry::AddMother(), FatalException, G3Vol, G4CreateCloneVTE(), G4Exception(), G3VolTableEntry::GetClone(), G3VolTableEntry::GetNoClones(), G3VolTableEntry::GetNpar(), G3VolTableEntry::GetRpar(), G3VolTable::GetVTE(), and G3VolTableEntry::HasNegPars().

Referenced by PG4gspos().

00067 {
00068   // find VTEs
00069   G3VolTableEntry* vte = G3Vol.GetVTE(vname);
00070   G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
00071 
00072   if (vte == 0) {
00073     G4String text = "G4gspos: '" + vname + "' has no VolTableEntry";
00074     G4Exception("G4gspos()", "G3toG40017", FatalException, text);
00075     return;
00076   } 
00077   else if (mvte == 0) {
00078     G4String text = "G4gspos: '" + vmoth + "' has no VolTableEntry";
00079     G4Exception("G4gspos()", "G3toG40018", FatalException, text);
00080     return;
00081   } 
00082   else { 
00083     if (!vte->HasNegPars()) {
00084       // position vector
00085       G4ThreeVector* offset = new G4ThreeVector(x*cm, y*cm, z*cm);
00086 
00087       // create a G3Pos object and add it to the vte
00088       G3Pos* aG3Pos = new G3Pos(vmoth, num, offset, irot, vonly);              
00089       vte->AddG3Pos(aG3Pos);
00090 
00091       // loop over all mothers
00092       for (G4int i=0; i<mvte->GetNoClones(); i++) {
00093                        // (mvte is retrieved from its "master" name
00094                        //  -> there is no need to call GetMasterClone()
00095         G3VolTableEntry* mvteClone = mvte->GetClone(i);
00096         vte->AddMother(mvteClone);
00097         mvteClone->AddDaughter(vte);
00098       }     
00099     } 
00100     else {
00101       // if vte has neg parameters 
00102       // a new vte clone copy is created for each mother (clone copy)  
00103       // and its parameters are derived from it if possible
00104 
00105       G4CreateCloneVTE(vte, mvte, vte->GetRpar(), vte->GetNpar(), num,
00106                      x, y, z, irot, vonly);
00107     }    
00108   }      
00109 }

void PG4gspos ( G4String tokens  ) 

Definition at line 42 of file G4gspos.cc.

References G3fillParams(), G4gspos(), Ipar, PTgspos, Rpar, and Spar.

Referenced by G3CLEval().

00043 {
00044         // fill the parameter containers
00045     G3fillParams(tokens,PTgspos);
00046   
00047         // interpret the parameters
00048     G4String name = Spar[0];
00049     G4String moth = Spar[1];
00050     G4String only = Spar[2];
00051     G4int num = Ipar[0];
00052     G4int irot = Ipar[1];
00053         // all parameters are passed to G4gsxxx methods
00054         // in G3 default units         
00055     //G4double x = Rpar[0]*cm;
00056     //G4double y = Rpar[1]*cm;
00057     //G4double z = Rpar[2]*cm;
00058     G4double x = Rpar[0];
00059     G4double y = Rpar[1];
00060     G4double z = Rpar[2];
00061   
00062     G4gspos(name, num, moth, x, y, z, irot, only);
00063 }


Generated on Mon May 27 17:50:46 2013 for Geant4 by  doxygen 1.4.7