G4FieldManager is a manager (store) for a pointer to the Field subclass that describes the field of a detector (magnetic, electric or other). It also stores a reference to the chord finder. A field manager can be set to a logical volume (or to more than one), in order to vary its field from that of the world volume. In this manner a zero or constant field can override a global field, a more or less exact version can override the external approximation, lower or higher precision for tracking can be specified, a different stepper can be chosen for different volumes, etc... The Chord Finder must be created either by calling CreateChordFinder() for a Magnetic Field or by the user creating a Chord Finder object "manually" and setting the pointer. The current design envisions that one Field manager is valid for each detector region. It is expected that a particular geometrical region has a Field manager. By default a Field Manager is created for the world volume, and will be utilised for all volumes unless it is overridden by a 'local' field manager. Note also that a region with both electric E and magnetic B field will have these treated as one field. Similarly it could be extended to treat other fields as additional components of a single field type. More...

#include <G4FieldManager.hh>

Public Member Functions
	G4FieldManager (G4Field detectorField=nullptr, G4ChordFinder pChordFinder=nullptr, G4bool b=true)
	G4FieldManager (G4MagneticField *detectorMagneticField)
virtual	~G4FieldManager ()
	G4FieldManager (const G4FieldManager &)=delete
G4FieldManager &	operator= (const G4FieldManager &)=delete
G4bool	SetDetectorField (G4Field *detectorField, G4int failMode=0)
void	ProposeDetectorField (G4Field *detectorField)
void	ChangeDetectorField (G4Field *detectorField)
const G4Field *	GetDetectorField () const
G4bool	DoesFieldExist () const
void	CreateChordFinder (G4MagneticField *detectorMagField)
void	SetChordFinder (G4ChordFinder *aChordFinder)
G4ChordFinder *	GetChordFinder ()
const G4ChordFinder *	GetChordFinder () const
virtual void	ConfigureForTrack (const G4Track *pTrack)
G4double	GetDeltaIntersection () const
G4double	GetDeltaOneStep () const
void	SetAccuraciesWithDeltaOneStep (G4double valDeltaOneStep)
void	SetDeltaOneStep (G4double valueD1step)
void	SetDeltaIntersection (G4double valueDintersection)
G4double	GetMinimumEpsilonStep () const
G4bool	SetMinimumEpsilonStep (G4double newEpsMin)
G4double	GetMaximumEpsilonStep () const
G4bool	SetMaximumEpsilonStep (G4double newEpsMax)
G4bool	DoesFieldChangeEnergy () const
void	SetFieldChangesEnergy (G4bool value)
virtual G4FieldManager *	Clone () const

Static Public Member Functions
static void	SetGlobalFieldManager (G4FieldManager *fieldManager)
static G4FieldManager *	GetGlobalFieldManager ()
static G4double	GetMaxAcceptedEpsilon ()
static G4bool	SetMaxAcceptedEpsilon (G4double maxEps, G4bool softFail=false)

Protected Member Functions
void	ReportBadEpsilonValue (G4ExceptionDescription &erm, G4double value, const G4String &name) const

Static Protected Attributes
static G4double	fMaxAcceptedEpsilon = 0.01
static constexpr G4double	fMinAcceptedEpsilon = 1000.0 * std::numeric_limits<G4double>::epsilon()
static constexpr G4double	fMaxWarningEpsilon = 0.001
static constexpr G4double	fMaxFinalEpsilon = 0.02
static G4bool	fVerboseConstruction = false

Detailed Description

G4FieldManager is a manager (store) for a pointer to the Field subclass that describes the field of a detector (magnetic, electric or other). It also stores a reference to the chord finder. A field manager can be set to a logical volume (or to more than one), in order to vary its field from that of the world volume. In this manner a zero or constant field can override a global field, a more or less exact version can override the external approximation, lower or higher precision for tracking can be specified, a different stepper can be chosen for different volumes, etc... The Chord Finder must be created either by calling CreateChordFinder() for a Magnetic Field or by the user creating a Chord Finder object "manually" and setting the pointer. The current design envisions that one Field manager is valid for each detector region. It is expected that a particular geometrical region has a Field manager. By default a Field Manager is created for the world volume, and will be utilised for all volumes unless it is overridden by a 'local' field manager. Note also that a region with both electric E and magnetic B field will have these treated as one field. Similarly it could be extended to treat other fields as additional components of a single field type.

