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

Include dependency graph for clparse.cc:

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

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
	)

Here is the caller graph for this function:

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

Definition at line 171 of file clparse.cc.

 {
   //
   // G3CLEval
   //
   // Evaluate the token List as a Geant3 call, and execute it as
   // a Geant4 call.
 
     const char* context = tokens[0];
     const char* routine = tokens[1];
     const char* wcard = "*";
 
     // If context is selected, return unless context matches
     //
     if ((select != 0) && (select != wcard))
     {
       if ( strcmp(select,context) )  { return; }
     }
 
     // Branch on Geant3 routine name
     //
     ofile << "Do routine " << routine << " in context " << context << G4endl;
     
     if ( !strcmp(routine,"GSVOLU") ) { PG4gsvolu(&tokens[2]); return;}
     if ( !strcmp(routine,"GSPOS") )  { PG4gspos (&tokens[2]); return;}
     if ( !strcmp(routine,"GSPOSP") ) { PG4gsposp(&tokens[2]); return;}
     if ( !strcmp(routine,"GSATT") )  { PG4gsatt (&tokens[2]); return;}
     if ( !strcmp(routine,"GSROTM") ) { PG4gsrotm(&tokens[2]); return;}
     if ( !strcmp(routine,"GSDVN") )  { PG4gsdvn (&tokens[2]); return;}
     if ( !strcmp(routine,"GSDVT") )  { PG4gsdvt (&tokens[2]); return;}
     if ( !strcmp(routine,"GSDVX") )  { PG4gsdvx (&tokens[2]); return;}
     if ( !strcmp(routine,"GSDVN2") ) { PG4gsdvn2(&tokens[2]); return;}
     if ( !strcmp(routine,"GSDVT2") ) { PG4gsdvt2(&tokens[2]); return;}
     if ( !strcmp(routine,"GSMATE") ) { PG4gsmate(&tokens[2]); return;}
     if ( !strcmp(routine,"GSMIXT") ) { PG4gsmixt(&tokens[2]); return;}
     if ( !strcmp(routine,"GSTMED") ) { PG4gstmed(&tokens[2]); return;}
     if ( !strcmp(routine,"GSTPAR") ) { PG4gstpar(&tokens[2]); return;}
     if ( !strcmp(routine,"GSPART") ) { PG4gspart(&tokens[2]); return;}
     if ( !strcmp(routine,"GSDK") )   { PG4gsdk  (&tokens[2]); return;}
     if ( !strcmp(routine,"GSDET") )  { PG4gsdet (&tokens[2]); return;}
     if ( !strcmp(routine,"GSDETV") ) { PG4gsdetv(&tokens[2]); return;}
     if ( !strcmp(routine,"GSDETA") ) { PG4gsdeta(&tokens[2]); return;}
     if ( !strcmp(routine,"GSDETH") ) { PG4gsdeth(&tokens[2]); return;}
     if ( !strcmp(routine,"GSDETD") ) { PG4gsdetd(&tokens[2]); return;}
     if ( !strcmp(routine,"GSDETU") ) { PG4gsdetu(&tokens[2]); return;}
     if ( !strcmp(routine,"GGCLOS") ) { PG4ggclos(); return;}
 }

Here is the call graph for this function:

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

