ScalingFFAMagnet.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2017, Chris Rogers
 *  All rights reserved.
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *  3. Neither the name of STFC nor the names of its contributors may be used to
 *     endorse or promote products derived from this software without specific
 *     prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */
 
#include "Fields/BMultipoleField.h"
#include "BeamlineGeometry/PlanarArcGeometry.h"
#include "AbsBeamline/EndFieldModel/EndFieldModel.h"
#include "AbsBeamline/Component.h"
 
#ifndef ABSBEAMLINE_ScalingFFAMagnet_H
#define ABSBEAMLINE_ScalingFFAMagnet_H
 
class ScalingFFAMagnet : public Component {
  public:
    explicit ScalingFFAMagnet(const std::string &name);
 
    ~ScalingFFAMagnet();
 
    ScalingFFAMagnet* clone() const override;
 
    bool apply(const size_t &i, const double &t, Vector_t &E, Vector_t &B) override;
 
    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;}
 
    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;
    double tanDelta_m = 0.;
    double k_m = 0.;
    double Bz_m = 0.;
    double r0_m = 0.;
    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
    Vector_t centre_m;
    endfieldmodel::EndFieldModel* endField_m = nullptr;
    std::string endFieldName_m = ""; 
    const double fp_tolerance = 1e-18;
    std::vector<std::vector<double> > dfCoefficients_m;
};
 
#endif