clparse.cc File Reference

#include "globals.hh"
#include <fstream>
#include "G4Tokenizer.hh"
#include "G3toG4.hh"
#include "G3EleTable.hh"
#include "G3VolTable.hh"
#include "G3MatTable.hh"
#include "G3MedTable.hh"
#include "G3RotTable.hh"
#include "G3PartTable.hh"
#include "G3DetTable.hh"
#include "G3SensVolVector.hh"
#include <stdlib.h>

Go to the source code of this file.

Functions

char gSeparator ('_')
G4int G3CLTokens (G4String *line, G4String *tokens)
void G3CLEval (G4String *tokens, char *select)
void PG4gsvolu (G4String *tokens)
void PG4gspos (G4String *tokens)
void PG4gsposp (G4String *tokens)
void PG4gsatt (G4String *tokens)
void PG4gsrotm (G4String *tokens)
void PG4gsdvn (G4String *tokens)
void PG4gsdvt (G4String *tokens)
void PG4gsdvx (G4String *tokens)
void PG4gsdvn2 (G4String *tokens)
void PG4gsdvt2 (G4String *tokens)
void PG4gsmate (G4String *tokens)
void PG4gsmixt (G4String *tokens)
void PG4gstmed (G4String *tokens)
void PG4gstpar (G4String *tokens)
void PG4gspart (G4String *tokens)
void PG4gsdk (G4String *tokens)
void PG4gsdet (G4String *tokens)
void PG4gsdetv (G4String *tokens)
void PG4gsdeta (G4String *tokens)
void PG4gsdeth (G4String *tokens)
void PG4gsdetd (G4String *tokens)
void PG4gsdetu (G4String *tokens)
void PG4ggclos ()
void G3CLRead (G4String &fname, char *select=0)
G4int G3CLTokens (G4String *line, G4String tokens[])
void G3CLEval (G4String tokens[], char *select)
void G3fillParams (G4String *tokens, const char *ptypes)

Variables

std::ofstream ofile
std::ofstream ofile
G3VolTable G3Vol
G3MatTable G3Mat
G3MedTable G3Med
G3RotTable G3Rot
G3PartTable G3Part
G3DetTable G3Det
G3EleTable G3Ele
G3SensVolVector G3SensVol
G4int narray
G4int Ipar [1000]
G4double Rpar [1000]
G4String Spar [1000]


Function Documentation

void G3CLEval ( G4String  tokens[],
char *  select 
)

Definition at line 171 of file clparse.cc.

References G4endl, ofile, PG4ggclos(), PG4gsatt(), PG4gsdet(), PG4gsdeta(), PG4gsdetd(), PG4gsdeth(), PG4gsdetu(), PG4gsdetv(), PG4gsdk(), PG4gsdvn(), PG4gsdvn2(), PG4gsdvt(), PG4gsdvt2(), PG4gsdvx(), PG4gsmate(), PG4gsmixt(), PG4gspart(), PG4gspos(), PG4gsposp(), PG4gsrotm(), PG4gstmed(), PG4gstpar(), and PG4gsvolu().

