BMultipoleField.h

Go to the documentation of this file.

#ifndef CLASSIC_BMultipoleField_HH
#define CLASSIC_BMultipoleField_HH
 
// ------------------------------------------------------------------------
// $RCSfile: BMultipoleField.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: BMultipoleField
//
// ------------------------------------------------------------------------
// Class category: Fields
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:35 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "Fields/StaticMagneticField.h"
 
// Class BMultipoleField
// ------------------------------------------------------------------------
//  The static components are defined by the equation
//  {center}
//  By + i * Bx = sum (Bn + i * An) (x + i * y) ** (n - 1)
//  {/center}
//  where the index  n  runs from  1  (dipole) to  N  (2N-pole).
//  The field component n is stored in the pairs[n-1],
//  The array  pairs  has the dimension N.
 
class BMultipoleField: public StaticMagneticField {
 
public:
 
    //  Constructs a null field.
    BMultipoleField();
 
    BMultipoleField(const BMultipoleField &);
    virtual ~BMultipoleField();
    BMultipoleField &operator=(const BMultipoleField &);
 
    //  Return the time-independent part of the magnetic field in point [b]P[/b].
    //  This override forces implementation in derived classes.
    virtual BVector Bfield(const Point3D &P) const;
 
    //  Return the magnetic field at time [b]t[/b] in point [b]P[/b].
    //  This override forces implementation in derived classes.
    virtual BVector Bfield(const Point3D &P, double t) const;
 
    //  Return the value of the n'th normal multipole component in  T/m**(n-1).
    //  If [b]n[/b] is larger than N, the return value is zero.
    double getNormalComponent(int n) const;
 
    //  Return the value of the n'th skew multipole component in T/m**(n-1).
    //  If [b]n[/b] is larger than N, the return value is zero.
    double getSkewComponent(int n) const;
 
    //  Assign the value of the n'th normal multipole component in T/m**(n-1).
    //  If [b]n[/b] is larger than N, the new field component is inserted.
    void setNormalComponent(int n, double Bn);
 
    //  Assign the value of the n'th skew multipole component in T/m**(n-1).
    //  If [b]n[/b] is larger than N, the new field component is inserted.
    void setSkewComponent(int n, double Bn);
 
    //  Return the value of the n'th normal multipole component in T/m**(n-1).
    //  Fast version: [b]n[/b] is not checked.
    //  the result is undefined if it is larger than N.
    double normal(int) const;
 
    //  Return the value of the n'th skew multipole component in T/m**(n-1).
    //  Fast version: [b]n[/b] is not checked.
    //  the result is undefined if it is larger than N.
    double skew(int) const;
 
    //  Return a reference to the n'th normal multipole component in T/m**(n-1).
    //  Fast version: [b]n[/b] is not checked.
    //  the result is undefined if it is larger than N.
    double &normal(int);
 
    //  Return a reference to the n'th skew multipole component in T/m**(n-1).
    //  Fast version: [b]n[/b] is not checked.
    //  the result is undefined if it is larger than N.
    double &skew(int);
 
    //  Add [b]field[/b] to the old field; return new field.
    BMultipoleField &addField(const BMultipoleField &field);
 
    //  Subtract [b]field[/b] from the old field; return new field.
    BMultipoleField &subtractField(const BMultipoleField &field);
 
    //  Multiply the field by [b]scalar[/b].
    void scale(double scalar);
 
    int order() const;
 
private:
 
    struct Pair {
        // constructors and destructor
        Pair();
        Pair(double normal, double skewed = 0.0);
        Pair(const Pair &);
        ~Pair();
 
        // operators
        void operator=(const Pair &);
        Pair operator+(const Pair &) const;
        Pair operator-(const Pair &) const;
        Pair operator*(double scale) const;
        void operator+=(const Pair &);
        void operator-=(const Pair &);
        void operator*=(double scale);
        Pair operator-() const;
 
        double B;   // normal multipole coefficient
        double A;   // skewed multipole coefficient
    };
 
    // Reserve space for additional coefficients.
    void reserve(int n);
 
    // The array of multipole coefficients.
    // The dimension is N, where N is the largest order (2N-pole),
    // and pairs[n-1] is the coefficient for the (2n-pole).
    Pair *pairs;
 
    // The highest order N.
    int itsOrder;
};
 
 
// Inline functions
// ------------------------------------------------------------------------
 
inline int BMultipoleField::order() const {
    return itsOrder;
}
 
 
inline double BMultipoleField::getNormalComponent(int n) const {
    if(n > 0 && n <= itsOrder) {
        return pairs[n-1].B;
    } else {
        return 0.0;
    }
}
 
 
inline double BMultipoleField::getSkewComponent(int n) const {
    if(n > 0 && n <= itsOrder) {
        return pairs[n-1].A;
    } else {
        return 0.0;
    }
}
 
 
inline double &BMultipoleField::normal(int n)
{ return pairs[n-1].B; }
 
 
inline double &BMultipoleField::skew(int n)
{ return pairs[n-1].A; }
 
 
inline double BMultipoleField::normal(int n) const
{ return pairs[n-1].B; }
 
 
inline double BMultipoleField::skew(int n) const
{ return pairs[n-1].A; }
 
#endif // CLASSIC_BMultipoleField_HH