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/Component.h"
#include "AbsBeamline/EndFieldModel/Tanh.h"
#include "BeamlineGeometry/PlanarArcGeometry.h"
#include "Fields/BMultipoleField.h"
//  
#include <vector>
#include "AbsBeamline/BeamlineVisitor.h"
#include "AbsBeamline/Component.h"
#include "AbsBeamline/MultipoleTFunctions/RecursionRelation.h"
#include "AbsBeamline/MultipoleTFunctions/RecursionRelationTwo.h"
#include "gsl/gsl_sf.h"
 
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<double, 3>& R, const Vector_t<double, 3>& P, const double& t,
        Vector_t<double, 3>& E, Vector_t<double, 3>& B) override;
    bool apply(
        const size_t& i, const double& t, Vector_t<double, 3>& E, Vector_t<double, 3>& B) override;
    void initialise(PartBunch_t*, 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<double, 3> rotateFrame(const Vector_t<double, 3>& R);
    Vector_t<double, 3> rotateFrameInverse(Vector_t<double, 3>& B);
    Vector_t<double, 3> transformCoords(const Vector_t<double, 3>& R);
    double length_m;
    double angle_m;
    double entranceAngle_m;
    double rotation_m;
    bool variableRadius_m;
    double boundingBoxLength_m;
    double getBx(const Vector_t<double, 3>& R);
    double getBz(const Vector_t<double, 3>& R);
    double getBs(const Vector_t<double, 3>& 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<double, 3>& 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