Scans input file for /MagnetField/xyz commands. More...

#include <QweakSimMagneticFieldMessenger.hh>

Inherits G4UImessenger.

Collaboration diagram for QweakSimMagneticFieldMessenger:

Public Member Functions
	QweakSimMagneticFieldMessenger (QweakSimMagneticField *)

	~QweakSimMagneticFieldMessenger ()

void	SetNewValue (G4UIcommand *command, G4String newValue)

Private Attributes
QweakSimMagneticField *	fMagneticField

G4UIdirectory *	MagneticFieldDir

G4UIcmdWithAString *	ReadCmd

G4UIcmdWith3VectorAndUnit *	PrintCmd

G4UIcmdWithADoubleAndUnit *	RotationCmd

G4UIcmdWithADoubleAndUnit *	TranslationCmd

G4UIcmdWith3VectorAndUnit *	TranslationVectorCmd

G4UIcmdWithADoubleAndUnit *	MinZCmd

G4UIcmdWithADoubleAndUnit *	MaxZCmd

G4UIcmdWithADoubleAndUnit *	StepZCmd

G4UIcmdWithADoubleAndUnit *	MinRCmd

G4UIcmdWithADoubleAndUnit *	MaxRCmd

G4UIcmdWithADoubleAndUnit *	StepRCmd

G4UIcmdWithADoubleAndUnit *	MinPhiCmd

G4UIcmdWithADoubleAndUnit *	MaxPhiCmd

G4UIcmdWithADoubleAndUnit *	StepPhiCmd

G4UIcmdWithAnInteger *	WrapPhiCmd

G4UIcmdWithADouble *	ScaleCmd

G4UIcmdWithADouble *	RefCurrentCmd

G4UIcmdWithADouble *	ActCurrentCmd

G4UIcmdWithAnInteger *	StepperCmd

G4UIcmdWithADoubleAndUnit *	MinStepCmd

G4UIcmdWithoutParameter *	UpdateCmd

Detailed Description

Scans input file for /MagnetField/xyz commands.

Not used yet. Intended to set the StepperType and SetMinStep for the magnet fields.

Placeholder for a long explaination

Definition at line 64 of file QweakSimMagneticFieldMessenger.hh.

Constructor & Destructor Documentation

QweakSimMagneticFieldMessenger::QweakSimMagneticFieldMessenger ( QweakSimMagneticField * magneticfield )

Definition at line 44 of file QweakSimMagneticFieldMessenger.cc.