00172 {
00173   //
00174   // G3CLEval
00175   //
00176   // Evaluate the token List as a Geant3 call, and execute it as
00177   // a Geant4 call.
00178 
00179     const char* context = tokens[0];
00180     const char* routine = tokens[1];
00181     const char* wcard = "*";
00182 
00183     // If context is selected, return unless context matches
00184     //
00185     if ((select != 0) && (select != wcard))
00186     {
00187       if ( strcmp(select,context) )  { return; }
00188     }
00189 
00190     // Branch on Geant3 routine name
00191     //
00192     ofile << "Do routine " << routine << " in context " << context << G4endl;
00193     
00194     if ( !strcmp(routine,"GSVOLU") ) { PG4gsvolu(&tokens[2]); return;}
00195     if ( !strcmp(routine,"GSPOS") )  { PG4gspos (&tokens[2]); return;}
00196     if ( !strcmp(routine,"GSPOSP") ) { PG4gsposp(&tokens[2]); return;}
00197     if ( !strcmp(routine,"GSATT") )  { PG4gsatt (&tokens[2]); return;}
00198     if ( !strcmp(routine,"GSROTM") ) { PG4gsrotm(&tokens[2]); return;}
00199     if ( !strcmp(routine,"GSDVN") )  { PG4gsdvn (&tokens[2]); return;}
00200     if ( !strcmp(routine,"GSDVT") )  { PG4gsdvt (&tokens[2]); return;}
00201     if ( !strcmp(routine,"GSDVX") )  { PG4gsdvx (&tokens[2]); return;}
00202     if ( !strcmp(routine,"GSDVN2") ) { PG4gsdvn2(&tokens[2]); return;}
00203     if ( !strcmp(routine,"GSDVT2") ) { PG4gsdvt2(&tokens[2]); return;}
00204     if ( !strcmp(routine,"GSMATE") ) { PG4gsmate(&tokens[2]); return;}
00205     if ( !strcmp(routine,"GSMIXT") ) { PG4gsmixt(&tokens[2]); return;}
00206     if ( !strcmp(routine,"GSTMED") ) { PG4gstmed(&tokens[2]); return;}
00207     if ( !strcmp(routine,"GSTPAR") ) { PG4gstpar(&tokens[2]); return;}
00208     if ( !strcmp(routine,"GSPART") ) { PG4gspart(&tokens[2]); return;}
00209     if ( !strcmp(routine,"GSDK") )   { PG4gsdk  (&tokens[2]); return;}
00210     if ( !strcmp(routine,"GSDET") )  { PG4gsdet (&tokens[2]); return;}
00211     if ( !strcmp(routine,"GSDETV") ) { PG4gsdetv(&tokens[2]); return;}
00212     if ( !strcmp(routine,"GSDETA") ) { PG4gsdeta(&tokens[2]); return;}
00213     if ( !strcmp(routine,"GSDETH") ) { PG4gsdeth(&tokens[2]); return;}
00214     if ( !strcmp(routine,"GSDETD") ) { PG4gsdetd(&tokens[2]); return;}
00215     if ( !strcmp(routine,"GSDETU") ) { PG4gsdetu(&tokens[2]); return;}
00216     if ( !strcmp(routine,"GGCLOS") ) { PG4ggclos(); return;}
00217 }

void G3CLEval ( G4String tokens,
char *  select 
)

Referenced by G3CLRead().

void G3CLRead ( G4String fname,
char *  select = 0 
)

Definition at line 99 of file clparse.cc.

References G3CLEval(), G3CLTokens(), G4endl, ofile, and G4String::readLine().

Referenced by G4BuildGeom().

00100 {
00101   //
00102   //  G3CLRead
00103   //  Read the call List file, parse the tokens, and pass the token
00104   //  List to the Geant4 interpreter
00105   //
00106   //  fname: call List filename
00107   
00108     G4String line;
00109     G4String tokens[1000];
00110 
00111     const char* ofname = "clparse.out";
00112     ofile.open(ofname);
00113     ofile << "Output file open\n";
00114 
00115     G4int count = 0;
00116     G4int ntokens = 0;
00117     std::ifstream istr(fname);
00118     
00119     while (line.readLine(istr) && ! istr.eof())
00120     {
00121         count++;
00122         ntokens = G3CLTokens(&line,tokens);  // tokenize the line
00123         for (G4int i=0; i < ntokens; i++)
00124         {
00125           ofile << tokens[i] << G4endl;
00126         }
00127 
00128         // interpret the line as a Geant call
00129         //
00130         G3CLEval(tokens, select);
00131     }
00132 }

G4int G3CLTokens ( G4String line,
G4String  tokens[] 
)

Definition at line 135 of file clparse.cc.

