#include <G4HarmonicPolMagField.hh>

Inheritance diagram for G4HarmonicPolMagField:

Public Member Functions
	G4HarmonicPolMagField ()

	~G4HarmonicPolMagField () override

void	GetFieldValue (const G4double yTrack[], G4double B[]) const override

G4HarmonicPolMagField *	Clone () const override

Public Member Functions inherited from G4MagneticField
	G4MagneticField ()

	~G4MagneticField () override

	G4MagneticField (const G4MagneticField &r)

G4MagneticField &	operator= (const G4MagneticField &p)

G4bool	DoesFieldChangeEnergy () const override

void	GetFieldValue (const G4double Point[4], G4double *Bfield) const override=0

Public Member Functions inherited from G4Field
	G4Field (G4bool gravityOn=false)

	G4Field (const G4Field &)

virtual	~G4Field ()

G4Field &	operator= (const G4Field &p)

G4bool	IsGravityActive () const

void	SetGravityActive (G4bool OnOffFlag)

Additional Inherited Members
Static Public Attributes inherited from G4Field
static constexpr G4int	MAX_NUMBER_OF_COMPONENTS = 24

Detailed Description

Definition at line 44 of file G4HarmonicPolMagField.hh.

Constructor & Destructor Documentation

◆ G4HarmonicPolMagField()

G4HarmonicPolMagField::G4HarmonicPolMagField ( )

default

Referenced by Clone().

◆ ~G4HarmonicPolMagField()

G4HarmonicPolMagField::~G4HarmonicPolMagField ( )

overridedefault

Member Function Documentation

◆ Clone()

G4HarmonicPolMagField * G4HarmonicPolMagField::Clone ( ) const

overridevirtual

Reimplemented from G4Field.

Definition at line 36 of file G4HarmonicPolMagField.cc.

{
  return new G4HarmonicPolMagField;
}

◆ GetFieldValue()

void G4HarmonicPolMagField::GetFieldValue	(	const G4double	yTrack[],
		G4double	B[] ) const

override

Definition at line 47 of file G4HarmonicPolMagField.cc.

{
   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 G4ThreadLocal G4double
   c[24] = {
             .010, .010, .010,                                       // 3(0)
             .0001, .0001, .0001, .0001, .0001,                      // 5(1)
             .00001, .00001, .00001, .00001, .00001, .00001, .00001, // 7(2)
             .000001, .000001, .000001, .000001, .000001, .000001,
             .0000001, .0000001, .0000001                            // 9(3)
            } ;                                            // total :   24
   
   //   for(auto 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(auto i=0; i<3 ; ++i)
   {
      B[i] = 0.1*B[i] ;
   }
}

The documentation for this class was generated from the following files:

Public Member Functions