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>

Include dependency graph for clparse.cc:

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

G3CLEval() [1/2]

void G3CLEval	(	G4String *	tokens,
		char *	select
	)

Here is the caller graph for this function:

G3CLEval() [2/2]

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:

G3CLRead()

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:

G3CLTokens() [1/2]

G4int G3CLTokens	(	G4String *	line,
		G4String *	tokens
	)

Here is the caller graph for this function:

G3CLTokens() [2/2]

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;
}

G3fillParams()

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:

gSeparator()

char gSeparator

(

'_'

)

PG4ggclos()

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:

PG4gsatt()

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:

PG4gsdet()

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:

PG4gsdeta()

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:

PG4gsdetd()

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:

PG4gsdeth()

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:

PG4gsdetu()

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:

PG4gsdetv()

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:

PG4gsdk()

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:

PG4gsdvn()

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:

PG4gsdvn2()

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:

PG4gsdvt()

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:

PG4gsdvt2()

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:

PG4gsdvx()

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:

PG4gsmate()

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:

PG4gsmixt()

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:

PG4gspart()

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:

PG4gspos()

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:

PG4gsposp()

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:

PG4gsrotm()

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:

PG4gstmed()

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:

PG4gstpar()

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:

PG4gsvolu()

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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

G3Det

G3DetTable G3Det

Definition at line 59 of file clparse.cc.

G3Ele

G3EleTable G3Ele

Definition at line 60 of file clparse.cc.

G3Mat

G3MatTable G3Mat

Definition at line 55 of file clparse.cc.

G3Med

G3MedTable G3Med

Definition at line 56 of file clparse.cc.

G3Part

G3PartTable G3Part

Definition at line 58 of file clparse.cc.

G3Rot

G3RotTable G3Rot

Definition at line 57 of file clparse.cc.

G3SensVol

G3SensVolVector G3SensVol

Definition at line 61 of file clparse.cc.

G3Vol

G3VolTable G3Vol

Definition at line 54 of file clparse.cc.

Ipar

G4int Ipar[1000]

Definition at line 66 of file clparse.cc.

narray

G4int narray

Definition at line 64 of file clparse.cc.

ofile

std::ofstream ofile

Definition at line 45 of file clparse.cc.

Rpar

G4double Rpar[1000]

Definition at line 67 of file clparse.cc.

Spar

G4String Spar[1000]

Definition at line 68 of file clparse.cc.