Definition at line 108 of file G4FieldManager.hh.

Constructor & Destructor Documentation

◆ G4FieldManager() [1/3]

G4FieldManager::G4FieldManager	(	G4Field *	detectorField = nullptr,
		G4ChordFinder *	pChordFinder = nullptr,
		G4bool	b = true )

General Constructor for any field. Must be set with field and chord finder for use.

Parameters

[in]	detectorField	Pointer to the field.
[in]	pChordFinder	Pointer to the chord finder object.
[in]	b	Flag to indicate if the field changes the energy; it is taken from the provided field, if specified.

Definition at line 50 of file G4FieldManager.cc.

   : fDetectorField(detectorField), 
     fChordFinder(pChordFinder)
{ 
   if ( detectorField != nullptr )
   {
     fFieldChangesEnergy = detectorField->DoesFieldChangeEnergy();
   }
   else
   {
     fFieldChangesEnergy = fieldChangesEnergy;
   }
 
   if( fVerboseConstruction)
   {
     G4cout << "G4FieldManager/ctor#1 fEpsilon Min/Max:  eps_min = " << fEpsilonMin << " eps_max=" << fEpsilonMax << G4endl;
   }
 
   // Add to store
   //
   G4FieldManagerStore::Register(this);
}

Referenced by Clone(), G4FieldManager(), GetGlobalFieldManager(), operator=(), SetFieldChangesEnergy(), and SetGlobalFieldManager().

◆ G4FieldManager() [2/3]

G4FieldManager::G4FieldManager ( G4MagneticField * detectorMagneticField )

Constructor creating the chord finder. It assumes pure magnetic field, so energy constant.

Parameters

[in] detectorMagneticField Pointer to the magnetic field.

Definition at line 75 of file G4FieldManager.cc.

   : fDetectorField(detectorField), fAllocatedChordFinder(true)
{
   fChordFinder = new G4ChordFinder( detectorField );
 
   if( fVerboseConstruction )
   {
     G4cout << "G4FieldManager/ctor#2 fEpsilon Min/Max:  eps_min = " << fEpsilonMin << " eps_max=" << fEpsilonMax << G4endl;
   }
   // Add to store
   //
   G4FieldManagerStore::Register(this);
}

◆ ~G4FieldManager()

G4FieldManager::~G4FieldManager ( )

virtual

Virtual Destructor.

Definition at line 89 of file G4FieldManager.cc.

{
   if( fAllocatedChordFinder )
   {
      delete fChordFinder;
   }
   G4FieldManagerStore::DeRegister(this);
}

◆ G4FieldManager() [3/3]

G4FieldManager::G4FieldManager ( const G4FieldManager & )

delete

Copy constructor and assignment operator not allowed.

Member Function Documentation

◆ ChangeDetectorField()

void G4FieldManager::ChangeDetectorField ( G4Field * detectorField )

inline

Pushes the field to the equation and keeps its address. Can be used only once the equation, stepper, driver and chord finder have all been created; else it is an error.

Parameters

[in] detectorField Pointer to the field.

◆ Clone()

G4FieldManager * G4FieldManager::Clone ( ) const

virtual

Needed for multi-threading, create and returns an allocated clone of this object.

Definition at line 98 of file G4FieldManager.cc.

{
    G4Field* aField = nullptr;
    G4FieldManager* aFM = nullptr;
    G4ChordFinder* aCF = nullptr;
    try
    {
        if ( fDetectorField != nullptr )
        {
           aField = fDetectorField->Clone();
        }
 
        // Create a new field manager, note that we do not set
        // any chordfinder now
        //
        aFM = new G4FieldManager( aField , nullptr , fFieldChangesEnergy );
 
        // Check if originally we have the fAllocatedChordFinder variable
        // set, in case, call chord constructor
        //
        if ( fAllocatedChordFinder )
        {
            aFM->CreateChordFinder( dynamic_cast<G4MagneticField*>(aField) );
        }
        else
        {
            // Chord was specified by user, should we clone?
            // TODO: For the moment copy pointer, to be understood
            //       if cloning of ChordFinder is needed
            //
            aCF = fChordFinder; /*->Clone*/
            aFM->fChordFinder = aCF;
        }
 
        // Copy values of other variables
 
        aFM->fEpsilonMax = fEpsilonMax;
        aFM->fEpsilonMin = fEpsilonMin;
        aFM->fDelta_Intersection_Val = fDelta_Intersection_Val;
        aFM->fDelta_One_Step_Value = fDelta_One_Step_Value;
          // TODO: Should we really add to the store the cloned FM?
          //       Who will use this?
    }
    catch ( ... )
    {
        // Failed creating clone: probably user did not implement Clone method
        // in derived classes?
        // Perform clean-up after ourselves...
        delete aField;
        delete aFM;
        delete aCF;
        throw;
    }
 
    G4cout << "G4FieldManager/clone fEpsilon Min/Max:  eps_min = " << fEpsilonMin << " eps_max=" << fEpsilonMax << G4endl;
    return aFM;
}

