Messenger class that defines commands for TG4DetConstruction. More...

#include <G4FieldParametersMessenger.hh>

Inheritance diagram for G4FieldParametersMessenger:

Public Member Functions
	G4FieldParametersMessenger (G4FieldParameters *fieldParameters)
	Standard constructor.

	~G4FieldParametersMessenger () override
	Destructor.

void	SetNewValue (G4UIcommand *command, G4String newValues) override
	Apply command to the associated object.

Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default

	G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

virtual	~G4UImessenger ()

virtual G4String	GetCurrentValue (G4UIcommand *command)

G4bool	CommandsShouldBeInMaster () const

Additional Inherited Members
Protected Member Functions inherited from G4UImessenger
G4String	ItoS (G4int i)

G4String	LtoS (G4long l)

G4String	DtoS (G4double a)

G4String	BtoS (G4bool b)

G4int	StoI (const G4String &s)

G4long	StoL (const G4String &s)

G4double	StoD (const G4String &s)

G4bool	StoB (const G4String &s)

void	AddUIcommand (G4UIcommand *newCommand)

void	CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)

template<typename T>
T *	CreateCommand (const G4String &cname, const G4String &dsc)

Protected Attributes inherited from G4UImessenger
G4UIdirectory *	baseDir = nullptr

G4String	baseDirName = ""

G4bool	commandsShouldBeInMaster = false

Detailed Description

Messenger class that defines commands for TG4DetConstruction.

Implements commands:

/field/fieldType fieldType
fieldType = Magnetic | ElectroMagnetic | Gravity
/field/equationType eqType
eqType = EqMagnetic | EqMagneticWithSpin | EqElectroMagnetic | EqEMfieldWithSpin | EqEMfieldWithEDM
/field/stepperType stepperType
stepperType = CashKarpRKF45 | ClassicalRK4 | ExplicitEuler | ImplicitEuler | SimpleHeum | SimpleRunge | ConstRK4 | ExactHelixStepper | HelixExplicitEuler | HelixHeum | HelixImplicitEuler | HelixMixedStepper | HelixSimpleRunge | NystromRK4 | RKG3Stepper
/field/setMinimumStep value
/field/setDeltaChord value
/field/setDeltaOneStep value
/field/setDeltaIntersection value
/field/setMinimumEpsilonStep value
/field/setMaximumEpsilonStep value
/field/setConstDistance value
/field/printParameters

Author: I. Hrivnacova; IJClab, Orsay

Definition at line 77 of file G4FieldParametersMessenger.hh.

Constructor & Destructor Documentation

◆ G4FieldParametersMessenger()

G4FieldParametersMessenger::G4FieldParametersMessenger ( G4FieldParameters * fieldParameters )

Standard constructor.

