EIC code displayed by LXR master/​include/​Geant4/​G4FieldManager.hh	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

Warning, file /include/Geant4/G4FieldManager.hh was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 //
 // ********************************************************************
 // * License and Disclaimer                                           *
 // *                                                                  *
 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
 // * conditions of the Geant4 Software License,  included in the file *
 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
 // * include a list of copyright holders.                             *
 // *                                                                  *
 // * Neither the authors of this software system, nor their employing *
 // * institutes,nor the agencies providing financial support for this *
 // * work  make  any representation or  warranty, express or implied, *
 // * regarding  this  software system or assume any liability for its *
 // * use.  Please see the license in the file  LICENSE  and URL above *
 // * for the full disclaimer and the limitation of liability.         *
 // *                                                                  *
 // * This  code  implementation is the result of  the  scientific and *
 // * technical work of the GEANT4 collaboration.                      *
 // * By using,  copying,  modifying or  distributing the software (or *
 // * any work based  on the software)  you  agree  to acknowledge its *
 // * use  in  resulting  scientific  publications,  and indicate your *
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
 // G4FieldManager
 //
 // Class description:
 //
 // A class to manage (Store) a pointer to the Field subclass that
 // describes the field of a detector (magnetic, electric or other).
 // Also stores a reference to the chord finder.
 //
 // The G4FieldManager class exists to allow the user program to specify 
 // the electric, magnetic and/or other field(s) of the detector.
 // 
 // 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.  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, ...
 //
 // It also stores a pointer to the ChordFinder object that can do the
 // propagation in this field. All geometrical track "advancement" 
 // in the field is handled by this ChordFinder object.
 //
 // G4FieldManager allows the other classes/object (of the MagneticField 
 // & other class categories) to find out whether a detector field object 
 // exists and what that object is.
 //
 // 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.
 //
 // A default FieldManager is created by the singleton class
 // G4NavigatorForTracking and exists before main is called.
 // However a new one can be created and given to G4NavigatorForTracking.
 //
 // Our current design envisions that one Field manager is 
 // valid for each region detector.
 //
 // 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.
 
 // Author: John Apostolakis (CERN), 10.03.1997 - Design and implementation
 // -------------------------------------------------------------------
 #ifndef G4FIELDMANAGER_HH
 #define G4FIELDMANAGER_HH
 
 #include "G4FieldParameters.hh"
 #include "globals.hh"
 
 class G4Field;
 class G4MagneticField;
 class G4ChordFinder;
 class G4Track;  // Forward reference for parameter configuration
 
 /**
  * @brief 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.
  */
 
 class G4FieldManager
 {
   public:
 
     /**
      * General Constructor for any field. Must be set with field and chord finder
      * for use.
      *  @param[in] detectorField Pointer to the field.
      *  @param[in] pChordFinder Pointer to the chord finder object.
      *  @param[in] b Flag to indicate if the field changes the energy; it is
      *             taken from the provided field, if specified.
      */
     G4FieldManager(G4Field* detectorField = nullptr, 
                    G4ChordFinder* pChordFinder = nullptr, 
                    G4bool b = true ); // fieldChangesEnergy is taken from field
 
     /**
      * Constructor creating the chord finder. It assumes pure magnetic field,
      * so energy constant.
      *  @param[in] detectorMagneticField Pointer to the magnetic field.
      */
     G4FieldManager(G4MagneticField* detectorMagneticField);
 
     /**
      * Virtual Destructor.
      */
     virtual ~G4FieldManager();
 
     /**
      * Copy constructor and assignment operator not allowed.
      */
     G4FieldManager(const G4FieldManager&) = delete;
     G4FieldManager& operator=(const G4FieldManager&) = delete;
 
     /**
      * 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.
      *  @param[in] detectorField Pointer to the field.
      *  @param[in] failMode Flag (0/1/2) for selected failure mode.
      *  @returns Success (true) or failure (false).
      */
     G4bool SetDetectorField(G4Field* detectorField, G4int failMode = 0);
 
     /**
      * 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.
      *  @param[in] detectorField Pointer to the field.
      */
     inline void ProposeDetectorField(G4Field* detectorField);
 
     /**
      * 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.
      *  @param[in] detectorField Pointer to the field.
      */
     inline void ChangeDetectorField(G4Field* detectorField);    
         
     /**
      * Methods to get and check (existance of) the field object.
      */
     inline const G4Field* GetDetectorField() const;
     inline G4bool DoesFieldExist() const;
 
     /**
      * Methods to create, set or get the associated Chord Finder.
      */
     void CreateChordFinder(G4MagneticField* detectorMagField);
     inline void SetChordFinder(G4ChordFinder* aChordFinder);
     inline G4ChordFinder* GetChordFinder();
     inline const G4ChordFinder* GetChordFinder() const;
 
     /**
      * 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.
      *  @param[in] pTrack Pointer to a track.
      */
     virtual void ConfigureForTrack( const G4Track* pTrack );
 
     /**
      * Static methods to set/get the global field.
      */
     static void SetGlobalFieldManager(G4FieldManager* fieldManager);
     static G4FieldManager* GetGlobalFieldManager();
 
     /**
      * Returns the accuracy for boundary intersection.
      */
     inline G4double GetDeltaIntersection() const;
 
     /**
      * Returns the accuracy for one tracking/physics step.
      */
     inline G4double GetDeltaOneStep() const;
 
     /**
      * Sets both accuracies, maintaining a fixed ratio for accuracies 
      * of volume Intersection and Integration (in One Step).
      */
     inline void SetAccuraciesWithDeltaOneStep(G4double valDeltaOneStep); 
 
     /**
      * Sets the accuracy for integration of one step (only).
      */
     inline void SetDeltaOneStep(G4double valueD1step); 
 
     /**
      * Sets the accuracy of intersection of a volume (only).
      */
     inline void     SetDeltaIntersection(G4double valueDintersection); 
 
     /**
      * Methods to set/get the minimum for Relative accuracy of a Step.
      */
     inline G4double GetMinimumEpsilonStep() const;
     G4bool SetMinimumEpsilonStep( G4double newEpsMin );
 
     /**
      * Methods to set/get the maximum for Relative accuracy of a Step.
      */
     inline G4double GetMaximumEpsilonStep() const;
     G4bool SetMaximumEpsilonStep( G4double newEpsMax );
  
     /**
      * Methods to set/get flag for field changing energy.
      * For electric field this should be true; for magnetic field this
      * should be false.
      */
     inline G4bool DoesFieldChangeEnergy() const;
     inline void SetFieldChangesEnergy(G4bool value);
     
     /**
      * Needed for multi-threading, create and returns an allocated clone
      * of this object.
      */
     virtual G4FieldManager* Clone() const;
 
     /**
      * Static methods to set/get the maximum accepted epsilon.
      * If setting fails, with softFail=true it gives Warning, else
      * a FatalException.
      */
     static G4double GetMaxAcceptedEpsilon();
     static G4bool SetMaxAcceptedEpsilon(G4double maxEps, G4bool softFail= false);
    
   protected:
 
     /**
      * Logger for reporting on correctness of the proposed epsilon value.
      */
     void ReportBadEpsilonValue(G4ExceptionDescription& erm, G4double value,
                                const G4String& name) const;
 
     /** Epsilon_min/max values must be smaller than this for robust integration. */
     static G4double fMaxAcceptedEpsilon;
     static constexpr G4double fMinAcceptedEpsilon = 1000.0 * std::numeric_limits<G4double>::epsilon();
 
     /** Setting larger value will give warning. */
     static constexpr G4double fMaxWarningEpsilon = 0.001;
 
     /** Will not accept larger values. */
     static constexpr G4double fMaxFinalEpsilon = 0.02;
    
     /** Controls verbosity of constructors. */
     static G4bool fVerboseConstruction;
   
   private:
 
     /**
      * Checks whether the field/equation changes the energy and sets the data
      * member accordingly. Does not handle special cases - this must be done
      * separately (e.g. magnetic monopole in B field).
      */
     void InitialiseFieldChangesEnergy();
   
   private:
 
     /** Dependent objects -- with state that depends on tracking. */
     G4Field* fDetectorField = nullptr;
     G4ChordFinder* fChordFinder = nullptr;
 
     /** Flag to indicate if "new" was used to create the Chord Finder. */
     G4bool fAllocatedChordFinder = false; // 
 
     //  1. CHARACTERISTIC of field
 
     G4bool fFieldChangesEnergy = false;
 
     //  2. PARAMETERS that determine the accuracy of integration or intersection
 
     /** Value for the required accuracies for one tracking/physics step. */
     G4double fDelta_One_Step_Value = G4FieldDefaults::kDeltaOneStep;
 
     /** Value for the required accuracies for boundary intersection. */
     G4double fDelta_Intersection_Val = G4FieldDefaults::kDeltaIntersection;
 
     /** Values for the small possible relative accuracy of a step
         (corresponding to the greatest possible integration accuracy). */
     G4double fEpsilonMin = G4FieldDefaults::kMinimumEpsilonStep;
     G4double fEpsilonMax = G4FieldDefaults::kMaximumEpsilonStep;
 
     /** Global field manager set by G4TransportationManager to allow accessing
         the global field without dependency on navigation. */
     static G4ThreadLocal G4FieldManager* fGlobalFieldManager;
 };
 
 // Implementation of inline functions
 
 #include "G4FieldManager.icc"
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team