Referenced by G4VUserDetectorConstruction::CloneF().

◆ ConfigureForTrack()

void G4FieldManager::ConfigureForTrack ( const G4Track * pTrack )

virtual

Setups the choice of the configurable parameters, relying on the current track's energy, particle identity... Note: in addition to the values of member variables, a user can use this to change the ChordFinder, the field, etc.

Parameters

[in] pTrack Pointer to a track.

Definition at line 156 of file G4FieldManager.cc.

{
   // Default is to do nothing!
}

Referenced by G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), and G4ITTransportation::AlongStepGetPhysicalInteractionLength().

◆ CreateChordFinder()

void G4FieldManager::CreateChordFinder ( G4MagneticField * detectorMagField )

Methods to create, set or get the associated Chord Finder.

Definition at line 162 of file G4FieldManager.cc.

{
   if ( fAllocatedChordFinder )
   { 
      delete fChordFinder;
   }
   fAllocatedChordFinder = false;
 
   if( detectorMagField != nullptr )
   {
      fChordFinder = new G4ChordFinder( detectorMagField );
      fAllocatedChordFinder = true;
   }
   else
   {
      fChordFinder = nullptr;
   }
}

Referenced by Clone().

◆ DoesFieldChangeEnergy()

G4bool G4FieldManager::DoesFieldChangeEnergy ( ) const

inline

Methods to set/get flag for field changing energy. For electric field this should be true; for magnetic field this should be false.

◆ DoesFieldExist()

G4bool G4FieldManager::DoesFieldExist ( ) const

inline

Referenced by G4VFieldModel::DescribeYourselfTo(), and G4ITTransportation::DoesGlobalFieldExist().

◆ GetChordFinder() [1/2]

G4ChordFinder * G4FieldManager::GetChordFinder ( )

inline

Referenced by G4ErrorPropagatorManager::InitFieldForBackwards().

◆ GetChordFinder() [2/2]

const G4ChordFinder * G4FieldManager::GetChordFinder ( ) const

inline

◆ GetDeltaIntersection()

G4double G4FieldManager::GetDeltaIntersection ( ) const

inline

Returns the accuracy for boundary intersection.

◆ GetDeltaOneStep()

G4double G4FieldManager::GetDeltaOneStep ( ) const

inline

Returns the accuracy for one tracking/physics step.

◆ GetDetectorField()

const G4Field * G4FieldManager::GetDetectorField ( ) const

inline

Methods to get and check (existance of) the field object.

Referenced by G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4ITTransportation::AlongStepGetPhysicalInteractionLength(), G4DecayWithSpin::AtRestDoIt(), G4ErrorSurfaceTrajState::BuildErrorMatrix(), G4PathFinder::ComputeStep(), G4VFieldModel::DescribeYourselfTo(), G4ErrorFreeTrajState::G4ErrorFreeTrajState(), G4SynchrotronRadiation::GetMeanFreePath(), G4SynchrotronRadiationInMat::GetMeanFreePath(), G4SynchrotronRadiationInMat::GetPhotonEnergy(), G4ErrorPropagatorManager::InitFieldForBackwards(), G4SynchrotronRadiation::PostStepDoIt(), G4SynchrotronRadiationInMat::PostStepDoIt(), G4ErrorMagFieldLimitProcess::PostStepGetPhysicalInteractionLength(), and G4ErrorFreeTrajState::PropagateError().

◆ GetGlobalFieldManager()

G4FieldManager * G4FieldManager::GetGlobalFieldManager ( )

static

Referenced by G4FieldSetup::G4FieldSetup().

