Gabriele Cosmo
215 lines
8.6 KiB
C++
215 lines
8.6 KiB
C++
//
|
|
// ********************************************************************
|
|
// * 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. *
|
|
// ********************************************************************
|
|
//
|
|
// G4ChordFinder
|
|
//
|
|
// Class description:
|
|
//
|
|
// A class that provides RK integration of motion ODE (as does g4magtr)
|
|
// and also has a method that returns an Approximate point on the curve
|
|
// near to a (chord) point.
|
|
|
|
// Author: John Apostolakis (CERN), 25.02.1997 - Design and implementation
|
|
// -------------------------------------------------------------------
|
|
#ifndef G4CHORDFINDER_HH
|
|
#define G4CHORDFINDER_HH
|
|
|
|
#include "G4VIntegrationDriver.hh"
|
|
#include "G4FieldParameters.hh"
|
|
#include "G4MagIntegratorStepper.hh"
|
|
|
|
#include <memory>
|
|
|
|
class G4VFSALIntegrationStepper;
|
|
|
|
class G4MagneticField;
|
|
class G4CachedMagneticField;
|
|
class G4HelixHeum;
|
|
class G4QSStepper;
|
|
|
|
/**
|
|
* @brief G4ChordFinder is a class that provides Runge-Kutta integration of
|
|
* motion ODE and also has a method that returns an approximate point on the
|
|
* curve near to a (chord) point.
|
|
*/
|
|
|
|
class G4ChordFinder
|
|
{
|
|
public:
|
|
|
|
enum kIntegrationType {kDefaultDriverType=0, kFSALStepperType=1,
|
|
kTemplatedStepperType, kRegularStepperType,
|
|
kBfieldDriverType, kQss2DriverType, kQss3DriverType};
|
|
|
|
/**
|
|
* The most flexible constructor, which allows the user to specify
|
|
* any type of field, equation, stepper and integration driver.
|
|
* @param[in] pIntegrationDriver Pointer to the integrator driver to use.
|
|
*/
|
|
explicit G4ChordFinder( G4VIntegrationDriver* pIntegrationDriver );
|
|
|
|
/**
|
|
* Constructor that creates defaults for all "children" classes.
|
|
* The type of equation of motion is fixed.
|
|
* A default type of stepper (Dormand Prince since release 10.4) is used,
|
|
* and the corresponding integration driver.
|
|
* @param[in] itsMagField Pointer to the magnetic field.
|
|
* @param[in] stepMinimum Pointer to the magnetic field.
|
|
* @param[in] pItsStepper Optional pointer to the stepper algorithm.
|
|
* @param[in] stepperDriverChoice Type of stepper driver.
|
|
*/
|
|
G4ChordFinder( G4MagneticField* itsMagField,
|
|
G4double stepMinimum = G4FieldDefaults::kMinimumStep,
|
|
G4MagIntegratorStepper* pItsStepper = nullptr,
|
|
G4int stepperDriverChoice = kTemplatedStepperType );
|
|
|
|
/**
|
|
* Destructor.
|
|
*/
|
|
~G4ChordFinder();
|
|
|
|
/**
|
|
* Copy constructor and assignment operator not allowed.
|
|
*/
|
|
G4ChordFinder(const G4ChordFinder&) = delete;
|
|
G4ChordFinder& operator=(const G4ChordFinder&) = delete;
|
|
|
|
/**
|
|
* Computes the step to take, based on chord limits.
|
|
* Uses ODE solver's driver to find the endpoint that satisfies
|
|
* the chord criterion that: d_chord < delta_chord.
|
|
* @param[in,out] yCurrent The current track in field.
|
|
* @param[in] stepInitial Proposed initial step length.
|
|
* @param[in] epsStep_Relative Requested accuracy.
|
|
* @param[in] latestSafetyOrigin Last safety origin point. Unused.
|
|
* @param[in] lasestSafetyRadius Last safety distance. Unused.
|
|
* @returns The length of step taken.
|
|
*/
|
|
inline G4double AdvanceChordLimited( G4FieldTrack& yCurrent,
|
|
G4double stepInitial,
|
|
G4double epsStep_Relative,
|
|
const G4ThreeVector& latestSafetyOrigin,
|
|
G4double lasestSafetyRadius );
|
|
|
|
/**
|
|
* Uses the Brent algorithm when possible, to determine the closest point
|
|
* on the curve. Given a starting curve point A (CurveA_PointVelocity),
|
|
* curve point B (CurveB_PointVelocity), a point E which is (generally)
|
|
* not on the curve and a point F which is on the curve (first
|
|
* approximation), find new point S on the curve closer to point E.
|
|
* While advancing towards S utilise 'eps_step' as a measure of the
|
|
* relative accuracy of each Step.
|
|
* @returns The end point on the curve closer to the given point E.
|
|
*/
|
|
G4FieldTrack ApproxCurvePointS( const G4FieldTrack& curveAPointVelocity,
|
|
const G4FieldTrack& curveBPointVelocity,
|
|
const G4FieldTrack& ApproxCurveV,
|
|
const G4ThreeVector& currentEPoint,
|
|
const G4ThreeVector& currentFPoint,
|
|
const G4ThreeVector& PointG,
|
|
G4bool first, G4double epsStep );
|
|
|
|
/**
|
|
* If r=|AE|/|AB|, and s=true path lenght (AB)
|
|
* returns the point that is r*s along the curve.
|
|
*/
|
|
G4FieldTrack ApproxCurvePointV( const G4FieldTrack& curveAPointVelocity,
|
|
const G4FieldTrack& curveBPointVelocity,
|
|
const G4ThreeVector& currentEPoint,
|
|
G4double epsStep);
|
|
|
|
/**
|
|
* Calculates the inverse parabolic through the three points (x,y) and
|
|
* returns the value x that, for the inverse parabolic, corresponds to y=0.
|
|
*/
|
|
inline G4double InvParabolic( const G4double xa, const G4double ya,
|
|
const G4double xb, const G4double yb,
|
|
const G4double xc, const G4double yc );
|
|
|
|
/**
|
|
* Accessors and modifiers.
|
|
*/
|
|
inline G4double GetDeltaChord() const;
|
|
inline void SetDeltaChord(G4double newval);
|
|
inline void SetIntegrationDriver(G4VIntegrationDriver* IntegrationDriver);
|
|
inline G4VIntegrationDriver* GetIntegrationDriver();
|
|
|
|
/**
|
|
* Clears the internal state (last step estimate).
|
|
*/
|
|
inline void ResetStepEstimate();
|
|
|
|
/**
|
|
* Sets the verbosity.
|
|
* @returns The old verbosity value.
|
|
*/
|
|
inline G4int SetVerbose( G4int newvalue=1 );
|
|
|
|
/**
|
|
* Dispatch interface method for computing step.
|
|
*/
|
|
inline void OnComputeStep(const G4FieldTrack* track);
|
|
|
|
/**
|
|
* Writes out to stream the parameters/state of the driver.
|
|
*/
|
|
friend std::ostream& operator<<( std::ostream& os, const G4ChordFinder& cf);
|
|
|
|
/**
|
|
* Sets verbosity for constructor.
|
|
*/
|
|
static void SetVerboseConstruction(G4bool v = true);
|
|
|
|
private: // ............................................................
|
|
|
|
static G4bool gVerboseCtor; // Verbosity for contructor
|
|
|
|
// Constants
|
|
// ---------------------
|
|
const G4double fDefaultDeltaChord = G4FieldDefaults::kDeltaChord;
|
|
|
|
// PARAMETERS
|
|
// ---------------------
|
|
G4double fDeltaChord; // Maximum miss distance
|
|
|
|
G4int fStatsVerbose = 0; // if > 0, print Statistics in destructor
|
|
|
|
// DEPENDENT Objects
|
|
// ---------------------
|
|
G4VIntegrationDriver* fIntgrDriver = nullptr;
|
|
G4MagIntegratorStepper* fRegularStepperOwned = nullptr;
|
|
G4MagIntegratorStepper* fNewFSALStepperOwned = nullptr;
|
|
std::unique_ptr<G4HelixHeum> fLongStepper;
|
|
G4CachedMagneticField* fCachedField = nullptr;
|
|
G4QSStepper* fQssStepperOwned = nullptr;
|
|
G4EquationOfMotion* fEquation = nullptr;
|
|
};
|
|
|
|
// Inline function implementation:
|
|
|
|
#include "G4ChordFinder.icc"
|
|
|
|
#endif
|