MultipoleT.h

Go to the documentation of this file.

//
// Cubic Spline Interpolation to replace GSL spline
//
// Copyright (c) 2023, Paul Scherrer Institute, Villigen PSI, Switzerland
// All rights reserved
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
 
#ifndef ABSBEAMLINE_MULTIPOLET_H
#define ABSBEAMLINE_MULTIPOLET_H
 
#include <vector>
#include "AbsBeamline/Component.h"
#include "Algorithms/AbstractTimeDependence.h"
#include "Fields/BMultipoleField.h"
#include "MultipoleTBase.h"
#include "MultipoleTConfig.h"
 
class MultipoleT : 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 std::shared_ptr<ParticleContainer_t>& pc) override;
    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;
    bool apply(const size_t& i, const double& t, Vector_t<double, 3>& E, Vector_t<double, 3>& B)
            override;
    void initialise(PartBunch_t* bunch, double& startField, double& endField) override;
    void finalise() override;
    bool bends() const override;
    size_t getMaxFOrder() const { return config_m.maxFOrder_m; }
    size_t getMaxXOrder() const { return config_m.maxXOrder_m; }
    void setMaxOrder(size_t orderZ, size_t orderX);
    std::size_t getTransMaxOrder() const { return config_m.transverseProfileMaxOrder_m; }
    void setTransProfile(const std::vector<double>& profile);
    const Kokkos::Array<double, MultipoleTConfig::NumPoles>& getTransProfile() const {
        return config_m.transverseProfile_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 config_m.entryOffset_m; }
    bool getVariableRadius() const { return config_m.variableRadius_m; }
    void setBendAngle(double angle, bool variableRadius);
    double getBendAngle() const { return config_m.bendAngle_m; }
    double getEntranceAngle() const { return config_m.entranceAngle_m; }
    void setElementLength(double length) override;
    double getLength() const { return config_m.length_m; }
    void setAperture(const double& vertAp, const double& horizAp);
    std::tuple<double, double> getAperture() {
        return {config_m.verticalAperture_m, config_m.horizontalAperture_m};
    }
 
    void setRotation(double rot);
    double getRotation() const { return config_m.rotation_m; }
    double getBoundingBoxLength() const { return config_m.boundingBoxLength_m; }
    void setBoundingBoxLength(double boundingBoxLength);
    void getFieldExtend(double& zBegin, double& zEnd) const override {
        zBegin = 0.0;
        zEnd   = getElementLength();
    }
 
    void setScalingName(const std::string& name);
    std::string getScalingName() const { return scalingName_m; }
    void initialiseTimeDependencies() const;
 
    MultipoleTConfig& getConfig() { return config_m; }
 
protected:
    MultipoleTConfig config_m;
 
    void chooseImplementation();
    double getScaling(double t) const;
    void validateConfiguration() const;
 
    BMultipoleField dummy;
 
    // Time dependence
    std::string scalingName_m;
    mutable std::shared_ptr<AbstractTimeDependence> scalingTD_m;
 
    // The object that does the work
    std::unique_ptr<MultipoleTBase> implementation_{};
};
#endif