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

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

Function Documentation

G3CLEval() [1/2]

void G3CLEval	(	G4String *	tokens,
		char *	select
	)

Referenced by G3CLRead().

G3CLEval() [2/2]

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

Definition at line 170 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;}
}

References g4zmq::context, 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().

G3CLRead()

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

Definition at line 98 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 (G4StrUtil::readline(istr, line) && ! 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);
    }
}

References test::fname, G3CLEval(), G3CLTokens(), G4endl, ofile, and G4StrUtil::readline().

Referenced by G4BuildGeom().

G3CLTokens() [1/2]

G4int G3CLTokens	(	G4String *	line,
		G4String *	tokens
	)

Referenced by G3CLRead().

G3CLTokens() [2/2]

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

Definition at line 134 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("\"")).empty())
    {
        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()).empty())
            {
                tokens[ntokens] = token2;
                ntokens++;
            }
        }
    }
    return ntokens;
}

References anonymous_namespace{G4MTcoutDestination.cc}::empty.

G3fillParams()

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

Definition at line 218 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++;
    }
}

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().

gSeparator()

char gSeparator

(

'_'

)

PG4ggclos()

void PG4ggclos

(

)

Definition at line 31 of file G4ggclos.cc.

                {
  G4ggclos();
}

References G4ggclos().

Referenced by G3CLEval().

PG4gsatt()

void PG4gsatt

(

G4String *

tokens

)

Definition at line 32 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);
}

References G3fillParams(), G4gsatt(), Ipar, G4InuclParticleNames::name(), PTgsatt, and Spar.

Referenced by G3CLEval().

PG4gsdet()

void PG4gsdet

(

G4String *

tokens

)

Definition at line 31 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);
}

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

Referenced by G3CLEval().

PG4gsdeta()

void PG4gsdeta

(

G4String *

tokens

)

Definition at line 37 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);
}

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

Referenced by G3CLEval().

PG4gsdetd()

void PG4gsdetd

(

G4String *

tokens

)

Definition at line 33 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);
}

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

Referenced by G3CLEval().

PG4gsdeth()

void PG4gsdeth

(

G4String *

tokens

)

Definition at line 33 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);
}

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

Referenced by G3CLEval().

PG4gsdetu()

void PG4gsdetu

(

G4String *

tokens

)

Definition at line 30 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);
}

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

Referenced by G3CLEval().

PG4gsdetv()

void PG4gsdetv

(

G4String *

tokens

)

Definition at line 35 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);
}

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

Referenced by G3CLEval().

PG4gsdk()

void PG4gsdk

(

G4String *

tokens

)

Definition at line 32 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);
}

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

Referenced by G3CLEval().

PG4gsdvn()

void PG4gsdvn

(

G4String *

tokens

)

Definition at line 37 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);
}

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

Referenced by G3CLEval().

PG4gsdvn2()

void PG4gsdvn2

(

G4String *

tokens

)

Definition at line 40 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);
}

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

Referenced by G3CLEval().

PG4gsdvt()

void PG4gsdvt

(

G4String *

tokens

)

Definition at line 40 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);
}

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

Referenced by G3CLEval().

PG4gsdvt2()

void PG4gsdvt2

(

G4String *

tokens

)

Definition at line 40 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);
}

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

Referenced by G3CLEval().

PG4gsdvx()

void PG4gsdvx

(

G4String *

tokens

)

Definition at line 39 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);
}

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

Referenced by G3CLEval().

PG4gsmate()

void PG4gsmate

(

G4String *

tokens

)

Definition at line 41 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);
}

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

Referenced by G3CLEval().

PG4gsmixt()

void PG4gsmixt

(

G4String *

tokens

)

Definition at line 42 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);
}

References G3fillParams(), G4gsmixt(), Ipar, G4InuclParticleNames::name(), PTgsmixt, Rpar, and Spar.

Referenced by G3CLEval().

PG4gspart()

void PG4gspart

(

G4String *

tokens

)

Definition at line 32 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);
}

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

Referenced by G3CLEval().

PG4gspos()

void PG4gspos

(

G4String *

tokens

)

Definition at line 41 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);
}

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

Referenced by G3CLEval().

PG4gsposp()

void PG4gsposp

(

G4String *

tokens

)

Definition at line 41 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);
}

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

Referenced by G3CLEval().

PG4gsrotm()

void PG4gsrotm

(

G4String *

tokens

)

Definition at line 34 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);
}

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

Referenced by G3CLEval().

PG4gstmed()

void PG4gstmed

(

G4String *

tokens

)

Definition at line 43 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);
}

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

Referenced by G3CLEval().

PG4gstpar()

void PG4gstpar

(

G4String *

tokens

)

Definition at line 31 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);
}

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

Referenced by G3CLEval().

PG4gsvolu()

void PG4gsvolu

(

G4String *

tokens

)

Definition at line 36 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);
}

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

Referenced by G3CLEval().

Variable Documentation

G3Det

G3DetTable G3Det

Definition at line 58 of file clparse.cc.

Referenced by G4BuildGeom(), and G4gsdeta().

G3Ele

G3EleTable G3Ele

Definition at line 59 of file clparse.cc.

Referenced by G4gsmate(), and G4gsmixt().

G3Mat

G3MatTable G3Mat

Definition at line 54 of file clparse.cc.

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

G3Med

G3MedTable G3Med

Definition at line 55 of file clparse.cc.

Referenced by G3toG4BuildLVTree(), and G4gstmed().

G3Part

G3PartTable G3Part

Definition at line 57 of file clparse.cc.

Referenced by G4BuildGeom().

G3Rot

G3RotTable G3Rot

Definition at line 56 of file clparse.cc.

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

G3SensVol

G3SensVolVector G3SensVol

Definition at line 60 of file clparse.cc.

Referenced by G3toG4BuildLVTree().

G3Vol

G3VolTable G3Vol

Definition at line 53 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().

Ipar

G4int Ipar[1000]

Definition at line 65 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().

narray

G4int narray

Definition at line 63 of file clparse.cc.

Referenced by G3fillParams().

ofile

std::ofstream ofile

Definition at line 44 of file clparse.cc.

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

Rpar

G4double Rpar[1000]

Definition at line 66 of file clparse.cc.

Referenced by G3Division::CreateEnvelope(), G3Division::CreateSolid(), G3Division::Dvn(), G3Division::Dvn2(), G3Division::Dvt(), G3Division::Dvt2(), G3fillParams(), PG4gsdeth(), PG4gsdetu(), PG4gsdk(), PG4gsdvn2(), PG4gsdvt(), PG4gsdvt2(), PG4gsdvx(), PG4gsmate(), PG4gsmixt(), PG4gspart(), PG4gspos(), PG4gsposp(), PG4gsrotm(), PG4gstmed(), PG4gstpar(), PG4gsvolu(), and G3Division::SetRangeAndAxis().

Spar

G4String Spar[1000]

Definition at line 67 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().