F04GlobalField Class Reference

#include <F04GlobalField.hh>

Inheritance diagram for F04GlobalField:

Collaboration diagram for F04GlobalField:

Public Member Functions
virtual	~F04GlobalField ()
virtual void	GetFieldValue (const G4double *point, G4double *field) const
virtual G4bool	DoesFieldChangeEnergy () const
	DoesFieldChangeEnergy() returns true. More...
void	AddElementField (F04ElementField *f)
void	Clear ()
void	ConstructField ()
	constructs all field tracking objects More...
void	SetStepperType (G4int i)
	Set the Stepper types. More...
void	SetStepper ()
	Set the Stepper. More...
void	SetMinStep (G4double stp)
	Set the minimum step length. More...
void	SetDeltaChord (G4double dcr)
	Set the delta chord length. More...
void	SetDeltaOneStep (G4double stp)
	Set the delta one step length. More...
void	SetDeltaIntersection (G4double its)
	Set the delta intersection length. More...
void	SetEpsMin (G4double eps)
	Set the minimum eps length. More...
void	SetEpsMax (G4double eps)
	Set the maximum eps length. More...
FieldList *	GetFields ()
	Return the list of Element Fields. More...
Public Member Functions inherited from G4ElectroMagneticField
	G4ElectroMagneticField ()
virtual	~G4ElectroMagneticField ()
	G4ElectroMagneticField (const G4ElectroMagneticField &r)
G4ElectroMagneticField &	operator= (const G4ElectroMagneticField &p)
virtual void	GetFieldValue (const G4double Point[4], G4double *Bfield) const =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)
virtual G4Field *	Clone () const

Static Public Member Functions
static F04GlobalField *	GetObject (F04DetectorConstruction *const)
static F04GlobalField *	GetObject ()

Protected Member Functions
G4FieldManager *	GetGlobalFieldManager ()
	Get the global field manager. More...

Detailed Description

Definition at line 68 of file F04GlobalField.hh.

Constructor & Destructor Documentation

F04GlobalField::~F04GlobalField ( )

virtual

Definition at line 91 of file F04GlobalField.cc.

{
  Clear();

  delete fFields;

  delete fFieldMessenger;

  if (fEquation)        delete fEquation;
  if (fStepper)         delete fStepper;
  if (fChordFinder)     delete fChordFinder;
}

Here is the call graph for this function:

Member Function Documentation

void F04GlobalField::AddElementField ( F04ElementField *  f )

inline

AddElementField() adds the ElementField object for a single element to the global field.

Definition at line 99 of file F04GlobalField.hh.

  {
    if (fFields) fFields->push_back(f);
  }

Here is the caller graph for this function:

void F04GlobalField::Clear

(

)

Clear() removes all ElementField-s from the global object, and destroys them. Used before the geometry is completely re-created.

Definition at line 292 of file F04GlobalField.cc.

{
  if (fFields) {
     if (fFields->size()>0) {
        FieldList::iterator i;
        for (i=fFields->begin(); i!=fFields->end(); ++i) delete *i;
        fFields->clear();
     }
  }

  if (fFp) { delete [] fFp; }
  fFirst = true;
  fNfp = 0;
  fFp = NULL;
}

Here is the caller graph for this function:

void F04GlobalField::ConstructField

(

)

constructs all field tracking objects

Definition at line 106 of file F04GlobalField.cc.