Definition at line 47 of file G4FieldParametersMessenger.cc.

  : fFieldParameters(fieldParameters)
{
  // Standard constructor
 
  G4String directoryName = "/field/";
  if (fieldParameters->GetVolumeName() != "") {
    directoryName.append(fieldParameters->GetVolumeName());
    directoryName.append("/");
    fDirectory = new G4UIdirectory(directoryName);
    fDirectory->SetGuidance("Magnetic field control commands.");
  }
 
  G4String commandName = directoryName;
  commandName.append("fieldType");
  fFieldTypeCmd = new G4UIcmdWithAString(commandName, this);
  G4String guidance = "Select type of the field";
  fFieldTypeCmd->SetGuidance(guidance);
  fFieldTypeCmd->SetParameterName("FieldType", false);
  G4String candidates;
  for (G4int i = kMagnetic; i <= kGravity; i++) {
    G4FieldType ft = (G4FieldType)i;
    candidates += G4FieldParameters::FieldTypeName(ft);
    candidates += " ";
  }
  fFieldTypeCmd->SetCandidates(candidates);
  fFieldTypeCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("equationType");
  fEquationTypeCmd = new G4UIcmdWithAString(commandName, this);
  guidance = "Select type of the equation of motion of a particle in a field";
  fEquationTypeCmd->SetGuidance(guidance);
  fEquationTypeCmd->SetParameterName("EquationType", false);
  candidates = "";
  for (G4int i = kEqMagnetic; i <= kEqEMfieldWithEDM; i++) {
    G4EquationType et = (G4EquationType)i;
    candidates += G4FieldParameters::EquationTypeName(et);
    candidates += " ";
  }
  fEquationTypeCmd->SetCandidates(candidates);
  fEquationTypeCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("stepperType");
  fStepperTypeCmd = new G4UIcmdWithAString(commandName, this);
  guidance =
    "Select type of the the integrator of particle's equation of motion in a "
    "field";
  fStepperTypeCmd->SetGuidance(guidance);
  fStepperTypeCmd->SetParameterName("StepperType", false);
  candidates = "";
  for (G4int i = kCashKarpRKF45; i <= kRK547FEq3; i++) {    
    G4StepperType st = (G4StepperType)i;
    if (st == kUserStepper) continue;
    candidates += G4FieldParameters::StepperTypeName(st);
    candidates += " ";
  }
  fStepperTypeCmd->SetCandidates(candidates);
  fStepperTypeCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("setMinimumStep");
  fSetMinimumStepCmd = new G4UIcmdWithADoubleAndUnit(commandName, this);
  fSetMinimumStepCmd->SetGuidance("Set minimum step in G4ChordFinder");
  fSetMinimumStepCmd->SetParameterName("StepMinimum", false);
  fSetMinimumStepCmd->SetDefaultUnit("mm");
  fSetMinimumStepCmd->SetUnitCategory("Length");
  fSetMinimumStepCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("setDeltaChord");
  fSetDeltaChordCmd = new G4UIcmdWithADoubleAndUnit(commandName, this);
  fSetDeltaChordCmd->SetGuidance("Set delta chord in G4ChordFinder");
  fSetDeltaChordCmd->SetParameterName("DeltaChord", false);
  fSetDeltaChordCmd->SetDefaultUnit("mm");
  fSetDeltaChordCmd->SetUnitCategory("Length");
  fSetDeltaChordCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("setDeltaOneStep");
  fSetDeltaOneStepCmd = new G4UIcmdWithADoubleAndUnit(commandName, this);
  fSetDeltaOneStepCmd->SetGuidance(
    "Set delta one step in global field manager");
  fSetDeltaOneStepCmd->SetParameterName("DeltaOneStep", false);
  fSetDeltaOneStepCmd->SetDefaultUnit("mm");
  fSetDeltaOneStepCmd->SetUnitCategory("Length");
  fSetDeltaOneStepCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("setDeltaIntersection");
  fSetDeltaIntersectionCmd = new G4UIcmdWithADoubleAndUnit(commandName, this);
  fSetDeltaIntersectionCmd->SetGuidance(
    "Set delta intersection in global field manager");
  fSetDeltaIntersectionCmd->SetParameterName("DeltaIntersection", false);
  fSetDeltaIntersectionCmd->SetDefaultUnit("mm");
  fSetDeltaIntersectionCmd->SetUnitCategory("Length");
  fSetDeltaIntersectionCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("setMinimumEpsilonStep");
  fSetMinimumEpsilonStepCmd = new G4UIcmdWithADouble(commandName, this);
  fSetMinimumEpsilonStepCmd->SetGuidance(
    "Set minimum epsilon step in global field manager");
  fSetMinimumEpsilonStepCmd->SetParameterName("MinimumEpsilonStep", false);
  fSetMinimumEpsilonStepCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("setMaximumEpsilonStep");
  fSetMaximumEpsilonStepCmd = new G4UIcmdWithADouble(commandName, this);
  fSetMaximumEpsilonStepCmd->SetGuidance(
    "Set maximum epsilon step in global field manager");
  fSetMaximumEpsilonStepCmd->SetParameterName("MaximumEpsilonStep", false);
  fSetMaximumEpsilonStepCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
 
  commandName = directoryName;
  commandName.append("setConstDistance");
  fSetConstDistanceCmd = new G4UIcmdWithADoubleAndUnit(commandName, this);
  fSetConstDistanceCmd->SetGuidance(
    "Set the distance within which the field is considered constant.");
  fSetConstDistanceCmd->SetGuidance(
    "Non-zero value will trigger creating a cached magnetic field.");
  fSetConstDistanceCmd->SetParameterName("ConstDistance", false);
  fSetConstDistanceCmd->SetDefaultUnit("mm");
  fSetConstDistanceCmd->SetUnitCategory("Length");
  fSetConstDistanceCmd->SetRange("ConstDistance >= 0");
  fSetConstDistanceCmd->AvailableForStates(G4State_PreInit);
 
  commandName = std::move(directoryName);
  commandName.append("printParameters");
  fPrintParametersCmd = new G4UIcmdWithoutParameter(commandName, this);
  fPrintParametersCmd->SetGuidance("Prints all accuracy parameters.");
  fPrintParametersCmd->AvailableForStates(
    G4State_PreInit, G4State_Init, G4State_Idle);
}

