#include "globals.hh"

Functions
void	G4gsvolu (G4String name, G4String shape, G4int nmed, G4double *par, G4int npar)

void	G4gspos (G4String name, G4int num, G4String moth, G4double x, G4double y, G4double z, G4int irot, G4String only)

void	G4gsposp (G4String name, G4int num, G4String moth, G4double x, G4double y, G4double z, G4int irot, G4String only, G4double Rpar[], G4int npar)

void	G4gsbool (G4String volName, G4String manyVolName)

void	G4gsrotm (G4int irot, G4double theta1, G4double phi1, G4double theta2, G4double phi2, G4double theta3, G4double phi3)

void	G4gsatt (G4String name, G4String attr, G4int ival)

void	G4gsdvn (G4String vname, G4String vmoth, G4int ndiv, G4int iaxis)

void	G4gsdvt (G4String name, G4String moth, G4double Step, G4int iaxis, G4int numed, G4int ndvmx)

void	G4gsdvx (G4String name, G4String moth, G4int ndiv, G4int iaxis, G4double Step, G4double c0, G4int numed, G4int ndvmx)

void	G4gsdvn2 (G4String name, G4String moth, G4int ndiv, G4int iaxis, G4double c0, G4int numed)

void	G4gsdvt2 (G4String name, G4String moth, G4double Step, G4int iaxis, G4double c0, G4int numed, G4int ndvmx)

void	G4gsmate (G4int imate, G4String name, G4double a, G4double z, G4double dens, G4double radl, G4int nwbf, G4double *ubuf)

void	G4gsmixt (G4int imate, G4String name, G4double a[], G4double z, G4double dens, G4int nlmat, G4double wmat)

void	G4gstmed (G4int itmed, G4String name, G4int nmat, G4int isvol, G4int ifield, G4double fieldm, G4double tmaxfd, G4double stemax, G4double deemax, G4double epsil, G4double stmin, G4double *par, G4int npar)

void	G4gstpar (G4int itmed, G4String chpar, G4double parval)

void	G4gspart (G4int ipart, G4String chnpar, G4int itrtyp, G4double amass, G4double charge, G4double tlife, G4double *ubuf, G4int nwb)

void	G4gsdk (G4int ipart, G4double bratio, G4int mode)

void	G4gsdet (G4String chset, G4String chdet, G4int nv, G4String chnmsv, G4int nbitsv, G4int idtyp, G4int nwhi, G4int nwdi)

void	G4gsdetv (G4String chset, G4String chdet, G4int idtyp, G4int nwhi, G4int nwdi)

void	G4gsdeta (G4String chset, G4String chdet, G4String chali, G4int nwhi, G4int nwdi)

void	G4gsdeth (G4String chset, G4String chdet, G4int nh, G4String chnamh, G4int nbitsh, G4double orig, G4double fact)

void	G4gsdetd (G4String chset, G4String chdet, G4int nd, G4String chnmsd, G4int nbitsd)

void	G4gsdetu (G4String chset, G4String chdet, G4int nupar, G4double *upar)

void	G4ggclos ()

G4LogicalVolume *	G4BuildGeom (G4String &inFile)

Function Documentation

◆ G4BuildGeom()

G4LogicalVolume * G4BuildGeom ( G4String & inFile )

Definition at line 54 of file G4BuildGeom.cc.

                                              {
 
  G4int irot=0;
  G4gsrotm(0, 90, 0, 90, 90, 0, 0);
 
  G4cout << "Instantiated unit rotation matrix irot=" << irot << G4endl;
 
  // Read the call List and interpret to Generate Geant4 geometry
 
  G4cout << "Reading the call List file " << inFile << "..." << G4endl;
 
  G3CLRead(inFile, 0);
 
  G3Part.PrintAll();
 
  G3Det.PrintAll();
 
  G3Vol.PrintAll();
 
  G4cout << "Call List file read completed. Build geometry" << G4endl;
 
  // Build the geometry
 
  G3VolTableEntry* topVTE = G3Vol.GetFirstVTE();
  G4cout << "G3toG4 top level volume is " << topVTE->GetName() << G4endl;
 
  // modified
  G3toG4BuildTree(topVTE, 0);
 
  // Retrieve the top-level G3toG4 logical mother volume pointer
 
  G4LogicalVolume* topLV = topVTE->GetLV();
 
  // position the top logical volume
  // (in Geant3 the top volume is not positioned)
  // 
  new G4PVPlacement(0, G4ThreeVector(), topLV->GetName(), topLV, 0, false, 0);
 
  // mark as invisible
 
  topLV->SetVisAttributes(G4VisAttributes::GetInvisible());
    
  G4cout << "Top-level G3toG4 logical volume " << topLV->GetName() << " "
         << *(topLV->GetVisAttributes()) << G4endl;
        
        // check the geometry here
 
  #ifdef G3G4DEBUG
    G4cout << "scan through G4LogicalVolumeStore:" << G4endl;
    checkVol();
  #endif
 
  return topLV;
}

