EMField.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: EMField.cpp,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:35 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "Fields/EMField.h"
 
 
// Class Point3D
// ------------------------------------------------------------------------
 
Point3D::Point3D(double xx, double yy, double zz)
{ x = xx; y = yy; z = zz; }
 
double Point3D::getX() const
{ return x; }
 
double Point3D::getY() const
{ return y; }
 
double Point3D::getZ() const
{ return z; }
 
 
// Class EVector
// ------------------------------------------------------------------------
 
EVector::EVector(double Exx, double Eyy, double Ezz)
{ Ex = Exx; Ey = Eyy; Ez = Ezz; }
 
 
EVector EVector::operator*(double scale) const
{ return EVector(scale * Ex, scale * Ey, scale * Ez); }
 
 
double EVector::getEx() const
{ return Ex; }
 
 
double EVector::getEy() const
{ return Ey; }
 
 
double EVector::getEz() const
{ return Ez; }
 
 
// Class BVector
// ------------------------------------------------------------------------
 
BVector::BVector(double Bxx, double Byy, double Bzz)
{ Bx = Bxx; By = Byy; Bz = Bzz; }
 
 
BVector BVector::operator*(double scale) const
{ return BVector(scale * Bx, scale * By, scale * Bz); }
 
 
double BVector::getBx() const
{ return Bx; }
 
 
double BVector::getBy() const
{ return By; }
 
 
double BVector::getBz() const
{ return Bz; }
 
 
// Class EBVectors
// ------------------------------------------------------------------------
 
EBVectors::EBVectors(const EVector &eField, const BVector &bField):
    E(eField), B(bField)
{}
 
 
EVector EBVectors::getE() const
{ return E; }
 
 
double EBVectors::getEx() const
{ return E.getEx(); }
 
 
double EBVectors::getEy() const
{ return E.getEy(); }
 
 
double EBVectors::getEz() const
{ return E.getEz(); }
 
 
BVector EBVectors::getB() const
{ return B; }
 
 
double EBVectors::getBx() const
{ return B.getBx(); }
 
 
double EBVectors::getBy() const
{ return B.getBy(); }
 
 
double EBVectors::getBz() const
{ return B.getBy(); }
 
 
// Class EMField
// ------------------------------------------------------------------------
 
// Zero field representations.
const EVector
EMField::ZeroEfield(0.0, 0.0, 0.0);
 
 
const BVector
EMField::ZeroBfield(0.0, 0.0, 0.0);
 
 
const EBVectors
EMField::ZeroEBfield(EMField::ZeroEfield, EMField::ZeroBfield);
 
 
EMField::EMField()
{}
 
 
EMField::EMField(const EMField &)
{}
 
 
EMField::~EMField()
{}
 
 
const EMField &EMField::operator=(const EMField &) {
    return *this;
}
 
 
EVector EMField::Efield(const Point3D &) const {
    return ZeroEfield;
}
 
 
BVector EMField::Bfield(const Point3D &) const {
    return ZeroBfield;
}
 
 
EVector EMField::Efield(const Point3D &X, double) const {
    return Efield(X);
}
 
 
BVector EMField::Bfield(const Point3D &X, double) const {
    return Bfield(X);
}
 
 
EBVectors EMField::EBfield(const Point3D &X) const {
    return EBVectors(Efield(X), Bfield(X));
}
 
 
EBVectors EMField::EBfield(const Point3D &X, double) const {
    return EBfield(X);
}