F01FieldSetup Class Reference

#include <Doxymodules_field.h>

Public Member Functions
	F01FieldSetup (G4ThreeVector, G4int stepperNum=-1000, G4bool useFSALstepper=false)
	F01FieldSetup ()
	F01FieldSetup (F01FieldSetup &)=delete
virtual	~F01FieldSetup ()
void	SetStepperType (G4int i)
void	SetStepper ()
void	SetMinStep (G4double s)
void	InitialiseAll ()
void	CreateStepperAndChordFinder ()
void	CreateFSALStepperAndChordFinder ()
void	CreateAndSetupBorisDriver ()
void	SetUseFSALstepper (G4bool val=true)
G4bool	GetUseFSALstepper ()
G4double	GetEpsilonMin ()
G4double	GetEpsilonMax ()
void	SetEpsilonMin (G4double val)
void	SetEpsilonMax (G4double val)
void	SetDeltaOneStep (G4double val)
void	SetFieldValue (G4ThreeVector fieldVector)
void	SetFieldZValue (G4double fieldValue)
G4ThreeVector	GetConstantFieldValue ()

Protected Member Functions
G4VIntegrationDriver *	CreateFSALStepperAndDriver ()
G4FieldManager *	GetGlobalFieldManager ()

Protected Attributes
G4FieldManager *	fFieldManager = nullptr
G4ChordFinder *	fChordFinder = nullptr
G4Mag_UsualEqRhs *	fEquation = nullptr
G4MagneticField *	fMagneticField = nullptr
G4MagIntegratorStepper *	fStepper = nullptr
G4bool	fUseFSALstepper = false
G4VIntegrationDriver *	fDriver = nullptr
G4int	fStepperType = -1
F01FieldMessenger *	fFieldMessenger = nullptr
G4double	fMinStep = -1.0
G4double	fDeltaOneStep = -1.0
G4double	fDesiredEpsilonMin = 1.0e-05
G4double	fDesiredEpsilonMax = 0.005

Detailed Description

Definition at line 40 of file Doxymodules_field.h.

Constructor & Destructor Documentation

F01FieldSetup() [1/3]

F01FieldSetup::F01FieldSetup	(	G4ThreeVector	fieldVector,
		G4int	stepperNum = -1000,
		G4bool	useFSALstepper = false
	)

Definition at line 83 of file F01FieldSetup.cc.

 : fMagneticField(new G4UniformMagField(fieldVector)),
   fUseFSALstepper(useFSALstepper),
   fStepperType(0)
{
  G4cout << " F01FieldSetup: magnetic field set to Uniform( "
         << fieldVector << " ) " << G4endl;
 
  if( stepperNum == -1000 )
  {
     fUseFSALstepper = useFSALstepper;
     if( !useFSALstepper )
        fStepperType=   17;   // Use Dormand Prince (7) 4/5 as default stepper
     else
        fStepperType = 101;
  }
  else
  {
     fUseFSALstepper = ( stepperNum > 0 );
     if( stepperNum > 0 )
        fStepperType =   stepperNum;
     else
        fStepperType = - stepperNum;
  }
 
  InitialiseAll();
}

F01FieldSetup() [2/3]

F01FieldSetup::F01FieldSetup

(

)

Definition at line 115 of file F01FieldSetup.cc.

 : fMagneticField(new G4UniformMagField(G4ThreeVector())),
   fUseFSALstepper(false),
   fStepperType(17)   // Use Dormand Prince (7) 4/5 as default stepper
{
  G4cout << " F01FieldSetup: magnetic field set to Uniform( 0.0, 0, 0 ) "
         << G4endl;
  InitialiseAll();
}

F01FieldSetup() [3/3]

F01FieldSetup::F01FieldSetup ( F01FieldSetup &  )

delete

~F01FieldSetup()

F01FieldSetup::~F01FieldSetup ( )

virtual

Definition at line 206 of file F01FieldSetup.cc.

{
  delete fMagneticField;
  delete fChordFinder;
  delete fStepper;
  delete fFieldMessenger;
}