Referenced by G4FieldParametersMessenger().

◆ ~G4FieldParametersMessenger()

G4FieldParametersMessenger::~G4FieldParametersMessenger ( )

override

Destructor.

Definition at line 194 of file G4FieldParametersMessenger.cc.

{
  // Destructor
 
  delete fDirectory;
  delete fFieldTypeCmd;
  delete fEquationTypeCmd;
  delete fStepperTypeCmd;
  delete fSetMinimumStepCmd;
  delete fSetDeltaChordCmd;
  delete fSetDeltaOneStepCmd;
  delete fSetDeltaIntersectionCmd;
  delete fSetMinimumEpsilonStepCmd;
  delete fSetMaximumEpsilonStepCmd;
  delete fSetConstDistanceCmd;
}

Member Function Documentation

◆ SetNewValue()

void G4FieldParametersMessenger::SetNewValue	(	G4UIcommand *	command,
		G4String	newValues )

overridevirtual

Apply command to the associated object.

Reimplemented from G4UImessenger.

Definition at line 216 of file G4FieldParametersMessenger.cc.

{
  // Apply command to the associated object.
 
  if (command == fFieldTypeCmd) {
    for (G4int i = kMagnetic; i <= kGravity; i++) {
      G4FieldType ft = (G4FieldType)i;
      if (newValues == G4FieldParameters::FieldTypeName(ft)) {
        fFieldParameters->SetFieldType(ft);
        break;
      }
    }
    return;
  }
  
  if (command == fEquationTypeCmd) {
    for (G4int i = kEqMagnetic; i <= kEqEMfieldWithEDM; i++) {
      G4EquationType et = (G4EquationType)i;
      if (newValues == G4FieldParameters::EquationTypeName(et)) {
        fFieldParameters->SetEquationType(et);
        break;
      }
    }
    return;
  }
 
  if (command == fStepperTypeCmd) {
    for (G4int i = kCashKarpRKF45; i <= kRK547FEq3; i++) {
      G4StepperType st = (G4StepperType)i;
      if (newValues == G4FieldParameters::StepperTypeName(st)) {
        fFieldParameters->SetStepperType(st);
        break;
      }
    }
    return;
  }
 
  if (command == fSetMinimumStepCmd) {
    fFieldParameters->SetMinimumStep(
      fSetMinimumStepCmd->GetNewDoubleValue(newValues));
    return;
  }
 
  if (command == fSetDeltaChordCmd) {
    fFieldParameters->SetDeltaChord(
      fSetDeltaChordCmd->GetNewDoubleValue(newValues));
    return;
  }
 
  if (command == fSetDeltaOneStepCmd) {
    fFieldParameters->SetDeltaOneStep(
      fSetDeltaOneStepCmd->GetNewDoubleValue(newValues));
    return;
  }
 
  if (command == fSetDeltaIntersectionCmd) {
    fFieldParameters->SetDeltaIntersection(
      fSetDeltaIntersectionCmd->GetNewDoubleValue(newValues));
    return;
  }
 
  if (command == fSetMinimumEpsilonStepCmd) {
    fFieldParameters->SetMinimumEpsilonStep(
      fSetMinimumEpsilonStepCmd->GetNewDoubleValue(newValues));
    return;
  }
 
  if (command == fSetMaximumEpsilonStepCmd) {
    fFieldParameters->SetMaximumEpsilonStep(
      fSetMaximumEpsilonStepCmd->GetNewDoubleValue(newValues));
    return;
  }
 
  if (command == fSetConstDistanceCmd) {
    fFieldParameters->SetConstDistance(
      fSetConstDistanceCmd->GetNewDoubleValue(newValues));
    return;
  }
 
  if (command == fPrintParametersCmd) {
    fFieldParameters->PrintParameters();
    return;
  }
}

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