lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 8.3.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 15:07:44 +02:00
parent fe73f43734
commit 75c7fd177d
764 changed files with 45230 additions and 95238 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/magneticfield/History
+21 -6
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.113 2006/11/13 18:23:55 gcosmo Exp $
$Id: History,v 1.117 2007/05/10 10:11:08 japost Exp $
-------------------------------------------------------------------
=========================================================
@@ -16,6 +16,26 @@ committal in the CVS repository !
----------------------------------------------------------
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
May 10th, 2007 J.Apostolakis - field-V08-02-01
-------------------------------
- G4MagIntegratorDriver:
* added protections against zero initial or internal step h=0, (exceptions)
* revised (re)calculation of h, and quit loop if h/length < smallest-fraction (~ 10^-12)
April 26th, 2007 T.Nikitina - field-V08-02-00
----------------------------
- Corrected integration constants in G4MagHelicalStepper
- Added implementation of G4RKG3_Stepper, stepper derived from Geant3.
- Updated NTST unit test. New unit test "field06" for comparison of steppers.
November 14th, 2006 J.Apostolakis - field-V08-01-02
----------------------------------
- G4MagIntegratorDriver
* Made first argument of GetDerivatives a reference - avoid copy
- G4MagIntegratorStepper
* Include the SetEquationOfMotion() method in G4MagIntegratorStepper
(for Geant4e, as in field-V08-01-00)
* Update of disclaimers.
November 13th, 2006 G.Cosmo - field-V08-01-01
----------------------------
@@ -43,11 +63,6 @@ June 21st, 2006 J.Apostolakis - field-V08-00-06
--- The field-V08-00-0x , x > 6, tags do not include the change below
June 21st, 2006 J.Apostolakis - field-V08-01-00
-----------------------------
- G4MagIntegratorStepper
Added SetEquationOfMotion method - needed for Geant4e
May 27th, 2006 J.Apostolakis - field-V08-00-05
-----------------------------
- G4FieldTrack: Fix for simple compilation error on Sun.
source/geometry/magneticfield/include/G4MagIntegratorDriver.hh
+11 -4
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MagIntegratorDriver.hh,v 1.17 2006/06/29 18:22:58 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4MagIntegratorDriver.hh,v 1.20 2007/05/10 10:10:05 japost Exp $
// GEANT4 tag $Name: geant4-08-03 $
//
//
// class G4MagInt_Driver
@@ -91,7 +91,7 @@ class G4MagInt_Driver
inline G4double GetPshrnk() const;
inline G4double GetPgrow() const;
inline G4double GetErrcon() const;
inline void GetDerivatives( const G4FieldTrack y_curr, // const, INput
inline void GetDerivatives( const G4FieldTrack &y_curr, // const, INput
G4double dydx[] ); // OUTput
// Accessors.
@@ -158,6 +158,9 @@ class G4MagInt_Driver
inline void SetVerboseLevel(G4int newLevel);
inline G4double GetVerboseLevel() const;
inline G4double GetSmallestFraction() const;
void SetSmallestFraction( G4double val );
protected: // without description
void WarnSmallStepSize( G4double hnext, G4double hstep,
G4double h, G4double xDone,
@@ -208,7 +211,11 @@ class G4MagInt_Driver
private:
G4double fMinimumStep;
// Minimum Step allowed in a Step.
// Minimum Step allowed in a Step (in absolute units)
G4double fSmallestFraction; // Expected range 1e-12 to 5e-15;
// Smallest fraction of (existing) curve length - in relative units
// below this fraction the current step will be the last
const G4int fNoIntegrationVariables; // Number of Variables in integration
const G4int fMinNoVars; // Minimum number for FieldTrack
source/geometry/magneticfield/include/G4MagIntegratorDriver.icc
+9 -3
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MagIntegratorDriver.icc,v 1.11 2006/06/29 18:23:00 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4MagIntegratorDriver.icc,v 1.13 2007/05/10 10:10:48 japost Exp $
// GEANT4 tag $Name: geant4-08-03 $
//
// --------------------------------------------------------------------
@@ -142,7 +142,7 @@ void G4MagInt_Driver::SetMaxNoSteps(G4int val)
}
inline
void G4MagInt_Driver::GetDerivatives(const G4FieldTrack y_curr, // const, INput
void G4MagInt_Driver::GetDerivatives(const G4FieldTrack &y_curr, // const, INput
G4double dydx[]) // OUTput
{
G4double tmpValArr[G4FieldTrack::ncompSVEC];
@@ -161,3 +161,9 @@ void G4MagInt_Driver::SetVerboseLevel(G4int newLevel)
{
fVerboseLevel= newLevel;
}
inline
G4double G4MagInt_Driver::GetSmallestFraction() const
{
return fSmallestFraction;
}
source/geometry/magneticfield/include/G4MagIntegratorStepper.hh
+3 -14
View File
@@ -23,9 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4MagIntegratorStepper.hh,v 1.10.2.1 2006/06/29 18:23:03 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4MagIntegratorStepper.hh,v 1.12 2006/09/20 09:31:01 japost Exp $
// GEANT4 tag $Name: geant4-08-03 $
//
//
// class G4MagIntegratorStepper
@@ -97,17 +96,7 @@ class G4MagIntegratorStepper
inline G4EquationOfMotion *GetEquationOfMotion();
// As some steppers (eg RKG3) require other methods of Eq_Rhs
// this function allows for access to them.
public: // without description
#if 0
void
SetChargeAndMomentum( G4double particleCharge, // in e+ units
G4double MomentumXc)
// Supply the standard Evaluation of the Right Hand side
// of the associated equation.
{theEquation_Rhs -> SetChargeAndMomentum(particleCharge, MomentumXc);}
#endif
inline void SetEquationOfMotion(G4EquationOfMotion* newEquation);
private:
source/geometry/magneticfield/include/G4MagIntegratorStepper.icc
+10 -3
View File
@@ -23,9 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4MagIntegratorStepper.icc,v 1.8.2.1 2006/06/29 18:23:05 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4MagIntegratorStepper.icc,v 1.10 2006/09/20 09:31:46 japost Exp $
// GEANT4 tag $Name: geant4-08-03 $
//
inline
@@ -34,6 +33,14 @@ G4EquationOfMotion* G4MagIntegratorStepper::GetEquationOfMotion()
return fEquation_Rhs;
}
inline void
G4MagIntegratorStepper::SetEquationOfMotion(G4EquationOfMotion* newEquation)
{
if( newEquation != 0 ) {
fEquation_Rhs= newEquation;
}
}
inline
G4int G4MagIntegratorStepper::GetNumberOfVariables() const
{
source/geometry/magneticfield/src/G4MagHelicalStepper.cc
+7 -3
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MagHelicalStepper.cc,v 1.16 2006/06/29 18:24:20 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4MagHelicalStepper.cc,v 1.17 2007/04/26 06:26:54 tnikitin Exp $
// GEANT4 tag $Name: geant4-08-03 $
//
// --------------------------------------------------------------------
@@ -58,8 +58,12 @@ G4MagHelicalStepper::AdvanceHelix( const G4double yIn[],
G4double yHelix[]) const
{
// const G4int nvar = 6;
const G4double approc_limit = 0.05;
//OLD const G4double approc_limit = 0.05;
// OLD approc_limit = 0.05 gives max.error=x^5/5!=(0.05)^5/5!=2.6*e-9
// NEW approc_limit = 0.005 gives max.error=x^5/5!=2.6*e-14
const G4double approc_limit = 0.005;
G4ThreeVector Bnorm, B_x_P, vperp, vpar;
// G4double norm;
G4double B_d_P; // B_perp;
source/geometry/magneticfield/src/G4MagIntegratorDriver.cc
+70 -24
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4MagIntegratorDriver.cc,v 1.44 2006/06/29 18:24:23 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4MagIntegratorDriver.cc,v 1.46 2007/05/10 10:10:31 japost Exp $
// GEANT4 tag $Name: geant4-08-03 $
//
//
//
@@ -66,7 +66,8 @@ G4MagInt_Driver::G4MagInt_Driver( G4double hminimum,
G4MagIntegratorStepper *pItsStepper,
G4int numComponents,
G4int statisticsVerbose)
: fNoIntegrationVariables(numComponents),
: fSmallestFraction( 1.0e-12 ),
fNoIntegrationVariables(numComponents),
fMinNoVars(12),
fNoVars( std::max( fNoIntegrationVariables, fMinNoVars )),
fVerboseLevel(0),
@@ -143,16 +144,26 @@ G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
G4double x1, x2;
G4bool succeeded = true, lastStepSucceeded;
G4double startCurveLength;
G4int noFullIntegr=0, noSmallIntegr = 0 ;
static G4int noGoodSteps =0 ; // Bad = chord > curve-len
const int nvar= fNoVars;
G4FieldTrack yStartFT(y_current);
// Assume that hstep > 0
// Ensure that hstep > 0
if( hstep <= 0.0 ) {
G4cerr << " Hstep is " << hstep << G4endl;
G4Exception("G4MagInt_Driver::AccurateAdvance()",
"Requested Integration Step is zero or negative: it must be positive",
FatalException, "Requested-Step-not-Positive.");
}
y_current.DumpToArray( ystart );
x1= y_current.GetCurveLength();
startCurveLength= y_current.GetCurveLength();
x1= startCurveLength;
x2= x1 + hstep;
if( (hinitial > 0.0)
@@ -182,13 +193,6 @@ G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
pIntStepper->RightHandSide( y, dydx );
if( x+h > x2 ) {
h = x2 - x ; // When stepsize overshoots, decrease it!
if( h < eps * hstep) {
lastStep = true; // Avoid numerous small last steps
}
}
fNoTotalSteps++;
// Perform the Integration
//
@@ -233,6 +237,10 @@ G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
<< G4endl;
}
#endif
if( h == 0.0 ) {
G4Exception("G4MagInt_Driver::AccurateAdvance()", "Integration Step became Zero",
FatalException, "IntegrationStepUnderflow.");
}
dyerr = dyerr_len / h;
hdid= h;
x += hdid;
@@ -277,15 +285,23 @@ G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
}
// #endif
// Check the proposed next stepsize
if(std::fabs(hnext) <= Hmin())
{
// Avoid numerous small last steps
if( (h < eps * hstep) || (h < fSmallestFraction * startCurveLength) ) {
// No more integration -- the next step will not happen
lastStep = true;
// fNoLastStep++;
} else {
// Check the proposed next stepsize
if(std::fabs(hnext) <= Hmin())
{
#ifdef G4DEBUG_FIELD
// If simply a very small interval is being integrated, do not warn
if( (x < x2 * (1-eps) ) && // The last step can be small: it's OK
(std::fabs(hstep) > Hmin()) // and if we are asked, it's OK
// && (hnext < hstep * PerThousand )
){
// If simply a very small interval is being integrated, do not warn
if( (x < x2 * (1-eps) ) && // The last step can be small: it's OK
(std::fabs(hstep) > Hmin()) // and if we are asked, it's OK
// && (hnext < hstep * PerThousand )
)
{
if(dbg>0){ // G4cerr << "Mid:SmallStep> ";
WarnSmallStepSize( hnext, hstep, h, x-x1, nstp );
PrintStatus( ystart, x1, y, x, hstep, no_warnings?nstp:-nstp);
@@ -293,10 +309,29 @@ G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
no_warnings++;
}
#endif
// Make sure that the next step is at least Hmin.
h = Hmin();
}else{
h = hnext ;
// Make sure that the next step is at least Hmin.
h = Hmin();
}else{
h = hnext ;
}
// Ensure that the next step does not overshoot
if( x+h > x2 ) {
h = x2 - x ; // When stepsize overshoots, decrease it!
// Must cope with difficult rounding-error issues if hstep << x2
}
// if( h < smallestFraction * startCurveLength )
if( h == 0.0 ){
// Cannot progress - accept this as last step - by default
lastStep = true;
#ifdef G4DEBUG_FIELD
if(dbg){
G4cout << "Warning: G4MagIntegratorDriver::AccurateAdvance" << G4endl
<< " Integration step 'h' became " << h << " due to roundoff " << G4endl
<< " Forcing termination of advance." << G4endl;
}
#endif
}
}
}while ( ((nstp++)<=fMaxNoSteps)
@@ -908,3 +943,14 @@ void G4MagInt_Driver::PrintStatisticsReport()
G4cout.precision(oldPrec);
}
void G4MagInt_Driver::SetSmallestFraction(G4double newFraction)
{
if( (newFraction > 1.e-16) && (newFraction < 1e-8) ) {
fSmallestFraction= newFraction;
}else{
G4cerr << "Warning: SmallestFraction not changed. " << G4endl
<< " Proposed value was " << newFraction << G4endl
<< " Value must be between 1.e-8 and 1.e-16" << G4endl;
}
}
source/geometry/magneticfield/src/G4RKG3_Stepper.cc
+47 -25
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4RKG3_Stepper.cc,v 1.10 2006/06/29 18:24:48 gunter Exp $
// GEANT4 tag $Name: geant4-08-02 $
// $Id: G4RKG3_Stepper.cc,v 1.12 2007/04/26 12:23:55 tnikitin Exp $
// GEANT4 tag $Name: geant4-08-03 $
//
// -------------------------------------------------------------------
@@ -36,8 +36,8 @@
G4RKG3_Stepper::G4RKG3_Stepper(G4Mag_EqRhs *EqRhs)
: G4MagIntegratorStepper(EqRhs,6)
{
G4Exception("G4RKG3_Stepper::G4RKG3_Stepper()", "NotImplemented",
FatalException, "Stepper not yet available.");
// G4Exception("G4RKG3_Stepper::G4RKG3_Stepper()", "NotImplemented",
// FatalException, "Stepper not yet available.");
}
G4RKG3_Stepper::~G4RKG3_Stepper()
@@ -128,6 +128,7 @@ void G4RKG3_Stepper::StepWithEst( const G4double*,
// -----------------------------------------------------------------
// Integrator RK Stepper from G3 with only two field evaluation per Step.
// It is used in propagation initial Step by small substeps after solution
// error and delta geometry considerations. B[3] is magnetic field which
@@ -140,62 +141,83 @@ void G4RKG3_Stepper::StepNoErr(const G4double tIn[7],
G4double B[3] ) // const
{
// Copy and edit the routine above, to delete alpha2, beta2, ...
G4double K1[7],K2[7],K3[7],K4[7] ;
G4double tTemp[7], yderiv[6] ;
// Need Momentum value to give correct values to the coefficients in equation
// Integration on unit velocity, but tIn[3,4,5] is momentum
G4double mom;
G4int i ;
#ifdef END_CODE_G3STEPPER
G4Exception(" G4RKG3_Stepper::StepNoErr(): method to be no longer used.");
#else
// GetEquationOfMotion()->EvaluateRhsReturnB(tIn,dydx,B1) ;
// Correction for momentum not a velocity
mom=std::sqrt(tIn[3]*tIn[3]+tIn[4]*tIn[4]+tIn[5]*tIn[5]);
for(i=0;i<3;i++)
{
K1[i] = Step * dydx[i+3];
tTemp[i] = tIn[i] + Step*(0.5*tIn[i+3] + 0.125*K1[i]) ;
tTemp[i+3] = tIn[i+3] + 0.5*K1[i] ;
K1[i] = Step * dydx[i+3]/mom;
tTemp[i] = tIn[i] + Step*(0.5*tIn[i+3]/mom + 0.125*K1[i]) ;
tTemp[i+3] = tIn[i+3] + 0.5*K1[i]*mom ;
}
GetEquationOfMotion()->EvaluateRhsReturnB(tTemp,yderiv,B) ;
// Calculates yderiv & returns B too!
for(i=0;i<3;i++)
{
K2[i] = Step * yderiv[i+3];
tTemp[i+3] = tIn[i+3] + 0.5*K2[i] ;
K2[i] = Step * yderiv[i+3]/mom;
tTemp[i+3] = tIn[i+3] + 0.5*K2[i]*mom ;
}
// Given B, calculate yderiv !
GetEquationOfMotion()->EvaluateRhsGivenB(tTemp,B,yderiv) ;
for(i=0;i<3;i++)
{
K3[i] = Step * yderiv[i+3];
tTemp[i] = tIn[i] + Step*(tIn[i+3] + 0.5*K3[i]) ;
tTemp[i+3] = tIn[i+3] + K3[i] ;
K3[i] = Step * yderiv[i+3]/mom;
tTemp[i] = tIn[i] + Step*(tIn[i+3]/mom + 0.5*K3[i]) ;
tTemp[i+3] = tIn[i+3] + K3[i]*mom ;
}
// Calculates y-deriv(atives) & returns B too!
GetEquationOfMotion()->EvaluateRhsReturnB(tTemp,yderiv,B) ;
for(i=0;i<3;i++) // Output trajectory vector
{
K4[i] = Step * yderiv[i+3];
tOut[i] = tIn[i] + Step*(tIn[i+3] + (K1[i] + K2[i] + K3[i])/6.0) ;
tOut[i+3] = tIn[i+3] + (K1[i] + 2*K2[i] + 2*K3[i] +K4[i])/6.0 ;
K4[i] = Step * yderiv[i+3]/mom;
tOut[i] = tIn[i] + Step*(tIn[i+3]/mom + (K1[i] + K2[i] + K3[i])/6.0) ;
tOut[i+3] = tIn[i+3] + mom*(K1[i] + 2*K2[i] + 2*K3[i] +K4[i])/6.0 ;
}
// NormaliseTangentVector( tOut );
#endif
}
// ---------------------------------------------------------------------------
G4double G4RKG3_Stepper::DistChord() const
{
// Soon: must check whether h/R > 2 pi !!
// Method below is good only for < 2 pi
G4double distChord,distLine;
if (fyInitial != fyFinal) {
distLine= G4LineSection::Distline(fyMidPoint,fyInitial,fyFinal );
distChord = distLine;
}else{
distChord = (fyMidPoint-fyInitial).mag();
}
return G4LineSection::Distline( fyMidPoint, fyInitial, fyFinal );
// This is a class method that gives distance of Mid
// from the Chord between the Initial and Final points.
return distChord;
}