Member Function Documentation

SetStepperType()

void F01FieldSetup::SetStepperType ( G4int  i )

inline

Definition at line 69 of file F01FieldSetup.hh.

     { fStepperType = i; CreateStepperAndChordFinder(); }

SetStepper()

void F01FieldSetup::SetStepper

(

)

Definition at line 238 of file F01FieldSetup.cc.

{
// Set stepper according to the stepper type
 
  delete fStepper;
 
  switch ( fStepperType )
  {
     //  The new default in G4 and here ( since G4 10.4 Dec 2017 )
    case 17:
    case 457:
    case 745:
      fStepper = new G4DormandPrince745( fEquation );
      G4cout<<"G4DormandPrince745 Stepper is chosen"<<G4endl;
      break;
 
    case 0:
      fStepper = new G4ExplicitEuler( fEquation );
      G4cout<<"G4ExplicitEuler is chosen."<<G4endl;
      break;
    case 1:
      fStepper = new G4ImplicitEuler( fEquation );
      G4cout<<"G4ImplicitEuler is chosen"<<G4endl;
      break;
    case 2:
      fStepper = new G4SimpleRunge( fEquation );
      G4cout<<"G4SimpleRunge is chosen"<<G4endl;
      break;
    case 3:
      fStepper = new G4SimpleHeum( fEquation );
      G4cout<<"G4SimpleHeum is chosen"<<G4endl;
      break;
    case 4:
      fStepper = new G4ClassicalRK4( fEquation );
      G4cout<<"G4ClassicalRK4 (default) is chosen"<<G4endl;
      break;
    case 5:
      fStepper = new G4HelixExplicitEuler( fEquation );
      G4cout<<"G4HelixExplicitEuler is chosen"<<G4endl;
      break;
    case 6:
      fStepper = new G4HelixImplicitEuler( fEquation );
      G4cout<<"G4HelixImplicitEuler is chosen"<<G4endl;
      break;
    case 7:
      fStepper = new G4HelixSimpleRunge( fEquation );
      G4cout<<"G4HelixSimpleRunge is chosen"<<G4endl;
      break;
    case 8:
      fStepper = new G4CashKarpRKF45( fEquation );
      G4cout<<"G4CashKarpRKF45 is chosen"<<G4endl;
      break;
    case 9:
      fStepper = new G4RKG3_Stepper( fEquation );
      G4cout<<"G4RKG3_Stepper is chosen"<<G4endl;
      break;
    case 10:
       fStepper = new G4ExactHelixStepper( fEquation );
       G4cout<<"G4ExactHelixStepper is chosen"<<G4endl;
       break;
    case 11:
       fStepper = new G4HelixMixedStepper( fEquation );
       G4cout<<"G4HelixMixedStepper is chosen"<<G4endl;
       break;
    case 12:
       fStepper = new G4ConstRK4( fEquation );
       G4cout<<"G4ConstRK4 Stepper is chosen"<<G4endl;
       break;
    case 13:
    case 40:
      fStepper = new G4NystromRK4( fEquation );
      G4cout<<" G4NystromRK4 Stepper is chosen"<<G4endl;
      break;
    case 14:
    case 23:
      fStepper = new G4BogackiShampine23( fEquation );
      G4cout<<"G4BogackiShampine23 Stepper is chosen"<<G4endl;
      break;
 
      // Other optimised 4/5th order embedded steppers
    case 15:
    case 45:
      fStepper = new G4BogackiShampine45( fEquation );
      G4cout<<"G4BogackiShampine45 Stepper is chosen"<<G4endl;
      break;
 
    // case 145:
    case kTsitouras45:
      fStepper = new G4TsitourasRK45( fEquation );
      G4cout<<"G4TsitourasRK45 Stepper is chosen"<<G4endl;
      break;
 
      // Higher order embedded steppers - for very smooth fields
    case 56:
      fStepper = new G4DormandPrinceRK56( fEquation );
      G4cout<<"G4DormandPrinceRK56 Stepper is chosen"<<G4endl;
      break;
    case 78:
      fStepper = new G4DormandPrinceRK78( fEquation );
      G4cout<<"G4DormandPrinceRK78 Stepper is chosen"<<G4endl;
      break;
 
    default:
      // fStepper = new G4ClassicalRK4( fEquation );
      // G4cout<<"G4ClassicalRK4 Stepper (default) is chosen"<<G4endl;
      fStepper = new G4DormandPrince745( fEquation );
      G4cout<<"G4DormandPrince745 (default) Stepper is chosen"<<G4endl;
      break;
  }
}

