MultipoleTBase.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_MULTIPOLETBASE_H
#define CLASSIC_MULTIPOLETBASE_H
 
#include <vector>
#include "AbsBeamline/BeamlineVisitor.h"
#include "AbsBeamline/Component.h"
#include "AbsBeamline/EndFieldModel/Tanh.h"
 
#include "Fields/BMultipoleField.h"
 
class MultipoleTBase : public Component {
public:
    MultipoleTBase();
    explicit MultipoleTBase(const std::string& name);
    MultipoleTBase(const MultipoleTBase& right);
    ~MultipoleTBase();
    EMField& getField();
    const EMField& getField() const;
    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);
    bool apply(const size_t& i, const double& t, Vector_t<double, 3>& E, Vector_t<double, 3>& B);
    void initialise(PartBunch_t*, double& startField, double& endField);
    void finalise();
    bool bends() const;
    double getDipoleConstant() const;
    void setDipoleConstant(const double& B0);
    std::size_t getMaxOrder() const;
    virtual void setMaxOrder(const std::size_t& maxOrder);
    std::size_t getTransMaxOrder() const;
    void setTransMaxOrder(const std::size_t& transMaxOrder);
    void setTransProfile(const std::size_t& n, const double& Bn);
    double getTransProfile(const std::size_t& n) const;
    std::vector<double> getTransProfile() const;
    bool setFringeField(const double& s0, const double& lambda_left, const double& lambda_right);
    std::vector<double> getFringeLength() const;
    void setEntranceAngle(const double& entranceAngle);
    virtual void setBendAngle(const double& angle);
    virtual double getBendAngle() const;
    double getEntranceAngle() const;
    void setLength(const double& length);
    double getLength() const;
    void setAperture(const double& vertAp, const double& horizAp);
    std::vector<double> getAperture() const;
    void setRotation(const double& rot);
    double getRotation() const;
    double getBoundingBoxLength() const;
    void setBoundingBoxLength(const double& boundingBoxLength);
    virtual void getDimensions(double& zBegin, double& zEnd) const;
 
protected:
    double getFringeDeriv(const std::size_t& n, const double& s);
    double getTransDeriv(const std::size_t& n, const double& x);
 
private:
    // MultipoleTBase operator=(const MultipoleTBase &rhs);
    //  End fields
    endfieldmodel::Tanh fringeField_l;  // Left
    endfieldmodel::Tanh fringeField_r;  // Right
    std::size_t maxOrder_m;
    std::size_t transMaxOrder_m = 0;
    std::vector<double> transProfile_m;
    Vector_t<double, 3> rotateFrame(const Vector_t<double, 3>& R);
    Vector_t<double, 3> rotateFrameInverse(Vector_t<double, 3>& B);
    virtual void transformCoords(Vector_t<double, 3>& R) = 0;
    virtual void transformBField(Vector_t<double, 3>& B, const Vector_t<double, 3>& R) = 0;
    double length_m;
    double entranceAngle_m;
    double rotation_m;
    double boundingBoxLength_m;
    virtual double getBx(const Vector_t<double, 3>& R);
    double getBz(const Vector_t<double, 3>& R);
    virtual double getBs(const Vector_t<double, 3>& R);
    double verticalApert_m;
    double horizontalApert_m;
    BMultipoleField dummy;
    bool insideAperture(const Vector_t<double, 3>& R);
    virtual double getRadius(const double& s) = 0;
    virtual double getScaleFactor(const double& x, const double& s) = 0;
    double getFnDerivX(const std::size_t& n, const double& x, const double& s);
    double getFnDerivS(const std::size_t& n, const double& x, const double& s);
    virtual double getFn(const std::size_t& n, const double& x, const double& s) = 0;
};
 