◆ GetMaxAcceptedEpsilon()

G4double G4FieldManager::GetMaxAcceptedEpsilon ( )

static

Static methods to set/get the maximum accepted epsilon. If setting fails, with softFail=true it gives Warning, else a FatalException.

Definition at line 336 of file G4FieldManager.cc.

{
   return fMaxAcceptedEpsilon;
}

◆ GetMaximumEpsilonStep()

G4double G4FieldManager::GetMaximumEpsilonStep ( ) const

inline

Methods to set/get the maximum for Relative accuracy of a Step.

◆ GetMinimumEpsilonStep()

G4double G4FieldManager::GetMinimumEpsilonStep ( ) const

inline

Methods to set/get the minimum for Relative accuracy of a Step.

◆ operator=()

G4FieldManager & G4FieldManager::operator= ( const G4FieldManager & )

delete

◆ ProposeDetectorField()

void G4FieldManager::ProposeDetectorField ( G4Field * detectorField )

inline

Pushes the field to this class only – no further. Should be used to initialise this field, only before creating the chord finder and its dependent classes. User is then responsible to ensure that: i) an equation, stepper, driver and chord finder are created; ii) this field is used by the equation.

Parameters

[in] detectorField Pointer to the field.

◆ ReportBadEpsilonValue()

void G4FieldManager::ReportBadEpsilonValue	(	G4ExceptionDescription &	erm,
		G4double	value,
		const G4String &	name ) const

protected

Logger for reporting on correctness of the proposed epsilon value.

Definition at line 415 of file G4FieldManager.cc.

{
  erm << "Incorrect proposed value of " << name << " = " << value << G4endl
      << " Its value is outside the permitted range from "
      << fMinAcceptedEpsilon << "  to " <<  fMaxAcceptedEpsilon << G4endl
      << " Clarification: " << G4endl;
  G4long oldPrec = erm.precision();
  if(value < fMinAcceptedEpsilon )
  {
    erm << "  a) The value must be positive and enough larger than the accuracy limit"
        << " of the (G4)double type - ("
        <<  (value < fMinAcceptedEpsilon ? "FAILED" : "OK" ) << ")" << G4endl
        << "     i.e. std::numeric_limits<G4double>::epsilon()= "
        <<  std::numeric_limits<G4double>::epsilon()
        << " to ensure that integration " << G4endl
        << "     could potentially achieve this acccuracy." << G4endl
        << "     Minimum accepted eps_min/max value = " << fMinAcceptedEpsilon << G4endl;
  }
  else if( value > fMaxAcceptedEpsilon)
  {
    erm << "  b) It must be smaller than (or equal) " << std::setw(8)
        << std::setprecision(4) << fMaxAcceptedEpsilon
        << " to ensure robustness of integration - ("
        << (( value < fMaxAcceptedEpsilon) ? "OK" : "FAILED" ) << ")" << G4endl;
  }
  else
  {
    G4bool badRoundoff = (std::fabs(1.0+value) == 1.0);
    erm << "  Unknown ERROR case -- extra check: " << G4endl;
    erm << "  c) as a floating point number (of type G4double) the sum (1+" << name
        << " ) must be > 1 , ("
        <<  (badRoundoff ? "FAILED" : "OK" ) << ")" << G4endl
        << "     Now    1+eps_min          = " << std::setw(20)
        << std::setprecision(17) << (1+value) << G4endl
        << "     and   (1.0+" << name << ") - 1.0 = " << std::setw(20)
        << std::setprecision(9) << (1.0+value)-1.0;
  }
  erm.precision(oldPrec);
}

Referenced by SetMaximumEpsilonStep(), and SetMinimumEpsilonStep().

◆ SetAccuraciesWithDeltaOneStep()

void G4FieldManager::SetAccuraciesWithDeltaOneStep ( G4double valDeltaOneStep )

inline

Sets both accuracies, maintaining a fixed ratio for accuracies of volume Intersection and Integration (in One Step).

◆ SetChordFinder()

void G4FieldManager::SetChordFinder ( G4ChordFinder * aChordFinder )

inline

Referenced by G4ErrorPropagatorManager::InitFieldForBackwards().

◆ SetDeltaIntersection()

void G4FieldManager::SetDeltaIntersection ( G4double valueDintersection )

inline

