VerticalFFAMagnet.h

Go to the documentation of this file.

//
// Class VerticalFFAMagnet
//   Defines the abstract interface for a vertical FFA magnet
//   with vertical scaling fringe fields.
//
// Copyright (c) 2019 - 2023, Chris Rogers, STFC Rutherford Appleton Laboratory, Didcot, UK
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef ABSBEAMLINE_VerticalFFAMagnet_H
#define ABSBEAMLINE_VerticalFFAMagnet_H
 
#include "AbsBeamline/Component.h"
#include "Algorithms/PartBunch.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "Fields/BMultipoleField.h"
#include "Physics/Units.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);
 
    double getB0() const {return Bz_m * Units::kG2T;}
 
    void setB0(double Bz) {Bz_m = Bz * Units::T2kG;}
 
    double getFieldIndex() const {return k_m;} // units are [m^{-1}]
 
    void setFieldIndex(double index) {k_m = index;}
 
    double getNegativeVerticalExtent() const {return zNegExtent_m;}
 
    inline void setNegativeVerticalExtent(double negativeExtent);
 
    double getPositiveVerticalExtent() const {return zPosExtent_m;}
 
    inline void setPositiveVerticalExtent(double positiveExtent);
 
    double getBBLength() const {return bbLength_m;}
 
    void setBBLength(double bbLength) {bbLength_m = bbLength;}
 
    double getWidth() const {return halfWidth_m * 2.;}
 
    void setWidth(double width) {halfWidth_m = width / 2;}
 
    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;
};
 
void VerticalFFAMagnet::setNegativeVerticalExtent(double negativeExtent) {
    zNegExtent_m = negativeExtent;
}
 
void VerticalFFAMagnet::setPositiveVerticalExtent(double positiveExtent) {
    zPosExtent_m = positiveExtent;
}
 
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& , Vector_t& /*E*/, Vector_t& B) {
    return getFieldValue(R, B);
}
 
std::vector<std::vector<double> > VerticalFFAMagnet::getDfCoefficients() const {
    return dfCoefficients_m;
}
 
#endif