SetMinStep()

void F01FieldSetup::SetMinStep ( G4double  s )

inline

Definition at line 74 of file F01FieldSetup.hh.

{ fMinStep = s; }

InitialiseAll()

void F01FieldSetup::InitialiseAll

(

)

Definition at line 127 of file F01FieldSetup.cc.

{
  fFieldMessenger = new F01FieldMessenger(this);
 
  fEquation = new G4Mag_UsualEqRhs(fMagneticField);
 
  fMinStep      = 3.0e-3*mm;
  // minimal step of 1 um is default ==> accept any error for smallersteps!
  fDeltaOneStep = 1.0e-5*mm;
  // Errors of this size in an integration sub-step are acceptable
  //   except limited by the relative integration error limits (epsilon_min/max)
  //  Notes: - their initial values are set in the header.
  //         - both this and the eps min/max can be changed using Set methods.
  fFieldManager = G4TransportationManager::GetTransportationManager()
                    ->GetFieldManager();
 
  if( fUseFSALstepper ) {
    CreateFSALStepperAndChordFinder();
  }
  else
  {
    CreateStepperAndChordFinder();
    // To try the symplectic method (Boris Scheme/Driver) replace the line above
    // with the one below:
    // CreateAndSetupBorisDriver();
  }
 
  G4cout  << "   4/5. Updating eps_min and eps_max in Field Manager."  << G4endl;
  fFieldManager->SetChordFinder( fChordFinder );
  fFieldManager->SetDetectorField(fMagneticField );
 
  // For controling the accurancy
  fFieldManager -> SetMinimumEpsilonStep( fDesiredEpsilonMin ) ;
  //
  // const G4double increaseFactor = 3.0 ;     // typical rangle  1.0 - 10.0
  //  maxEpsilon must not exceed a ceiling, ideally 0.001 -- above this integration is unreliable
  // const G4double maxEpsilon = increaseFactor * fDesiredEpsilonMin;
  // fFieldManager -> SetMaximumEpsilonStep( maxEpsilon );
 
  // For now, though, let's demonstrate how to extend the ceiling, if needed:
  if( fDesiredEpsilonMax < G4FieldManager::GetMaxAcceptedEpsilon()  )
  {
     G4cout << "F01FieldSetup: requesting Max(imum) Epsilon = " << fDesiredEpsilonMax << G4endl;
     fFieldManager -> SetMaximumEpsilonStep( fDesiredEpsilonMax );
  }
  else
  {
     G4bool softFail= true;
     G4bool good= G4FieldManager::SetMaxAcceptedEpsilon(fDesiredEpsilonMax, softFail);
 
     if( good ) {
        G4cout << "F01FieldSetup: requested increase Max(imum) Accepted Epsilon to "
               << fDesiredEpsilonMax << " succeeded." << G4endl;
        fFieldManager -> SetMaximumEpsilonStep( fDesiredEpsilonMax );
     } else {
        G4double maxEpsAllowed = G4FieldManager::GetMaxAcceptedEpsilon();
        fFieldManager -> SetMaximumEpsilonStep( maxEpsAllowed );
        G4cout << "F01FieldSetup: requested increase Max(imum) Accepted Epsilon to "
               << fDesiredEpsilonMax << " FAILED." << G4endl
               << "  Setting it to max allowed = " << maxEpsAllowed << G4endl;
     }
  }
  // To demonstrate that it is now possible to change the maximum accepted epsilon
 
  // Note: The values of both epsilon parameters must be between
  //    fMaxAcceptedEpsilon = 0.001
  //   to ensure robustness of integration (adequate accuracy of intermediate results)
  // and (much bigger than)
  //    fMinAcceptedEpsilon ~= 2.2e-13  ( 1000.0 * std::numeric_limits<G4double>::epsilon() )
  // which even the best integration methods would struggle greatly to achieve.
 
  G4cout << " Changed FieldManager epsilon values to  epsilon_min= "
         << fFieldManager -> GetMinimumEpsilonStep()
         <<  " and epsilon_max= "
         << fFieldManager -> GetMaximumEpsilonStep() << G4endl;
}