References ActCurrentCmd, MagneticFieldDir, MaxPhiCmd, MaxRCmd, MaxZCmd, MinPhiCmd, MinRCmd, MinStepCmd, MinZCmd, PrintCmd, ReadCmd, RefCurrentCmd, RotationCmd, ScaleCmd, StepperCmd, StepPhiCmd, StepRCmd, StepZCmd, TranslationCmd, TranslationVectorCmd, UpdateCmd, and WrapPhiCmd.

   : fMagneticField(magneticfield)
 {
   MagneticFieldDir = new G4UIdirectory("/MagneticField/");
   MagneticFieldDir->SetGuidance("Main Magnet control.");
 
   ReadCmd = new G4UIcmdWithAString("/MagneticField/ReadFieldMap",this);
   ReadCmd->SetGuidance("Read the specified magnetic field from file");
   ReadCmd->SetParameterName("file",true);
   ReadCmd->SetDefaultValue("MainMagnet_FieldMap.dat");
   ReadCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 
   PrintCmd = new G4UIcmdWith3VectorAndUnit("/MagneticField/PrintValue",this);
   PrintCmd->SetGuidance("Print the magnetic field value for specified position");
   PrintCmd->SetParameterName("x","y","z",false);
   PrintCmd->SetDefaultValue(G4ThreeVector(0.0,0.0,0.0));
   PrintCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 
   RefCurrentCmd = new G4UIcmdWithADouble("/MagneticField/SetReferenceCurrent",this);
   RefCurrentCmd->SetGuidance("Set reference current of read field map");
   RefCurrentCmd->SetParameterName("current",false);
   RefCurrentCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   ActCurrentCmd = new G4UIcmdWithADouble("/MagneticField/SetActualCurrent",this);
   ActCurrentCmd->SetGuidance("Set actual current of the magnetic field for simulation");
   ActCurrentCmd->SetParameterName("current",false);
   ActCurrentCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   ScaleCmd = new G4UIcmdWithADouble("/MagneticField/SetScale",this);
   ScaleCmd->SetGuidance("Set scale of the magnetic field for simulation");
   ScaleCmd->SetParameterName("bfil",false);
   ScaleCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 
   RotationCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetRotation",this);
   RotationCmd->SetGuidance("Set rotation angle of the magnetic field to be read");
   RotationCmd->SetParameterName("rotation",false);
   RotationCmd->SetDefaultUnit("degree");
   RotationCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   TranslationCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetTranslation",this);
   TranslationCmd->SetGuidance("Set translation in z of the magnetic field (applied on field read-in)");
   TranslationCmd->SetParameterName("z",false);
   TranslationCmd->SetDefaultUnit("cm");
   TranslationCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   TranslationVectorCmd = new G4UIcmdWith3VectorAndUnit("/MagneticField/SetTranslationVector",this);
   TranslationVectorCmd->SetGuidance("Set translation vector of the magnetic field (applied on field evaluation)");
   TranslationVectorCmd->SetParameterName("x","y","z",false);
   TranslationVectorCmd->SetDefaultUnit("cm");
   TranslationVectorCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 
   MinZCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetMinZ",this);
   MinZCmd->SetGuidance("Set the minimum z position of the field map grid to be read");
   MinZCmd->SetParameterName("min_r",false);
   MinZCmd->SetDefaultUnit("cm");
   MinZCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   MaxZCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetMaxZ",this);
   MaxZCmd->SetGuidance("Set the maximum z position of the field map grid to be read");
   MaxZCmd->SetParameterName("max_r",false);
   MaxZCmd->SetDefaultUnit("cm");
   MaxZCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   StepZCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetStepZ",this);
   StepZCmd->SetGuidance("Set the step z position of the field map grid to be read");
   StepZCmd->SetParameterName("step_r",false);
   StepZCmd->SetDefaultUnit("cm");
   StepZCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 
   MinRCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetMinR",this);
   MinRCmd->SetGuidance("Set the minimum radius of the field map grid to be read");
   MinRCmd->SetParameterName("min_r",false);
   MinRCmd->SetDefaultUnit("cm");
   MinRCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   MaxRCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetMaxR",this);
   MaxRCmd->SetGuidance("Set the maximum radius of the field map grid to be read");
   MaxRCmd->SetParameterName("max_r",false);
   MaxRCmd->SetDefaultUnit("cm");
   MaxRCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   StepRCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetStepR",this);
   StepRCmd->SetGuidance("Set the step radius of the field map grid to be read");
   StepRCmd->SetParameterName("step_r",false);
   StepRCmd->SetDefaultUnit("cm");
   StepRCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 
   MinPhiCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetMinPhi",this);
   MinPhiCmd->SetGuidance("Set the minimum phi of the field map grid to be read");
   MinPhiCmd->SetParameterName("min_phi",false);
   MinPhiCmd->SetDefaultUnit("degree");
   MinPhiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   MaxPhiCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetMaxPhi",this);
   MaxPhiCmd->SetGuidance("Set the maximum phi of the field map grid to be read");
   MaxPhiCmd->SetParameterName("max_phi",false);
   MaxPhiCmd->SetDefaultUnit("degree");
   MaxPhiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   StepPhiCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetStepPhi",this);
   StepPhiCmd->SetGuidance("Set the step phi of the field map grid to be read");
   StepPhiCmd->SetParameterName("step_phi",false);
   StepPhiCmd->SetDefaultUnit("degree");
   StepPhiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   WrapPhiCmd = new G4UIcmdWithAnInteger("/MagneticField/SetWrapPhi",this);
   WrapPhiCmd->SetGuidance("Set the wrap in phi of the field map grid to be read");
   WrapPhiCmd->SetParameterName("wrap_phi",false);
   WrapPhiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
 
   StepperCmd = new G4UIcmdWithAnInteger("/MagneticField/SetStepperType",this);
   StepperCmd->SetGuidance("Select stepper type for magnetic field");
   StepperCmd->SetParameterName("choice",true);
   StepperCmd->SetDefaultValue(4);
   StepperCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 
   MinStepCmd = new G4UIcmdWithADoubleAndUnit("/MagneticField/SetMinStep",this);
   MinStepCmd->SetGuidance("Define minimal step");
   MinStepCmd->SetParameterName("min step",false,false);
   MinStepCmd->SetDefaultUnit("mm");
   MinStepCmd->AvailableForStates(G4State_Idle);
 
   UpdateCmd = new G4UIcmdWithoutParameter("/MagneticField/Update",this);
   UpdateCmd->SetGuidance("Update Main Magnet geometry.");
   UpdateCmd->SetGuidance("This command MUST be applied before \"beamOn\" ");
   UpdateCmd->SetGuidance("if you changed geometrical value(s).");
   UpdateCmd->AvailableForStates(G4State_Idle);
 
 }

