G4tgrLineProcessor Class Reference

#include <G4tgrLineProcessor.hh>

Public Member Functions
	G4tgrLineProcessor ()
virtual	~G4tgrLineProcessor ()
virtual G4bool	ProcessLine (const std::vector< G4String > &wl)

Protected Member Functions
G4tgrVolume *	FindVolume (const G4String &volname)

Detailed Description

Definition at line 44 of file G4tgrLineProcessor.hh.

Constructor & Destructor Documentation

G4tgrLineProcessor()

G4tgrLineProcessor::G4tgrLineProcessor

(

)

Definition at line 50 of file G4tgrLineProcessor.cc.

{
  volmgr = G4tgrVolumeMgr::GetInstance();
}

~G4tgrLineProcessor()

G4tgrLineProcessor::~G4tgrLineProcessor ( )

virtual

Definition at line 56 of file G4tgrLineProcessor.cc.

{
}

Member Function Documentation

FindVolume()

G4tgrVolume * G4tgrLineProcessor::FindVolume ( const G4String & volname )

protected

Definition at line 314 of file G4tgrLineProcessor.cc.

{
  G4tgrVolume* vol = volmgr->FindVolume(volname, 1);
 
  if(vol->GetType() == "VOLDivision")
  {
    G4Exception("G4tgrLineProcessor::FindVolume()", "InvalidSetup",
                FatalException,
                "Using 'PLACE' for a volume created by a division !");
  }
 
  return vol;
}

Referenced by ProcessLine().

ProcessLine()

G4bool G4tgrLineProcessor::ProcessLine ( const std::vector< G4String > & wl )

virtual

Definition at line 61 of file G4tgrLineProcessor.cc.