CreateStepperAndChordFinder()

void F01FieldSetup::CreateStepperAndChordFinder

(

)

Definition at line 216 of file F01FieldSetup.cc.

{
  delete fChordFinder;
  fChordFinder= nullptr;
 
  // Update field
  G4cout << " F01FieldSetup::CreateStepperAndChordFinder() called. " << G4endl
         << "   1. Creating Stepper."  << G4endl;
 
  SetStepper();
  G4cout<<"The minimal step is equal to "<<fMinStep/mm<<" mm"<<G4endl;
 
  G4cout << "   2. Creating ChordFinder."  << G4endl;
  fChordFinder = new G4ChordFinder( fMagneticField, fMinStep,fStepper );
 
  G4cout << "   3. Updating Field Manager (chord finder, field-ptr)."  << G4endl;
  fFieldManager->SetChordFinder( fChordFinder );
  fFieldManager->SetDetectorField(fMagneticField );
}

CreateFSALStepperAndChordFinder()

void F01FieldSetup::CreateFSALStepperAndChordFinder

(

)

Definition at line 428 of file F01FieldSetup.cc.

{
  // using FsalStepperType = G4DormandPrince745; // eventually ?
  delete fChordFinder;
  fChordFinder= nullptr;
 
  G4cout << " F01FieldSetup::CreateFSALStepperAndChordFinder() called. " << G4endl;
 
  auto FSALdriver= CreateFSALStepperAndDriver();
  fDriver = FSALdriver;
  G4cout<<"The minimal step is equal to "<<fMinStep/mm<<" mm"<<G4endl;
 
  G4cout << "    3. Creating ChordFinder."  << G4endl;
  fChordFinder = new G4ChordFinder( FSALdriver );  // ( fMagneticField, fMinStep, fStepper );
}

CreateAndSetupBorisDriver()

void F01FieldSetup::CreateAndSetupBorisDriver

(

)

Definition at line 505 of file F01FieldSetup.cc.

{
 
  G4cout << " F01FieldSetup::CreateAndSetupBorisDriver() called. " << G4endl;
  G4cout << "   1. Creating Scheme (Stepper)."  << G4endl;
  auto borisStepr = new G4BorisScheme(fEquation);
  G4cout << "   2. Creating Driver."  << G4endl;
  auto driver = new G4BorisDriver(fMinStep, borisStepr);
 
  GetGlobalFieldManager()->SetFieldChangesEnergy(true);  // To test energy conservation!!
 
  G4cout  << "  3. Creating ChordFinder."  << G4endl;
  fChordFinder = new G4ChordFinder( driver );
 
  G4cout  << "  4. Updating Field Manager (with ChordFinder, field)."  << G4endl;
  fFieldManager->SetChordFinder( fChordFinder );
  fFieldManager->SetDetectorField(fMagneticField );
}

SetUseFSALstepper()

void F01FieldSetup::SetUseFSALstepper ( G4bool  val = true )

inline

Definition at line 87 of file F01FieldSetup.hh.

{ fUseFSALstepper = val; }

GetUseFSALstepper()

G4bool F01FieldSetup::GetUseFSALstepper ( )

inline

Definition at line 88 of file F01FieldSetup.hh.

{ return fUseFSALstepper; }

GetEpsilonMin()

G4double F01FieldSetup::GetEpsilonMin ( )

inline

