EMField.h

Go to the documentation of this file.

#ifndef CLASSIC_EMField_HH
#define CLASSIC_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 // CLASSIC_EMField_HH