00136 {
00137   //
00138   // G3CLTokens
00139   //
00140   // Tokenize line, returning tokens in tokens[]. Items in ".."
00141   // are extracted as single tokens, despite embedded spaces.
00142 
00143     G4Tokenizer next(*line);
00144 
00145     // first tokenize using " to identify strings
00146     //
00147     G4int itok = 0;
00148     G4int ntokens = 0;
00149     G4String token1, token2;
00150     while (!(token1=next("\"")).isNull())
00151     {
00152         itok++;
00153         if (itok%2 == 0 ) // even: inside a string
00154         {
00155             tokens[ntokens++] = token1;
00156         }
00157         else              // not in a quoted string: finish tokenization
00158         {
00159             G4Tokenizer lev2(token1);
00160             while (!(token2=lev2()).isNull())
00161             {
00162                 tokens[ntokens] = token2;
00163                 ntokens++;
00164             }
00165         }
00166     }
00167     return ntokens;
00168 }

G4int G3CLTokens ( G4String line,
G4String tokens 
)

Referenced by G3CLRead().

void G3fillParams ( G4String tokens,
const char *  ptypes 
)

Definition at line 219 of file clparse.cc.

References G4endl, Ipar, narray, ofile, Rpar, and Spar.

Referenced by PG4gsatt(), PG4gsdet(), PG4gsdeta(), PG4gsdetd(), PG4gsdeth(), PG4gsdetu(), PG4gsdetv(), PG4gsdk(), PG4gsdvn(), PG4gsdvn2(), PG4gsdvt(), PG4gsdvt2(), PG4gsdvx(), PG4gsmate(), PG4gsmixt(), PG4gspart(), PG4gspos(), PG4gsposp(), PG4gsrotm(), PG4gstmed(), PG4gstpar(), and PG4gsvolu().

00220 {
00221   //
00222   // G3fillParams
00223   //
00224   // Interpret tokens to fill call parameters, based on parameter types ptypes
00225 
00226     // loop over ptypes
00227     //
00228     G4int i =0, ipt = 0, k = 0;
00229     G4int ni =0, nr = 0, nq = 0;
00230     while (ptypes[i] != '\0')
00231     {
00232         switch (ptypes[i])
00233         {
00234             case 'i':
00235                 Ipar[ni] = atoi(tokens[ipt].data());
00236                 narray = Ipar[ni];
00237                 ni++; ipt++;
00238                 break;
00239             case 'r':
00240                 Rpar[nr] = atof(tokens[ipt].data());
00241                 nr++; ipt++;
00242                 break;
00243             case 's':
00244                 Spar[nq] = tokens[ipt];
00245                 nq++; ipt++;
00246                 break;
00247             case 'I':
00248                 for (k=0; k < narray; k++)
00249                 {
00250                     Ipar[ni] = atoi(tokens[ipt].data());
00251                     ni++; ipt++;
00252                 }
00253                 break;
00254             case 'R':
00255                 for (k=0; k < narray; k++) 
00256                 { 
00257                     Rpar[nr] = atof(tokens[ipt].data()); 
00258                     nr++; ipt++;
00259                 }
00260                 break;
00261             case 'Q':
00262                 // special case of reading three successive R arrays 
00263                 // into one (used in gsmixt)
00264                 //
00265                 narray = 3 * std::abs(narray);
00266                 for (k=0; k < narray; k++) 
00267                 { 
00268                     Rpar[nr] = atof(tokens[ipt].data()); 
00269                     nr++; ipt++;
00270                 }
00271                 break;
00272             case 'S':
00273                 for (k=0; k < narray; k++)
00274                 {
00275                     Spar[nq] = tokens[ipt];
00276                     nq++; ipt++;
00277                 }
00278                 break;
00279             default:
00280                 ofile << "unidentified ptype '" << ptypes[i] << G4endl;
00281         };
00282         i++;
00283     }
00284 }

char gSeparator ( '_'   ) 

void PG4ggclos (  ) 

Definition at line 32 of file G4ggclos.cc.

References G4ggclos().

Referenced by G3CLEval().

00032                 {
00033   G4ggclos();
00034 }

void PG4gsatt ( G4String tokens  ) 

Definition at line 33 of file G4gsatt.cc.

References G3fillParams(), G4gsatt(), Ipar, PTgsatt, and Spar.

Referenced by G3CLEval().