Sets the accuracy of intersection of a volume (only).

◆ SetDeltaOneStep()

void G4FieldManager::SetDeltaOneStep ( G4double valueD1step )

inline

Sets the accuracy for integration of one step (only).

◆ SetDetectorField()

G4bool G4FieldManager::SetDetectorField	(	G4Field *	detectorField,
		G4int	failMode = 0 )

Pushes the field to the equation. Failure to push the field (due to absence of a chord finder, driver, stepper or equation) is

'0' = quiet : Do not complain if chordFinder == 0 (It will still warn for other error);
'1' = warn : a warning if anything is missing;
'2'/else = FATAL : a fatal error for all other values.
Parameters

[in] detectorField Pointer to the field.

[in] failMode Flag (0/1/2) for selected failure mode.

Returns
Success (true) or failure (false).

Definition at line 193 of file G4FieldManager.cc.

{
   G4VIntegrationDriver* driver = nullptr;
   G4EquationOfMotion* equation = nullptr;
   // G4bool  compatibleField = false;
   G4bool ableToSet = false;
 
   fDetectorField = pDetectorField;
   InitialiseFieldChangesEnergy();
   
   // Must 'propagate' the field to the dependent classes
   //
   if( fChordFinder != nullptr )
   {
     failMode= std::max( failMode, 1) ;
       // If a chord finder exists, warn in case of error!
      
     driver = fChordFinder->GetIntegrationDriver();
     if( driver != nullptr )
     {
       equation = driver->GetEquationOfMotion();
 
       // Should check the compatibility between the
       // field and the equation HERE
 
       if( equation != nullptr )
       {
          equation->SetFieldObj(pDetectorField);
          ableToSet = true;
       }
     }
   }
   
   if( !ableToSet && (failMode > 0) )
   {
     // If this fails, report the issue !
 
     G4ExceptionDescription msg;
     msg << "Unable to set the field in the dependent objects of G4FieldManager"
         << G4endl;
     msg << "All the dependent classes must be fully initialised,"
         << "before it is possible to call this method." << G4endl;
     msg << "The problem encountered was the following: " << G4endl;
     if( fChordFinder == nullptr ) { msg << "  No ChordFinder. " ; }
     else if( driver == nullptr )  { msg << "  No Integration Driver set. ";}
     else if( equation == nullptr ) { msg << "  No Equation found. " ; }
     // else if( !compatibleField ) { msg << "  Field not compatible. ";}
     else { msg << "  Can NOT find reason for failure. ";}
     msg << G4endl;
     G4ExceptionSeverity severity = (failMode != 1)
                                  ? FatalException : JustWarning ;
     G4Exception("G4FieldManager::SetDetectorField", "Geometry001",
                 severity, msg);
   }
   return ableToSet;
}

◆ SetFieldChangesEnergy()

void G4FieldManager::SetFieldChangesEnergy ( G4bool value )

inline

◆ SetGlobalFieldManager()

void G4FieldManager::SetGlobalFieldManager ( G4FieldManager * fieldManager )

static

Static methods to set/get the global field.

Referenced by G4TransportationManager::SetFieldManager().

◆ SetMaxAcceptedEpsilon()

G4bool G4FieldManager::SetMaxAcceptedEpsilon	(	G4double	maxEps,
		G4bool	softFail = false )

static

Definition at line 343 of file G4FieldManager.cc.

