MultipoleT.h

Go to the documentation of this file.

/*
*  Copyright (c) 2017, Titus Dascalu
*  Copyright (c) 2018, Martin Duy Tat
*  Copyright (c) 2025, Jon Thompson
*  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 "Algorithms/PartBunch.h"
#include "AbsBeamline/EndFieldModel/Tanh.h"
#include "Fields/BMultipoleField.h"
#include "Algorithms/Vektor.h"
#include "AbsBeamline/Component.h"
#include <vector>
#include "MultipoleTBase.h"
#include "Algorithms/AbstractTimeDependence.h"
 
class MultipoleT final: public Component {
public:
    explicit MultipoleT(const std::string &name);
    MultipoleT(const MultipoleT &right);
    ~MultipoleT() override = default;
    ElementBase* clone() const override;
    void accept(BeamlineVisitor &visitor) const override;
    BGeometryBase& getGeometry() override;
    const BGeometryBase& getGeometry() const override;
    EMField &getField() override { return dummy; }
    const EMField &getField() const override { return dummy; }
    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>* bunch, double& startField,
                    double& endField) override;
    void finalise() override;
    bool bends() const override;
    size_t getMaxFOrder() const { return maxFOrder_m; }
    size_t getMaxXOrder() const { return maxXOrder_m; }
    void setMaxOrder(size_t orderZ, size_t orderX);
    std::size_t getTransMaxOrder() const { return transMaxOrder_m; }
    void setTransProfile(const std::vector<double>& profile);
    const std::vector<double>& getTransProfile() const { return transProfile_m; }
    void setFringeField(const double& s0, const double& lambda_left,
                        const double& lambda_right);
    std::tuple<double, double, double> getFringeField() const;
    void setEntranceAngle(double entranceAngle);
    void setEntryOffset(double offset);
    double getEntryOffset() const { return entryOffset_m; }
    bool getVariableRadius() const { return variableRadius_m; }
    void setBendAngle(double angle, bool variableRadius);
    double getBendAngle() const { return bendAngle_m; }
    double getEntranceAngle() const { return entranceAngle_m; }
    void setElementLength(double length) override;
    double getLength() const { return length_m; }
    void setAperture(const double& vertAp, const double& horizAp);
    std::tuple<double, double> getAperture() { return {verticalApert_m, horizontalApert_m}; }
    void setRotation(double rot);
    double getRotation() const { return rotation_m; }
    double getBoundingBoxLength() const { return boundingBoxLength_m; }
    void setBoundingBoxLength(double boundingBoxLength);
    void getDimensions(double &/*zBegin*/, double &/*zEnd*/) const override {}
    double getFringeDeriv(const std::size_t& n, const double& s);
    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);
    double getTransDeriv(const std::size_t& n, const double& x) const;
 
    Vector_t toMagnetCoords(const Vector_t& R);
    Vector_t getField(const Vector_t& magnetCoords);
    Vector_t localCartesianToOpalCartesian(const Vector_t& r);
    double localCartesianRotation();
 
    void setScalingName(const std::string& name);
    void setScalingModel(const std::shared_ptr<AbstractTimeDependence>& td) {scalingTD_m = td; }
    std::string getScalingName() const { return scalingName_m; }
    void initialiseTimeDepencencies() const;
 
protected:
    Vector_t rotateFrame(const Vector_t& R) const;
    bool insideAperture(const Vector_t& R) const;
    bool insideBoundingBox(const Vector_t& R) const;
    void chooseImplementation();
 
    // End fields
    endfieldmodel::Tanh fringeField_l{endfieldmodel::Tanh()}; // Left
    endfieldmodel::Tanh fringeField_r{endfieldmodel::Tanh()}; // Right
    std::size_t maxFOrder_m{3};
    std::size_t maxXOrder_m{20};
    std::vector<double> transProfile_m{0.0};
    size_t transMaxOrder_m{1};
    double length_m{1.0};
    double entranceAngle_m{0.0};
    double rotation_m{0.0};
    double bendAngle_m{0.0};
    bool variableRadius_m{false};
    double boundingBoxLength_m{0.0};
    double entryOffset_m{0.0};
    double verticalApert_m{0.5};
    double horizontalApert_m{0.5};
    BMultipoleField dummy;
    // Time dependence
    std::string scalingName_m;
    mutable std::shared_ptr<AbstractTimeDependence> scalingTD_m;
 
    std::unique_ptr<MultipoleTBase> implementation_{};
};
 
#endif