#include <G4PolarizationMessenger.hh>

Inheritance diagram for G4PolarizationMessenger:

Public Member Functions
	G4PolarizationMessenger (G4PolarizationManager *runMgr)

	~G4PolarizationMessenger () override

void	SetNewValue (G4UIcommand *command, G4String newValues) override

G4String	GetCurrentValue (G4UIcommand *command) override

G4PolarizationMessenger &	operator= (const G4PolarizationMessenger &right)=delete

	G4PolarizationMessenger (const G4PolarizationMessenger &)=delete

Public Member Functions inherited from G4UImessenger
	G4UImessenger ()=default

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

virtual	~G4UImessenger ()

G4bool	CommandsShouldBeInMaster () const

Public Attributes
G4PolarizationManager *	polarizationManager

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

Definition at line 52 of file G4PolarizationMessenger.hh.

Constructor & Destructor Documentation

◆ G4PolarizationMessenger() [1/2]

G4PolarizationMessenger::G4PolarizationMessenger ( G4PolarizationManager * runMgr )

explicit

Definition at line 48 of file G4PolarizationMessenger.cc.

  : polarizationManager(polMgr)
{
  polarizationDirectory = new G4UIdirectory("/polarization/");
  polarizationDirectory->SetGuidance("polarization control commands.");
 
  managerDirectory = new G4UIdirectory("/polarization/manager/");
  managerDirectory->SetGuidance("general polarization information.");
 
  verboseCmd = new G4UIcmdWithAnInteger("/polarization/manager/verbose", this);
  verboseCmd->SetGuidance("Set the Verbose level of G4PolarizationManager.");
  verboseCmd->SetGuidance(" 0 : Silent (default)");
  verboseCmd->SetGuidance(" 1 : Verbose");
  verboseCmd->SetParameterName("level", true);
  verboseCmd->SetDefaultValue(0);
  verboseCmd->SetRange("level >=0 && level <=1");
 
  optActivateCmd = new G4UIcmdWithABool("/polarization/manager/activate", this);
  optActivateCmd->SetGuidance("activate/deactivate polarization treatment");
  optActivateCmd->SetParameterName("flag", true);
  optActivateCmd->SetDefaultValue(true);
 
  volumeDirectory = new G4UIdirectory("/polarization/volume/");
  volumeDirectory->SetGuidance(
    "Status control commands of registered polarized logical volumes.");
 
  printVolumeListCmd =
    new G4UIcmdWithoutParameter("/polarization/volume/list", this);
  printVolumeListCmd->SetGuidance(
    "print list of registered polarized logical volumes");
  printVolumeListCmd->AvailableForStates(G4State_PreInit, G4State_Idle,
                                         G4State_GeomClosed);
 
  setPolarizationCmd = new G4UIcommand("/polarization/volume/set", this);
  setPolarizationCmd->SetGuidance(
    "set or change polarization of a logical volume");
  setPolarizationCmd->AvailableForStates(G4State_PreInit, G4State_Idle,
                                         G4State_GeomClosed);
 
  G4UIparameter* param;
  param = new G4UIparameter("logicalVolumeName", 's', false);
  param->SetDefaultValue("worldVolume");
  setPolarizationCmd->SetParameter(param);
  param = new G4UIparameter("px", 'd', true);
  param->SetDefaultValue("0.0");
  setPolarizationCmd->SetParameter(param);
  param = new G4UIparameter("py", 'd', true);
  param->SetDefaultValue("0.0");
  setPolarizationCmd->SetParameter(param);
  param = new G4UIparameter("pz", 'd', true);
  param->SetDefaultValue("0.0");
  setPolarizationCmd->SetParameter(param);
 
  testDirectory = new G4UIdirectory("/polarization/test/");
  testDirectory->SetGuidance("provides access to some internal test routines.");
 
  testPolarizationTransformationCmd = new G4UIcmdWithoutParameter(
    "/polarization/test/polarizationTransformation", this);
  testPolarizationTransformationCmd->SetGuidance(
    "checks definition of particle reference frame and corresponding "
    "translation routines");
  testPolarizationTransformationCmd->AvailableForStates(
    G4State_PreInit, G4State_Idle, G4State_GeomClosed);
 
  testInteractionFrameCmd =
    new G4UIcmdWithoutParameter("/polarization/test/interactionFrame", this);
  testInteractionFrameCmd->SetGuidance(
    "checks definition of interaction frame");
  testInteractionFrameCmd->AvailableForStates(G4State_PreInit, G4State_Idle,
                                              G4State_GeomClosed);
}

Referenced by G4PolarizationMessenger(), and operator=().

◆ ~G4PolarizationMessenger()

G4PolarizationMessenger::~G4PolarizationMessenger ( )

override

Definition at line 120 of file G4PolarizationMessenger.cc.

{
  delete verboseCmd;
  delete testInteractionFrameCmd;
  delete testPolarizationTransformationCmd;
  delete testDirectory;
  delete setPolarizationCmd;
  delete printVolumeListCmd;
  delete volumeDirectory;
  delete optActivateCmd;
  delete managerDirectory;
  delete polarizationDirectory;
}

◆ G4PolarizationMessenger() [2/2]

G4PolarizationMessenger::G4PolarizationMessenger ( const G4PolarizationMessenger & )

delete

Member Function Documentation

◆ GetCurrentValue()

G4String G4PolarizationMessenger::GetCurrentValue ( G4UIcommand * command )

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 181 of file G4PolarizationMessenger.cc.

{
  G4String cv;
  if(command == verboseCmd)
  {
    cv = verboseCmd->ConvertToString(polarizationManager->GetVerbose());
  }
 
  return cv;
}

◆ operator=()

G4PolarizationMessenger & G4PolarizationMessenger::operator= ( const G4PolarizationMessenger & right )

delete

◆ SetNewValue()

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

overridevirtual

Reimplemented from G4UImessenger.

Definition at line 134 of file G4PolarizationMessenger.cc.

{
  if(command == verboseCmd)
  {
    polarizationManager->SetVerbose(verboseCmd->GetNewIntValue(newValue));
  }
  else if(command == optActivateCmd)
  {
    polarizationManager->SetActivated(
      optActivateCmd->GetNewBoolValue(newValue));
  }
  else if(command == printVolumeListCmd)
  {
    polarizationManager->ListVolumes();
  }
  else if(command == setPolarizationCmd)
  {
    G4Tokenizer next(newValue);
    G4String volumeName = next();
    G4double px = 0., py = 0., pz = 0.;
    G4String dvalue = next();
    if(!dvalue.empty())
    {
      px     = StoD(dvalue);
      dvalue = next();
      if(!dvalue.empty())
      {
        py     = StoD(dvalue);
        dvalue = next();
        if(!dvalue.empty())
          pz = StoD(dvalue);
      }
    }
    G4ThreeVector pol(px, py, pz);
    polarizationManager->SetVolumePolarization(volumeName, pol);
  }
  else if(command == testPolarizationTransformationCmd)
  {
    G4PolarizationHelper::TestPolarizationTransformations();
  }
  else if(command == testInteractionFrameCmd)
  {
    G4PolarizationHelper::TestInteractionFrame();
  }
}

Member Data Documentation

◆ polarizationManager

G4PolarizationManager* G4PolarizationMessenger::polarizationManager

Definition at line 61 of file G4PolarizationMessenger.hh.

Referenced by G4PolarizationMessenger(), GetCurrentValue(), and SetNewValue().

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

Public Member Functions

Public Attributes

Additional Inherited Members