{
#ifdef G4VERBOSE
  if(G4tgrMessenger::GetVerboseLevel() >= 1)
  {
    G4tgrUtils::DumpVS(wl, "@@@ Processing input line");
  }
#endif
 
  G4String wl0 = wl[0];
  for(G4int ii = 0; ii < (G4int)wl0.length(); ++ii)
  {
    wl0[ii] = (char)std::toupper(wl0[ii]);
  }
 
  //------------------------------- parameter number
  if(wl0 == ":P")
  {
    G4tgrParameterMgr::GetInstance()->AddParameterNumber(wl);
 
    //------------------------------- parameter string
  }
  else if(wl0 == ":PS")
  {
    G4tgrParameterMgr::GetInstance()->AddParameterString(wl);
 
    //------------------------------- isotope
  }
  else if(wl0 == ":ISOT")
  {
    G4tgrIsotope* isot = G4tgrMaterialFactory::GetInstance()->AddIsotope(wl);
    volmgr->RegisterMe(isot);
 
    //------------------------------- element
  }
  else if(wl0 == ":ELEM")
  {
    G4tgrElementSimple* elem =
      G4tgrMaterialFactory::GetInstance()->AddElementSimple(wl);
    volmgr->RegisterMe(elem);
 
    //------------------------------- element from isotopes
  }
  else if(wl0 == ":ELEM_FROM_ISOT")
  {
    //:ELEM_FROM_ISOT NAME SYMBOL N_ISOT (ISOT_NAME ISOT_ABUNDANCE)
    G4tgrElementFromIsotopes* elem =
      G4tgrMaterialFactory::GetInstance()->AddElementFromIsotopes(wl);
    volmgr->RegisterMe(elem);
 
    //------------------------------- material
  }
  else if(wl0 == ":MATE")
  {
    G4tgrMaterialSimple* mate =
      G4tgrMaterialFactory::GetInstance()->AddMaterialSimple(wl);
    volmgr->RegisterMe(mate);
 
    //------------------------------- material mixtures & by weight
  }
  else if((wl0 == ":MIXT") || (wl0 == ":MIXT_BY_WEIGHT"))
  {
    G4tgrMaterialMixture* mate =
      G4tgrMaterialFactory::GetInstance()->AddMaterialMixture(
        wl, "MaterialMixtureByWeight");
    volmgr->RegisterMe(mate);
 
    //------------------------------- material mixture by number of atoms
  }
  else if(wl0 == ":MIXT_BY_NATOMS")
  {
    G4tgrMaterialMixture* mate =
      G4tgrMaterialFactory::GetInstance()->AddMaterialMixture(
        wl, "MaterialMixtureByNoAtoms");
    volmgr->RegisterMe(mate);
 
    //------------------------------- material mixture by volume
  }
  else if(wl0 == ":MIXT_BY_VOLUME")
  {
    G4tgrMaterialMixture* mate =
      G4tgrMaterialFactory::GetInstance()->AddMaterialMixture(
        wl, "MaterialMixtureByVolume");
    volmgr->RegisterMe(mate);
 
    //------------------------------- material Mean Excitation Energy of
    //                                Ionisation Potential
  }
  else if(wl0 == ":MATE_MEE")
  {
    G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
      G4tgrUtils::GetString(wl[1]));
    if(mate == 0)
    {
      G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
                  FatalException, G4tgrUtils::GetString(wl[1]));
      return false;
    }
    mate->SetIonisationMeanExcitationEnergy(G4tgrUtils::GetDouble(wl[2]));
 
    //------------------------------- material
  }
  else if(wl0 == ":MATE_STATE")
  {
    G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
      G4tgrUtils::GetString(wl[1]));
    if(mate == 0)
    {
      G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
                  FatalException, wl[1]);
    }
    mate->SetState(wl[2]);
 
    //------------------------------- material
  }
  else if(wl0 == ":MATE_TEMPERATURE")
  {
    G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
      G4tgrUtils::GetString(wl[1]));
    if(mate == 0)
    {
      G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
                  FatalException, wl[1]);
    }
    mate->SetTemperature(G4tgrUtils::GetDouble(wl[2], kelvin));
 
    //------------------------------- material
  }
  else if(wl0 == ":MATE_PRESSURE")
  {
    G4tgrMaterial* mate = G4tgrMaterialFactory::GetInstance()->FindMaterial(
      G4tgrUtils::GetString(wl[1]));
    if(mate == 0)
    {
      G4Exception("G4tgrLineProcessor::ProcessLine()", "Material not found",
                  FatalException, wl[1]);
    }
    mate->SetPressure(G4tgrUtils::GetDouble(wl[2], atmosphere));
 
    //------------------------------- solid
  }
  else if(wl0 == ":SOLID")
  {  // called from here or from G4tgrVolume::G4tgrVolume
    volmgr->CreateSolid(wl, 0);
 
    //------------------------------- volume
  }
  else if(wl0 == ":VOLU")
  {
    G4tgrVolume* vol = new G4tgrVolume(wl);
    volmgr->RegisterMe(vol);
 
    //--------------------------------- single placement
  }
  else if(wl0 == ":PLACE")
  {
    G4tgrVolume* vol = FindVolume(G4tgrUtils::GetString(wl[1]));
    G4tgrPlace* vpl  = vol->AddPlace(wl);
    volmgr->RegisterMe(vpl);
 
    //--------------------------------- parameterisation
  }
  else if(wl0 == ":PLACE_PARAM")
  {
    G4tgrVolume* vol                = FindVolume(G4tgrUtils::GetString(wl[1]));
    G4tgrPlaceParameterisation* vpl = vol->AddPlaceParam(wl);
    volmgr->RegisterMe(vpl);
 
    //--------------------------------- division
  }
  else if((wl0 == ":DIV_NDIV") || (wl0 == ":DIV_WIDTH") ||
          (wl0 == ":DIV_NDIV_WIDTH"))
  {
    //---------- Create G4tgrVolumeDivision and fill the volume params
    G4tgrVolumeDivision* vol = new G4tgrVolumeDivision(wl);
    volmgr->RegisterMe(vol);
 
    //--------------------------------- replica
  }
  else if(wl0 == ":REPL")
  {
    G4tgrVolume* vol      = FindVolume(G4tgrUtils::GetString(wl[1]));
    G4tgrPlaceDivRep* vpl = vol->AddPlaceReplica(wl);
    volmgr->RegisterMe(vpl);
 
    //----------------------------- assembly volume: definition of components
  }
  else if(wl0 == ":VOLU_ASSEMBLY")
  {
    G4tgrVolumeAssembly* vol = new G4tgrVolumeAssembly(wl);
    volmgr->RegisterMe(vol);
 
    //----------------------------- assembly volume: definition of components
  }
  else if(wl0 == ":PLACE_ASSEMBLY")
  {
    G4tgrVolume* vol = FindVolume(G4tgrUtils::GetString(wl[1]));
    G4tgrPlace* vpl  = vol->AddPlace(wl);
    volmgr->RegisterMe(vpl);
 
    //---------------------------------  rotation matrix
  }
  else if(wl0 == ":ROTM")
  {
    //---------- When second word is ':NEXT/:MNXT' it is used for defining a
    //           rotation matrix that will be used for the next placement/s
    G4tgrRotationMatrix* rm =
      G4tgrRotationMatrixFactory::GetInstance()->AddRotMatrix(wl);
    volmgr->RegisterMe(rm);
 
    //------------------------------- visualisation
  }
  else if(wl0 == ":VIS")
  {
    std::vector<G4tgrVolume*> vols =
      volmgr->FindVolumes(G4tgrUtils::GetString(wl[1]), 1);
    for(std::size_t ii = 0; ii < vols.size(); ++ii)
    {
      vols[ii]->AddVisibility(wl);
    }
 
    //--------------------------------- colour
  }
  else if((wl0 == ":COLOUR") || (wl0 == ":COLOR"))
  {
    std::vector<G4tgrVolume*> vols =
      volmgr->FindVolumes(G4tgrUtils::GetString(wl[1]), 1);
    for(std::size_t ii = 0; ii < vols.size(); ++ii)
    {
      vols[ii]->AddRGBColour(wl);
    }
 
    //--------------------------------- check overlaps
  }
  else if(wl0 == ":CHECK_OVERLAPS")
  {
    std::vector<G4tgrVolume*> vols =
      volmgr->FindVolumes(G4tgrUtils::GetString(wl[1]), 1);
    for(std::size_t ii = 0; ii < vols.size(); ++ii)
    {
      vols[ii]->AddCheckOverlaps(wl);
    }
    //--------------------------------- ERROR
  }
  else
  {
    return false;
  }
 
  return true;
}

Referenced by G4tgrFileReader::ReadFiles().

---

The documentation for this class was generated from the following files:

• G4tgrLineProcessor.hh
• G4tgrLineProcessor.cc