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

Import Geant4 4.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:18:25 +02:00
parent 36c080dca6
commit 921d3b1cda
3990 changed files with 185376 additions and 82884 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/magneticfield/src/G4CashKarpRKF45.cc
+4 -3
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4CashKarpRKF45.cc,v 1.8.2.1 2001/06/28 19:08:18 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4CashKarpRKF45.cc,v 1.10 2001/11/21 17:56:18 japost Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// The Cash-Karp Runge-Kutta-Fehlberg 4/5 method is an embedded fourth
// order method (giving fifth-order accuracy) for the solution
@@ -51,6 +51,7 @@ G4CashKarpRKF45::G4CashKarpRKF45(G4EquationOfMotion *EqRhs, G4int numberOfVariab
ak4 = new G4double[fNumberOfVariables] ;
ak5 = new G4double[fNumberOfVariables] ;
ak6 = new G4double[fNumberOfVariables] ;
ak7 = 0;
yTemp = new G4double[fNumberOfVariables] ;
yIn = new G4double[fNumberOfVariables] ;
@@ -77,7 +78,7 @@ G4CashKarpRKF45::~G4CashKarpRKF45()
delete[] ak4;
delete[] ak5;
delete[] ak6;
delete[] ak7;
// delete[] ak7;
delete[] yTemp;
delete[] yIn;
source/geometry/magneticfield/src/G4ChordFinder.cc
+22 -20
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4ChordFinder.cc,v 1.18.2.1 2001/06/28 19:08:18 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4ChordFinder.cc,v 1.24 2001/11/30 17:36:18 japost Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
// 25.02.97 John Apostolakis, design and implimentation
@@ -94,9 +94,9 @@ G4ChordFinder::AdvanceChordLimited( G4FieldTrack& yCurrent,
G4double dyErr;
G4FieldTrack yEnd( yCurrent);
G4double startCurveLen= yCurrent.GetCurveLength();
G4bool dbg= false;
#ifdef G4VERBOSE
#ifdef G4DEBUG_FIELD
static G4bool dbg= false;
if( dbg )
G4cerr << "Entered AdvanceChordLimited with:\n yCurrent: " << yCurrent
<< " and initial Step=stepMax=" << stepMax << " mm. " << G4endl;
@@ -114,7 +114,7 @@ G4ChordFinder::AdvanceChordLimited( G4FieldTrack& yCurrent,
{
// Advance more accurately to "end of chord"
good_advance = fIntgrDriver->AccurateAdvance(yCurrent, stepPossible, epsStep);
#ifdef G4VERBOSE
#ifdef G4DEBUG_FIELD
if (dbg) G4cerr << "Accurate advance to end of chord attemped"
<< "with result " << good_advance << G4endl ;
#endif
@@ -124,7 +124,7 @@ G4ChordFinder::AdvanceChordLimited( G4FieldTrack& yCurrent,
}
}
#ifdef G4VERBOSE
#ifdef G4DEBUG_FIELD
if( dbg ) G4cerr << "Exiting FindNextChord Limited with:\n yCurrent: "
<< yCurrent<< G4endl;
#endif
@@ -212,7 +212,7 @@ G4ChordFinder::FindNextChord( const G4FieldTrack yStart,
G4cout << " d-";
G4cout.precision(5);
G4cout << " new_step= " << G4std::setw(10) << fLastStepEstimate_Unconstrained
<< " new_step_constr= " << G4std::setw(10) << stepTrial << endl;
<< " new_step_constr= " << G4std::setw(10) << stepTrial << G4endl;
#endif
noTrials++;
}
@@ -220,8 +220,9 @@ G4ChordFinder::FindNextChord( const G4FieldTrack yStart,
stepOfLastGoodChord = stepTrial;
#ifdef TEST_CHORD_PRINT
G4cout << "ChordF/FindNextChord: NoTrials= " << noTrials
<< " StepForGoodChord=" << G4std::setw(10) << stepTrial << endl;
if( dbg )
G4cout << "ChordF/FindNextChord: NoTrials= " << noTrials
<< " StepForGoodChord=" << G4std::setw(10) << stepTrial << G4endl;
#endif
yEnd= yCurrent;
@@ -230,12 +231,11 @@ G4ChordFinder::FindNextChord( const G4FieldTrack yStart,
// ----------------------------------------------------------------------------
#if 0
// First debug print // older OPTIONAL code
// #ifdef G4VERBOSE
if( dbg ) {
G4cerr << "Returned from QuickAdvance with: yCur=" << yCurrent <<G4endl;
G4cerr << " dChordStep= "<< dChordStep <<" dyErr=" << dyErr << G4endl;
}
if( dbg ) {
G4cerr << "Returned from QuickAdvance with: yCur=" << yCurrent <<G4endl;
G4cerr << " dChordStep= "<< dChordStep <<" dyErr=" << dyErr << G4endl;
}
#endif
// ----------------------------------------------------------------------------
@@ -322,21 +322,19 @@ G4FieldTrack G4ChordFinder::ApproxCurvePointV(
// const
G4double integrationInaccuracyLimit= G4std::max( perMillion, 0.5*eps_step );
if( curve_length < ABdist * (1. - integrationInaccuracyLimit) ){
// #ifdef G4DEBUG
#ifdef G4DEBUG_FIELD
G4cerr << " Warning in G4ChordFinder::ApproxCurvePoint: " << G4endl <<
" The two points are further apart than the curve length " << G4endl <<
" Dist = " << ABdist <<
" curve length = " << curve_length
<< " relativeDiff = " << (curve_length-ABdist)/ABdist
<< G4endl;
// #endif
if( curve_length < ABdist * (1. - 10*eps_step) ) {
// #ifdef G4DEBUG
G4cerr << " ERROR: the size of the above difference exceeds allowed limits. Aborting."
<< G4endl;
// #endif
G4Exception("G4ChordFinder::ApproxCurvePoint> Unphysical curve length.");
}
#endif
// Take default corrective action:
// --> adjust the maximum curve length.
// NOTE: this case only happens for relatively straight paths.
@@ -348,18 +346,22 @@ G4FieldTrack G4ChordFinder::ApproxCurvePointV(
if ( ABdist > 0.0 ){
AE_fraction = ChordAE_Vector.mag() / ABdist;
}else{
G4cerr << " Error in G4ChordFinder::ApproxCurvePoint: A and B are the same point\n" <<
" Chord AB length = " << ChordAE_Vector.mag() << G4endl << G4endl;
AE_fraction = 0.5; // Guess .. ?;
#ifdef G4DEBUG_FIELD
G4cout << "Warning in G4ChordFinder::ApproxCurvePoint: A and B are the same point\n" <<
" Chord AB length = " << ChordAE_Vector.mag() << G4endl << G4endl;
#endif
}
if( (AE_fraction> 1.0 + perMillion) || (AE_fraction< 0.) ){
#ifdef G4DEBUG_FIELD
G4cerr << " G4ChordFinder::ApproxCurvePointV: Warning: Anomalous condition:AE > AB or AE/AB <= 0 " << G4endl <<
" AE_fraction = " << AE_fraction << G4endl <<
" Chord AE length = " << ChordAE_Vector.mag() << G4endl <<
" Chord AB length = " << ABdist << G4endl << G4endl;
G4cerr << " OK if this condition occurs after a recalculation of 'B'" << G4endl
<< " Otherwise it is an error. " << G4endl ;
#endif
// This course can now result if B has been re-evaluated,
// without E being recomputed (1 July 99)
// In this case this is not a "real error" - but it undesired
source/geometry/magneticfield/src/G4ClassicalRK4.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4ClassicalRK4.cc,v 1.3.4.1 2001/06/28 19:08:18 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4ClassicalRK4.cc,v 1.4 2001/07/11 09:59:10 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4ClassicalRK4.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4DELPHIMagField.cc
+93
View File
@@ -0,0 +1,93 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4DELPHIMagField.hh"
#include "globals.hh"
#include "geomdefs.hh"
G4DELPHIMagField::G4DELPHIMagField()
{
;
}
////////////////////////////////////////////////////////////////////////
G4DELPHIMagField::~G4DELPHIMagField()
{
;
}
///////////////////////////////////////////////////////////////////////
void
G4DELPHIMagField::GetFieldValue( const G4double yTrack[7],
G4double B[3] ) const
{
G4int i, n = 8 ;
G4double a = 0.001 ; // mm -> m
G4double x = a*yTrack[0], y = a*yTrack[1], z = a*yTrack[2] ;
G4double x2 = x*x, y2 = y*y, z2 = z*z, r2 = x2 + y2 ;
G4double r4 = r2*r2, z4 = z2*z2, r6 = r4*r2, z6 = z4*z2 ;
G4double r8 = r4*r4, z8 = z4*z4, r10 = r8*r2, z10 = z8*z2 ;
G4double rz = z*sqrt(r2), r = sqrt(r2+a*a) ;
G4double Br ;
G4double P[8], Q[8] ;
static G4double c[8] = {
-9.26e-5, -3.51e-5, 2.94e-6, -1.10e-6,
6.25e-8, -1.77e-8, -6.88e-10, -7.52e-11
} ;
P[0] = 2*rz ;
P[1] = 4*rz*(r2 - 4.0*z2/3.0) ;
P[2] = 6*rz*(r4 - 4*r2*z2 + 1.6*z4) ;
P[3] = 8*rz*(r6 - 8*r4*z2 + 9.6*r2*z4 - 64.0*z6/35.0) ;
P[4] = 10*rz*(r8 - 40.0*r6*z2/3.0 + 32*r4*z4 - 128.0*r2*z6/7.0 + 128.0*z8/63.0);
P[5] = 0 ;
P[6] = 0 ;
P[7] = 0 ;
Q[0] = r2 - 2*z2 ;
Q[1] = r4 - 8*r2*z2 + 8.0*z4/3.0 ;
Q[2] = r6 - 18*r4*z2 + 24*r2*z4 - 3.2*z6 ;
Q[3] = r8 - 32*r6*z2 + 96*r4*z4 - 51.2*r2*z6 +128.0*z8/35.0 ;
Q[4] = r10 - 50*r8*z2 + 800.0*r6*z4/3.0 - 320*r4*z6
+ 640.0*r2*z8/7.0 - 256.0*z10/63.0 ;
Q[5] = 0 ;
Q[6] = 0 ;
Q[7] = 0 ;
Br = 0 ;
B[2] = 1.2*tesla ; // the principal Bz value of DELPHI detector
for(i=0;i<n;i++)
{
Br += c[i]*P[i] ;
B[2] += c[i]*Q[i] ;
}
B[0] = Br*x/r ;
B[1] = Br*y/r ;
return ;
}
// -----------------------------------------------------------------
source/geometry/magneticfield/src/G4EqMagElectricField.cc
+11 -1
View File
@@ -54,10 +54,14 @@ G4EqMagElectricField::EvaluateRhsGivenB(const G4double y[],
G4double pSquared = y[3]*y[3] + y[4]*y[4] + y[5]*y[5] ;
G4double cof2 = sqrt( pSquared + fMassCof )/c_light ;
G4double Energy = sqrt( pSquared + fMassCof );
G4double cof2 = Energy/c_light ;
G4double pModuleInverse = 1.0/sqrt(pSquared) ;
// G4double inverse_velocity = Energy * c_light * pModuleInverse;
G4double inverse_velocity = Energy * pModuleInverse / c_light;
G4double cof1 = fElectroMagCof*pModuleInverse ;
// G4double vDotE = y[3]*Field[3] + y[4]*Field[4] + y[5]*Field[5] ;
@@ -72,5 +76,11 @@ G4EqMagElectricField::EvaluateRhsGivenB(const G4double y[],
dydx[4] = cof1*(cof2*Field[4] + (y[5]*Field[0] - y[3]*Field[2])) ;
dydx[5] = cof1*(cof2*Field[5] + (y[3]*Field[1] - y[4]*Field[0])) ;
// Lab Time of flight
dydx[7] = inverse_velocity;
return ;
}
source/geometry/magneticfield/src/G4EquationOfMotion.cc
+21 -4
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4EquationOfMotion.cc,v 1.3.4.1 2001/06/28 19:08:18 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4EquationOfMotion.cc,v 1.5 2001/11/09 20:39:07 japost Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4EquationOfMotion.hh"
@@ -36,8 +36,16 @@ G4EquationOfMotion::RightHandSide( const G4double y[],
G4double dydx[] ) const
{
G4double Field[G4maximum_number_of_field_components];
G4double PositionAndTime[4];
GetFieldValue(y, Field) ;
// Position
PositionAndTime[0] = y[0];
PositionAndTime[1] = y[1];
PositionAndTime[2] = y[2];
// Global Time
PositionAndTime[3] = y[7]; // See G4FieldTrack::LoadFromArray
GetFieldValue(PositionAndTime, Field) ;
EvaluateRhsGivenB( y, Field, dydx );
}
@@ -46,7 +54,16 @@ G4EquationOfMotion::EvaluateRhsReturnB( const G4double y[],
G4double dydx[],
G4double Field[] ) const
{
GetFieldValue(y, Field) ;
G4double PositionAndTime[4];
// Position
PositionAndTime[0] = y[0];
PositionAndTime[1] = y[1];
PositionAndTime[2] = y[2];
// Global Time
PositionAndTime[3] = y[7]; // See G4FieldTrack::LoadFromArray
GetFieldValue(PositionAndTime, Field) ;
EvaluateRhsGivenB( y, Field, dydx );
}
source/geometry/magneticfield/src/G4ExplicitEuler.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4ExplicitEuler.cc,v 1.3.4.1 2001/06/28 19:08:18 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4ExplicitEuler.cc,v 1.4 2001/07/11 09:59:11 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
// Explicit Euler: x_1 = x_0 + h * dx_0
source/geometry/magneticfield/src/G4FieldManager.cc
+6 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4FieldManager.cc,v 1.4.2.1 2001/06/28 19:08:18 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4FieldManager.cc,v 1.6 2001/11/28 18:44:43 japost Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4FieldManager.hh"
@@ -33,6 +33,8 @@ G4FieldManager::G4FieldManager()
fDelta_One_Step_Value= fDefault_Delta_One_Step_Value;
fDelta_Intersection_Val= fDefault_Delta_Intersection_Val;
fFieldChangesEnergy= false;
}
G4FieldManager::G4FieldManager(G4MagneticField *detectorField)
@@ -43,6 +45,8 @@ G4FieldManager::G4FieldManager(G4MagneticField *detectorField)
fDelta_One_Step_Value= fDefault_Delta_One_Step_Value;
fDelta_Intersection_Val= fDefault_Delta_Intersection_Val;
fFieldChangesEnergy= false;
}
source/geometry/magneticfield/src/G4FieldTrack.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4FieldTrack.cc,v 1.3.2.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4FieldTrack.cc,v 1.4 2001/07/11 09:59:11 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4FieldTrack.hh"
source/geometry/magneticfield/src/G4HarmonicPolMagField.cc
+97
View File
@@ -0,0 +1,97 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4HarmonicPolMagField.hh"
#include "globals.hh"
#include "geomdefs.hh"
G4HarmonicPolMagField::G4HarmonicPolMagField()
{
;
}
/////////////////////////////////////////////////////////////////////////
G4HarmonicPolMagField::~G4HarmonicPolMagField()
{
;
}
/////////////////////////////////////////////////////////////////////////
void
G4HarmonicPolMagField::GetFieldValue(const G4double yTrack[7],
G4double B[3] ) const
{
G4int i ;
G4double a = 1.00 ; // mm -> m
G4double x = a*yTrack[0], y = a*yTrack[1], z = a*yTrack[2] ;
G4double x2 = x*x, y2 = y*y, z2 = z*z ;
G4double x3 = x2*x, y3 = y2*y, z3 = z2*z ;
G4double xy = x*y, xz = x*z, yz = y*z, xyz = x*y*z ;
static G4double
c[24] = {
0.010, 0.010, 0.010, // 3(0)
0.0001, 0.0001, 0.0001, 0.0001, 0.0001, // 5(1)
0.00001, 0.00001, 0.00001, 0.00001, 0.00001, 0.00001, 0.00001, // 7(2)
0.000001, 0.000001, 0.000001, 0.000001, 0.000001, 0.000001,
0.0000001, 0.0000001, 0.0000001 // 9(3)
} ; // total : 24
// for(i=0;i<24;i++)
// {
// c[i] = 1.0*c[i] ;
// }
B[0] = c[1]
-2*c[3]*x + c[4]*z +c[6]*y -2*c[7]*x
-6*c[8]*xz + c[9]*(z2-x2) -2*c[10]*xy + c[11]*yz - 2*c[12]*xz
+c[13]*(y2-x2) - 6*c[14]*xy
-4*c[15]*(3*x*z2-x3) +c[16]*(z3-3*x2*z) - 6*c[17]*xyz +c[18]*y*(z2-x2)
-2*c[19]*(x*z2+x*y2-2*x3/3) + c[20]*z*(y2-x2) - 6*c[21]*xyz
+c[22]*(y3-3*x2*y) - 4*c[23]*(3*x*y2-x3) ;
B[1] = c[2]
+c[5]*z + c[6]*x + 2*c[7]*y
+c[10]*(z2-x2) + c[11]*xz +2*c[12]*yz +2*c[13]*xy + 3*c[14]*(y2-x2)
+c[17]*(z3-3*x2*z) + c[18]*(x*z2-x3/3) +2*c[19]*y*(z2-x2)
+2*c[20]*xyz
+3*c[21]*z*(y2-x2) + c[22]*(3*x*y2-x3) + 4*c[23]*(y3-3*x2*y) ;
B[2] = c[0]
+c[3]*z + c[4]*x + c[5]*y
+3*c[8]*(z2-x2) + 2*c[9]*xz + 2*c[10]*yz + c[11]*xy + c[12]*(y2-x2)
+4*c[15]*(z3-3*x2*z) + c[16]*(3*x*z2-x3) + 3*c[17]*(y*z2-x2*y)
+2*c[18]*xyz
+2*c[19]*z*(y2-x2) + c[20]*(x*y2-x3/3) + c[21]*(y3-3*x2*y) ;
for(i=0;i<3;i++)
{
B[i] = 0.1*B[i] ;
}
return ;
}
// -----------------------------------------------------------------
source/geometry/magneticfield/src/G4HelixExplicitEuler.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4HelixExplicitEuler.cc,v 1.3.4.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4HelixExplicitEuler.cc,v 1.4 2001/07/11 09:59:11 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4HelixExplicitEuler.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4HelixHeum.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4HelixHeum.cc,v 1.3.4.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4HelixHeum.cc,v 1.4 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4HelixHeum.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4HelixImplicitEuler.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4HelixImplicitEuler.cc,v 1.3.4.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4HelixImplicitEuler.cc,v 1.4 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4HelixImplicitEuler.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4HelixSimpleRunge.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4HelixSimpleRunge.cc,v 1.4.4.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4HelixSimpleRunge.cc,v 1.5 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4HelixSimpleRunge.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4ImplicitEuler.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4ImplicitEuler.cc,v 1.3.4.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4ImplicitEuler.cc,v 1.4 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
// Implicit Euler:
source/geometry/magneticfield/src/G4LineCurrentMagField.cc
+60
View File
@@ -0,0 +1,60 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4LineCurrentMagField.hh"
#include "globals.hh"
#include "geomdefs.hh"
G4LineCurrentMagField::G4LineCurrentMagField(G4double pFieldConstant)
{
fFieldConstant = pFieldConstant ;
}
////////////////////////////////////////////////////////////////////////
G4LineCurrentMagField::~G4LineCurrentMagField()
{
;
}
///////////////////////////////////////////////////////////////////////////
void
G4LineCurrentMagField::GetFieldValue( const G4double yTrack[7],
G4double B[3] ) const
{
// G4double fFieldConstant = 100 ;
G4double a = 1.00*mm ; // mm -> m
G4double x = a*yTrack[0], y = a*yTrack[1] ;
G4double x2 = x*x, y2 = y*y, r2 = x2 + y2 ;
G4double r = sqrt(r2+a*a) ;
G4double Br = fFieldConstant/r;
B[0] = -Br*y/r ;
B[1] = Br*x/r ;
B[2] = 0 ;
return ;
}
// -----------------------------------------------------------------
source/geometry/magneticfield/src/G4LineSection.cc
+26 -18
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4LineSection.cc,v 1.4.4.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4LineSection.cc,v 1.6 2001/12/04 15:10:01 grichine Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// typedef double G4double;
@@ -33,6 +33,8 @@ G4LineSection::G4LineSection( const G4ThreeVector& PntA,
: EndpointA(PntA),
VecAtoB(PntB-PntA)
{
fABdistanceSq = VecAtoB.mag2() ;
/*
G4double distABsquared = VecAtoB.mag2() ;
if ( distABsquared == 0.0)
{
@@ -42,6 +44,7 @@ G4LineSection::G4LineSection( const G4ThreeVector& PntA,
{
inverse_square_distAB=1.0 / distABsquared ;
}
*/
}
G4double G4LineSection::Dist( G4ThreeVector OtherPnt ) const
@@ -57,31 +60,36 @@ G4double G4LineSection::Dist( G4ThreeVector OtherPnt ) const
// Determine Projection(AZ on AB) / Length(AB)
//
unit_projection= inner_prod * InvsqDistAB();
if( (0. <= unit_projection ) && (unit_projection <= 1.0 ) )
if( fABdistanceSq != 0.0 )
{
dist_sq= sq_VecAZ - unit_projection * inner_prod ;
}
else
{
// unit_projection= inner_prod * InvsqDistAB();
unit_projection = inner_prod/fABdistanceSq;
if( (0. <= unit_projection ) && (unit_projection <= 1.0 ) )
{
dist_sq= sq_VecAZ - unit_projection * inner_prod ;
}
else
{
// The perpendicular from the point to the line AB meets the line
// in a point outside the line segment!
if( unit_projection < 0. )
{
// A is the closest point
if( unit_projection < 0. ) // A is the closest point
{
dist_sq= sq_VecAZ;
}
else
{
// B is the closest point
}
else // B is the closest point
{
G4ThreeVector EndpointB = EndpointA + VecAtoB;
G4ThreeVector VecBZ = OtherPnt - EndpointB;
dist_sq = VecBZ.mag2();
}
}
}
}
else
{
dist_sq = (OtherPnt - EndpointA).mag2() ;
}
if( dist_sq < 0.0 ) dist_sq = 0.0 ;
return sqrt(dist_sq) ;
source/geometry/magneticfield/src/G4MagErrorStepper.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4MagErrorStepper.cc,v 1.8.4.1 2001/06/28 19:08:19 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4MagErrorStepper.cc,v 1.9 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4MagErrorStepper.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4MagHelicalStepper.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4MagHelicalStepper.cc,v 1.7.2.1 2001/06/28 19:08:20 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4MagHelicalStepper.cc,v 1.8 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4MagHelicalStepper.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4MagIntegratorDriver.cc
+283 -58
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4MagIntegratorDriver.cc,v 1.14.4.1 2001/06/28 19:08:20 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4MagIntegratorDriver.cc,v 1.20 2001/11/21 16:43:16 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
//
@@ -49,14 +49,15 @@ const G4double G4MagInt_Driver::max_stepping_decrease = 0.1;
// The (default) maximum number of steps is Base divided by the order of Stepper
//
const G4int G4MagInt_Driver::fMaxStepBase = 5000;
const G4int G4MagInt_Driver::fMaxStepBase = 500; // Was 5000
// Constructor
//
G4MagInt_Driver::G4MagInt_Driver( G4double hminimum,
G4MagIntegratorStepper *pItsStepper,
G4int numComponents)
: nvar(numComponents)
: nvar(numComponents),
fVerboseLevel(0)
{
RenewStepperAndAdjust( pItsStepper );
hminimum_val= hminimum;
@@ -69,6 +70,9 @@ G4MagInt_Driver::~G4MagInt_Driver()
{
}
// To add much printing for debugging purposes, uncomment this:
// #define G4DEBUG_FIELD 1
G4bool
G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
G4double hstep,
@@ -84,18 +88,23 @@ G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
{
G4int nstp, i;
static G4int dbg=0;
G4double x, hnext, hdid, h ;
#ifdef G4DEBUG
G4int no_warnings=0;
#ifdef G4DEBUG_FIELD
static G4int dbg=0;
dbg=1;
fVerboseLevel=2;
#endif
// G4double yscal[ncompSVEC];
G4double y[G4FieldTrack::ncompSVEC], dydx[G4FieldTrack::ncompSVEC];
G4double ystart[G4FieldTrack::ncompSVEC];
G4double ystart[G4FieldTrack::ncompSVEC], yEnd[G4FieldTrack::ncompSVEC];
G4double x1, x2;
G4bool succeeded = true, lastStepSucceeded;
G4FieldTrack yStartFT(y_current);
// Assume that hstep > 0
// ystart = y_current.PosVelVec();
@@ -132,68 +141,133 @@ G4MagInt_Driver::AccurateAdvance(G4FieldTrack& y_current,
// could otherwise force lots of small last steps.
}
// static G4int nStpPr=50; // For debug printing of integrations with many steps
// Perform the Integration
//
OneGoodStep(y,dydx,x,h,eps,hdid,hnext) ;
//--------------------------------------
//
lastStepSucceeded= (hdid == h);
// #ifdef G4DEBUG
if( h > Hmin() ){
OneGoodStep(y,dydx,x,h,eps,hdid,hnext) ;
//--------------------------------------
lastStepSucceeded= (hdid == h);
}else{
#if 0
OneGoodStep(y,dydx,x,h,2*eps,hdid,hnext) ;
//--------------------------------------
lastStepSucceeded= (hdid == h);
#else
G4FieldTrack yFldTrk( G4ThreeVector(0,0,0),
G4ThreeVector(0,0,0), 0., 0., 0., 0. );
G4double dchord_step, dyerr, dyerr_len; // Must figure what to do with these
yFldTrk.LoadFromArray(y);
yFldTrk.SetCurveLength( x );
// G4double s_start = yFldTrk.GetCurveLength();
QuickAdvance( yFldTrk, dydx, h, dchord_step, dyerr_len );
# ifdef G4DEBUG_FIELD
if(dbg>1) OneGoodStep(y,dydx,x,h,2*eps,hdid,hnext) ;
if(dbg>1) PrintStatus( ystart, x1, y, x, h, -nstp);
yFldTrk.DumpToArray(y);
if(dbg>1) PrintStatus( ystart, x1, y, x, h, nstp); // Only this
# endif
dyerr = dyerr_len / hstep;
hdid= h;
x += hdid;
// Compute suggested new step
hnext= ComputeNewStepSize( dyerr/eps, h);
lastStepSucceeded= (dyerr<= eps);
#endif
}
// #ifdef G4DEBUG_FIELD
if(lastStepSucceeded) noFullIntegr++ ; else noSmallIntegr++ ;
G4ThreeVector EndPos( y[0], y[1], y[2] );
#ifdef G4DEBUG_FIELD
if(nstp>nStpPr) {
G4cout << "hdid=" << hdid << "hnext =" << hnext << " " << endl;
PrintStatus( ystart, x1, y, x, h, nstp==nStpPr ? -nstp: nstp);
}
#endif
// Check the endpoint
G4double endPointDist= (EndPos-StartPos).mag();
if( endPointDist >= h*(1.+perMillion) ){
if( endPointDist >= hdid*(1.+perMillion) ){
noBadSteps ++;
// Issue a warning only for gross differences -
// we understand how small difference occur.
if( endPointDist >= h*(1.+perThousand) ){
WarnEndPointTooFar ( endPointDist, h, eps, dbg );
if( endPointDist >= hdid*(1.+perThousand) ){
#ifdef G4DEBUG_FIELD
WarnEndPointTooFar ( endPointDist, hdid, eps, dbg );
G4cerr << " Total steps: bad" << noBadSteps << " good " << noGoodSteps << endl;
// G4cerr << "Mid:EndPtFar> ";
PrintStatus( ystart, x1, y, x, hstep, no_warnings?nstp:-nstp);
// Potentially add as arguments: <dydx> - as Initial Force
#endif
no_warnings++;
}
noBadSteps ++;
} else { // ie (!dbg)
noGoodSteps ++;
}
// #endif
// Check the proposed next stepsize
if(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
(fabs(hstep) > Hmin()) // and if we are asked, it's OK
// && (hnext < hstep * PerThousand )
)
// Issue WARNING
WarnSmallStepSize( hnext, hstep, h, x-x1, nstp );
else
succeeded = false; // Meaningful only if we break out of the loop.
){
// Issue WARNING
WarnSmallStepSize( hnext, hstep, h, x-x1, nstp );
// G4cerr << "Mid:SmallStep> ";
PrintStatus( ystart, x1, y, x, hstep, no_warnings?nstp:-nstp);
no_warnings++;
}
#endif
// else
// succeeded = false; // Meaningful only if we break out of the loop.
//
// lastStep = true; // Make this the last step ... Dubious now
lastStep = true; // ensure that this was the last step
// Make sure that the next step is at least Hmin.
h = Hmin();
}else{
h = hnext ;
}
h = hnext ;
}while (((nstp++)<=fMaxNoSteps) &&
(x < x2) // Have we reached the end ?
// --> a better test might be x-x2 > an_epsilon
}while ( ((nstp++)<=fMaxNoSteps)
&& (x < x2) // Have we reached the end ?
// --> a better test might be x-x2 > an_epsilon
&& (!lastStep)
);
succeeded= (x>=x2); // If it was a "forced" last step
for(i=0;i<nvar;i++) ystart[i] = y[i] ;
if(nstp > fMaxNoSteps){
WarnTooManyStep( x1, x2, x ); // Issue WARNING
succeeded = false;
}
for(i=0;i<nvar;i++) yEnd[i] = y[i] ;
// Put back the values.
y_current.LoadFromArray( ystart );
y_current.LoadFromArray( yEnd );
y_current.SetCurveLength( x );
if(nstp > fMaxNoSteps){
no_warnings++;
succeeded = false;
#ifdef G4DEBUG_FIELD
WarnTooManyStep( x1, x2, x ); // Issue WARNING
PrintStatus( yEnd, x1, y, x, hstep, -nstp);
#endif
}
#ifdef G4DEBUG_FIELD
if( no_warnings ){
G4cerr << " Exiting status: "
<< " no-steps " << nstp
<<endl;
PrintStatus( yEnd, x1, y, x, hstep, nstp);
}
#endif
return succeeded;
} // end of AccurateAdvance ...........................
@@ -204,15 +278,23 @@ G4MagInt_Driver::WarnSmallStepSize( G4double hnext, G4double hstep,
G4int nstp)
{
static G4int noWarningsIssued =0;
const G4int maxNoWarnings = 100;
if( noWarningsIssued < maxNoWarnings ){
G4cerr<< " Warning (G4MagIntegratorDriver): The stepsize for the "
<< " next iteration=" << hnext << " is too small - in Step number "
<< nstp << "." << G4endl;
G4cerr << " Requested step size was " << hstep << " ." << G4endl ;
G4cerr << " Previous step size was " << h << " ." << G4endl ;
const G4int maxNoWarnings = 10; // Number of verbose warnings
if( (noWarningsIssued < maxNoWarnings) || fVerboseLevel > 10 ){
G4cerr<< " Warning (G4MagIntegratorDriver::AccurateAdvance): The stepsize for the "
<< " next iteration=" << hnext << " is too small "
<< "- in Step number " << nstp << "." << G4endl;
G4cerr << " The minimum for the driver is " << Hmin() << G4endl ;
G4cerr << " Requested integr. length was " << hstep << " ." << G4endl ;
G4cerr << " The size of this sub-step was " << h << " ." << G4endl ;
G4cerr << " The integrations has already gone " << xDone << G4endl ;
}else{
G4cerr<< " G4MagInt_Driver: Too small 'next' step " << hnext
<< " step-no " << nstp ; // << G4setw(4)
G4cerr << " this sub-step " << h
<< " req_tot_len " << hstep
<< " done " << xDone
<< " min " << Hmin()
<< G4endl ;
}
noWarningsIssued++;
}
@@ -236,20 +318,22 @@ G4MagInt_Driver::WarnEndPointTooFar (G4double endPointDist,
G4double eps,
G4int dbg)
{
static G4double maxRelError= 0.0;
static G4double maxRelError= 0.0, maxRelError_last_printed=0.0;
G4bool isNewMax, prNewMax;
isNewMax = endPointDist > (1.0 + maxRelError) * h;
prNewMax = endPointDist > (1.0 + 1.05 * maxRelError) * h;
if( isNewMax )
maxRelError= endPointDist / h - 1.0;
if( prNewMax )
maxRelError_last_printed = maxRelError;
if( dbg
&& (h > kCarTolerance)
&& ( prNewMax || (endPointDist >= h*(1.+eps) ) )
&& ( (dbg>1) || prNewMax || (endPointDist >= h*(1.+eps) ) )
){
static G4int noWarnings = 0;
if( (noWarnings ++ < 10) || (dbg>1) ){
if( (noWarnings ++ < 10) || (dbg>2) ){
G4cerr << " Warning (G4MagIntegratorDriver): "
<< " The integration produced an endpoint which " << G4endl
<< " is further from the startpoint than the curve length." << G4endl;
@@ -258,26 +342,29 @@ G4MagInt_Driver::WarnEndPointTooFar (G4double endPointDist,
<< " curve length = " << h
<< " Difference (curveLen-endpDist)= " << (h - endPointDist)
<< " relative = " << (h-endPointDist) / h
<< " epsilon = " << eps
<< G4endl;
}else{
G4cerr << " EndpointDist = " << endPointDist
<< " curve length = " << h
<< " Diff (cl-ed)= " << (h - endPointDist)
G4cerr << " Warning:"
<< " dist_e= " << endPointDist
<< " h_step = " << h
<< " Diff (hs-ed)= " << (h - endPointDist)
<< " rel = " << (h-endPointDist) / h
<< " (from G4MagIntegratorDriver)" << G4endl;
<< " eps = " << eps
<< " (from G4MagInt_Driver)" << G4endl;
}
}
}
// ---------------------------------------------------------
void
G4MagInt_Driver::OneGoodStep( G4double y[],
G4MagInt_Driver::OneGoodStep( G4double y[], // InOut
const G4double dydx[],
G4double& x,
G4double& x, // InOut
G4double htry,
G4double eps_rel_max,
G4double& hdid,
G4double& hnext )
G4double& hdid, // Out
G4double& hnext ) // Out
// Driver for one Runge-Kutta Step with monitoring of local truncation error
// to ensure accuracy and adjust stepsize. Input are dependent variable
@@ -411,6 +498,22 @@ G4bool G4MagInt_Driver::QuickAdvance(
return true;
}
#ifdef QUICK_ADV_TWO
G4bool G4MagInt_Driver::QuickAdvance(
G4double yarrin[], // IN
const G4double dydx[],
G4double hstep, // In
G4double yarrout[],
G4double& dchord_step,
G4double& dyerr ) // in length
{
G4Exception("Not implemented in current version");
dyerr = dchord_step = hstep * yarrin[0] * dydx[0];
yarrout[0]= yarrin[0];
}
#endif
// --------------------------------------------------------------------------
// This method computes new step sizes - but does not limit changes to
// within certain factors
@@ -436,12 +539,11 @@ G4MagInt_Driver::ComputeNewStepSize(
return hnew;
}
// --------------------------------------------------------------------------
// This method computes new step sizes - but does not limit changes to
// within certain factors
// -----------------------------------------------------------------------------
// This method computes new step sizes limiting changes within certain factors
//
// It shares its logic with AccurateAdvance, so they should eventually
// be merged ??
// It shares its logic with AccurateAdvance.
// They are kept separate currently for optimisation.
G4double
G4MagInt_Driver::ComputeNewStepSize_WithinLimits(
@@ -469,3 +571,126 @@ G4MagInt_Driver::ComputeNewStepSize_WithinLimits(
return hnew;
}
void G4MagInt_Driver::PrintStatus( const G4double* StartArr,
G4double xstart,
const G4double* CurrentArr,
G4double xcurrent,
G4double requestStep,
G4int subStepNo)
// Potentially add as arguments:
// <dydx> - as Initial Force
// stepTaken(hdid) - last step taken
// nextStep (hnext) - proposal for size
{
G4FieldTrack StartFT(G4ThreeVector(0,0,0), G4ThreeVector(0,0,0), 0., 0., 0., 0. );
G4FieldTrack CurrentFT (StartFT);
StartFT.LoadFromArray( StartArr);
StartFT.SetCurveLength( xstart);
CurrentFT.LoadFromArray( CurrentArr);
CurrentFT.SetCurveLength( xcurrent );
PrintStatus(StartFT, CurrentFT, requestStep, subStepNo );
}
#include "g4std/iomanip"
void G4MagInt_Driver::PrintStatus(
const G4FieldTrack& StartFT,
const G4FieldTrack& CurrentFT,
G4double requestStep,
// G4double safety,
G4int subStepNo)
{
G4int verboseLevel= fVerboseLevel;
static G4int noPrecision= 5;
G4int oldPrec= G4cout.precision(noPrecision);
// G4cout.setf(ios_base::fixed,ios_base::floatfield);
const G4ThreeVector StartPosition= StartFT.GetPosition();
const G4ThreeVector StartUnitVelocity= StartFT.GetMomentumDir();
const G4ThreeVector CurrentPosition= CurrentFT.GetPosition();
const G4ThreeVector CurrentUnitVelocity= CurrentFT.GetMomentumDir();
G4double step_len= CurrentFT.GetCurveLength()
- StartFT.GetCurveLength();
if( (subStepNo <= 0) && (verboseLevel <= 3) )
{
subStepNo = - subStepNo; // To allow printing banner
G4cout << G4std::setw( 6) << " "
<< G4std::setw( 25) << " G4MagInt_Driver: Current Position and Direction" << " "
<< G4endl;
G4cout << G4std::setw( 5) << "Step#" << " "
<< G4std::setw( 7) << "s-curve" << " "
<< G4std::setw( 9) << "X(mm)" << " "
<< G4std::setw( 9) << "Y(mm)" << " "
<< G4std::setw( 9) << "Z(mm)" << " "
<< G4std::setw( 7) << " N_x " << " "
<< G4std::setw( 7) << " N_y " << " "
<< G4std::setw( 7) << " N_z " << " "
<< G4std::setw( 7) << "KinEner " << " "
<< G4std::setw( 9) << "StepLen" << " " // Add the Sub-step ??
<< G4std::setw( 9) << "ReqStep" << " "
<< G4endl;
PrintStat_Aux( StartFT, requestStep, 0., 0);
//*************
}
if( verboseLevel <= 3 )
{
G4cout.precision(noPrecision);
PrintStat_Aux( CurrentFT, requestStep, step_len, subStepNo);
//*************
}
else // if( verboseLevel > 3 )
{
// Multi-line output
// G4cout << "Current Position is " << CurrentPosition << G4endl
// << " and UnitVelocity is " << CurrentUnitVelocity << G4endl;
// G4cout << "Step taken was " << step_len
// << " out of PhysicalStep= " << requestStep << G4endl;
// G4cout << "Final safety is: " << safety << G4endl;
// G4cout << "Chord length = " << (CurrentPosition-StartPosition).mag() << G4endl;
// G4cout << G4endl;
}
G4cout.precision(oldPrec);
}
void G4MagInt_Driver::PrintStat_Aux(
const G4FieldTrack& aFieldTrack,
G4double requestStep,
G4double step_len,
G4int subStepNo)
{
const G4ThreeVector Position= aFieldTrack.GetPosition();
const G4ThreeVector UnitVelocity= aFieldTrack.GetMomentumDir();
if( subStepNo >= 0)
G4cout << G4std::setw( 5) << subStepNo << " ";
else
G4cout << G4std::setw( 5) << "Start" << " ";
G4cout << G4std::setw( 7) << aFieldTrack.GetCurveLength();
G4cout << G4std::setw( 9) << Position.x() << " "
<< G4std::setw( 9) << Position.y() << " "
<< G4std::setw( 9) << Position.z() << " "
<< G4std::setw( 7) << UnitVelocity.x() << " "
<< G4std::setw( 7) << UnitVelocity.y() << " "
<< G4std::setw( 7) << UnitVelocity.z() << " ";
G4cout << G4std::setw( 7) << aFieldTrack.GetKineticEnergy();
G4cout << G4std::setw( 9) << step_len << " ";
if( requestStep != -1.0 )
G4cout << G4std::setw( 9) << requestStep << " ";
else
G4cout << G4std::setw( 9) << " InitialStep " << " ";
// G4cout << G4std::setw(12) << safety << " ";
G4cout << G4endl;
}
source/geometry/magneticfield/src/G4MagIntegratorStepper.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4MagIntegratorStepper.cc,v 1.5.2.1 2001/06/28 19:08:20 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4MagIntegratorStepper.cc,v 1.6 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4MagIntegratorStepper.hh"
source/geometry/magneticfield/src/G4Mag_EqRhs.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4Mag_EqRhs.cc,v 1.6.2.1 2001/06/28 19:08:21 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4Mag_EqRhs.cc,v 1.7 2001/07/11 09:59:12 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// This is the standard right-hand side for equation of motion
// in a pure Magnetic Field .
source/geometry/magneticfield/src/G4Mag_SpinEqRhs.cc
+1 -1
View File
@@ -28,7 +28,7 @@
//
// J. Apostolakis, February 8th, 1999
// P. Gumplinger, February 8th, 1999
// P. Gumplinger, April 11th, 2001
// D. Cote-Ahern, P. Gumplinger, April 11th, 2001
//
#include "G4Mag_SpinEqRhs.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4Mag_UsualEqRhs.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4Mag_UsualEqRhs.cc,v 1.3.2.1 2001/06/28 19:08:21 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4Mag_UsualEqRhs.cc,v 1.4 2001/07/11 09:59:13 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
// This is the standard right-hand side for equation of motion.
source/geometry/magneticfield/src/G4QuadrupoleMagField.cc
+56
View File
@@ -0,0 +1,56 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
#include "G4QuadrupoleMagField.hh"
#include "globals.hh"
#include "geomdefs.hh"
G4QuadrupoleMagField::G4QuadrupoleMagField(G4double pGradient)
{
fGradient = pGradient ;
}
/////////////////////////////////////////////////////////////////////////
G4QuadrupoleMagField::~G4QuadrupoleMagField()
{
;
}
////////////////////////////////////////////////////////////////////////
void
G4QuadrupoleMagField::GetFieldValue( const G4double y[7],
G4double B[3] ) const
{
// G4double fGradient = 0.001 ; // Tesla/mm
B[0] = fGradient*y[1] ;
B[1] = fGradient*y[0] ;
B[2] = 0 ;
return ;
}
source/geometry/magneticfield/src/G4RKG3_Stepper.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4RKG3_Stepper.cc,v 1.5.4.1 2001/06/28 19:08:21 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4RKG3_Stepper.cc,v 1.6 2001/07/11 09:59:13 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
#include "G4RKG3_Stepper.hh"
#include "G4ThreeVector.hh"
source/geometry/magneticfield/src/G4SimpleHeum.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4SimpleHeum.cc,v 1.4.4.1 2001/06/28 19:08:21 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4SimpleHeum.cc,v 1.5 2001/07/11 09:59:13 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Simple Heum:
// x_1 = x_0 + h *
source/geometry/magneticfield/src/G4SimpleRunge.cc
+2 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4SimpleRunge.cc,v 1.3.4.1 2001/06/28 19:08:21 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4SimpleRunge.cc,v 1.4 2001/07/11 09:59:13 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
// Simple Runge:
//
source/geometry/magneticfield/src/G4UniformElectricField.cc
+4 -4
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4UniformElectricField.cc,v 1.3.2.1 2001/06/28 19:08:21 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4UniformElectricField.cc,v 1.6 2001/12/04 17:35:54 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
//
@@ -86,8 +86,8 @@ G4UniformElectricField& G4UniformElectricField::operator = (const G4UniformElect
// ------------------------------------------------------------------------
void G4UniformElectricField::GetFieldValue (const G4double [3],
G4double fieldBandE[6] ) const
void G4UniformElectricField::GetFieldValue (const G4double[4],
G4double *fieldBandE ) const
{
fieldBandE[0]= 0.0;
fieldBandE[1]= 0.0;
source/geometry/magneticfield/src/G4UniformMagField.cc
+3 -3
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4UniformMagField.cc,v 1.3.4.1 2001/06/28 19:08:22 gunter Exp $
// GEANT4 tag $Name: $
// $Id: G4UniformMagField.cc,v 1.5 2001/11/08 17:32:21 grichine Exp $
// GEANT4 tag $Name: geant4-04-00 $
//
//
//
@@ -89,7 +89,7 @@ G4UniformMagField& G4UniformMagField::operator = (const G4UniformMagField &p)
// ------------------------------------------------------------------------
void G4UniformMagField::GetFieldValue (const G4double [3],
void G4UniformMagField::GetFieldValue (const G4double [4],
G4double *B ) const
{
B[0]= fFieldComponents[0] ;