00034 {
00035     // fill the parameter containers
00036     G3fillParams(tokens,PTgsatt);
00037 
00038     // interpret the parameters
00039     G4String name = Spar[0];
00040     G4String attr = Spar[1];
00041     G4int ival = Ipar[0];
00042 
00043     G4gsatt(name, attr, ival);
00044 }

void PG4gsdet ( G4String tokens  ) 

Definition at line 32 of file G4gsdet.cc.

References G3fillParams(), G4gsdet(), Ipar, PTgsdet, and Spar.

Referenced by G3CLEval().

00033 {
00034     // fill the parameter containers
00035     G3fillParams(tokens,PTgsdet);
00036 
00037     // interpret the parameters
00038     G4String chset = Spar[0];
00039     G4String chdet = Spar[1];
00040     G4int nv = Ipar[0];
00041     G4String chnmsv[100];
00042     for (G4int i=0; i<=nv; i++ ) chnmsv[i] = Spar[2+i].data();
00043     G4int *nbits = &Ipar[1];
00044     G4int idtyp = Ipar[1+nv];
00045     G4int nwhi = Ipar[2+nv];
00046     G4int nwdi = Ipar[3+nv];
00047 
00048     G4gsdet(chset,chdet,nv,chnmsv,nbits,idtyp,nwhi,nwdi);
00049 }

void PG4gsdeta ( G4String tokens  ) 

Definition at line 38 of file G4gsdeta.cc.

References G3fillParams(), G4gsdeta(), Ipar, PTgsdeta, and Spar.

Referenced by G3CLEval().

00039 {
00040     // fill the parameter containers
00041     G3fillParams(tokens,PTgsdeta);
00042 
00043     // interpret the parameters
00044     G4String chset = Spar[0];
00045     G4String chdet = Spar[1];
00046     G4String chali = Spar[2];
00047     G4int nwhi = Ipar[0];
00048     G4int nwdi = Ipar[1];
00049 
00050     G4gsdeta(chset,chdet,chali,nwhi,nwdi);
00051 }

void PG4gsdetd ( G4String tokens  ) 

Definition at line 34 of file G4gsdetd.cc.

References G3fillParams(), G4gsdetd(), Ipar, PTgsdetd, and Spar.

Referenced by G3CLEval().

00035 {
00036     // fill the parameter containers
00037     G3fillParams(tokens,PTgsdetd);
00038 
00039     // interpret the parameters
00040     G4String chset = Spar[0];
00041     G4String chdet = Spar[1];
00042     G4int nd = Ipar[0];
00043     G4String chnmsd[100];
00044     for (G4int i=0; i<=nd; i++ ) chnmsd[i] = Spar[2+i].data();
00045     G4int *nbitsd = &Ipar[1];
00046 
00047     G4gsdetd(chset,chdet,nd,chnmsd,nbitsd);
00048 }

void PG4gsdeth ( G4String tokens  ) 

Definition at line 34 of file G4gsdeth.cc.

References G3fillParams(), G4gsdeth(), Ipar, PTgsdeth, Rpar, and Spar.

Referenced by G3CLEval().

00035 {
00036     // fill the parameter containers
00037     G3fillParams(tokens,PTgsdeth);
00038 
00039     // interpret the parameters
00040     G4String chset = Spar[0];
00041     G4String chdet = Spar[1];
00042     G4int nh = Ipar[0];
00043     G4String chnamh[100];
00044     for (G4int i=0; i<=nh; i++ ) chnamh[i] = Spar[2+i].data();
00045     G4int *nbitsh = &Ipar[1];
00046     G4double *orig = Rpar;
00047     G4double *fact = &Rpar[nh];
00048 
00049     G4gsdeth(chset,chdet,nh,chnamh,nbitsh,orig,fact);
00050 }

void PG4gsdetu ( G4String tokens  ) 

Definition at line 31 of file G4gsdetu.cc.

References G4String::data(), G3fillParams(), G4gsdetu(), Ipar, PTgsdetu, Rpar, and Spar.

Referenced by G3CLEval().