{
  G4bool success= false;
  // Limit for warning and absolute limit chosen from experience in and 
  // investigation of integration with G4DormandPrince745 in HEP-type setups.
  if( maxAcceptValue <= fMaxWarningEpsilon )
  {
    fMaxAcceptedEpsilon= maxAcceptValue;
    success= true;
  }
  else
  {
    G4ExceptionDescription erm;
    G4ExceptionSeverity  severity;
 
    G4cout << "G4FieldManager::" << __func__ 
           << " Parameters:   fMaxAcceptedEpsilon = " << fMaxAcceptedEpsilon
           << " fMaxFinalEpsilon = " << fMaxFinalEpsilon << G4endl;
    
    if( maxAcceptValue <= fMaxFinalEpsilon )
    {
      success= true;
      fMaxAcceptedEpsilon = maxAcceptValue;
      // Integration is poor, and robustness will likely suffer
      erm << "Proposed value for maximum-accepted-epsilon = " << maxAcceptValue
          << " is larger than the recommended = " << fMaxWarningEpsilon
          << G4endl
          << "This may impact the robustness of integration of tracks in field."
          << G4endl
          << "The request was accepted and the value = "  << fMaxAcceptedEpsilon
          << " , but future releases are expected " << G4endl
          << " to tighten the limit of acceptable values to " 
          << fMaxWarningEpsilon << G4endl << G4endl          
          << "Suggestion: If you need better performance investigate using "
          << "alternative, low-order RK integration methods or " << G4endl
          << " helix-based methods (for pure B-fields) for low(er) energy tracks, "
          << " especially electrons if you need better performance." << G4endl;
      severity= JustWarning;
    }
    else
    {
      fMaxAcceptedEpsilon= fMaxFinalEpsilon;
      erm << " Proposed value for maximum accepted epsilon " << maxAcceptValue
          << " is larger than the top of the range = " << fMaxFinalEpsilon
          << G4endl;
      if( softFailure )
      {
        erm << " Using the latter value instead." << G4endl;
      }
      erm << G4endl;
      erm << " Please adjust to request maxAccepted <= " << fMaxFinalEpsilon
          << G4endl << G4endl;
      if( !softFailure )
      {
        erm << " NOTE: you can accept the ceiling value and turn this into a " 
            << " warning by using a 2nd argument  " << G4endl
            << " in your call to SetMaxAcceptedEpsilon:  softFailure = true ";
      }
      severity = softFailure ? JustWarning : FatalException; 
      // if( softFailure ) severity= JustWarning;
      // else severity= FatalException;
      success = false;
    }
    G4String methodName = G4String("G4FieldManager::")+ G4String(__func__);
    G4Exception(methodName.c_str(), "Geometry003", severity, erm);    
  }
  return success;
}

◆ SetMaximumEpsilonStep()

G4bool G4FieldManager::SetMaximumEpsilonStep ( G4double newEpsMax )

Definition at line 251 of file G4FieldManager.cc.

{
  G4bool succeeded= false;
  if(    (newEpsMax > 0.0) && ( newEpsMax <= fMaxAcceptedEpsilon)
     &&  (fMinAcceptedEpsilon <= newEpsMax ) ) // (std::fabs(1.0+newEpsMax)>1.0) )
  {
    if(newEpsMax >= fEpsilonMin)
    {
      fEpsilonMax = newEpsMax;
      succeeded = true;
      if (fVerboseConstruction)
      {
        G4cout << "G4FieldManager/SetEpsMax :  eps_max = " << std::setw(10) << fEpsilonMax
               << " ( Note: unchanged eps_min=" << std::setw(10) << fEpsilonMin << " )" << G4endl;
      }
    }
    else
    {
      G4ExceptionDescription erm;
      erm << " Call to set eps_max = " << newEpsMax << " . The problem is that"
          << " its value must be at larger or equal to eps_min= " << fEpsilonMin << G4endl;
      erm << " Modifying both to the same value " << newEpsMax << " to ensure consistency."
          << G4endl
          << " To avoid this warning, please set eps_min first, and ensure that "
          << " 0 < eps_min <= eps_max <= " << fMaxAcceptedEpsilon << G4endl;
      
      fEpsilonMax = newEpsMax;
      fEpsilonMin = newEpsMax;
      G4String methodName = G4String("G4FieldManager::")+ G4String(__func__);
      G4Exception(methodName.c_str(), "Geometry003", JustWarning, erm);
    }
  }
  else
  {
    G4ExceptionDescription erm;
    G4String paramName("eps_max");
    ReportBadEpsilonValue(erm, newEpsMax, paramName );
    G4String methodName = G4String("G4FieldManager::")+ G4String(__func__);
    G4Exception(methodName.c_str(), "Geometry001", FatalException, erm);
  }
  return succeeded;
}

◆ SetMinimumEpsilonStep()

G4bool G4FieldManager::SetMinimumEpsilonStep ( G4double newEpsMin )

Definition at line 296 of file G4FieldManager.cc.

