Multipole.h

Go to the documentation of this file.

#ifndef OPALX_Multipole_HH
#define OPALX_Multipole_HH
 
#include "AbsBeamline/Component.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "Fields/BMultipoleField.h"
 
class Fieldmap;
constexpr int MAX_MP_ORDER = 5;
 
class Multipole : public Component {
public:
    /* ============================== Constructors ============================== */
    explicit Multipole(const std::string& name);
    Multipole();
    Multipole(const Multipole&);
    virtual ~Multipole();
    /* ========================================================================== */
    /* =========================== Multipole Expansion ========================== */
 
    // @note n=0 corresponds to the dipol, n=1 to the quadrupole, etc...
 
    // @returns n-th normal component of the multipole expansion
    double getNormalComponent(int n) const;
 
    // @brief Sets the n-th normal component
    void setNormalComponent(int n, double);
 
    // @brief Sets the n-th normal component with an error
    void setNormalComponent(int n, double, double);
 
    // @returns n-th skew component of the multipole expansion
    double getSkewComponent(int n) const;
 
    // @brief Sets the n-th skew component
    void setSkewComponent(int n, double);
 
    // @brief Sets the n-th skew component with error
    void setSkewComponent(int n, double, double);
 
    // @brief Get index of maximal components
    size_t getMaxNormalComponentIndex() const;
    size_t getMaxSkewComponentIndex() const;
 
    /* ========================================================================== */
    /* ============================== Apply Functions =========================== */
    virtual bool apply(const std::shared_ptr<ParticleContainer_t>& pc) override;
 
    virtual bool apply(
            const size_t& i, const double& t, Vector_t<double, 3>& E,
            Vector_t<double, 3>& B) override;
 
    virtual 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;
 
    virtual bool applyToReferenceParticle(
            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;
    /* ========================================================================== */
    /* ============================== Functions ================================= */
    // @brief Apply visitor to Multipole.
    virtual void accept(BeamlineVisitor&) const override;
 
    // @brief Get multipole field.
    virtual BMultipoleField& getField() override = 0;
 
    // @breif Get multipole field. Version for const object.
    virtual const BMultipoleField& getField() const override = 0;
 
    // @returns Is the n-th component focusing?
    bool isFocusing(int n) const;
 
    virtual void initialise(PartBunch_t* bunch, double& startField, double& endField) override;
 
    virtual void finalise() override;
 
    virtual bool bends() const override;
 
    virtual ElementType getType() const override;
 
    virtual void getFieldExtend(double& zBegin, double& zEnd) const override;
 
    virtual bool isInside(const Vector_t<double, 3>& r) const override;
    /* ========================================================================== */
    /* =========================== Unused Functions ============================= */
    // @returns StraightGeometry
    virtual StraightGeometry& getGeometry() override = 0;
 
    // @returns StraightGeometry
    virtual const StraightGeometry& getGeometry() const override = 0;
 
    // @brief Set number of slices for map tracking
    void setNSlices(const std::size_t& nSlices);
 
    // @breif Get number of slices for map tracking
    std::size_t getNSlices() const;
 
    // Not implemented.
    void operator=(const Multipole&);
 
    /* ========================================================================== */
private:
    KOKKOS_INLINE_FUNCTION
    static void computeField(
            Vector_t<double, 3> R, Vector_t<double, 3>& E, Vector_t<double, 3>& B,
            const Kokkos::View<double*> NormalComponents,
            const Kokkos::View<double*> SkewComponents, int max_NormalComponent,
            int max_SkewComponent);
 
    void computeFieldHost(
            Vector_t<double, 3> R, Vector_t<double, 3>& E, Vector_t<double, 3>& B) const;
    /* ========================================================================== */
    /* =========================== Variables ==================================== */
    Kokkos::View<double*> NormalComponents;
    Kokkos::View<double*> NormalComponentErrors;
    Kokkos::View<double*> SkewComponents;
    Kokkos::View<double*> SkewComponentErrors;
    int max_SkewComponent_m;
    int max_NormalComponent_m;
    /* =========================== Unused Variables ============================= */
    std::size_t nSlices_m;
    /* ========================================================================== */
};
/* =========================== Inline Functions ============================= */
// @note Inlined function bodies need to be in the header for libraries
 
// @returns n-th normal component of the multipole expansion
inline void Multipole::setNormalComponent(int n, double v) { setNormalComponent(n, v, 0.0); }
// @returns n-th skew component of the multipole expansion
inline void Multipole::setSkewComponent(int n, double v) { setSkewComponent(n, v, 0.0); }
 
// @returns max index of normal components
inline size_t Multipole::getMaxNormalComponentIndex() const { return NormalComponents.size(); }
 
// @returns max index of skew components
inline size_t Multipole::getMaxSkewComponentIndex() const { return SkewComponents.size(); }
/* ========================================================================== */
#endif  // OPALX_Multipole_HH