00032 {
00033     // fill the parameter containers
00034     G3fillParams(tokens,PTgsdetu);
00035 
00036     // interpret the parameters
00037     G4String chset = Spar[0].data();
00038     G4String chdet = Spar[1].data();
00039     G4int nupar = Ipar[0];
00040     G4double *upar = Rpar;
00041 
00042     G4gsdetu(chset,chdet,nupar,upar);
00043 }

void PG4gsdetv ( G4String tokens  ) 

Definition at line 36 of file G4gsdetv.cc.

References G3fillParams(), G4gsdetv(), Ipar, PTgsdetv, and Spar.

Referenced by G3CLEval().

00037 {
00038     // fill the parameter containers
00039     G3fillParams(tokens,PTgsdetv);
00040 
00041     // interpret the parameters
00042     G4String chset = Spar[0];
00043     G4String chdet = Spar[1];
00044     G4int idtyp = Ipar[0];
00045     G4int nwhi = Ipar[1];
00046     G4int nwdi = Ipar[2];
00047 
00048     G4gsdetv(chset,chdet,idtyp,nwhi,nwdi);
00049 }

void PG4gsdk ( G4String tokens  ) 

Definition at line 33 of file G4gsdk.cc.

References G3fillParams(), G4gsdk(), Ipar, PTgsdk, and Rpar.

Referenced by G3CLEval().

00034 {
00035     // fill the parameter containers
00036     G3fillParams(tokens,PTgsdk);
00037 
00038     // interpret the parameters
00039     G4int ipart = Ipar[0];
00040     G4int *mode = &Ipar[3];
00041     G4double *bratio = Rpar;
00042 
00043     G4gsdk(ipart,bratio,mode);
00044 }

void PG4gsdvn ( G4String tokens  ) 

Definition at line 38 of file G4gsdvn.cc.

References G3fillParams(), G4gsdvn(), Ipar, PTgsdvn, and Spar.

Referenced by G3CLEval().

00039 {
00040   // fill the parameter containers
00041   G3fillParams(tokens,PTgsdvn);
00042   
00043   // interpret the parameters
00044   G4String vname = Spar[0];
00045   G4String vmoth = Spar[1];
00046   G4int ndiv = Ipar[0];
00047   G4int iaxis = Ipar[1];
00048   
00049   G4gsdvn(vname, vmoth, ndiv, iaxis);
00050 }

void PG4gsdvn2 ( G4String tokens  ) 

Definition at line 41 of file G4gsdvn2.cc.

References G3fillParams(), G4gsdvn2(), Ipar, PTgsdvn2, Rpar, and Spar.

Referenced by G3CLEval().

00041                                  {
00042   // fill the parameter containers
00043   G3fillParams(tokens, PTgsdvn2);
00044   
00045   // interpret the parameters
00046   G4String vname = Spar[0];
00047   G4String vmoth = Spar[1];
00048   G4int ndiv = Ipar[0];
00049   G4int iaxis = Ipar[1];
00050   G4int numed = Ipar[2];
00051   G4double c0 = Rpar[0];
00052   
00053   G4gsdvn2(vname, vmoth, ndiv, iaxis, c0, numed);
00054 }

void PG4gsdvt ( G4String tokens  ) 

Definition at line 41 of file G4gsdvt.cc.

References G3fillParams(), G4gsdvt(), Ipar, PTgsdvt, Rpar, and Spar.

Referenced by G3CLEval().

00042 {
00043   // fill the parameter containers
00044   G3fillParams(tokens,PTgsdvt);
00045   
00046   // interpret the parameters
00047   G4String vname = Spar[0];
00048   G4String vmoth = Spar[1];
00049   G4int iaxis = Ipar[0];
00050   G4int numed = Ipar[1];
00051   G4int ndvmx = Ipar[2];
00052   G4double Step = Rpar[0];
00053   
00054   G4gsdvt(vname,vmoth,Step,iaxis,numed,ndvmx);
00055 }

void PG4gsdvt2 ( G4String tokens  ) 

Definition at line 41 of file G4gsdvt2.cc.

References G3fillParams(), G4gsdvt2(), Ipar, PTgsdvt2, Rpar, and Spar.

Referenced by G3CLEval().

