G4FieldBuilder Class Reference

The manger class for building magnetic or other field using the configuration in field parameters. More...

#include <G4FieldBuilder.hh>

Public Member Functions
	~G4FieldBuilder ()
	Destructor.
G4FieldParameters *	CreateFieldParameters (const G4String &fieldVolName)
void	ConstructFieldSetup ()
	Construct setups for all registered fields.
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, G4String volumeName="")
	Set user equation of motion.
void	SetUserStepper (G4MagIntegratorStepper *stepper, G4String volumeName="")
	Set user stepper.
void	SetVerboseLevel (G4int value)
	Set verbose level.
G4FieldParameters *	GetFieldParameters (const G4String &volumeName="") const

Static Public Member Functions
static G4FieldBuilder *	Instance ()
static G4bool	IsInstance ()
	Return the information if an instance exists.

Detailed Description

The manger class for building magnetic or other field using the configuration in field parameters.

Purpose: Provide a single 'place' to configure field & integration

• It can configure a global field, and field(s) local to a (logical) volume
• The parameter values can be configured by the user (else use a default)
• They can be set/changed via a messenger provided or in the code of the user detector construciton

• It retains ownership of the following object(s): field parameters and field setups, field

  Note MT: an object of the builder class should be created on master only (in DetectorConstruction constructor) The functions SetGlobal/LocalField and ConstructFieldSetup should be called on workers (in DetectorConstruction::ConstructSDandField )

  This design/implementation covers the most common use cases. It cannot be used to create some complex setups such as

  • equations templated on the field type,
  • steppers/drivers templated on the equation and field types.

Author

I. Hrivnacova; IJCLab, Orsay

Definition at line 79 of file G4FieldBuilder.hh.

Constructor & Destructor Documentation

~G4FieldBuilder()

G4FieldBuilder::~G4FieldBuilder

(

)

Destructor.

Definition at line 71 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
}

Member Function Documentation

ConstructFieldSetup()

void G4FieldBuilder::ConstructFieldSetup

(

)

Construct setups for all registered fields.

Definition at line 228 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

)

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

Definition at line 213 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

Get field parameters with the given volumeName. Return global field parameters, if volume name is empty.

Definition at line 450 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) {
      // G4cout << "Found field parameters for " << volumeName << G4endl;
      return fieldParameters;
    }
  }
 
  G4Exception(
    "G4FieldBuilder::GetFieldParameters:", "GeomFieldParameters0001",
    JustWarning, "Field parameters not found.");
  return nullptr;
}

Instance()

G4FieldBuilder * G4FieldBuilder::Instance ( )

static

Create the class instance, if it does not exist, and return it on the next calls.

Definition at line 52 of file G4FieldBuilder.cc.

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

Referenced by G4RunManager::ReinitializeGeometry().

IsInstance()

G4bool G4FieldBuilder::IsInstance ( )

inlinestatic

Return the information if an instance exists.

Definition at line 219 of file G4FieldBuilder.hh.

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

Referenced by G4RunManager::ReinitializeGeometry().

Reinitialize()

void G4FieldBuilder::Reinitialize

(

)

Reinitialize if geometry has been modified. This function is called by G4RunManager during ReinitializeGeometry()

Definition at line 274 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

)

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.

Definition at line 312 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 )

Definition at line 335 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 )

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. 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 function multiple times), they will be applied in the order they were set.

Definition at line 357 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().push_back(std::pair(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,
		G4String	volumeName = "" )

Set user equation of motion.

Definition at line 412 of file G4FieldBuilder.cc.

{
  // Set user equation of motion
 
  if (!volumeName.size()) {
    // 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,
		G4String	volumeName = "" )

Set user stepper.

Definition at line 431 of file G4FieldBuilder.cc.

{
  // Set user stepper
 
  if (!volumeName.size()) {
    // 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 )

inline

Set verbose level.

Definition at line 225 of file G4FieldBuilder.hh.

{
  // Set verbose level
  fVerboseLevel = value;
}

UpdateField()

void G4FieldBuilder::UpdateField

(

)

Update magnetic field. This function must be called if the field parameters were changed in other than PreInit> phase.

Definition at line 252 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