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 "Algorithms/PartBunch.h"
#include "AbsBeamline/EndFieldModel/Tanh.h"
#include "Fields/BMultipoleField.h"
#include "Algorithms/Vektor.h"
#include "AbsBeamline/Component.h"
#include "AbsBeamline/BeamlineVisitor.h"
#include <vector>

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 &R, const Vector_t &P, const double &t,
               Vector_t &E, Vector_t &B);
    bool apply(const size_t &i, const double &t, Vector_t &E, Vector_t &B);
    void initialise(PartBunchBase<double, 3>*,
                    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 rotateFrame(const Vector_t &R);
    Vector_t rotateFrameInverse(Vector_t &B);
    virtual void transformCoords(Vector_t &R) = 0;
    virtual void transformBField(Vector_t &B, const Vector_t &R) = 0;
    double length_m;
    double entranceAngle_m;
    double rotation_m;
    double boundingBoxLength_m;
    virtual double getBx (const Vector_t &R);
    double getBz (const Vector_t &R);
    virtual double getBs (const Vector_t &R);
    double verticalApert_m;
    double horizontalApert_m;
    BMultipoleField dummy;
    bool insideAperture(const Vector_t &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 &E, Vector_t &B) {
        return apply(RefPartBunch_m->R[i], RefPartBunch_m->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 &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(PartBunchBase<double, 3>* /*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