◆ G4ggclos()

void G4ggclos ( )

Definition at line 35 of file G4ggclos.cc.

               {
  G4cout << "G4ggclos: setting top-level VolTableEntry" << G4endl;
  G3Vol.SetFirstVTE();
}

Referenced by PG4ggclos().

◆ G4gsatt()

void G4gsatt	(	G4String	name,
		G4String	attr,
		G4int	ival )

Definition at line 45 of file G4gsatt.cc.

{
    // get logical volume pointer
    // G4LogicalVolume *lvol = G3Vol.GetVTE(name)->GetLV();
    G4cerr << "G4gsatt not implemented" << G4endl;
}

Referenced by PG4gsatt().

◆ G4gsbool()

void G4gsbool	(	G4String	volName,
		G4String	manyVolName )

Definition at line 34 of file G4gsbool.cc.

{
  // find VTEs
  G3VolTableEntry* vte = G3Vol.GetVTE(volName);
  G3VolTableEntry* manyVTE = G3Vol.GetVTE(manyVolName);
 
  if (vte == 0) {
    G4String text = "G4gsbool: '" + volName + "' has no VolTableEntry";
    G4Exception("G4gsbool()", "G3toG40012", FatalException, text);
    return;
  } 
  else if (manyVTE == 0) {
    // warning
    G4cerr << "G4gsbool: '" << manyVolName << "' has no VolTableEntry." 
           << G4endl
           << "          Specified overlap will be ignored."
       << G4endl;
    return;    
  } 
  else { 
    manyVTE->AddOverlap(vte);
  }   
}

◆ G4gsdet()

void G4gsdet	(	G4String	chset,
		G4String	chdet,
		G4int	nv,
		G4String *	chnmsv,
		G4int *	nbitsv,
		G4int	idtyp,
		G4int	nwhi,
		G4int	nwdi )

Definition at line 50 of file G4gsdet.cc.

{ 
    G4gsdetv(chset, chdet, idtyp, nwhi, nwdi);
}

Referenced by PG4gsdet().

◆ G4gsdeta()

void G4gsdeta	(	G4String	chset,
		G4String	chdet,
		G4String	chali,
		G4int	nwhi,
		G4int	nwdi )

Definition at line 52 of file G4gsdeta.cc.

{
    G4int idtyp = G3Det.GetID(chset, chdet);
    // just associate another sensitive detector structure with
    // the volume chdet
    G4gsdetv(chset, chdet, idtyp, nwhi, nwdi);
}

Referenced by PG4gsdeta().

◆ G4gsdetd()

void G4gsdetd	(	G4String	chset,
		G4String	chdet,
		G4int	nd,
		G4String *	chnmsd,
		G4int *	nbitsd )

Definition at line 49 of file G4gsdetd.cc.

{
    // Get pointer to detector chset
    // G4VSensitiveDetector* sdet = G3Det.GetSD(chset, chdet);
    // Add hits to sensitive detector
    // for (G4int i=0; i<nd; i++) {
      // $$$        sdet->AddDigi(chnmsd[i],nbitsd[i]);
    // }
}

Referenced by PG4gsdetd().

◆ G4gsdeth()

void G4gsdeth	(	G4String	chset,
		G4String	chdet,
		G4int	nh,
		G4String *	chnamh,
		G4int *	nbitsh,
		G4double *	orig,
		G4double *	fact )

Definition at line 51 of file G4gsdeth.cc.

