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();

    ElementBase* 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;}

  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 = NULL;
    const double fp_tolerance = 1e-18;
    std::vector<std::vector<double> > dfCoefficients_m;
};

#endif