00042 {
00043   // fill the parameter containers
00044   G3fillParams(tokens,PTgsdvt2);
00045   
00046   // interpret the parameters
00047   G4String vname = Spar[0];
00048   G4String vmoth = Spar[1];
00049   G4int iaxis = Ipar[0];
00050   G4int numed = Ipar[1];
00051   G4int ndvmx = Ipar[2];
00052   G4double Step = Rpar[0];
00053   G4double c0 = Rpar[1];
00054   
00055   G4gsdvt2(vname,vmoth,Step,iaxis,c0,numed,ndvmx);
00056 }

void PG4gsdvx ( G4String tokens  ) 

Definition at line 40 of file G4gsdvx.cc.

References G3fillParams(), G4gsdvx(), Ipar, PTgsdvx, Rpar, and Spar.

Referenced by G3CLEval().

00041 {
00042     // fill the parameter containers
00043     G3fillParams(tokens,PTgsdvx);
00044 
00045     // interpret the parameters
00046     G4String name = Spar[0];
00047     G4String moth = Spar[1];
00048     G4int ndiv = Ipar[0];
00049     G4int iaxis = Ipar[1];
00050     G4int numed = Ipar[2];
00051     G4int ndvmx = Ipar[3];
00052     G4double Step = Rpar[0];
00053     G4double c0 = Rpar[1];
00054 
00055     G4gsdvx(name,moth,ndiv,iaxis,Step,c0,numed,ndvmx);
00056 }

void PG4gsmate ( G4String tokens  ) 

Definition at line 42 of file G4gsmate.cc.

References G3fillParams(), G4gsmate(), Ipar, PTgsmate, Rpar, and Spar.

Referenced by G3CLEval().

00043 {
00044   // fill the parameter containers
00045   G3fillParams(tokens,PTgsmate);
00046   G4String name = Spar[0];
00047   G4int imate = Ipar[0];
00048   G4int nwbf = Ipar[1];
00049   G4double a = Rpar[0];
00050   G4double z = Rpar[1];
00051   G4double dens = Rpar[2];
00052   G4double radl = Rpar[3];
00053   // G4double absl = Rpar[4];
00054   G4double *ubuf = &Rpar[5];
00055 
00056   G4gsmate(imate, name, a, z, dens, radl, nwbf, ubuf);
00057 }

void PG4gsmixt ( G4String tokens  ) 

Definition at line 43 of file G4gsmixt.cc.

References G4String::data(), G3fillParams(), G4gsmixt(), Ipar, PTgsmixt, Rpar, and Spar.

Referenced by G3CLEval().

00044 {
00045     // fill the parameter containers
00046     G3fillParams(tokens,PTgsmixt);
00047 
00048     // interpret the parameters
00049     G4String name = Spar[0].data();
00050     G4int imate = Ipar[0];
00051     G4int nlmat = Ipar[1];
00052     //G4double dens = Rpar[0]*g/cm3;
00053     G4double dens = Rpar[0];
00054     G4double *a = Rpar + 1;
00055     G4double *z = Rpar + 1+std::abs(nlmat);
00056     G4double *wmat = Rpar + 1 + 2*std::abs(nlmat);
00057 /*
00058     for (int i=0; i<std::abs(nlmat); i++){
00059       //Rpar[i]=Rpar[i]*g/mole;
00060       Rpar[i]=Rpar[i];
00061     };
00062 */
00063     G4gsmixt(imate,name,a,z,dens,nlmat,wmat);
00064 }

void PG4gspart ( G4String tokens  ) 

Definition at line 33 of file G4gspart.cc.

References G3fillParams(), G4gspart(), Ipar, PTgspart, Rpar, and Spar.

Referenced by G3CLEval().

00034 {
00035     // fill the parameter containers
00036     G3fillParams(tokens,PTgspart);
00037 
00038     // interpret the parameters
00039     G4String chnpar = Spar[0];
00040     G4int ipart = Ipar[0];
00041     G4int itrtyp = Ipar[1];
00042     G4int nwb = Ipar[2];
00043     G4double amass = Rpar[0];
00044     G4double charge = Rpar[1];
00045     G4double tlife = Rpar[2];
00046     G4double *ubuf = &Rpar[3];
00047 
00048     G4gspart(ipart,chnpar,itrtyp,amass,charge,tlife,ubuf,nwb);
00049 }

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 }