QweakSimMagneticFieldMessenger::~QweakSimMagneticFieldMessenger ( )

Definition at line 182 of file QweakSimMagneticFieldMessenger.cc.

References ActCurrentCmd, MagneticFieldDir, MaxPhiCmd, MaxRCmd, MaxZCmd, MinPhiCmd, MinRCmd, MinStepCmd, MinZCmd, RefCurrentCmd, RotationCmd, ScaleCmd, StepperCmd, StepPhiCmd, StepRCmd, StepZCmd, TranslationCmd, TranslationVectorCmd, UpdateCmd, and WrapPhiCmd.

 {
 
   delete ScaleCmd;
   delete RefCurrentCmd;
   delete ActCurrentCmd;
 
   delete MinZCmd;
   delete MaxZCmd;
   delete StepZCmd;
 
   delete MinRCmd;
   delete MaxRCmd;
   delete StepRCmd;
 
   delete MinPhiCmd;
   delete MaxPhiCmd;
   delete StepPhiCmd;
   delete WrapPhiCmd;
 
   delete RotationCmd;
   delete TranslationCmd;
   delete TranslationVectorCmd;
 
   delete StepperCmd;
   delete MinStepCmd;
   delete UpdateCmd;
 
   delete MagneticFieldDir;
 }

Member Function Documentation

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

Definition at line 214 of file QweakSimMagneticFieldMessenger.cc.

 {
   if (command == ScaleCmd) {
     fMagneticField->SetScaleFactor(ScaleCmd->GetNewDoubleValue(newValue));
   } else if (command == ActCurrentCmd) {
     fMagneticField->SetActualCurrent(ScaleCmd->GetNewDoubleValue(newValue));
   } else if (command == RefCurrentCmd) {
     fMagneticField->SetReferenceCurrent(ScaleCmd->GetNewDoubleValue(newValue));
   } else if (command == MinZCmd) {
     fMagneticField->SetMinimum(MinZCmd->GetNewDoubleValue(newValue)/cm,0);
   } else if (command == MinRCmd) {
     fMagneticField->SetMinimum(MinRCmd->GetNewDoubleValue(newValue)/cm,1);
   } else if (command == MinPhiCmd) {
     fMagneticField->SetMinimum(MinPhiCmd->GetNewDoubleValue(newValue)/radian,2);
   } else if (command == MaxZCmd) {
     fMagneticField->SetMaximum(MaxZCmd->GetNewDoubleValue(newValue)/cm,0);
   } else if (command == MaxRCmd) {
     fMagneticField->SetMaximum(MaxRCmd->GetNewDoubleValue(newValue)/cm,1);
   } else if (command == MaxPhiCmd) {
     fMagneticField->SetMaximum(MaxPhiCmd->GetNewDoubleValue(newValue)/radian,2);
   } else if (command == StepZCmd) {
     fMagneticField->SetStep(StepZCmd->GetNewDoubleValue(newValue)/cm,0);
   } else if (command == StepRCmd) {
     fMagneticField->SetStep(StepRCmd->GetNewDoubleValue(newValue)/cm,1);
   } else if (command == StepPhiCmd) {
     fMagneticField->SetStep(StepPhiCmd->GetNewDoubleValue(newValue)/radian,2);
   } else if (command == WrapPhiCmd) {
     fMagneticField->SetWrap(WrapPhiCmd->GetNewIntValue(newValue),2);
   } else if (command == RotationCmd) {
     fMagneticField->SetRotation(RotationCmd->GetNewDoubleValue(newValue));
   } else if (command == TranslationCmd) {
     fMagneticField->SetTranslation(TranslationCmd->GetNewDoubleValue(newValue));
   } else if (command == TranslationVectorCmd) {
     fMagneticField->SetTranslationVector(TranslationVectorCmd->GetNew3VectorValue(newValue));
   } else if (command == PrintCmd) {
     G4ThreeVector vector = PrintCmd->GetNew3VectorValue(newValue);
     G4double point[4];
     point[0] = vector.x();
     point[1] = vector.y();
     point[2] = vector.z();
     point[3] = 0.0;
     fMagneticField->PrintFieldValue(point);
   } else if (command == ReadCmd) {
     fMagneticField->ReadFieldMap(newValue);
   }
 }