{
  Clear();

  //  Construct equ. of motion of particles through B fields
//  fEquation = new G4Mag_EqRhs(this);
  //  Construct equ. of motion of particles through e.m. fields
//  fEquation = new G4EqMagElectricField(this);
  //  Construct equ. of motion of particles including spin through B fields
//  fEquation = new G4Mag_SpinEqRhs(this);
  //  Construct equ. of motion of particles including spin through e.m. fields
  fEquation = new G4EqEMFieldWithSpin(this);

  //  Get transportation, field, and propagator managers
  G4TransportationManager* transportManager =
         G4TransportationManager::GetTransportationManager();

  fFieldManager = GetGlobalFieldManager();

  fFieldPropagator = transportManager->GetPropagatorInField();

  //  Need to SetFieldChangesEnergy to account for a time varying electric
  //  field (r.f. fields)
  fFieldManager->SetFieldChangesEnergy(true);

  //  Set the field
  fFieldManager->SetDetectorField(this);

  //  Choose a stepper for integration of the equation of motion
  SetStepper();

  //  Create a cord finder providing the (global field, min step length,
  //  a pointer to the stepper)
  fChordFinder = new G4ChordFinder((G4MagneticField*)this,fMinStep,fStepper);

  // Set accuracy parameters
  fChordFinder->SetDeltaChord( fDeltaChord );

  fFieldManager->SetAccuraciesWithDeltaOneStep(fDeltaOneStep);

  fFieldManager->SetDeltaIntersection(fDeltaIntersection);

  fFieldPropagator->SetMinimumEpsilonStep(fEpsMin);
  fFieldPropagator->SetMaximumEpsilonStep(fEpsMax);

  G4cout << "Accuracy Parameters:" <<
            " MinStep=" << fMinStep <<
            " DeltaChord=" << fDeltaChord <<
            " DeltaOneStep=" << fDeltaOneStep << G4endl;
  G4cout << "                    " <<
            " DeltaIntersection=" << fDeltaIntersection <<
            " EpsMin=" << fEpsMin <<
            " EpsMax=" << fEpsMax <<  G4endl;

  fFieldManager->SetChordFinder(fChordFinder);

  G4double l = 0.0;
  G4double B1 = fDetectorConstruction->GetCaptureMgntB1();
  G4double B2 = fDetectorConstruction->GetCaptureMgntB2();

  G4LogicalVolume* logicCaptureMgnt = fDetectorConstruction->GetCaptureMgnt();
  G4ThreeVector captureMgntCenter =
                                 fDetectorConstruction->GetCaptureMgntCenter();

  F04FocusSolenoid* focusSolenoid =
           new F04FocusSolenoid(B1, B2, l, logicCaptureMgnt,captureMgntCenter);
  focusSolenoid -> SetHalf(true);

  G4double B = fDetectorConstruction->GetTransferMgntB();

  G4LogicalVolume* logicTransferMgnt =
                                      fDetectorConstruction->GetTransferMgnt();
  G4ThreeVector transferMgntCenter =
                                fDetectorConstruction->GetTransferMgntCenter();

  F04SimpleSolenoid* simpleSolenoid =
             new F04SimpleSolenoid(B, l, logicTransferMgnt,transferMgntCenter);

  simpleSolenoid->SetColor("1,0,1");
  simpleSolenoid->SetColor("0,1,1");
  simpleSolenoid->SetMaxStep(1.5*mm);
  simpleSolenoid->SetMaxStep(2.5*mm);

  if (fFields) {
     if (fFields->size()>0) {
        FieldList::iterator i;
        for (i=fFields->begin(); i!=fFields->end(); ++i){
            (*i)->Construct();
        }
     }
  }
}

Here is the call graph for this function:

virtual G4bool F04GlobalField::DoesFieldChangeEnergy ( ) const

inlinevirtual

DoesFieldChangeEnergy() returns true.

Implements G4ElectroMagneticField.

Definition at line 95 of file F04GlobalField.hh.

{ return true; }

FieldList* F04GlobalField::GetFields ( )

inline

Return the list of Element Fields.

Definition at line 137 of file F04GlobalField.hh.

{ return fFields; }

void F04GlobalField::GetFieldValue ( const G4double *  point, G4double *  field  ) const

virtual

GetFieldValue() returns the field value at a given point[]. field is really field[6]: Bx,By,Bz,Ex,Ey,Ez. point[] is in global coordinates: x,y,z,t.

Definition at line 267 of file F04GlobalField.cc.

{
  // NOTE: this routine dominates the CPU time for tracking.
  // Using the simple array fFp[] instead of fields[] 
  // directly sped it up

  field[0] = field[1] = field[2] = field[3] = field[4] = field[5] = 0.0;

  // protect against Geant4 bug that calls us with point[] NaN.
  if(point[0] != point[0]) return;

  // (can't use fNfp or fFp, as they may change)
  if (fFirst) ((F04GlobalField*)this)->SetupArray();   // (cast away const)

  for (int i=0; i<fNfp; ++i) {
      const F04ElementField* p = fFp[i];
      if (p->IsInBoundingBox(point)) {
         p->AddFieldValue(point,field);
      }
  }

}

Here is the call graph for this function:

G4FieldManager * F04GlobalField::GetGlobalFieldManager ( )

protected

Get the global field manager.

Definition at line 259 of file F04GlobalField.cc.