void PG4gsposp ( G4String tokens  ) 

Definition at line 42 of file G4gsposp.cc.

References G3fillParams(), G4gsposp(), Ipar, PTgsposp, Rpar, and Spar.

Referenced by G3CLEval().

00042                                 {
00043   // fill the parameter containers
00044   G3fillParams(tokens,PTgsposp);
00045   
00046   // interpret the parameters
00047   G4String name = Spar[0];
00048   G4String moth = Spar[1];
00049   G4String only = Spar[2];
00050   G4int num = Ipar[0];
00051   G4int irot = Ipar[1];
00052   G4int npar = Ipar[2];
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   G4double *pars = &Rpar[3];
00062   
00063   G4gsposp(name, num, moth, x, y, z, irot, only, pars, npar);
00064 }

void PG4gsrotm ( G4String tokens  ) 

Definition at line 35 of file G4gsrotm.cc.

References G3fillParams(), G4gsrotm(), Ipar, PTgsrotm, and Rpar.

Referenced by G3CLEval().

00036 {
00037     // fill the parameter containers
00038     G3fillParams(tokens,PTgsrotm);
00039 
00040     // interpret the parameters
00041     G4int irot = Ipar[0];
00042     
00043     // the angles in Geant are in degrees
00044     G4double theta1 = Rpar[0];
00045     G4double phi1   = Rpar[1];
00046     G4double theta2 = Rpar[2];
00047     G4double phi2   = Rpar[3];
00048     G4double theta3 = Rpar[4];
00049     G4double phi3   = Rpar[5];
00050 
00051     G4gsrotm(irot, theta1,phi1, theta2,phi2, theta3,phi3);
00052 }

void PG4gstmed ( G4String tokens  ) 

Definition at line 44 of file G4gstmed.cc.

References G3fillParams(), G4gstmed(), Ipar, PTgstmed, Rpar, and Spar.

Referenced by G3CLEval().

00045 {
00046     // fill the parameter containers
00047     G3fillParams(tokens,PTgstmed);
00048 
00049     // interpret the parameters
00050     G4String name = Spar[0];
00051     G4int itmed = Ipar[0];
00052     G4int nmat = Ipar[1];
00053     G4int isvol = Ipar[2];
00054     G4int ifield = Ipar[3];
00055     G4int nwbuf = Ipar[4];
00056     G4double fieldm = Rpar[0];
00057     G4double tmaxfd = Rpar[1];
00058     G4double stemax = Rpar[2];
00059     G4double deemax = Rpar[3];
00060     G4double epsil = Rpar[4];
00061     G4double stmin = Rpar[5];
00062     G4double *ubuf = &Rpar[6];
00063 
00064     G4gstmed(itmed,name,nmat,isvol,ifield,fieldm,tmaxfd,stemax,
00065              deemax,epsil,stmin,ubuf,nwbuf);
00066 }

void PG4gstpar ( G4String tokens  ) 

Definition at line 32 of file G4gstpar.cc.

References G3fillParams(), G4gstpar(), Ipar, PTgstpar, Rpar, and Spar.

Referenced by G3CLEval().

00033 {
00034     // fill the parameter containers
00035     G3fillParams(tokens,PTgstpar);
00036 
00037     // interpret the parameters
00038     G4String chpar = Spar[0];
00039     G4int itmed = Ipar[0];
00040     G4double parval = Rpar[0];
00041 
00042     G4gstpar(itmed,chpar,parval);
00043 }

void PG4gsvolu ( G4String tokens  ) 

Definition at line 37 of file G4gsvolu.cc.

References G3fillParams(), G4gsvolu(), Ipar, PTgsvolu, Rpar, and Spar.

Referenced by G3CLEval().

