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 "AbsBeamline/Component.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "Fields/BMultipoleField.h"
#include "PartBunch/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<double, 3>& E, Vector_t<double, 3>& B);

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

    bool getFieldValue(const Vector_t<double, 3>& R, Vector_t<double, 3>& B) const;

    void initialise(PartBunch_t* 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);

    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<double, 3>& E, Vector_t<double, 3>& B) {
    std::shared_ptr<ParticleContainer_t> pc = RefPartBunch_m->getParticleContainer();
    auto Rview                              = pc->R.getView();
    auto Pview                              = pc->P.getView();
    const Vector_t<double, 3> R             = Rview(i);
    const Vector_t<double, 3> P             = Pview(i);
    return apply(R, P, t, E, B);
}
 
bool VerticalFFAMagnet::apply(
    const Vector_t<double, 3>& R, const Vector_t<double, 3>& /*P*/, const double&,
    Vector_t<double, 3>& /*E*/, Vector_t<double, 3>& B) {
    return getFieldValue(R, B);
}
 
std::vector<std::vector<double> > VerticalFFAMagnet::getDfCoefficients() const {
    return dfCoefficients_m;
}
 
#endif