{
  G4bool succeeded= false;
 
  if( fMinAcceptedEpsilon <= newEpsMin  &&  newEpsMin <= fMaxAcceptedEpsilon )
  {
    fEpsilonMin = newEpsMin;
    //*********
    succeeded= true;
 
    if (fVerboseConstruction)
    {
      G4cout << "G4FieldManager/SetEpsMin :  eps_min = "
             << std::setw(10) << fEpsilonMin << G4endl;
    }
    if( fEpsilonMax < fEpsilonMin )
    {
      // Ensure consistency
      G4ExceptionDescription erm;
      erm << "Setting eps_min = " << newEpsMin
          << " For consistency set eps_max= " << fEpsilonMin
          << " ( Old value = " << fEpsilonMax << " )" << G4endl;
      fEpsilonMax = fEpsilonMin;
      G4String methodName = G4String("G4FieldManager::")+ G4String(__func__);
      G4Exception(methodName.c_str(), "Geometry003", JustWarning, erm);
    }
  }
  else
  {
    G4ExceptionDescription erm;
    G4String paramName("eps_min");
    ReportBadEpsilonValue(erm, newEpsMin, paramName );
    G4String methodName = G4String("G4FieldManager::")+ G4String(__func__);
    G4Exception(methodName.c_str(), "Geometry001", FatalException, erm);
  }
  return succeeded;
}

Member Data Documentation

◆ fMaxAcceptedEpsilon

G4double G4FieldManager::fMaxAcceptedEpsilon = 0.01

staticprotected

Epsilon_min/max values must be smaller than this for robust integration.

Definition at line 272 of file G4FieldManager.hh.

Referenced by GetMaxAcceptedEpsilon(), ReportBadEpsilonValue(), SetMaxAcceptedEpsilon(), SetMaximumEpsilonStep(), and SetMinimumEpsilonStep().

◆ fMaxFinalEpsilon

G4double G4FieldManager::fMaxFinalEpsilon = 0.02

staticconstexprprotected

Will not accept larger values.

Definition at line 279 of file G4FieldManager.hh.

Referenced by SetMaxAcceptedEpsilon().

◆ fMaxWarningEpsilon

G4double G4FieldManager::fMaxWarningEpsilon = 0.001

staticconstexprprotected

Setting larger value will give warning.

Definition at line 276 of file G4FieldManager.hh.

Referenced by SetMaxAcceptedEpsilon().

◆ fMinAcceptedEpsilon

G4double G4FieldManager::fMinAcceptedEpsilon = 1000.0 * std::numeric_limits<G4double>::epsilon()

staticconstexprprotected

Definition at line 273 of file G4FieldManager.hh.

Referenced by ReportBadEpsilonValue(), SetMaximumEpsilonStep(), and SetMinimumEpsilonStep().

◆ fVerboseConstruction

G4bool G4FieldManager::fVerboseConstruction = false

staticprotected

Controls verbosity of constructors.

Definition at line 282 of file G4FieldManager.hh.

Referenced by G4FieldManager(), G4FieldManager(), SetMaximumEpsilonStep(), and SetMinimumEpsilonStep().

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4FieldManager() [1/3]

◆ G4FieldManager() [2/3]

◆ ~G4FieldManager()

◆ G4FieldManager() [3/3]

Member Function Documentation

◆ ChangeDetectorField()

◆ Clone()

◆ ConfigureForTrack()

◆ CreateChordFinder()

◆ DoesFieldChangeEnergy()

◆ DoesFieldExist()

◆ GetChordFinder() [1/2]

◆ GetChordFinder() [2/2]

◆ GetDeltaIntersection()

◆ GetDeltaOneStep()

◆ GetDetectorField()

◆ GetGlobalFieldManager()

◆ GetMaxAcceptedEpsilon()

◆ GetMaximumEpsilonStep()

◆ GetMinimumEpsilonStep()

◆ operator=()

◆ ProposeDetectorField()

◆ ReportBadEpsilonValue()

◆ SetAccuraciesWithDeltaOneStep()

◆ SetChordFinder()

◆ SetDeltaIntersection()

◆ SetDeltaOneStep()

◆ SetDetectorField()

◆ SetFieldChangesEnergy()

◆ SetGlobalFieldManager()

◆ SetMaxAcceptedEpsilon()

◆ SetMaximumEpsilonStep()

◆ SetMinimumEpsilonStep()

Member Data Documentation

◆ fMaxAcceptedEpsilon

◆ fMaxFinalEpsilon

◆ fMaxWarningEpsilon

◆ fMinAcceptedEpsilon

◆ fVerboseConstruction