00037                                  {
00038     // fill the parameter containers
00039     G3fillParams(tokens,PTgsvolu);
00040 
00041     // interpret the parameters
00042     G4String vname = Spar[0];
00043     G4String shape = Spar[1];
00044     G4int nmed = Ipar[0];
00045     G4int npar = Ipar[1];
00046     G4double *pars = Rpar;
00047 
00048     G4gsvolu(vname, shape, nmed, pars, npar);
00049 }


Variable Documentation

G3DetTable G3Det

Definition at line 59 of file clparse.cc.

Referenced by G4BuildGeom(), and G4gsdeta().

G3EleTable G3Ele

Definition at line 60 of file clparse.cc.

Referenced by G4gsmate(), and G4gsmixt().

G3MatTable G3Mat

Definition at line 55 of file clparse.cc.

Referenced by G4gsmate(), G4gsmixt(), and G4gstmed().

G3MedTable G3Med

Definition at line 56 of file clparse.cc.

Referenced by G3toG4BuildLVTree(), and G4gstmed().

G3PartTable G3Part

Definition at line 58 of file clparse.cc.

Referenced by G4BuildGeom().

G3RotTable G3Rot

Definition at line 57 of file clparse.cc.

Referenced by G3toG4BuildPVTree(), G4gsrotm(), and GetTransform3D().

G3SensVolVector G3SensVol

Definition at line 61 of file clparse.cc.

Referenced by G3toG4BuildLVTree().

G3VolTable G3Vol

Definition at line 54 of file clparse.cc.

Referenced by G3VolTableEntry::AddG3Pos(), G4BuildGeom(), G4CloneDaughters(), G4CreateCloneVTE(), G4CreateCloneVTEWithDivision(), G4CreateVTE(), G4ggclos(), G4gsbool(), G4gsdvn(), G4gsdvn2(), G4gsdvt(), G4gsdvt2(), G4gspos(), G4gsposp(), G4gsvolu(), and G3VolTableEntry::GetMasterClone().

G4int Ipar[1000]

Definition at line 66 of file clparse.cc.

Referenced by G3fillParams(), PG4gsatt(), PG4gsdet(), PG4gsdeta(), PG4gsdetd(), PG4gsdeth(), PG4gsdetu(), PG4gsdetv(), PG4gsdk(), PG4gsdvn(), PG4gsdvn2(), PG4gsdvt(), PG4gsdvt2(), PG4gsdvx(), PG4gsmate(), PG4gsmixt(), PG4gspart(), PG4gspos(), PG4gsposp(), PG4gsrotm(), PG4gstmed(), PG4gstpar(), and PG4gsvolu().

G4int narray

Definition at line 64 of file clparse.cc.

Referenced by G3fillParams().

std::ofstream ofile

Definition at line 45 of file clparse.cc.

std::ofstream ofile

Definition at line 45 of file clparse.cc.

Referenced by G4VScoreWriter::DumpAllQuantitiesToFile(), G4VScoreWriter::DumpQuantityToFile(), G3CLEval(), G3CLRead(), G3fillParams(), G4GMocrenIO::storeData2(), G4GMocrenIO::storeData3(), and G4GMocrenIO::storeData4().

G4double Rpar[1000]

Definition at line 67 of file clparse.cc.

Referenced by G3fillParams(), PG4gsdeth(), PG4gsdetu(), PG4gsdk(), PG4gsdvn2(), PG4gsdvt(), PG4gsdvt2(), PG4gsdvx(), PG4gsmate(), PG4gsmixt(), PG4gspart(), PG4gspos(), PG4gsposp(), PG4gsrotm(), PG4gstmed(), PG4gstpar(), and PG4gsvolu().

G4String Spar[1000]

Definition at line 68 of file clparse.cc.

Referenced by G3fillParams(), PG4gsatt(), PG4gsdet(), PG4gsdeta(), PG4gsdetd(), PG4gsdeth(), PG4gsdetu(), PG4gsdetv(), PG4gsdvn(), PG4gsdvn2(), PG4gsdvt(), PG4gsdvt2(), PG4gsdvx(), PG4gsmate(), PG4gsmixt(), PG4gspart(), PG4gspos(), PG4gsposp(), PG4gstmed(), PG4gstpar(), and PG4gsvolu().


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