G4FieldBuilder Class Reference

G4FieldBuilder is a singleton manager class for building magnetic or other fields, using the configuration in G4FieldParameters. More...

#include <G4FieldBuilder.hh>

Public Member Functions
	~G4FieldBuilder ()
	G4FieldBuilder (const G4FieldBuilder &right)=delete
G4FieldBuilder &	operator= (const G4FieldBuilder &right)=delete
G4FieldParameters *	CreateFieldParameters (const G4String &fieldVolName)
void	ConstructFieldSetup ()
void	UpdateField ()
void	Reinitialize ()
void	SetFieldType (G4FieldType fieldType)
void	SetGlobalField (G4Field *field, G4bool warn=false)
void	SetLocalField (G4Field *field, G4LogicalVolume *lv, G4bool warn=false)
void	SetUserEquationOfMotion (G4EquationOfMotion *equation, const G4String &volumeName="")
void	SetUserStepper (G4MagIntegratorStepper *stepper, const G4String &volumeName="")
void	SetVerboseLevel (G4int value)
G4FieldParameters *	GetFieldParameters (const G4String &volumeName="") const

Static Public Member Functions
static G4FieldBuilder *	Instance ()
static G4bool	IsInstance ()

Detailed Description

G4FieldBuilder is a singleton manager class for building magnetic or other fields, using the configuration in G4FieldParameters.

Definition at line 75 of file G4FieldBuilder.hh.

Constructor & Destructor Documentation

~G4FieldBuilder()

G4FieldBuilder::~G4FieldBuilder

(

)

Destructor. Deletes associated messenger.

Definition at line 63 of file G4FieldBuilder.cc.

{
  // Destructor
 
  delete fMessenger;
 
  for (auto parameters : fFieldParameters)
  {
    delete parameters;
  }
 
  for (auto setup : GetFieldSetups())
  {
    delete setup;
  }
 
  fgIsInstance = false;
 
  // magnetic field objects are deleted via G4 kernel
}

G4FieldBuilder()

G4FieldBuilder::G4FieldBuilder ( const G4FieldBuilder & right )

delete

Copy constructor and assignment operator not allowed.

Referenced by G4FieldBuilder(), Instance(), and operator=().

Member Function Documentation

ConstructFieldSetup()

void G4FieldBuilder::ConstructFieldSetup

(

)

Constructs the setup for all registered fields.

Definition at line 247 of file G4FieldBuilder.cc.

{
  // Construct setups for all registered fields.
 
  if (fVerboseLevel > 1)
  {
    G4cout << "G4FieldBuilder::ConstructField" << G4endl;
  }
 
  if (fIsConstructed)
  {
    G4Exception(
      "G4FieldBuilder::ConstructField:", "GeomFieldParameters0001",
      JustWarning, "Field was already constructed.");
    return;
  }
 
  ConstructGlobalField();
  ConstructLocalFields();
 
  UpdateFieldSetups();
 
  fIsConstructed = true;
}

CreateFieldParameters()

G4FieldParameters * G4FieldBuilder::CreateFieldParameters

(

const G4String &

fieldVolName

)

Creates the local magnetic field parameters (configuration) which can be then configured by the user via UI commands. The parameters are used in geometry only if a local magnetic field is associated with the volumes with the given name.

Parameters

[in]

fieldVolName

Volume name.

Returns

A pointer to the field parameters.

Definition at line 232 of file G4FieldBuilder.cc.

{
  // Create local magnetic field parameters (configuration) which can be then
  // configured by the user via UI commands.
  // The parameters are used in geometry only if a local magnetic field is
  // associated with the volumes with the given name.
 
  auto fieldParameters = new G4FieldParameters(fieldVolName);
  fFieldParameters.push_back(fieldParameters);
 
  return fieldParameters;
}

GetFieldParameters()

G4FieldParameters * G4FieldBuilder::GetFieldParameters

(

const G4String &

volumeName = ""

)

const

Gets a pointer to the field parameters with the given 'volumeName'. Return global field parameters, if volume name is empty.

Definition at line 494 of file G4FieldBuilder.cc.

{
  // Get field parameters with the given volumeName.
  // Return global field parameters, if volume name is empty.
 
  // Get user field parameters
  for (auto fieldParameters : fFieldParameters)
  {
    if (fieldParameters->GetVolumeName() == volumeName)
    {
      return fieldParameters;
    }
  }
 
  G4Exception(
    "G4FieldBuilder::GetFieldParameters:", "GeomFieldParameters0001",
    JustWarning, "Field parameters not found.");
  return nullptr;
}