Definition at line 92 of file F01FieldSetup.hh.

{ return fDesiredEpsilonMin; }

GetEpsilonMax()

G4double F01FieldSetup::GetEpsilonMax ( )

inline

Definition at line 93 of file F01FieldSetup.hh.

{ return fDesiredEpsilonMax; }

SetEpsilonMin()

void F01FieldSetup::SetEpsilonMin ( G4double  val )

inline

Definition at line 95 of file F01FieldSetup.hh.

{ fDesiredEpsilonMin= val; }

SetEpsilonMax()

void F01FieldSetup::SetEpsilonMax ( G4double  val )

inline

Definition at line 96 of file F01FieldSetup.hh.

{ fDesiredEpsilonMax= val; }

SetDeltaOneStep()

void F01FieldSetup::SetDeltaOneStep ( G4double  val )

inline

Definition at line 98 of file F01FieldSetup.hh.

{ fDeltaOneStep= val; }

SetFieldValue()

void F01FieldSetup::SetFieldValue

(

G4ThreeVector

fieldVector

)

Definition at line 456 of file F01FieldSetup.cc.

{
  // Set the value of the Global Field
 
  delete fMagneticField;
 
#ifdef G4VERBOSE
     G4cout << "Setting Field strength to "
            << fieldVector / gauss  << " Gauss." << G4endl;
#endif
 
  if (fieldVector != G4ThreeVector(0.,0.,0.))
  {
    fMagneticField = new G4UniformMagField(fieldVector);
  }
  else
  {
#ifdef G4VERBOSE
     G4cout << " Magnetic field pointer is null." << G4endl;
#endif
    // If the new field's value is Zero, signal it as below
    // so that it is not used for propagation.
    fMagneticField = nullptr;
  }
 
  // Set this as the field of the global Field Manager
  GetGlobalFieldManager()->SetDetectorField(fMagneticField);
 
  // Now notify equation of new field
  fEquation->SetFieldObj( fMagneticField );
 
}

SetFieldZValue()

void F01FieldSetup::SetFieldZValue

(

G4double

fieldValue

)

Definition at line 447 of file F01FieldSetup.cc.

{
  // Set the value of the Global Field to fieldValue along Z
 
  SetFieldValue(G4ThreeVector(0, 0, fieldStrength));
}

GetConstantFieldValue()

G4ThreeVector F01FieldSetup::GetConstantFieldValue

(

)

CreateFSALStepperAndDriver()

G4VIntegrationDriver * F01FieldSetup::CreateFSALStepperAndDriver ( )

protected

Definition at line 358 of file F01FieldSetup.cc.

