GarfieldMessenger Class Reference

#include <GarfieldMessenger.hh>

Inheritance diagram for GarfieldMessenger:

Public Member Functions
	GarfieldMessenger (GarfieldDetectorConstruction *)
	~GarfieldMessenger ()
virtual void	SetNewValue (G4UIcommand *, G4String)

Detailed Description

Definition at line 46 of file GarfieldMessenger.hh.

Constructor & Destructor Documentation

GarfieldMessenger()

GarfieldMessenger::GarfieldMessenger

(

GarfieldDetectorConstruction *

Det

)

Definition at line 42 of file GarfieldMessenger.cc.

    : G4UImessenger(),
      fDetector(Det),
      fExampleDir(0),
      fAbsorberDir(0),
      fGarfieldPhysicsDir(0),
      fMaterialCmd(0),
      fIsotopeCmd(0),
      fIonizationModelCmd(0),
      fGeant4ParticleCmd(0) {
  fExampleDir = new G4UIdirectory("/exampleGarfield/");
  fExampleDir->SetGuidance("Commands specific to this example");
 
  G4bool broadcast = false;
  fAbsorberDir = new G4UIdirectory("/exampleGarfield/absorber/", broadcast);
  fAbsorberDir->SetGuidance("Absorber construction commands");
 
  fGarfieldPhysicsDir =
      new G4UIdirectory("/exampleGarfield/physics/", broadcast);
  fGarfieldPhysicsDir->SetGuidance(
      "Particle and energy ranges for Garfield++ physics model");
 
  fMaterialCmd =
      new G4UIcmdWithAString("/exampleGarfield/absorber/setMat", this);
  fMaterialCmd->SetGuidance("Select material of the absorber:");
  fMaterialCmd->SetParameterName("choice", false);
  fMaterialCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  fIsotopeCmd =
      new G4UIcommand("/exampleGarfield/absorber/setIsotopeMat", this);
  fIsotopeCmd->SetGuidance("Build and select a material with single isotope");
  fIsotopeCmd->SetGuidance("  symbol of isotope, Z, A, density of material");
  //
  G4UIparameter* symbPrm = new G4UIparameter("isotope", 's', false);
  symbPrm->SetGuidance("isotope symbol");
  fIsotopeCmd->SetParameter(symbPrm);
  //
  G4UIparameter* ZPrm = new G4UIparameter("Z", 'i', false);
  ZPrm->SetGuidance("Z");
  ZPrm->SetParameterRange("Z>0");
  fIsotopeCmd->SetParameter(ZPrm);
  //
  G4UIparameter* APrm = new G4UIparameter("A", 'i', false);
  APrm->SetGuidance("A");
  APrm->SetParameterRange("A>0");
  fIsotopeCmd->SetParameter(APrm);
  //
  G4UIparameter* densityPrm = new G4UIparameter("density", 'd', false);
  densityPrm->SetGuidance("density of material");
  densityPrm->SetParameterRange("density>0.");
  fIsotopeCmd->SetParameter(densityPrm);
  //
  G4UIparameter* unitPrm = new G4UIparameter("unit", 's', false);
  unitPrm->SetGuidance("unit of density");
  G4String unitList = G4UIcommand::UnitsList(G4UIcommand::CategoryOf("g/cm3"));
  unitPrm->SetParameterCandidates(unitList);
  fIsotopeCmd->SetParameter(unitPrm);
  //
  fIsotopeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
 
  fIonizationModelCmd =
      new G4UIcommand("/exampleGarfield/physics/setIonizationModel", this);
  fIonizationModelCmd->SetGuidance("Select ionization model for Garfield++");
  fIonizationModelCmd->SetGuidance(
      "  and choose whether to use default particles");
  fIonizationModelCmd->SetGuidance("  and energy ranges for the chosen model");
  //
  G4UIparameter* ionizationModelPrm =
      new G4UIparameter("ionizationModel", 's', false);
  ionizationModelPrm->SetGuidance(
      "ionization model (1. PAIPhot, 2. PAI or 3. Heed)");
  ionizationModelPrm->SetGuidance(
      "  1. PAIPhot model in Geant4, delta electrons transported by Heed");
  ionizationModelPrm->SetGuidance(
      "  2. PAI model in Geant4, delta electrons transported by Heed");
  ionizationModelPrm->SetGuidance("  3. Use directly Heed");
  fIonizationModelCmd->SetParameter(ionizationModelPrm);
  //
  G4UIparameter* useDefaultsPrm = new G4UIparameter("useDefaults", 'b', false);
  useDefaultsPrm->SetGuidance(
      "true to use default, false to manually choose particles and energies");
  fIonizationModelCmd->SetParameter(useDefaultsPrm);
  //
  fIonizationModelCmd->AvailableForStates(G4State_PreInit);
 
  fGeant4ParticleCmd = new G4UIcommand(
      "/exampleGarfield/physics/setGeant4ParticleTypeAndEnergy", this);
  fGeant4ParticleCmd->SetGuidance(
      "Select particle types and energies for PAI and PAIPhot model");
  fGeant4ParticleCmd->SetGuidance("  in Geant4");
  //
  G4UIparameter* particleGeant4Prm =
      new G4UIparameter("particleName", 's', false);
  particleGeant4Prm->SetGuidance(
      "Particle name (e-, e+, mu-, mu+, proton, pi-, pi+, alpha, He3, "
      "GenericIon)");
  fGeant4ParticleCmd->SetParameter(particleGeant4Prm);
  //
  G4UIparameter* minEnergyGeant4Prm =
      new G4UIparameter("minimumEnergyGeant4", 'd', false);
  minEnergyGeant4Prm->SetGuidance("minimum energy");
  minEnergyGeant4Prm->SetParameterRange("minimumEnergyGeant4>=0");
  fGeant4ParticleCmd->SetParameter(minEnergyGeant4Prm);
  //
  G4UIparameter* maxEnergyGeant4Prm =
      new G4UIparameter("maximumEnergyGeant4", 'd', false);
  maxEnergyGeant4Prm->SetGuidance("maximum energy");
  maxEnergyGeant4Prm->SetParameterRange("maximumEnergyGeant4>=0");
  fGeant4ParticleCmd->SetParameter(maxEnergyGeant4Prm);
  //
  G4UIparameter* unitGeant4Prm = new G4UIparameter("unit", 's', false);
  unitGeant4Prm->SetGuidance("unit of energy");
  G4String unitListGeant4 =
      G4UIcommand::UnitsList(G4UIcommand::CategoryOf("MeV"));
  unitGeant4Prm->SetParameterCandidates(unitListGeant4);
  fGeant4ParticleCmd->SetParameter(unitGeant4Prm);
  //
  fGeant4ParticleCmd->AvailableForStates(G4State_PreInit);
 
  fGarfieldParticleCmd = new G4UIcommand(
      "/exampleGarfield/physics/setGarfieldParticleTypeAndEnergy", this);
  fGarfieldParticleCmd->SetGuidance(
      "Select particle types and energies for Heed model.");
  fGarfieldParticleCmd->SetGuidance(
      " For PAI and PAIPhot model choose at which energy electrons are");
  fGarfieldParticleCmd->SetGuidance(
      " transported as delta electrons by Heed, and treatment of gammas");
  //
  G4UIparameter* particleGarfieldPrm =
      new G4UIparameter("particleName", 's', false);
  particleGarfieldPrm->SetGuidance(
      "Particle name (gamma, e-, e+, mu-, mu+, proton, anti_proton, pi-, pi+, "
      "kaon, kaon+, alpha, deuteron)");
  fGarfieldParticleCmd->SetParameter(particleGarfieldPrm);
  //
  G4UIparameter* minEnergyGarfieldPrm =
      new G4UIparameter("minimumEnergyGarfield", 'd', false);
  minEnergyGarfieldPrm->SetGuidance("minimum energy");
  minEnergyGarfieldPrm->SetParameterRange("minimumEnergyGarfield>=0");
  fGarfieldParticleCmd->SetParameter(minEnergyGarfieldPrm);
  //
  G4UIparameter* maxEnergyGarfieldPrm =
      new G4UIparameter("maximumEnergyGarfield", 'd', false);
  maxEnergyGarfieldPrm->SetGuidance("maximum energy");
  maxEnergyGarfieldPrm->SetParameterRange("maximumEnergyGarfield>=0");
  fGarfieldParticleCmd->SetParameter(maxEnergyGarfieldPrm);
  //
  G4UIparameter* unitGarfieldPrm = new G4UIparameter("unit", 's', false);
  unitGarfieldPrm->SetGuidance("unit of energy");
  G4String unitListGarfield =
      G4UIcommand::UnitsList(G4UIcommand::CategoryOf("MeV"));
  unitGarfieldPrm->SetParameterCandidates(unitListGarfield);
  fGarfieldParticleCmd->SetParameter(unitGarfieldPrm);
  //
  fGarfieldParticleCmd->AvailableForStates(G4State_PreInit);
}

