MultipoleT.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2017, Titus Dascalu
 *  Copyright (c) 2018, Martin Duy Tat
 *  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.
 */
 
 
#ifndef CLASSIC_MULTIPOLET_H
#define CLASSIC_MULTIPOLET_H
 
#include "AbsBeamline/EndFieldModel/Tanh.h"
#include "BeamlineGeometry/PlanarArcGeometry.h"
#include "Fields/BMultipoleField.h"
#include "Algorithms/Vektor.h"
#include "AbsBeamline/Component.h"
#include "AbsBeamline/BeamlineVisitor.h"
#include "AbsBeamline/MultipoleTFunctions/RecursionRelation.h"
#include "AbsBeamline/MultipoleTFunctions/RecursionRelationTwo.h"
#include "gsl/gsl_sf.h"
#include <vector>
 
class MultipoleT: public Component {
public:
    explicit MultipoleT(const std::string &name);
    MultipoleT(const MultipoleT &right);
    ~MultipoleT();
    ElementBase* clone() const override;
    EMField &getField() override;
    const EMField &getField() const override;
    void getDimensions(double &zBegin, double &zEnd) const override;
    bool apply(const Vector_t &R, const Vector_t &P, const double &t,
               Vector_t &E, Vector_t &B) override;
    bool apply(const size_t &i, const double &t, Vector_t &E, Vector_t &B) override;
    void initialise(PartBunchBase<double, 3>*,
                    double &startField,
                    double &endField) override;
    void initialise();
 
    void finalise() override;
    bool bends() const override;
    PlanarArcGeometry& getGeometry() override;
    const PlanarArcGeometry& getGeometry() const override;
    void accept(BeamlineVisitor& visitor) const override;
    double getDipoleConstant() const;
    void setDipoleConstant(double B0);
    std::size_t getMaxOrder() const;
    void setMaxOrder(std::size_t maxOrder);
    std::size_t getMaxXOrder() const;
    void setMaxXOrder(std::size_t maxXOrder);
    std::size_t getTransMaxOrder() const;
    void setTransMaxOrder(std::size_t transMaxOrder);
    void setTransProfile(std::size_t n, double Bn);
    double getTransProfile(int n) const;
    std::vector<double> getTransProfile() const;
    bool setFringeField(double s0, double lambda_left, double lambda_right);
    std::vector<double> getFringeLength() const;
    void setBendAngle(double angle);
    double getBendAngle() const;
    void setEntranceAngle(double entranceAngle);
    double getEntranceAngle() const;
    double getBendRadius() const;
    void setLength(double length);
    double getLength() const;
    double getChordLength() const;
    void setAperture(double vertAp, double horizAp);
    std::vector<double> getAperture() const;
    void setRotation(double rot);
    double getRotation() const;
    void setVarRadius();
    bool getVarRadius() const;
    double getBoundingBoxLength() const;
    void setBoundingBoxLength(const double &boundingBoxLength);
 
private:
    MultipoleT operator=(const MultipoleT& rhs);
    // End fields
    endfieldmodel::Tanh fringeField_l; // Left
    endfieldmodel::Tanh fringeField_r; // Right
    std::size_t maxOrder_m = 0;
    std::size_t maxOrderX_m = 0;
    std::vector<polynomial::RecursionRelationTwo> recursion_VarRadius_m;
    std::vector<polynomial::RecursionRelation> recursion_ConstRadius_m;
    std::size_t transMaxOrder_m = 0;
    std::vector<double> transProfile_m;
    PlanarArcGeometry planarArcGeometry_m;
    Vector_t rotateFrame(const Vector_t &R);
    Vector_t rotateFrameInverse(Vector_t &B);
    Vector_t transformCoords(const Vector_t &R);
    double length_m;
    double angle_m;
    double entranceAngle_m;
    double rotation_m;
    bool variableRadius_m;
    double boundingBoxLength_m;
    double getBx (const Vector_t &R);
    double getBz (const Vector_t &R);
    double getBs (const Vector_t &R);
    double verticalApert_m;
    double horizApert_m;
    BMultipoleField dummy;
    double getFringeDeriv(int n, double s);
    double getTransDeriv(std::size_t n, double x);
    bool insideAperture(const Vector_t &R);
    double getRadius(double s);
    double getScaleFactor(double x, double s);
    double getFnDerivX(std::size_t n, double x, double s);
    double getFnDerivS(std::size_t n, double x, double s);
    double getFn(std::size_t n, double x, double s);
};
 
inline
    void MultipoleT::setVarRadius() {
        variableRadius_m = true;
}
inline
    bool MultipoleT::getVarRadius() const {
        return variableRadius_m;
}
inline
    void MultipoleT::setEntranceAngle(double entranceAngle) {
        entranceAngle_m = entranceAngle;
}
inline
    double MultipoleT::getEntranceAngle() const {
        return entranceAngle_m;
}
inline
    double MultipoleT::getTransProfile(int n) const {
        return transProfile_m[n];
}
inline
    std::vector<double> MultipoleT::getTransProfile() const {
        return transProfile_m;
}
inline
    double MultipoleT::getDipoleConstant() const {
         return transProfile_m[0];
}
inline
    std::size_t MultipoleT::getMaxOrder() const {
         return maxOrder_m;
}
 
inline
    std::size_t MultipoleT::getMaxXOrder() const {
        return maxOrderX_m;
}
 
inline
    void MultipoleT::setMaxXOrder(std::size_t maxOrderX) {
        maxOrderX_m = maxOrderX;
}
inline
    std::size_t MultipoleT::getTransMaxOrder() const {
        return transMaxOrder_m;
}
inline
    void MultipoleT::setTransMaxOrder(std::size_t transMaxOrder) {
        transMaxOrder_m = transMaxOrder;
        transProfile_m.resize(transMaxOrder + 1, 0.);
}
inline
    double MultipoleT::getRotation() const {
         return rotation_m;
}
inline
    void MultipoleT::setRotation(double rot) {
         rotation_m = rot;
}
inline
    void MultipoleT::setBendAngle(double angle) {
        angle_m = angle;
}
inline
    double MultipoleT::getBendAngle() const {
        return angle_m;
}
inline
    void MultipoleT::setLength(double length) {
        length_m = std::abs(length);
}
inline
    double MultipoleT::getLength() const {
        return length_m;
}
inline
    double MultipoleT::getBoundingBoxLength() const {
        return boundingBoxLength_m;
}
inline
    void MultipoleT::setBoundingBoxLength(const double &boundingBoxLength) {
        boundingBoxLength_m = boundingBoxLength;
}
 
#endif