{
   // using FsalStepperType = G4RK547FEq1;
  const char *methodName= "F01FieldSetup::CreateFSALStepperAndDriver()";
  delete fStepper;
  fStepper = nullptr;
 
  G4cout << " F01FieldSetup::CreateFSALStepperAndDriver() called. " << G4endl;
  G4cout << "   1. Creating Stepper."  << G4endl;
  // auto fsalStepper = new FsalStepperType( fEquation );
  G4RK547FEq1* stepper1 = nullptr;
  G4RK547FEq2* stepper2 = nullptr;
  G4RK547FEq3* stepper3 = nullptr;
 
  G4cout << "   2. Creating FSAL Driver."  << G4endl;
  G4VIntegrationDriver* fsalDriver = nullptr;
  switch ( fStepperType )
  {
    case   1:
    case 101:
       stepper1 = new G4RK547FEq1( fEquation );
       fsalDriver = new G4FSALIntegrationDriver<G4RK547FEq1>( fMinStep, stepper1 );
       G4cout  << " Stepper type '1' is G4RK547FEq1 stepper (in FSAL mode) with FSAL driver. "
               << G4endl;
       fStepper = stepper1;
       stepper1 = nullptr;
       break;
 
    case   2:
    case 102:
       stepper2= new G4RK547FEq2( fEquation );
       fsalDriver = new G4FSALIntegrationDriver<G4RK547FEq2>( fMinStep, stepper2 );
       G4cout  << " Stepper type '2' is G4RK547FEq2 stepper (in FSAL mode) with FSAL driver. "
               << G4endl;
       fStepper = stepper2;
       stepper2 = nullptr;
       break;
 
    case   3:
    case 103:
       stepper3 = new G4RK547FEq3( fEquation );
       fsalDriver = new G4FSALIntegrationDriver<G4RK547FEq3>( fMinStep, stepper3 );
       G4cout  << " Stepper type '3' is G4RK547FEq3 stepper (in FSAL mode) with FSAL driver. "
               << G4endl;
       fStepper = stepper3;
       stepper3 = nullptr;
       break;
 
    default:
       G4cout << " Warning from " << methodName << " :  stepperType (= "
              << fStepperType << " ) is unknown. " << G4endl
              << " Using value '1' instead - i.e. G4RK547FEq1 stepper. "
              << G4endl;
       stepper1 = new G4RK547FEq1( fEquation );
       fsalDriver = new G4FSALIntegrationDriver<G4RK547FEq1>( fMinStep, stepper1 );
       fStepper = stepper1;
       stepper1 = nullptr;
       break;
  }
 
  delete stepper1;    stepper1 = nullptr;
  delete stepper2;    stepper2 = nullptr;
  delete stepper3;    stepper3 = nullptr;
 
  if( fsalDriver )
     fStepper = fsalDriver->GetStepper();
 
  return fsalDriver;
}

GetGlobalFieldManager()

G4FieldManager * F01FieldSetup::GetGlobalFieldManager ( )

protected

Definition at line 491 of file F01FieldSetup.cc.

{
  //  Utility method
 
  return G4TransportationManager::GetTransportationManager()
           ->GetFieldManager();
}

Member Data Documentation

fFieldManager

G4FieldManager* F01FieldSetup::fFieldManager = nullptr

protected

Definition at line 115 of file F01FieldSetup.hh.

fChordFinder

G4ChordFinder* F01FieldSetup::fChordFinder = nullptr

protected

Definition at line 116 of file F01FieldSetup.hh.

fEquation

G4Mag_UsualEqRhs* F01FieldSetup::fEquation = nullptr

protected

Definition at line 117 of file F01FieldSetup.hh.

fMagneticField

G4MagneticField* F01FieldSetup::fMagneticField = nullptr

protected

Definition at line 118 of file F01FieldSetup.hh.

fStepper

G4MagIntegratorStepper* F01FieldSetup::fStepper = nullptr

protected

Definition at line 120 of file F01FieldSetup.hh.

fUseFSALstepper

G4bool F01FieldSetup::fUseFSALstepper = false

protected

Definition at line 121 of file F01FieldSetup.hh.

fDriver

G4VIntegrationDriver* F01FieldSetup::fDriver = nullptr

protected

Definition at line 122 of file F01FieldSetup.hh.

fStepperType

G4int F01FieldSetup::fStepperType = -1

protected

Definition at line 123 of file F01FieldSetup.hh.

fFieldMessenger

F01FieldMessenger* F01FieldSetup::fFieldMessenger = nullptr

protected

Definition at line 124 of file F01FieldSetup.hh.

fMinStep

G4double F01FieldSetup::fMinStep = -1.0

protected

Definition at line 127 of file F01FieldSetup.hh.

fDeltaOneStep

G4double F01FieldSetup::fDeltaOneStep = -1.0

protected

Definition at line 128 of file F01FieldSetup.hh.

fDesiredEpsilonMin

G4double F01FieldSetup::fDesiredEpsilonMin = 1.0e-05

protected

Definition at line 129 of file F01FieldSetup.hh.

fDesiredEpsilonMax

G4double F01FieldSetup::fDesiredEpsilonMax = 0.005

protected

Definition at line 130 of file F01FieldSetup.hh.

---

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

• .doxygen/Doxymodules_field.h
• extended/field/field01/include/F01FieldSetup.hh
• extended/field/field01/src/F01FieldSetup.cc