{
    // Get pointer to sensitive detector chset
    // G4VSensitiveDetector* sdet = G3Det.GetSD(chset, chdet);
    // Add hits to sensitive detector
    // for (G4int i=0; i<nh; i++) {
      // $$$        sdet->AddHit(chnamh[i],nbitsh[i],orig[i],fact[i]);
    // }
}

Referenced by PG4gsdeth().

◆ G4gsdetu()

void G4gsdetu	(	G4String	chset,
		G4String	chdet,
		G4int	nupar,
		G4double *	upar )

Definition at line 44 of file G4gsdetu.cc.

{
    // $$$ nothing right now
}

Referenced by PG4gsdetu().

◆ G4gsdetv()

void G4gsdetv	(	G4String	chset,
		G4String	chdet,
		G4int	idtyp,
		G4int	nwhi,
		G4int	nwdi )

Definition at line 50 of file G4gsdetv.cc.

{  
  G4cout << "G4gsdetv not currently implemented." << G4endl;
  /*
    // get lvol for detector chdet
    G4LogicalVolume *lvol = G3Vol.GetLV(chdet);
    if (lvol == 0) {
    G4cout << "G4gsdetv: Logical volume " << chdet << " not available. Skip." << G4endl;
    return;
    }
    // Generate a sensitive detector structure
    // G4VSensitiveDetector *sdet;
    // $$$    G4VSensitiveDetector *sdet = new G4VSensitiveDetector(chset);
    // inform the logical volume of its sensitive detector
    // lvol->SetSensitiveDetector(sdet);
    // $$$ sdet->SetID(idtyp);
    // Add the sensitive detector to the table
    // G3Det.put(chset,idtyp,sdet);
    */
}

Referenced by G4gsdet(), G4gsdeta(), and PG4gsdetv().

◆ G4gsdk()

void G4gsdk	(	G4int	ipart,
		G4double *	bratio,
		G4int *	mode )

Definition at line 45 of file G4gsdk.cc.

{
/*
    // create decay object for the particle
    G4Decay *decay = new G4Decay();
    // add decay modes
    for (G4int i=0; i<6; i++) {
        if (mode[i] != 0) {
// $$$            decay->AddMode(mode[i],bratio[i]);
        }
    }
    // associate decay object with particle ipart
    G4ParticleDefinition *part = G3Part.Get(ipart);
// $$$    part->SetDecay(decay);
*/
}

Referenced by PG4gsdk().

◆ G4gsdvn()

void G4gsdvn	(	G4String	vname,
		G4String	vmoth,
		G4int	ndiv,
		G4int	iaxis )

Definition at line 102 of file G4gsdvn.cc.

{
  // find mother VTE
  G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
 
  if (mvte == 0) {
    G4String text = "G4gsdvn:'" + vmoth + "' has no VolTableEntry";
    G4Exception("G4gsdvn()", "G3toG40013", FatalException, text);
    return;
  }  
  else {
    // a new vte clone copy with division is created
    // for each mother (clone copy)
    
    G4CreateCloneVTEWithDivision(vname, mvte, kDvn, ndiv, iaxis, 0, 0., 0.); 
  }  
}

Referenced by PG4gsdvn().

◆ G4gsdvn2()

void G4gsdvn2	(	G4String	name,
		G4String	moth,
		G4int	ndiv,
		G4int	iaxis,
		G4double	c0,
		G4int	numed )

Definition at line 55 of file G4gsdvn2.cc.

{
  // find mother VTE
  G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
  if (mvte == 0) {
    G4String text = "G4gsdvn2:'" + vmoth + "' has no VolTableEntry";
    G4Exception("G4gsdvn2()", "G3toG40025", FatalException, text);
    return;
  }    
  else {
    // a new vte clone copy with division is created
    // for each mother (clone copy)
    
    G4CreateCloneVTEWithDivision(vname, mvte, 
                                  kDvn2, ndiv, iaxis, numed, c0, 0.); 
  }  
}

◆ G4gsdvt()

void G4gsdvt	(	G4String	name,
		G4String	moth,
		G4double	Step,
		G4int	iaxis,
		G4int	numed,
		G4int	ndvmx )

Definition at line 56 of file G4gsdvt.cc.

