TG4FieldParameters.h

Go to the documentation of this file.

#ifndef TG4_FIELD_PARAMETERS_H
#define TG4_FIELD_PARAMETERS_H
 
//-------------------------------------------------
// The Geant4 Virtual Monte Carlo package
// Copyright (C) 2007 - 2014 Ivana Hrivnacova
// All rights reserved.
//
// For the licensing terms see geant4_vmc/LICENSE.
// Contact: root-vmc@cern.ch
//-------------------------------------------------
 
 
#include <G4MagneticField.hh>
#include <globals.hh>
 
class TG4FieldParametersMessenger;
 
class G4EquationOfMotion;
class G4MagIntegratorStepper;
 
enum FieldType
{
  kMagnetic,        
  kElectroMagnetic, 
  kGravity          
};
 
enum EquationType
{
  kMagUsualEqRhs, 
  kMagSpinEqRhs,  
  kEqMagElectric, 
  kEqEMFieldWithSpin, 
  kEqEMFieldWithEDM,  
  kUserEquation       
};
 
enum StepperType
{
  // steppers with equation of motion of generic type (G4EquationOfMotion)
  kCashKarpRKF45,     
  kClassicalRK4,      
  kBogackiShampine23, 
  kBogackiShampine45, 
  kDormandPrince745,  
  kDormandPrinceRK56, 
  kDormandPrinceRK78, 
  kExplicitEuler,     
  kImplicitEuler,     
  kSimpleHeum,        
  kSimpleRunge,       
  kTsitourasRK45,     
 
  // steppers with equation of motion of G4Mag_UsualEqRhs type
  kConstRK4,           
  kExactHelixStepper,  
  kHelixExplicitEuler, 
  kHelixHeum,          
  kHelixImplicitEuler, 
  kHelixMixedStepper,  
  kHelixSimpleRunge,   
  kNystromRK4,         
  kRKG3Stepper,        
  kUserStepper,        
 
  // FSAL steppers
  kRK547FEq1, 
  kRK547FEq2, 
  kRK547FEq3  
};
 
 
class TG4FieldParameters
{
 public:
  TG4FieldParameters(const G4String& volumeName = "");
  ~TG4FieldParameters();
 
  // methods
  void PrintParameters() const;
 
  static G4String FieldTypeName(FieldType field);
  static G4String EquationTypeName(EquationType equation);
  static G4String StepperTypeName(StepperType stepper);
  static FieldType GetFieldType(const G4String& name);
  static EquationType GetEquationType(const G4String& name);
  static StepperType GetStepperType(const G4String& name);
 
  // set methods
  void SetFieldType(FieldType field);
  void SetEquationType(EquationType equation);
  void SetStepperType(StepperType stepper);
  void SetUserEquationOfMotion(G4EquationOfMotion* equation);
  void SetUserStepper(G4MagIntegratorStepper* stepper);
 
  void SetStepMinimum(G4double value);
  void SetDeltaChord(G4double value);
  void SetDeltaOneStep(G4double value);
  void SetDeltaIntersection(G4double value);
  void SetMinimumEpsilonStep(G4double value);
  void SetMaximumEpsilonStep(G4double value);
  void SetConstDistance(G4double value);
  void SetIsMonopole(G4bool isMonopole);
 
  // get methods
  G4String GetVolumeName() const;
 
  FieldType GetFieldType() const;
  EquationType GetEquationType() const;
  StepperType GetStepperType() const;
  G4EquationOfMotion* GetUserEquationOfMotion() const;
  G4MagIntegratorStepper* GetUserStepper() const;
 
  G4double GetStepMinimum() const;
  G4double GetDeltaChord() const;
  G4double GetDeltaOneStep() const;
  G4double GetDeltaIntersection() const;
  G4double GetMinimumEpsilonStep() const;
  G4double GetMaximumEpsilonStep() const;
  G4double GetConstDistance() const;
  G4bool GetIsMonopole() const;
 
