EMField.h

Go to the documentation of this file.

#ifndef OPALX_EMField_HH
#define OPALX_EMField_HH
 
// ------------------------------------------------------------------------
// $RCSfile: EMField.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Classes:
//   Point3D:      a point in 3-dimensional space.
//   EVector:      an electric field vector.
//   BVector:      a magnetic field vector.
//   EBVectors:    an electromagnetic field, containing E and B.
//   EMField:      a virtual base class for electromagnetic fields.
//
// ------------------------------------------------------------------------
// Class category: Fields
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:36 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
// Class Point3D
// ------------------------------------------------------------------------
 
class Point3D {
public:
    //  Construct the point from its coordinates (x,y,z) in m.
    Point3D(double x, double y, double z);
 
    //  Return the x-coordinate for the point in m.
    double getX() const;
 
    //  Return the y-coordinate for the point in m.
    double getY() const;
 
    //  Return the z-coordinate for the point in m.
    double getZ() const;
 
private:
    double x, y, z;
};
 
// Class EVector
// ------------------------------------------------------------------------
 
class EVector {
public:
    //  Construct the field vector from is components (Ex,Ey,Ez) in A/m.
    EVector(double, double, double);
 
    //  Multiply the field vector by [b]scalar[/b].
    EVector operator*(double scalar) const;
 
    //  Return the x-component of the field in A/m.
    double getEx() const;
 
    //  Return the y-component of the field in A/m.
    double getEy() const;
 
    //  Return the z-component of the field in A/m.
    double getEz() const;
 
private:
    double Ex, Ey, Ez;
};
 
// Class BVector
// ------------------------------------------------------------------------
 
class BVector {
public:
    //  Construct the field vector from its components (Bx,By,Bz) in T.
    BVector(double, double, double);
 
    //  Multiply the field vector by [b]scalar[/b].
    BVector operator*(double scalar) const;
 
    //  Return the x-component of the field in T.
    double getBx() const;
 
    //  Return the y-component of the field in T.
    double getBy() const;
 
    //  Return the z-component of the field in T.
    double getBz() const;
 
private:
    double Bx, By, Bz;
};
 
// Class EBVectors
// ------------------------------------------------------------------------
//  Contains both an electric and a magnetic field vector.
//  These represent the instantaneous electromagnetic field in a given point.
 
class EBVectors {
public:
    //  Construct the field from the two field vectors [b]E[/b] (in A/m)
    //  and [b]B[/b] (in T).
    EBVectors(const EVector& E, const BVector& B);
 
    //  Return the electric field vector in A/m.
    EVector getE() const;
 
    //  Return the x-component of the electric field in A/m.
    double getEx() const;
 
    //  Return the y-component of the electric field in A/m.
    double getEy() const;
 
    //  Return the z-component of the electric field in A/m.
    double getEz() const;
 
    //  Return the magnetic field vector in T.
    BVector getB() const;
 
    //  Return the x-component of the magnetic field in T.
    double getBx() const;
 
    //  Return the y-component of the magnetic field in T.
    double getBy() const;
 
    //  Return the z-component of the magnetic field in T.
    double getBz() const;
 
private:
    EVector E;
    BVector B;
};
 
// Class EMField
// ------------------------------------------------------------------------
//  This class represent a time-varying position dependent electromagnetic
//  field.  Derived classes include time-constant fields as well as
//  spatially homogeneous fields.
 
class EMField {
public:
    //  Construct zero field.
    EMField();
 
    EMField(const EMField& right);
    virtual ~EMField();
    const EMField& operator=(const EMField& right);
 
    //  Return the time-independent part of the electric field in point [b]P[/b].
    //  This default action returns a zero field.
    virtual EVector Efield(const Point3D& P) const;
 
    //  Return the time-independent part of the magnetic field in point [b]P[/b].
    //  This default action returns a zero field.
    virtual BVector Bfield(const Point3D& P) const;
 
    //  Return the electric field at time [b]t[/b] in point [b]P[/b].
    //  This default action returns the static part  EField(P).
    virtual EVector Efield(const Point3D& P, double t) const;
 
    //  Return the magnetic field at time [b]t[/b] in point [b]P[/b].
    //  This default action returns the static part  BField(P).
    virtual BVector Bfield(const Point3D& P, double t) const;
 
    //  Return the static part of the field pair (E,B) in point [b]P[/b].
    //  This default action returns  EBVectors(EField(P), BField(P)).
    virtual EBVectors EBfield(const Point3D& P) const;
 
    //  Return the field pair (E,B) at time [b]t[/b] in point [b]P[/b].
    //  This default action returns the static part  EBfield(P).
    virtual EBVectors EBfield(const Point3D& P, double t) const;
 
    //  Multiply the field by [b]scalar[/b].
    //  This method must be defined for each derived class.
    virtual void scale(double scalar) = 0;
 
    static const EVector ZeroEfield;
 
    static const BVector ZeroBfield;
 
    static const EBVectors ZeroEBfield;
};
 
#endif  // OPALX_EMField_HH