{
  // find mother VTE
  G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
  if (mvte == 0) {
    G4String text = "G4gsdvt:'" + vmoth + "' has no VolTableEntry";
    G4Exception("G4gsdvt()", "G3toG40014", FatalException, text);
    return;
  }    
  else {
    // a new vte clone copy with division is created
    // for each mother (clone copy)
    
    G4CreateCloneVTEWithDivision(vname, mvte, 
                                  kDvt, ndvmx, iaxis, numed, 0., step); 
  }  
}

Referenced by PG4gsdvt().

◆ G4gsdvt2()

void G4gsdvt2	(	G4String	name,
		G4String	moth,
		G4double	Step,
		G4int	iaxis,
		G4double	c0,
		G4int	numed,
		G4int	ndvmx )

Definition at line 57 of file G4gsdvt2.cc.

{
  // find mother VTE
  G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
  if (mvte == 0) {
    G4String text = "G4gsdvt2:'" + vmoth + "' has no VolTableEntry";
    G4Exception("G4gsdvt2()", "G3toG40015", FatalException, text);
    return;
  }    
  else {
    // a new vte clone copy with division is created
    // for each mother (clone copy)
    
    G4CreateCloneVTEWithDivision(vname, mvte, 
                                  kDvt2, ndvmx, iaxis, numed, c0, step); 
  }  
}

◆ G4gsdvx()

void G4gsdvx	(	G4String	name,
		G4String	moth,
		G4int	ndiv,
		G4int	iaxis,
		G4double	Step,
		G4double	c0,
		G4int	numed,
		G4int	ndvmx )

Definition at line 57 of file G4gsdvx.cc.

{
    // pass to gsdvn2 or gsdvt2
    if (Step > 0.) {
        G4gsdvt2(name,moth,Step,iaxis,c0,numed,ndvmx);
    } else if (ndiv > 0) {
        G4gsdvn2(name,moth,ndiv,iaxis,c0,numed);
    }
}

Referenced by PG4gsdvx().

◆ G4gsmate()

void G4gsmate	(	G4int	imate,
		G4String	name,
		G4double	a,
		G4double	z,
		G4double	dens,
		G4double	radl,
		G4int	nwbf,
		G4double *	ubuf )

Definition at line 58 of file G4gsmate.cc.

{
  G4double G3_minimum_density = 1.e-10*g/cm3;
 
  // add units
  G4double z = zin;    
  G4double a = ain*g/mole;
  G4double dens = densin*g/cm3;
 
  G4Material* material=0;
  
  G4String sname = G4StrUtil::strip_copy(name);
  if (sname == "AIR") {
    // handle the built in AIR mixture
    G4double aa[2], zz[2], wmat[2];
    aa[0] = 14.01*g/mole;
    aa[1] = 16.00*g/mole;
    zz[0] = 7;
    zz[1] = 8;
    wmat[0] = 0.7;
    wmat[1] = 0.3;
    // G4double theDensity = 1.2931*mg/cm3;
    G4double theDensity = 0.0012931;
    G4int n=2;
    G4gsmixt(imate, sname, aa, zz, theDensity, n, wmat);
  } 
  else if ( z<1 || dens < G3_minimum_density ) {
    // define vacuum according to definition from N03 example
    G4double density     = universe_mean_density;    //from PhysicalConstants.h
    G4double pressure    = 3.e-18*pascal;
    G4double temperature = 2.73*kelvin;
    material = new G4Material(name, z=1., a=1.01*g/mole, density,
                    kStateGas,temperature,pressure);
  }
  else {
    //G4Element* element = CreateElement(z, a, name);
    G4Element* element = G3Ele.GetEle(z);
    material = new G4Material(name, dens, 1);
    material->AddElement(element, 1.);    
  }  
 
  // add the material to the List
  G3Mat.put(imate, material);
}

Referenced by PG4gsmate().

◆ G4gsmixt()

void G4gsmixt	(	G4int	imate,
		G4String	name,
		G4double	a[],
		G4double *	z,
		G4double	dens,
		G4int	nlmat,
		G4double *	wmat )

Referenced by G4gsmate().

◆ G4gspart()

