ScalingFFAMagnet.h

Go to the documentation of this file.

//
// Class ScalingFFAMagnet
//   Defines the abstract interface for a sector FFA magnet
//   with radially scaling fringe fields.
//
// Copyright (c) 2017 - 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_ScalingFFAMagnet_H
#define ABSBEAMLINE_ScalingFFAMagnet_H

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

#include <cmath>

class ScalingFFAMagnet: public Component {

public:
    explicit ScalingFFAMagnet(const std::string& name);

    ~ScalingFFAMagnet();

    ScalingFFAMagnet* clone() const override;

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

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

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

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

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

    void initialise();

    void finalise() override;

    inline bool bends() const override;

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

    BGeometryBase& getGeometry() override;

    const BGeometryBase& getGeometry() const override;

    EMField& getField() override;

    const EMField& getField() const override;

    void accept(BeamlineVisitor& visitor) const override;

    double getTanDelta() const {return tanDelta_m;}

    void setTanDelta(double tanDelta) {tanDelta_m = tanDelta;}

    double getFieldIndex() const {return k_m;}

    void setFieldIndex(double k) {k_m = k;}

    double getDipoleConstant() const {return Bz_m;}

    void setDipoleConstant(double Bz) {Bz_m = Bz;}

    double getR0() const {return r0_m;}

    void setR0(double r0) {r0_m = r0; r0Sign_m = r0_m / std::abs(r0_m);}

    Vector_t getCentre() const {return centre_m;}

    void setCentre(Vector_t centre) {centre_m = centre;}

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

    void setEndField(endfieldmodel::EndFieldModel* endField);

    size_t getMaxOrder() const {return maxOrder_m;}

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

    double getPhiStart() const {return phiStart_m;}

    void setPhiStart(double phiStart) {phiStart_m = phiStart;}

    double getPhiEnd() const {return phiEnd_m;}

    void setPhiEnd(double phiEnd) {phiEnd_m = phiEnd;}

    double getRMin() const {return rMin_m;}

    void setRMin(double rMin) {rMin_m = rMin;}

    double getRMax() const {return rMax_m;}

    void setRMax(double rMax) {rMax_m = rMax;}

    double getAzimuthalExtent() const {return azimuthalExtent_m;}

    void setAzimuthalExtent(double azimuthalExtent) {azimuthalExtent_m = azimuthalExtent;}

    double getVerticalExtent() const {return verticalExtent_m;}

    void setVerticalExtent(double verticalExtent) {verticalExtent_m = verticalExtent;}

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

    void setupEndField();

    void setEndFieldName(std::string name) {endFieldName_m = name;}

    std::string getEndFieldName() const {return endFieldName_m;}


private:
    void calculateDfCoefficients();

    ScalingFFAMagnet(const ScalingFFAMagnet& right);

    ScalingFFAMagnet& operator=(const ScalingFFAMagnet& rhs);
    PlanarArcGeometry planarArcGeometry_m;
    BMultipoleField dummy;

    size_t maxOrder_m = 0; // maximum order used in the calculation
    double tanDelta_m = 0.; // tan(spiral angle)
    double k_m = 0.; // field index
    double Bz_m = 0.; // nominal field on the radius
    double r0_m = 0.; // radius; negative for clockwise geometry, else positive
    double rMin_m = 0.; // minimum radius
    double rMax_m = 0.; // maximum radius
    double phiStart_m = 0.; // offsets this element
    double phiEnd_m = 0.; // used for placement of next element
    double azimuthalExtent_m = 0.; // maximum distance used for field calculation
    double verticalExtent_m = 0.; // maximum allowed distance from the midplane
    double r0Sign_m = 0.0; // -1 for clockwise geometry, else +1
    Vector_t centre_m; // nominal ring centre
    endfieldmodel::EndFieldModel* endField_m = nullptr;
    std::string endFieldName_m = ""; 
    const double fp_tolerance = 1e-18;
    std::vector<std::vector<double> > dfCoefficients_m;
};

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

bool ScalingFFAMagnet::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);
}

#endif