Instance()

G4FieldBuilder * G4FieldBuilder::Instance ( )

static

Creates the class instance, if it does not exist; simply returns it on the next calls.

Returns

A pointer to the singleton instance.

Definition at line 44 of file G4FieldBuilder.cc.

{
  static G4FieldBuilder instance;
  fgIsInstance = true;
  return &instance;
}

Referenced by G4RunManager::ReinitializeGeometry().

IsInstance()

G4bool G4FieldBuilder::IsInstance ( )

static

Tells if the singleton instance exists.

Returns

true if the singleton instance exists.

Definition at line 85 of file G4FieldBuilder.cc.

{
  // Return the information if an instance exists
 
  return fgIsInstance;
}

Referenced by G4RunManager::ReinitializeGeometry().

operator=()

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

delete

Reinitialize()

void G4FieldBuilder::Reinitialize

(

)

Reinitialises if geometry has been modified. This method is called by G4RunManager during ReinitializeGeometry().

Definition at line 297 of file G4FieldBuilder.cc.

{
  // Reinitialize if geometry has been modified.
  // This function is called by G4RunManager during ReinitializeGeometry()
 
  if (fVerboseLevel > 1)
  {
    G4cout << "G4FieldBuilder::Reinitialize" << G4endl;
  }
  
  // Delete global field
  delete fGlobalField;
  fGlobalField = nullptr;
 
  // Delete local fields if defined
  if (fLocalFields.Get() != nullptr)
  {
    for (auto vectorElement : GetLocalFields())
    {
      delete vectorElement.second;
    }
    // Clear local fields map
    GetLocalFields().clear();
  }
 
  // Clear field setups if defined
  if (fFieldSetups.Get() != nullptr)
  {
    for (auto fieldSetup : GetFieldSetups())
    {
      fieldSetup->SetG4Field(nullptr);
      fieldSetup->Clear();
    }
  }
 
  fIsConstructed = false;
 
  if (fVerboseLevel > 1)
  {
    G4cout << "End of G4FieldBuilder::Reinitialize" << G4endl;
  }
}

Referenced by G4RunManager::ReinitializeGeometry().

SetFieldType()

void G4FieldBuilder::SetFieldType

(

G4FieldType

fieldType

)

The default field type is set to "kMagnetic". This method should be called for other than magnetic field, in order to update the default equation and stepper types.

Parameters

[in]

fieldType

The field type-ID.

Definition at line 341 of file G4FieldBuilder.cc.

{
// Default field type is set to kMagnetic;
// this function should be called for other than magnetic field
// in order to update the default equation and stepper types.
 
  if (fIsConstructed)
  {
    G4Exception(
      "G4FieldBuilder::SetFieldType:", "GeomFieldParameters0001",
      JustWarning, "Field was already constructed.");
    return;
  }
 
  fFieldParameters[0]->SetFieldType(fieldType);
 
  // change default equation and stepper if other than magnetic field
  if (fieldType == kElectroMagnetic)
  {
    fFieldParameters[0]->SetEquationType(kEqElectroMagnetic);
    fFieldParameters[0]->SetStepperType(kClassicalRK4);
  }
}

SetGlobalField()

void G4FieldBuilder::SetGlobalField	(	G4Field *	field,
		G4bool	warn = false )

Sets or resets the global field. It updates the field objects, if the field was already constructed.

Parameters

[in]	field	Pointer to the global field.
[in]	warn	If flag is true, issues a warning if the previous field is deleted.

Definition at line 366 of file G4FieldBuilder.cc.

{
  // Set or reset the global field.
  // Update field objects, if the field was already constructed.
  // If warn, issue a warning if the previous field is deleted.
 
  if (fGlobalField != nullptr && warn)
  {
    G4Exception(
      "G4FieldBuilder::SetGlobalField:", "GeomFieldParameters0001",
      JustWarning, "The global field already exists, it will be deleted.");
  }
  delete fGlobalField;
  fGlobalField = field;
 
  if (fIsConstructed)
  {
    // update the global field objects if already constructed
    GetFieldSetups()[0]->SetG4Field(field);
    GetFieldSetups()[0]->Update();
  }
}

SetLocalField()

void G4FieldBuilder::SetLocalField	(	G4Field *	field,
		G4LogicalVolume *	lv,
		G4bool	warn = false )

Registers the local field in the map. It updates the field objects, if the field was already constructed. The field is propagated to all volume daughters regardless if they have already assigned a field manager or not. When multiple local fields are defined (by calling this method multiple times), they will be applied in the order they were set.