~GarfieldMessenger()

GarfieldMessenger::~GarfieldMessenger

(

)

Definition at line 201 of file GarfieldMessenger.cc.

                                      {
  delete fMaterialCmd;
  delete fIsotopeCmd;
  delete fAbsorberDir;
  delete fExampleDir;
  delete fGarfieldPhysicsDir;
  delete fIonizationModelCmd;
  delete fGeant4ParticleCmd;
  delete fGarfieldParticleCmd;
}

Member Function Documentation

SetNewValue()

void GarfieldMessenger::SetNewValue ( G4UIcommand *  command, G4String  newValue  )

virtual

Definition at line 214 of file GarfieldMessenger.cc.

                                                                           {
  if (command == fMaterialCmd) {
    fDetector->SetAbsorberMaterial(newValue);
  } else if (command == fIsotopeCmd) {
    G4int Z;
    G4int A;
    G4double dens;
    G4String name, unt;
    std::istringstream is(newValue);
    is >> name >> Z >> A >> dens >> unt;
    dens *= G4UIcommand::ValueOf(unt);
    fDetector->AbsorberMaterialWithSingleIsotope(name, name, dens, Z, A);
    fDetector->SetAbsorberMaterial(name);
  } else if (command == fIonizationModelCmd) {
    GarfieldPhysics* garfieldPhysics = GarfieldPhysics::GetInstance();
    G4String modelName;
    G4bool useDefaults;
    std::istringstream is(newValue);
    is >> modelName >> std::boolalpha >> useDefaults;
    garfieldPhysics->SetIonizationModel(modelName, useDefaults);
  } else if (command == fGeant4ParticleCmd) {
    GarfieldPhysics* garfieldPhysics = GarfieldPhysics::GetInstance();
    G4String particleName, unit, programName;
    G4double minEnergy;
    G4double maxEnergy;
    std::istringstream is(newValue);
    is >> particleName >> minEnergy >> maxEnergy >> unit;
    minEnergy *= G4UIcommand::ValueOf(unit);
    maxEnergy *= G4UIcommand::ValueOf(unit);
    garfieldPhysics->AddParticleName(particleName, minEnergy, maxEnergy,
                                     "geant4");
  } else if (command == fGarfieldParticleCmd) {
    GarfieldPhysics* garfieldPhysics = GarfieldPhysics::GetInstance();
    G4String particleName, unit, programName;
    G4double minEnergy;
    G4double maxEnergy;
    std::istringstream is(newValue);
    is >> particleName >> minEnergy >> maxEnergy >> unit;
    minEnergy *= G4UIcommand::ValueOf(unit);
    maxEnergy *= G4UIcommand::ValueOf(unit);
    garfieldPhysics->AddParticleName(particleName, minEnergy, maxEnergy,
                                     "garfield");
  }
}

---

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

• GarfieldMessenger.hh
• GarfieldMessenger.cc