Definition at line 99 of file clparse.cc.

 {
   //
   //  G3CLRead
   //  Read the call List file, parse the tokens, and pass the token
   //  List to the Geant4 interpreter
   //
   //  fname: call List filename
   
     G4String line;
     G4String tokens[1000];
 
     const char* ofname = "clparse.out";
     ofile.open(ofname);
     ofile << "Output file open\n";
 
     G4int count = 0;
     G4int ntokens = 0;
     std::ifstream istr(fname);
     
     while (line.readLine(istr) && ! istr.eof())
     {
         count++;
         ntokens = G3CLTokens(&line,tokens);  // tokenize the line
         for (G4int i=0; i < ntokens; i++)
         {
           ofile << tokens[i] << G4endl;
         }
 
         // interpret the line as a Geant call
         //
         G3CLEval(tokens, select);
     }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G3CLTokens	(	G4String *	line,
		G4String *	tokens
	)

Here is the caller graph for this function:

G4int G3CLTokens	(	G4String *	line,
		G4String	tokens[]
	)

Definition at line 135 of file clparse.cc.

 {
   //
   // G3CLTokens
   //
   // Tokenize line, returning tokens in tokens[]. Items in ".."
   // are extracted as single tokens, despite embedded spaces.
 
     G4Tokenizer next(*line);
 
     // first tokenize using " to identify strings
     //
     G4int itok = 0;
     G4int ntokens = 0;
     G4String token1, token2;
     while (!(token1=next("\"")).isNull())
     {
         itok++;
         if (itok%2 == 0 ) // even: inside a string
         {
             tokens[ntokens++] = token1;
         }
         else              // not in a quoted string: finish tokenization
         {
             G4Tokenizer lev2(token1);
             while (!(token2=lev2()).isNull())
             {
                 tokens[ntokens] = token2;
                 ntokens++;
             }
         }
     }
     return ntokens;
 }

void G3fillParams	(	G4String *	tokens,
		const char *	ptypes
	)

Definition at line 219 of file clparse.cc.

 {
   //
   // G3fillParams
   //
   // Interpret tokens to fill call parameters, based on parameter types ptypes
 
     // loop over ptypes
     //
     G4int i =0, ipt = 0, k = 0;
     G4int ni =0, nr = 0, nq = 0;
     while (ptypes[i] != '\0')
     {
         switch (ptypes[i])
         {
             case 'i':
                 Ipar[ni] = atoi(tokens[ipt].data());
                 narray = Ipar[ni];
                 ni++; ipt++;
                 break;
             case 'r':
                 Rpar[nr] = atof(tokens[ipt].data());
                 nr++; ipt++;
                 break;
             case 's':
                 Spar[nq] = tokens[ipt];
                 nq++; ipt++;
                 break;
             case 'I':
                 for (k=0; k < narray; k++)
                 {
                     Ipar[ni] = atoi(tokens[ipt].data());
                     ni++; ipt++;
                 }
                 break;
             case 'R':
                 for (k=0; k < narray; k++) 
                 { 
                     Rpar[nr] = atof(tokens[ipt].data()); 
                     nr++; ipt++;
                 }
                 break;
             case 'Q':
                 // special case of reading three successive R arrays 
                 // into one (used in gsmixt)
                 //
                 narray = 3 * std::abs(narray);
                 for (k=0; k < narray; k++) 
                 { 
                     Rpar[nr] = atof(tokens[ipt].data()); 
                     nr++; ipt++;
                 }
                 break;
             case 'S':
                 for (k=0; k < narray; k++)
                 {
                     Spar[nq] = tokens[ipt];
                     nq++; ipt++;
                 }
                 break;
             default:
                 ofile << "unidentified ptype '" << ptypes[i] << G4endl;
         };
         i++;
     }
 }

Here is the caller graph for this function:

char gSeparator ( '_' )

void PG4ggclos ( )

Definition at line 32 of file G4ggclos.cc.

                 {
   G4ggclos();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsatt ( G4String * tokens )

Definition at line 33 of file G4gsatt.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsatt);
 
     // interpret the parameters
     G4String name = Spar[0];
     G4String attr = Spar[1];
     G4int ival = Ipar[0];
 
     G4gsatt(name, attr, ival);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdet ( G4String * tokens )

Definition at line 32 of file G4gsdet.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdet);
 
     // interpret the parameters
     G4String chset = Spar[0];
     G4String chdet = Spar[1];
     G4int nv = Ipar[0];
     G4String chnmsv[100];
     for (G4int i=0; i<=nv; i++ ) chnmsv[i] = Spar[2+i].data();
     G4int *nbits = &Ipar[1];
     G4int idtyp = Ipar[1+nv];
     G4int nwhi = Ipar[2+nv];
     G4int nwdi = Ipar[3+nv];
 
     G4gsdet(chset,chdet,nv,chnmsv,nbits,idtyp,nwhi,nwdi);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdeta ( G4String * tokens )

Definition at line 38 of file G4gsdeta.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdeta);
 
     // interpret the parameters
     G4String chset = Spar[0];
     G4String chdet = Spar[1];
     G4String chali = Spar[2];
     G4int nwhi = Ipar[0];
     G4int nwdi = Ipar[1];
 
     G4gsdeta(chset,chdet,chali,nwhi,nwdi);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdetd ( G4String * tokens )

Definition at line 34 of file G4gsdetd.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdetd);
 
     // interpret the parameters
     G4String chset = Spar[0];
     G4String chdet = Spar[1];
     G4int nd = Ipar[0];
     G4String chnmsd[100];
     for (G4int i=0; i<=nd; i++ ) chnmsd[i] = Spar[2+i].data();
     G4int *nbitsd = &Ipar[1];
 
     G4gsdetd(chset,chdet,nd,chnmsd,nbitsd);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdeth ( G4String * tokens )

Definition at line 34 of file G4gsdeth.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdeth);
 
     // interpret the parameters
     G4String chset = Spar[0];
     G4String chdet = Spar[1];
     G4int nh = Ipar[0];
     G4String chnamh[100];
     for (G4int i=0; i<=nh; i++ ) chnamh[i] = Spar[2+i].data();
     G4int *nbitsh = &Ipar[1];
     G4double *orig = Rpar;
     G4double *fact = &Rpar[nh];
 
     G4gsdeth(chset,chdet,nh,chnamh,nbitsh,orig,fact);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdetu ( G4String * tokens )