Parameters

[in]	field	Pointer to the global field.
[in]	lv	Pointer to the logical volume.
[in]	warn	If flag is true, issues a warning if the previous field is deleted.

Definition at line 390 of file G4FieldBuilder.cc.

{
  // Register the local field in the map.
  // Update field objects, if the field was already constructed.
  // If warn, issue a warning if the previous field is deleted.
 
  if (lv == nullptr)
  {
    G4cerr << "Cannot register local field without Logical volume." << G4endl;
    return;
  }
 
  if (fLocalFields.Get() == nullptr)
  {
    auto localFields = new std::vector<std::pair<G4LogicalVolume*, G4Field*>>();
    fLocalFields.Put(localFields);
  }
 
  auto it = GetLocalFields().begin();
  for (it = GetLocalFields().begin(); it != GetLocalFields().end(); ++it)
  {
    if (it->first == lv) { break; }
  }
 
  if (it != GetLocalFields().end())
  {
    // replaced field if already in the map
    if (warn)
    {
      G4ExceptionDescription descr;
      descr << "Logical volume " << lv->GetName() << " has already field."
        " It will be deleted.";
      G4Exception(
        "G4FieldBuilder::SetLocalField:", "GeomFieldParameters0001",
        JustWarning, descr);
    }
    delete it->second;
    it->second = field;
  }
  else
  {
    // register field in the map
    GetLocalFields().emplace_back(lv,field);
  }
 
  if (fIsConstructed) {
    // update this local field objects if already constructed
    auto fieldSetup = GetFieldSetup(lv);
    if (fieldSetup == nullptr)
    {
      G4Exception(
        "G4FieldBuilder::SetLocalField:", "GeomFieldParameters0001",
        JustWarning, "Cannot get field setup for a local field.");
      return;
    }
    fieldSetup->SetG4Field(field);
    fieldSetup->Update();
  }
}

SetUserEquationOfMotion()

void G4FieldBuilder::SetUserEquationOfMotion	(	G4EquationOfMotion *	equation,
		const G4String &	volumeName = "" )

Sets the user equation of motion.

Parameters

[in]	equation	Pointer to the equation of motion algorithm.
[in]	volumeName	Optional volume name.

Definition at line 452 of file G4FieldBuilder.cc.

{
  // Set user equation of motion
 
  if (volumeName.empty())
  {
    // global field
    fFieldParameters[0]->SetUserEquationOfMotion(equation);
  }
  else
  {
    // local field
    // Get or create user field parameters
    G4FieldParameters* fieldParameters =
      GetOrCreateFieldParameters(volumeName);
    fieldParameters->SetUserEquationOfMotion(equation);
  }
}

SetUserStepper()

void G4FieldBuilder::SetUserStepper	(	G4MagIntegratorStepper *	stepper,
		const G4String &	volumeName = "" )

Sets the user stepper.

Parameters

[in]	stepper	Pointer to the stepper algorithm.
[in]	volumeName	Optional volume name.

Definition at line 473 of file G4FieldBuilder.cc.

{
  // Set user stepper
 
  if (volumeName.empty())
  {
    // global field
    fFieldParameters[0]->SetUserStepper(stepper);
  }
  else
  {
    // local field
    // Get or create user field parameters
    G4FieldParameters* fieldParameters =
      GetOrCreateFieldParameters(volumeName);
    fieldParameters->SetUserStepper(stepper);
  }
}

SetVerboseLevel()

void G4FieldBuilder::SetVerboseLevel

(

G4int

value

)

Sets the verbosity level.

Definition at line 97 of file G4FieldBuilder.cc.

{
  // Set verbose level
 
  fVerboseLevel = value;
}

UpdateField()

void G4FieldBuilder::UpdateField

(

)

Updates the magnetic field. It must be called if the field parameters were changed in other than PreInit> phase.

Definition at line 273 of file G4FieldBuilder.cc.

{
  // Update magnetic field.
  // This function must be called if the field parameters were changed
  // in other than PreInit> phase.
 
  if (fFieldSetups.Get() == nullptr)
  {
    G4Exception(
      "G4FieldBuilder::UpdateField", "GeomFieldParameters0001",
      JustWarning, "No field setup is defined.");
    return;
  }
 
  if (fVerboseLevel > 1)
  {
    G4cout << "G4FieldBuilder::UpdateField" << G4endl;
  }
 
  // Update the objects defined in G4FieldSetup's
  UpdateFieldSetups();
}

---

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

• G4FieldBuilder.hh
• G4FieldBuilder.cc