FM2DDynamic.h

Go to the documentation of this file.

#ifndef OPALX_FIELDMAP2DDYNAMIC_HH
#define OPALX_FIELDMAP2DDYNAMIC_HH
 
#include "Fields/Fieldmap.h"
 
#include <Kokkos_Core.hpp>
#include <Kokkos_DualView.hpp>
 
class FM2DDynamic : public Fieldmap {
public:
    virtual bool getFieldstrength(
            const Vector_t<double, 3>& R, Vector_t<double, 3>& E,
            Vector_t<double, 3>& B) const override;
    // virtual bool getFieldstrength(const Vector_t &R, Vector_t &E, Vector_t &B) const;
 
    virtual bool getFieldDerivative(
            const Vector_t<double, 3>& R, Vector_t<double, 3>& E, Vector_t<double, 3>& B,
            const DiffDirection& dir) const override;
    // virtual bool getFieldDerivative(const Vector_t &R, Vector_t &E, Vector_t &B, const
    // DiffDirection &dir) const;
 
    virtual void getFieldDimensions(double& zBegin, double& zEnd) const override;
    // virtual void getFieldDimensions(double &zBegin, double &zEnd) const;
 
    virtual void getFieldDimensions(
            double& xIni, double& xFinal, double& yIni, double& yFinal, double& zIni,
            double& zFinal) const override;
 
    virtual void swap() override;
 
    virtual void getInfo(Inform* msg) override;
 
    virtual double getFrequency() const override;
 
    virtual void setFrequency(double freq) override;
 
    bool isInside(const Vector_t<double, 3>& r) const override {
        return r(2) >= zbegin_m && r(2) < zend_m && sqrt(r(0) * r(0) + r(1) * r(1)) < rend_m;
    }
 
    template <class ViewType>
    KOKKOS_INLINE_FUNCTION static void computeField(
            const Vector_t<double, 3>& R, Vector_t<double, 3>& E, Vector_t<double, 3>& B,
            const ViewType& Ez, const ViewType& Er, const ViewType& Bt, double hr_m, double hz_m,
            double zbegin_m, int num_gridpr_m, int num_gridpz_m) {
        const double RR = sqrt(R(0) * R(0) + R(1) * R(1));
 
        const int indexr    = (int)floor(RR / hr_m);
        const double leverr = (RR / hr_m) - indexr;
 
        const int indexz    = (int)floor((R(2) - zbegin_m) / hz_m);
        const double leverz = (R(2) - zbegin_m) / hz_m - indexz;
 
        if ((indexz < 0) || (indexz + 2 > num_gridpz_m)) return;
 
        if (indexr + 2 > num_gridpr_m) return;
 
        const int index1 = indexz + indexr * num_gridpz_m;
        const int index2 = index1 + num_gridpz_m;
 
        const double EfieldR = (1.0 - leverz) * (1.0 - leverr) * Er(index1)
                               + leverz * (1.0 - leverr) * Er(index1 + 1)
                               + (1.0 - leverz) * leverr * Er(index2)
                               + leverz * leverr * Er(index2 + 1);
 
        const double EfieldZ = (1.0 - leverz) * (1.0 - leverr) * Ez(index1)
                               + leverz * (1.0 - leverr) * Ez(index1 + 1)
                               + (1.0 - leverz) * leverr * Ez(index2)
                               + leverz * leverr * Ez(index2 + 1);
 
        const double BfieldT = (1.0 - leverz) * (1.0 - leverr) * Bt(index1)
                               + leverz * (1.0 - leverr) * Bt(index1 + 1)
                               + (1.0 - leverz) * leverr * Bt(index2)
                               + leverz * leverr * Bt(index2 + 1);
 
        if (RR > 1e-14) {
            E(0) += EfieldR * R(0) / RR;
            E(1) += EfieldR * R(1) / RR;
            B(0) -= BfieldT * R(1) / RR;
            B(1) += BfieldT * R(0) / RR;
        }
        E(2) += EfieldZ;
        return;
    }
 
    void applyField(std::shared_ptr<ParticleContainer_t> pc, double) override;
 
    void applyRFField(
            std::shared_ptr<ParticleContainer_t> pc, double electricScale, double magneticScale,
            double startField, double endField);
 
    virtual void getOnaxisEz(std::vector<std::pair<double, double> >& F) override;
 
private:
    FM2DDynamic(const std::string& filename);
    ~FM2DDynamic();
 
    void readMap() override;
    void freeMap() override;
 
    Kokkos::DualView<double*> FieldstrengthEz_m; 
    Kokkos::DualView<double*> FieldstrengthEr_m; 
    Kokkos::DualView<double*> FieldstrengthBt_m; 
    double frequency_m;
 
    double rbegin_m;
    double rend_m;
 
    double zbegin_m;
    double zend_m;
 
    double hz_m;      
    double hr_m;      
    int num_gridpr_m; 
    int num_gridpz_m; 
    bool swap_m;
    friend class Fieldmap;
};
 
#endif