 private:
  // static data members
  //
  static const G4double fgkDefaultStepMinimum;
  static const G4double fgkDefaultDeltaChord;
  static const G4double fgkDefaultDeltaOneStep;
  static const G4double fgkDefaultDeltaIntersection;
  static const G4double fgkDefaultMinimumEpsilonStep;
  static const G4double fgkDefaultMaximumEpsilonStep;
  static const G4double fgkDefaultConstDistance;
 
  // data members
  //
  TG4FieldParametersMessenger* fMessenger;
 
  G4String fVolumeName;
 
  G4double fStepMinimum;
  G4double fDeltaChord;
  G4double fDeltaOneStep;
  G4double fDeltaIntersection;
  G4double fMinimumEpsilonStep;
  G4double fMaximumEpsilonStep;
 
  FieldType fField;
 
  EquationType fEquation;
 
  StepperType fStepper;
 
  G4EquationOfMotion* fUserEquation;
 
  G4MagIntegratorStepper* fUserStepper;
 
  G4double fConstDistance;
 
  G4bool fIsMonopole;
};
 
// inline functions
 
inline void TG4FieldParameters::SetFieldType(FieldType field)
{
  fField = field;
}
 
inline void TG4FieldParameters::SetEquationType(EquationType equation)
{
  fEquation = equation;
}
 
inline void TG4FieldParameters::SetStepperType(StepperType stepper)
{
  fStepper = stepper;
}
 
inline void TG4FieldParameters::SetStepMinimum(G4double value)
{
  fStepMinimum = value;
}
 
inline void TG4FieldParameters::SetDeltaChord(G4double value)
{
  fDeltaChord = value;
}
 
inline void TG4FieldParameters::SetDeltaOneStep(G4double value)
{
  fDeltaOneStep = value;
}
 
inline void TG4FieldParameters::SetDeltaIntersection(G4double value)
{
  fDeltaIntersection = value;
}
 
inline void TG4FieldParameters::SetMinimumEpsilonStep(G4double value)
{
  fMinimumEpsilonStep = value;
}
 
inline void TG4FieldParameters::SetMaximumEpsilonStep(G4double value)
{
  fMaximumEpsilonStep = value;
}
 
inline void TG4FieldParameters::SetConstDistance(G4double value)
{
  fConstDistance = value;
}
 
inline void TG4FieldParameters::SetIsMonopole(G4bool isMonopole)
{
  fIsMonopole = isMonopole;
}
 
inline G4String TG4FieldParameters::GetVolumeName() const
{
  return fVolumeName;
}
 
inline FieldType TG4FieldParameters::GetFieldType() const { return fField; }
 
inline EquationType TG4FieldParameters::GetEquationType() const
{
  return fEquation;
}
 
inline StepperType TG4FieldParameters::GetStepperType() const
{
  return fStepper;
}
 
inline G4EquationOfMotion* TG4FieldParameters::GetUserEquationOfMotion() const
{
  return fUserEquation;
}
 
inline G4MagIntegratorStepper* TG4FieldParameters::GetUserStepper() const
{
  return fUserStepper;
}
 
inline G4double TG4FieldParameters::GetStepMinimum() const
{
  return fStepMinimum;
}
 
inline G4double TG4FieldParameters::GetDeltaChord() const
{
  return fDeltaChord;
}
 
inline G4double TG4FieldParameters::GetDeltaOneStep() const
{
  return fDeltaOneStep;
}
 
inline G4double TG4FieldParameters::GetDeltaIntersection() const
{
  return fDeltaIntersection;
}
 
inline G4double TG4FieldParameters::GetMinimumEpsilonStep() const
{
  return fMinimumEpsilonStep;
}
 
inline G4double TG4FieldParameters::GetMaximumEpsilonStep() const
{
  return fMaximumEpsilonStep;
}
 
inline G4double TG4FieldParameters::GetConstDistance() const
{
  return fConstDistance;
}
 
inline G4bool TG4FieldParameters::GetIsMonopole() const { return fIsMonopole; }
 
#endif // TG4_FIELD_PARAMETERS_H