VerticalFFAMagnet.h

Go to the documentation of this file.

//
// Header file for VerticalFFAMagnet Component
//
// Copyright (c) 2019 Chris Rogers
// All rights reserved.
//
// OPAL is licensed under GNU GPL version 3.
//

#include "Fields/BMultipoleField.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "AbsBeamline/Component.h"
#include "Algorithms/PartBunch.h"

#ifndef ABSBEAMLINE_VerticalFFAMagnet_H
#define ABSBEAMLINE_VerticalFFAMagnet_H

namespace endfieldmodel {
    class EndFieldModel;
}

class VerticalFFAMagnet : public Component {
  public:
    explicit VerticalFFAMagnet(const std::string &name);

    ~VerticalFFAMagnet();

    ElementBase* clone() const;

    inline bool apply(const size_t &i, const double &t, Vector_t &E, Vector_t &B);

    inline bool apply(const Vector_t &R, const Vector_t &P, const double &t,
               Vector_t &E, Vector_t &B);

    bool getFieldValue(const Vector_t &R, Vector_t &B) const;

     void initialise(PartBunchBase<double, 3> *bunch, double &startField, double &endField);

    void initialise();

    void finalise();

    inline bool bends() const {return false;}

    void getDimensions(double &zBegin, double &zEnd) const {}

    BGeometryBase& getGeometry();

    const BGeometryBase& getGeometry() const;

    EMField &getField();

    const EMField &getField() const;

    void accept(BeamlineVisitor& visitor) const;

    endfieldmodel::EndFieldModel* getEndField() const {return endField_m.get();}

    void setEndField(endfieldmodel::EndFieldModel* endField);

    size_t getMaxOrder() const {return maxOrder_m;}

    void setMaxOrder(size_t maxOrder) {maxOrder_m = maxOrder;}

    double getB0() const {return Bz_m/Tesla;}

    void setB0(double Bz) {Bz_m = Bz*Tesla;}

    double getFieldIndex() const {return k_m*mm;} // units are [m^{-1}]

    void setFieldIndex(double index) {k_m = index/mm;}

    double getNegativeVerticalExtent() const {return zNegExtent_m/mm;}

    inline void setNegativeVerticalExtent(double negativeExtent);

    double getPositiveVerticalExtent() const {return zPosExtent_m/mm;}

    inline void setPositiveVerticalExtent(double positiveExtent);

    double getBBLength() const {return bbLength_m/mm;}

    void setBBLength(double bbLength) {bbLength_m = bbLength*mm;}

    double getWidth() const {return halfWidth_m/mm*2.;}

    void setWidth(double width) {halfWidth_m = width/2*mm;}

    inline std::vector<std::vector<double> > getDfCoefficients() const;
private:
    void calculateDfCoefficients();

    VerticalFFAMagnet(const VerticalFFAMagnet &right);

    VerticalFFAMagnet& operator=(const VerticalFFAMagnet& rhs);
    StraightGeometry straightGeometry_m;
    BMultipoleField dummy;

    size_t maxOrder_m = 0;
    double k_m = 0.;
    double Bz_m = 0.;
    double zNegExtent_m = 0.; // extent downwards from the midplane
    double zPosExtent_m = 0.; // extent upwards from the midplane
    double halfWidth_m = 0.; // extent in either +x or -x
    double bbLength_m = 0.;
    std::unique_ptr<endfieldmodel::EndFieldModel> endField_m;
    std::vector<std::vector<double> > dfCoefficients_m;

    const double mm=1000.;
    const double Tesla=10.;
};

void VerticalFFAMagnet::setNegativeVerticalExtent(double negativeExtent) {
    zNegExtent_m = negativeExtent*mm;
}

void VerticalFFAMagnet::setPositiveVerticalExtent(double positiveExtent) {
    zPosExtent_m = positiveExtent*mm;
}

bool VerticalFFAMagnet::apply(const size_t &i, const double &t,
                    Vector_t &E, Vector_t &B) {
    return apply(RefPartBunch_m->R[i], RefPartBunch_m->P[i], t, E, B);
}

bool VerticalFFAMagnet::apply(const Vector_t &R, const Vector_t &P,
                    const double &t, Vector_t &E, Vector_t &B) {
    return getFieldValue(R, B);
}

std::vector<std::vector<double> > VerticalFFAMagnet::getDfCoefficients() const {
    return dfCoefficients_m;
}

#endif