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 "AbsBeamline/Component.h"
#include "AbsBeamline/EndFieldModel/EndFieldModel.h"
#include "BeamlineGeometry/PlanarArcGeometry.h"
#include "Fields/BMultipoleField.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 std::shared_ptr<ParticleContainer_t>& pc) override;
 
    bool apply(const size_t& i, const double& t, Vector_t<double, 3>& E, Vector_t<double, 3>& B)
            override;
 
    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) override;
 
    bool getFieldValue(const Vector_t<double, 3>& R, Vector_t<double, 3>& B) const;
 
    bool getFieldValueCylindrical(const Vector_t<double, 3>& R, Vector_t<double, 3>& B) const;
 
    void initialise(PartBunch_t* bunch, double& startField, double& endField) override;
 
    void initialise();
 
    void finalise() override;
 
    inline bool bends() const override;
 
    void getFieldExtend(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<double, 3> getCentre() const { return centre_m; }
 
    void setCentre(Vector_t<double, 3> 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<double, 3> 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