void G4gspart	(	G4int	ipart,
		G4String	chnpar,
		G4int	itrtyp,
		G4double	amass,
		G4double	charge,
		G4double	tlife,
		G4double *	ubuf,
		G4int	nwb )

Definition at line 50 of file G4gspart.cc.

52{

53}

Referenced by PG4gspart().

◆ G4gspos()

void G4gspos	(	G4String	name,
		G4int	num,
		G4String	moth,
		G4double	x,
		G4double	y,
		G4double	z,
		G4int	irot,
		G4String	only )

Definition at line 64 of file G4gspos.cc.

{
  // find VTEs
  G3VolTableEntry* vte = G3Vol.GetVTE(vname);
  G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
 
  if (vte == 0) {
    G4String text = "G4gspos: '" + vname + "' has no VolTableEntry";
    G4Exception("G4gspos()", "G3toG40017", FatalException, text);
    return;
  } 
  else if (mvte == 0) {
    G4String text = "G4gspos: '" + vmoth + "' has no VolTableEntry";
    G4Exception("G4gspos()", "G3toG40018", FatalException, text);
    return;
  } 
  else { 
    if (!vte->HasNegPars()) {
      // position vector
      G4ThreeVector* offset = new G4ThreeVector(x*cm, y*cm, z*cm);
 
      // create a G3Pos object and add it to the vte
      G3Pos* aG3Pos = new G3Pos(vmoth, num, offset, irot, vonly);              
      vte->AddG3Pos(aG3Pos);
 
      // loop over all mothers
      for (G4int i=0; i<mvte->GetNoClones(); i++) {
                       // (mvte is retrieved from its "master" name
                       //  -> there is no need to call GetMasterClone()
        G3VolTableEntry* mvteClone = mvte->GetClone(i);
        vte->AddMother(mvteClone);
        mvteClone->AddDaughter(vte);
      }     
    } 
    else {
      // if vte has neg parameters 
      // a new vte clone copy is created for each mother (clone copy)  
      // and its parameters are derived from it if possible
 
      G4CreateCloneVTE(vte, mvte, vte->GetRpar(), vte->GetNpar(), num,
                     x, y, z, irot, vonly);
    }    
  }      
}

Referenced by PG4gspos().

◆ G4gsposp()

void G4gsposp	(	G4String	name,
		G4int	num,
		G4String	moth,
		G4double	x,
		G4double	y,
		G4double	z,
		G4int	irot,
		G4String	only,
		G4double	Rpar[],
		G4int	npar )

Definition at line 296 of file G4gsposp.cc.

{
  // find VTEs
  G3VolTableEntry* vte = G3Vol.GetVTE(vname);
  G3VolTableEntry* mvte = G3Vol.GetVTE(vmoth);
 
  if (vte == 0) {
    G4String err_message1 = "G4gsposp: '" + vname + "' has no VolTableEntry";
    G4Exception("G4psposp()", "G3toG40021", FatalException, err_message1);
    return;
  } 
  if (mvte == 0) {
    G4String err_message2 = "G4gsposp: '" + vmoth + "' has no VolTableEntry";
    G4Exception("G4psposp()", "G3toG40022", FatalException, err_message2);
    return;
  } 
  else { 
    // a new vte clone copy is created for each mother (clone copy)  
    // and its parameters are derived from it if possible
    
    G4CreateCloneVTE(vte, mvte, pars, npar, num, x, y, z, irot, vonly);
  }
}

Referenced by PG4gsposp().

◆ G4gsrotm()

void G4gsrotm	(	G4int	irot,
		G4double	theta1,
		G4double	phi1,
		G4double	theta2,
		G4double	phi2,
		G4double	theta3,
		G4double	phi3 )

Definition at line 53 of file G4gsrotm.cc.