Definition at line 31 of file G4gsdetu.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdetu);
 
     // interpret the parameters
     G4String chset = Spar[0].data();
     G4String chdet = Spar[1].data();
     G4int nupar = Ipar[0];
     G4double *upar = Rpar;
 
     G4gsdetu(chset,chdet,nupar,upar);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdetv ( G4String * tokens )

Definition at line 36 of file G4gsdetv.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdetv);
 
     // interpret the parameters
     G4String chset = Spar[0];
     G4String chdet = Spar[1];
     G4int idtyp = Ipar[0];
     G4int nwhi = Ipar[1];
     G4int nwdi = Ipar[2];
 
     G4gsdetv(chset,chdet,idtyp,nwhi,nwdi);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdk ( G4String * tokens )

Definition at line 33 of file G4gsdk.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdk);
 
     // interpret the parameters
     G4int ipart = Ipar[0];
     G4int *mode = &Ipar[3];
     G4double *bratio = Rpar;
 
     G4gsdk(ipart,bratio,mode);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdvn ( G4String * tokens )

Definition at line 38 of file G4gsdvn.cc.

 {
   // fill the parameter containers
   G3fillParams(tokens,PTgsdvn);
   
   // interpret the parameters
   G4String vname = Spar[0];
   G4String vmoth = Spar[1];
   G4int ndiv = Ipar[0];
   G4int iaxis = Ipar[1];
   
   G4gsdvn(vname, vmoth, ndiv, iaxis);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdvn2 ( G4String * tokens )

Definition at line 41 of file G4gsdvn2.cc.

                                  {
   // fill the parameter containers
   G3fillParams(tokens, PTgsdvn2);
   
   // interpret the parameters
   G4String vname = Spar[0];
   G4String vmoth = Spar[1];
   G4int ndiv = Ipar[0];
   G4int iaxis = Ipar[1];
   G4int numed = Ipar[2];
   G4double c0 = Rpar[0];
   
   G4gsdvn2(vname, vmoth, ndiv, iaxis, c0, numed);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdvt ( G4String * tokens )

Definition at line 41 of file G4gsdvt.cc.

 {
   // fill the parameter containers
   G3fillParams(tokens,PTgsdvt);
   
   // interpret the parameters
   G4String vname = Spar[0];
   G4String vmoth = Spar[1];
   G4int iaxis = Ipar[0];
   G4int numed = Ipar[1];
   G4int ndvmx = Ipar[2];
   G4double Step = Rpar[0];
   
   G4gsdvt(vname,vmoth,Step,iaxis,numed,ndvmx);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdvt2 ( G4String * tokens )

Definition at line 41 of file G4gsdvt2.cc.

 {
   // fill the parameter containers
   G3fillParams(tokens,PTgsdvt2);
   
   // interpret the parameters
   G4String vname = Spar[0];
   G4String vmoth = Spar[1];
   G4int iaxis = Ipar[0];
   G4int numed = Ipar[1];
   G4int ndvmx = Ipar[2];
   G4double Step = Rpar[0];
   G4double c0 = Rpar[1];
   
   G4gsdvt2(vname,vmoth,Step,iaxis,c0,numed,ndvmx);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsdvx ( G4String * tokens )

Definition at line 40 of file G4gsdvx.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsdvx);
 
     // interpret the parameters
     G4String name = Spar[0];
     G4String moth = Spar[1];
     G4int ndiv = Ipar[0];
     G4int iaxis = Ipar[1];
     G4int numed = Ipar[2];
     G4int ndvmx = Ipar[3];
     G4double Step = Rpar[0];
     G4double c0 = Rpar[1];
 
     G4gsdvx(name,moth,ndiv,iaxis,Step,c0,numed,ndvmx);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsmate ( G4String * tokens )

Definition at line 42 of file G4gsmate.cc.

 {
   // fill the parameter containers
   G3fillParams(tokens,PTgsmate);
   G4String name = Spar[0];
   G4int imate = Ipar[0];
   G4int nwbf = Ipar[1];
   G4double a = Rpar[0];
   G4double z = Rpar[1];
   G4double dens = Rpar[2];
   G4double radl = Rpar[3];
   // G4double absl = Rpar[4];
   G4double *ubuf = &Rpar[5];
 
   G4gsmate(imate, name, a, z, dens, radl, nwbf, ubuf);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsmixt ( G4String * tokens )

Definition at line 43 of file G4gsmixt.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsmixt);
 
     // interpret the parameters
     G4String name = Spar[0].data();
     G4int imate = Ipar[0];
     G4int nlmat = Ipar[1];
     //G4double dens = Rpar[0]*g/cm3;
     G4double dens = Rpar[0];
     G4double *a = Rpar + 1;
     G4double *z = Rpar + 1+std::abs(nlmat);
     G4double *wmat = Rpar + 1 + 2*std::abs(nlmat);
 /*
     for (int i=0; i<std::abs(nlmat); i++){
       //Rpar[i]=Rpar[i]*g/mole;
       Rpar[i]=Rpar[i];
     };
 */
     G4gsmixt(imate,name,a,z,dens,nlmat,wmat);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gspart ( G4String * tokens )

Definition at line 33 of file G4gspart.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgspart);
 
     // interpret the parameters
     G4String chnpar = Spar[0];
     G4int ipart = Ipar[0];
     G4int itrtyp = Ipar[1];
     G4int nwb = Ipar[2];
     G4double amass = Rpar[0];
     G4double charge = Rpar[1];
     G4double tlife = Rpar[2];
     G4double *ubuf = &Rpar[3];
 
     G4gspart(ipart,chnpar,itrtyp,amass,charge,tlife,ubuf,nwb);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gspos ( G4String * tokens )

Definition at line 42 of file G4gspos.cc.

 {
         // fill the parameter containers
     G3fillParams(tokens,PTgspos);
   
         // interpret the parameters
     G4String name = Spar[0];
     G4String moth = Spar[1];
     G4String only = Spar[2];
     G4int num = Ipar[0];
     G4int irot = Ipar[1];
         // all parameters are passed to G4gsxxx methods
         // in G3 default units         
     //G4double x = Rpar[0]*cm;
     //G4double y = Rpar[1]*cm;
     //G4double z = Rpar[2]*cm;
     G4double x = Rpar[0];
     G4double y = Rpar[1];
     G4double z = Rpar[2];
   
     G4gspos(name, num, moth, x, y, z, irot, only);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsposp ( G4String * tokens )

Definition at line 42 of file G4gsposp.cc.

                                 {
   // fill the parameter containers
   G3fillParams(tokens,PTgsposp);
   
   // interpret the parameters
   G4String name = Spar[0];
   G4String moth = Spar[1];
   G4String only = Spar[2];
   G4int num = Ipar[0];
   G4int irot = Ipar[1];
   G4int npar = Ipar[2];
   // all parameters are passed to G4gsxxx methods
   // in G3 default units         
   //G4double x = Rpar[0]*cm;
   //G4double y = Rpar[1]*cm;
   //G4double z = Rpar[2]*cm;
   G4double x = Rpar[0];
   G4double y = Rpar[1];
   G4double z = Rpar[2];
   G4double *pars = &Rpar[3];
   
   G4gsposp(name, num, moth, x, y, z, irot, only, pars, npar);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsrotm ( G4String * tokens )

Definition at line 35 of file G4gsrotm.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgsrotm);
 
     // interpret the parameters
     G4int irot = Ipar[0];
     
     // the angles in Geant are in degrees
     G4double theta1 = Rpar[0];
     G4double phi1   = Rpar[1];
     G4double theta2 = Rpar[2];
     G4double phi2   = Rpar[3];
     G4double theta3 = Rpar[4];
     G4double phi3   = Rpar[5];
 
     G4gsrotm(irot, theta1,phi1, theta2,phi2, theta3,phi3);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gstmed ( G4String * tokens )

Definition at line 44 of file G4gstmed.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgstmed);
 
     // interpret the parameters
     G4String name = Spar[0];
     G4int itmed = Ipar[0];
     G4int nmat = Ipar[1];
     G4int isvol = Ipar[2];
     G4int ifield = Ipar[3];
     G4int nwbuf = Ipar[4];
     G4double fieldm = Rpar[0];
     G4double tmaxfd = Rpar[1];
     G4double stemax = Rpar[2];
     G4double deemax = Rpar[3];
     G4double epsil = Rpar[4];
     G4double stmin = Rpar[5];
     G4double *ubuf = &Rpar[6];
 
     G4gstmed(itmed,name,nmat,isvol,ifield,fieldm,tmaxfd,stemax,
              deemax,epsil,stmin,ubuf,nwbuf);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gstpar ( G4String * tokens )

Definition at line 32 of file G4gstpar.cc.

 {
     // fill the parameter containers
     G3fillParams(tokens,PTgstpar);
 
     // interpret the parameters
     G4String chpar = Spar[0];
     G4int itmed = Ipar[0];
     G4double parval = Rpar[0];
 
     G4gstpar(itmed,chpar,parval);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void PG4gsvolu ( G4String * tokens )

Definition at line 37 of file G4gsvolu.cc.

                                  {
     // fill the parameter containers
     G3fillParams(tokens,PTgsvolu);
 
     // interpret the parameters
     G4String vname = Spar[0];
     G4String shape = Spar[1];
     G4int nmed = Ipar[0];
     G4int npar = Ipar[1];
     G4double *pars = Rpar;
 
     G4gsvolu(vname, shape, nmed, pars, npar);
 }