G4FieldManager Class Reference

#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 *)
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 G4double	GetMaxAcceptedEpsilon ()
static G4bool	SetMaxAcceptedEpsilon (G4double maxEps, G4bool softFail=false)

Protected Member Functions
void	ReportBadEpsilonValue (G4ExceptionDescription &erm, G4double value, 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

Definition at line 84 of file G4FieldManager.hh.

Constructor & Destructor Documentation

G4FieldManager() [1/3]

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

Definition at line 49 of file G4FieldManager.cc.

   : fDetectorField(detectorField), 
     fChordFinder(pChordFinder), 
     fDelta_One_Step_Value( fDefault_Delta_One_Step_Value ), 
     fDelta_Intersection_Val( fDefault_Delta_Intersection_Val ),     
     fEpsilonMin( fEpsilonMinDefault ),
     fEpsilonMax( fEpsilonMaxDefault)
{ 
   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() [2/3]

G4FieldManager::G4FieldManager

(

G4MagneticField *

detectorMagneticField

)

Definition at line 78 of file G4FieldManager.cc.

   : fDetectorField(detectorField), fAllocatedChordFinder(true),
     fDelta_One_Step_Value(   fDefault_Delta_One_Step_Value ), 
     fDelta_Intersection_Val( fDefault_Delta_Intersection_Val ),
     fEpsilonMin( fEpsilonMinDefault ),
     fEpsilonMax( fEpsilonMaxDefault )
{
   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

Definition at line 158 of file G4FieldManager.cc.

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

G4FieldManager() [3/3]

G4FieldManager::G4FieldManager ( const G4FieldManager & )

delete

Member Function Documentation

ChangeDetectorField()

void G4FieldManager::ChangeDetectorField ( G4Field * detectorField )

inline

Clone()

G4FieldManager * G4FieldManager::Clone ( ) const

virtual

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

virtual

Definition at line 153 of file G4FieldManager.cc.

{
   // Default is to do nothing!
}

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

CreateChordFinder()

void G4FieldManager::CreateChordFinder

(

G4MagneticField *

detectorMagField

)

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

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

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

Referenced by G4PropagatorInField::RefreshIntersectionLocator().

GetDeltaOneStep()

G4double G4FieldManager::GetDeltaOneStep ( ) const

inline

Referenced by G4PropagatorInField::ComputeStep().

GetDetectorField()

const G4Field * G4FieldManager::GetDetectorField ( ) const

inline

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().

GetMaxAcceptedEpsilon()

G4double G4FieldManager::GetMaxAcceptedEpsilon ( )

static

Definition at line 342 of file G4FieldManager.cc.

{
   return fMaxAcceptedEpsilon;
}

GetMaximumEpsilonStep()

G4double G4FieldManager::GetMaximumEpsilonStep ( ) const

inline

Referenced by G4PropagatorInField::ComputeStep(), and G4PropagatorInField::G4PropagatorInField().

GetMinimumEpsilonStep()

G4double G4FieldManager::GetMinimumEpsilonStep ( ) const

inline

Referenced by G4PropagatorInField::ComputeStep().

operator=()

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

delete

ProposeDetectorField()

void G4FieldManager::ProposeDetectorField ( G4Field * detectorField )

inline

ReportBadEpsilonValue()

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

protected

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

SetChordFinder()

void G4FieldManager::SetChordFinder ( G4ChordFinder * aChordFinder )

inline

Referenced by G4ErrorPropagatorManager::InitFieldForBackwards().

SetDeltaIntersection()

void G4FieldManager::SetDeltaIntersection ( G4double valueDintersection )

inline

SetDeltaOneStep()

void G4FieldManager::SetDeltaOneStep ( G4double valueD1step )

inline

SetDetectorField()

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

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

SetMaxAcceptedEpsilon()

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

static

Definition at line 349 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 257 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 302 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

Definition at line 181 of file G4FieldManager.hh.

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

fMaxFinalEpsilon

G4double G4FieldManager::fMaxFinalEpsilon = 0.02

staticconstexprprotected

Definition at line 186 of file G4FieldManager.hh.

Referenced by SetMaxAcceptedEpsilon().

fMaxWarningEpsilon

G4double G4FieldManager::fMaxWarningEpsilon = 0.001

staticconstexprprotected

Definition at line 185 of file G4FieldManager.hh.

Referenced by SetMaxAcceptedEpsilon().

fMinAcceptedEpsilon

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

staticconstexprprotected

Definition at line 182 of file G4FieldManager.hh.

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

fVerboseConstruction

G4bool G4FieldManager::fVerboseConstruction = false

staticprotected

Definition at line 188 of file G4FieldManager.hh.

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

---

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

• G4FieldManager.hh
• G4FieldManager.cc