{
    G4double degrad = pi/180;
    
    G4double th1r = theta1*degrad;
    G4double th2r = theta2*degrad;
    G4double th3r = theta3*degrad;
    
    G4double phi1r = phi1*degrad;
    G4double phi2r = phi2*degrad;
    G4double phi3r = phi3*degrad;
    
        // Construct unit vectors 
    
    G4ThreeVector x(std::sin(th1r)*std::cos(phi1r), std::sin(th1r)*std::sin(phi1r), std::cos(th1r));
    G4ThreeVector y(std::sin(th2r)*std::cos(phi2r), std::sin(th2r)*std::sin(phi2r), std::cos(th2r));
    G4ThreeVector z(std::sin(th3r)*std::cos(phi3r), std::sin(th3r)*std::sin(phi3r), std::cos(th3r));
 
        // check for orthonormality and left-handedness
 
    G4double check = (x.cross(y))*z;
    G4double tol = 1.0e-3;
        
    if (1-std::abs(check)>tol) {
        G4cerr << "Coordinate axes forming rotation matrix "
               << irot << " are not orthonormal.(" << 1-std::abs(check) << ")" 
         << G4endl;
        G4cerr << " theta1=" << theta1;
        G4cerr << " phi1=" << phi1;
        G4cerr << " theta2=" << theta2;
        G4cerr << " phi2=" << phi2;
        G4cerr << " theta3=" << theta3;
        G4cerr << " phi3=" << phi3;
        G4cerr << G4endl;
        G4Exception("G4gsrotm()", "G3toG40023", FatalException,
                    "Non orthogonal axes!");
        return;
    }
    //else if (1+check<=tol) {
    //    G4cerr << "G4gsrotm warning: coordinate axes forming rotation "
    //           << "matrix " << irot << " are left-handed" << G4endl;
    //}
    
    G3toG4RotationMatrix* rotp = new G3toG4RotationMatrix;
 
    rotp->SetRotationMatrixByRow(x, y, z);
    
        // add it to the List
 
    G3Rot.Put(irot, rotp);
}

Referenced by G4BuildGeom(), and PG4gsrotm().

◆ G4gstmed()

void G4gstmed	(	G4int	itmed,
		G4String	name,
		G4int	nmat,
		G4int	isvol,
		G4int	ifield,
		G4double	fieldm,
		G4double	tmaxfd,
		G4double	stemax,
		G4double	deemax,
		G4double	epsil,
		G4double	stmin,
		G4double *	par,
		G4int	npar )

Definition at line 67 of file G4gstmed.cc.

{
    // get the pointer to material nmat
    G4Material* material = G3Mat.get(nmat);
 
    // NB. there is the possibility for redundancy in the mag field
    //     and user limits objects. Who cares.
    // Generate the mag field object
    // $$$ G4MagneticField* field = new G4MagneticField(ifield, fieldm, tmaxfd);
    G4MagneticField* field = 0;
 
    // Generate the user limits object
    // !!! only "stemax" has its equivalent in G4
 
    G4UserLimits* limits = 0;
    if (useG3TMLimits) {
      limits = new G4UserLimits();
      limits->SetMaxAllowedStep(stemax*cm);
      // limits->SetG3DefaultCuts();
         // this is arranged globally by physics manager
    }
 
    // Store this medium in the G3Med structure
    G3Med.put(itmed, material, field, limits, isvol);
}

Referenced by PG4gstmed().

◆ G4gstpar()

void G4gstpar	(	G4int	itmed,
		G4String	chpar,
		G4double	parval )

Definition at line 44 of file G4gstpar.cc.

{
    // set special tracking medium parameter. Apply to all logical
    // volumes making use of the specified tracking medium.
  G4cerr << "G4gstpar: not implemented." << G4endl;
}

Referenced by PG4gstpar().

◆ G4gsvolu()

void G4gsvolu	(	G4String	name,
		G4String	shape,
		G4int	nmed,
		G4double *	par,
		G4int	npar )

Definition at line 72 of file G4gsvolu.cc.

{
  /*
  G4cout << "Creating logical volume " << vname << " shape " << shape
     << " nmed " << nmed << " #pars "<< npar << " parameters (cm): ";
  for (int ipar=0; ipar< npar; ipar++) G4cout << std::setw(8) << rpar[ipar];
  G4cout << G4endl;
  */
  if (G3Vol.GetVTE(vname)) {
    // abort if VTE with given name exists
    G4String text = "G4gsvolu: Attempt to create volume " + vname + " twice.";
    G4Exception("G4gsvolu()", "G3toG40024", FatalException, text);
    return;
  }
  else {  
    G4CreateVTE(vname, shape, nmed, rpar, npar);
  }  
}

Referenced by PG4gsvolu().

Functions