inline void MultipoleTBase::finalise() {
    RefPartBunch_m = nullptr;
}
inline bool MultipoleTBase::apply(
    const size_t& i, const double& t, Vector_t<double, 3>& E, Vector_t<double, 3>& B) {
    std::shared_ptr<ParticleContainer_t> pc = RefPartBunch_m->getParticleContainer();
    auto Rview                              = pc->R.getView();
    auto Pview                              = pc->P.getView();
 
    const Vector_t<double, 3> R = Rview(i);
    const Vector_t<double, 3> P = Pview(i);
 
    return apply(R(i), P(i), t, E, B);
}
inline void MultipoleTBase::setBendAngle(const double& /*angle*/) {
}
inline double MultipoleTBase::getBendAngle() const {
    return 0.0;
}
inline void MultipoleTBase::setEntranceAngle(const double& entranceAngle) {
    entranceAngle_m = entranceAngle;
}
inline bool MultipoleTBase::insideAperture(const Vector_t<double, 3>& R) {
    return (
        std::abs(R[1]) <= (verticalApert_m / 2.0) && std::abs(R[0]) <= (horizontalApert_m / 2.0));
}
inline double MultipoleTBase::getEntranceAngle() const {
    return entranceAngle_m;
}
inline double MultipoleTBase::getTransProfile(const std::size_t& n) const {
    return transProfile_m[n];
}
inline std::vector<double> MultipoleTBase::getTransProfile() const {
    return transProfile_m;
}
inline double MultipoleTBase::getDipoleConstant() const {
    return transProfile_m[0];
}
inline void MultipoleTBase::setMaxOrder(const std::size_t& maxOrder) {
    maxOrder_m = maxOrder;
}
inline std::size_t MultipoleTBase::getMaxOrder() const {
    return maxOrder_m;
}
inline std::size_t MultipoleTBase::getTransMaxOrder() const {
    return transMaxOrder_m;
}
inline void MultipoleTBase::setTransMaxOrder(const std::size_t& transMaxOrder) {
    transMaxOrder_m = transMaxOrder;
    transProfile_m.resize(transMaxOrder + 1, 0.);
}
inline double MultipoleTBase::getRotation() const {
    return rotation_m;
}
inline void MultipoleTBase::setRotation(const double& rot) {
    rotation_m = rot;
}
inline void MultipoleTBase::setLength(const double& length) {
    length_m = std::abs(length);
}
inline double MultipoleTBase::getLength() const {
    return length_m;
}
inline double MultipoleTBase::getBoundingBoxLength() const {
    return boundingBoxLength_m;
}
inline void MultipoleTBase::setBoundingBoxLength(const double& boundingBoxLength) {
    boundingBoxLength_m = boundingBoxLength;
}
inline void MultipoleTBase::setTransProfile(const std::size_t& n, const double& dTn) {
    if (n > transMaxOrder_m) {
        transMaxOrder_m = n;
        transProfile_m.resize(n + 1, 0.0);
    }
    transProfile_m[n] = dTn;
}
inline void MultipoleTBase::setDipoleConstant(const double& B0) {
    if (transMaxOrder_m < 1) {
        transProfile_m.resize(1, 0.);
    }
    transProfile_m[0] = B0;
}
inline void MultipoleTBase::setAperture(const double& vertAp, const double& horizAp) {
    verticalApert_m   = vertAp;
    horizontalApert_m = horizAp;
}
inline std::vector<double> MultipoleTBase::getAperture() const {
    std::vector<double> temp(2, 0.0);
    temp[0] = verticalApert_m;
    temp[1] = horizontalApert_m;
    return temp;
}
inline std::vector<double> MultipoleTBase::getFringeLength() const {
    std::vector<double> temp(2, 0.0);
    temp[0] = fringeField_l.getLambda();
    temp[1] = fringeField_r.getLambda();
    return temp;
}
inline void MultipoleTBase::initialise(
    PartBunch_t* /*bunch*/, double& /*startField*/, double& /*endField*/) {
}
inline bool MultipoleTBase::bends() const {
    return transProfile_m[0] != 0;
}
inline EMField& MultipoleTBase::getField() {
    return dummy;
}
inline const EMField& MultipoleTBase::getField() const {
    return dummy;
}
inline void MultipoleTBase::getDimensions(double& /*zBegin*/, double& /*zEnd*/) const {
}
 
#endif