{
  return G4TransportationManager::GetTransportationManager()
                                ->GetFieldManager();
}

Here is the call graph for this function:

Here is the caller graph for this function:

F04GlobalField * F04GlobalField::GetObject ( F04DetectorConstruction * const  det )

static

GetObject() returns the single F04GlobalField object. It is constructed, if necessary.

Definition at line 201 of file F04GlobalField.cc.

{
  if (!fObject) new F04GlobalField(det);
  return fObject;
}

F04GlobalField * F04GlobalField::GetObject ( )

static

Definition at line 209 of file F04GlobalField.cc.

{
  if (fObject) return fObject;
  return NULL;
}

Here is the caller graph for this function:

void F04GlobalField::SetDeltaChord ( G4double  dcr )

inline

Set the delta chord length.

Definition at line 122 of file F04GlobalField.hh.

{ fDeltaChord = dcr; }

Here is the caller graph for this function:

void F04GlobalField::SetDeltaIntersection ( G4double  its )

inline

Set the delta intersection length.

Definition at line 128 of file F04GlobalField.hh.

{ fDeltaIntersection = its; }

void F04GlobalField::SetDeltaOneStep ( G4double  stp )

inline

Set the delta one step length.

Definition at line 125 of file F04GlobalField.hh.

{ fDeltaOneStep = stp; }

void F04GlobalField::SetEpsMax ( G4double  eps )

inline

Set the maximum eps length.

Definition at line 134 of file F04GlobalField.hh.

{ fEpsMax = eps; }

Here is the caller graph for this function:

void F04GlobalField::SetEpsMin ( G4double  eps )

inline

Set the minimum eps length.

Definition at line 131 of file F04GlobalField.hh.

{ fEpsMin = eps; }

Here is the caller graph for this function:

void F04GlobalField::SetMinStep ( G4double  stp )

inline

Set the minimum step length.

Definition at line 119 of file F04GlobalField.hh.

{ fMinStep = stp; }

Here is the caller graph for this function:

void F04GlobalField::SetStepper

(

)

Set the Stepper.

Definition at line 217 of file F04GlobalField.cc.

{
  if(fStepper) delete fStepper;

  switch ( fStepperType )
  {
    case 0:
//      fStepper = new G4ExplicitEuler( fEquation, 8 ); // no spin tracking
      fStepper = new G4ExplicitEuler( fEquation, 12 ); // with spin tracking
      G4cout << "G4ExplicitEuler is called" << G4endl;
      break;
    case 1:
//      fStepper = new G4ImplicitEuler( fEquation, 8 ); // no spin tracking
      fStepper = new G4ImplicitEuler( fEquation, 12 ); // with spin tracking
      G4cout << "G4ImplicitEuler is called" << G4endl;
      break;
    case 2:
//      fStepper = new G4SimpleRunge( fEquation, 8 ); // no spin tracking
      fStepper = new G4SimpleRunge( fEquation, 12 ); // with spin tracking
      G4cout << "G4SimpleRunge is called" << G4endl;
      break;
    case 3:
//      fStepper = new G4SimpleHeum( fEquation, 8 ); // no spin tracking
      fStepper = new G4SimpleHeum( fEquation, 12 ); // with spin tracking
      G4cout << "G4SimpleHeum is called" << G4endl;
      break;
    case 4:
//      fStepper = new G4ClassicalRK4( fEquation, 8 ); // no spin tracking
      fStepper = new G4ClassicalRK4( fEquation, 12 ); // with spin tracking
      G4cout << "G4ClassicalRK4 (default) is called" << G4endl;
      break;
    case 5:
//      fStepper = new G4CashKarpRKF45( fEquation, 8 ); // no spin tracking
      fStepper = new G4CashKarpRKF45( fEquation, 12 ); // with spin tracking
      G4cout << "G4CashKarpRKF45 is called" << G4endl;
      break;
    default: fStepper = 0;
  }
}

Here is the caller graph for this function:

void F04GlobalField::SetStepperType ( G4int  i )

inline

Set the Stepper types.

Definition at line 113 of file F04GlobalField.hh.

{ fStepperType = i; }

Here is the caller graph for this function:

---

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

• source/geant4.10.03.p03/examples/extended/field/field04/include/F04GlobalField.hh
• source/geant4.10.03.p03/examples/extended/field/field04/src/F04GlobalField.cc