Component.h

Go to the documentation of this file.

 
#ifndef OPALX_Component_HH
#define OPALX_Component_HH
 
#include "AbsBeamline/ElementBase.h"
#include "Fields/EMField.h"
#include "OPALTypes.h"
 
#include <memory>
 
using ParticleContainer_t = ParticleContainer<double, 3>;
 
class PartData;
 
template <class T, int N>
class FVps;
 
struct Point {
    double x;
    double y;
};
 
class Component : public ElementBase {
public:
    /* ============================== Constructors ============================== */
    explicit Component(const std::string& name);
    Component();
    Component(const Component& right);
    virtual ~Component();
    /* ========================================================================== */
    /* ============================== Field Functions =========================== */
    //  The representation of the electro-magnetic field of the component
    //  (version for non-constant object).
    virtual EMField& getField() = 0;
 
    //  The representation of the electro-magnetic field of the component
    //  (version for constant object).
    virtual const EMField& getField() const = 0;
 
    //  Return the value of the time-independent part of the electric
    //  field at point [b]P[/b].
    EVector Efield(const Point3D& P) const;
 
    //  Return the value of the time-independent part of the magnetic
    //  field at point [b]P[/b].
    BVector Bfield(const Point3D& P) const;
 
    //  Return the value of the time-dependent part of the electric
    //  field at point [b]P[/b] for time [b]t[/b].
    EVector Efield(const Point3D& P, double t) const;
 
    //  Return the value of the time-dependent part of the magnetic
    //  field at point [b]P[/b] for time [b]t[/b].
    BVector Bfield(const Point3D& P, double t) const;
 
    //  Return the value of the time-independent part of both electric
    //  and magnetic fields at point [b]P[/b].
    EBVectors EBfield(const Point3D& P) const;
 
    //  Return the value of the time-dependent part of both electric
    //  and magnetic fields at point [b]P[/b] for time [b]t[/b].
    EBVectors EBfield(const Point3D& P, double t) const;
    /* ========================================================================== */
    /* ============================== Apply Functions =========================== */
    virtual bool apply(const std::shared_ptr<ParticleContainer_t>& pc);
 
    virtual bool apply(
            const size_t& i, const double& t, Vector_t<double, 3>& E, Vector_t<double, 3>& B);
 
    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);
 
    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);
 
    /* ========================================================================== */
    /* ============================== Functions ================================= */
    virtual bool getPotential(
            const Vector_t<double, 3>& /*R*/, const double& /*t*/, Vector_t<double, 3>& /*A*/,
            double& /*phi*/) {
        return false;
    }
 
    // Design energy for components such as RF-cavities
    virtual double getDesignEnergy() const;
    virtual void setDesignEnergy(const double& energy, bool changeable = true);
 
    // Setup
    virtual void initialise(PartBunch_t* bunch, double& startField, double& endField) = 0;
 
    // Clean-up
    virtual void finalise() = 0;
 
    // Does the component bend?
    virtual bool bends() const = 0;
 
    // Read & free fieldmaps
    virtual void goOnline(const double& kineticEnergy);
    virtual void goOffline();
 
    // Is the component online (been initialised)?
    virtual bool Online();
 
    virtual void getFieldExtend(double& zBegin, double& zEnd) const = 0;
 
    // Gets the element type defined in ElementBase
    virtual ElementType getType() const;
 
    //  If this method returns a pointer to this component.
    //  The default version returns ``this''.
    virtual const ElementBase& getDesign() const;
 
    virtual void trackBunch(PartBunch_t& bunch, const PartData&, bool revBeam, bool revTrack) const;
 
    //  This catch-all method implements a hook for tracking a transfer
    //  map through a non-standard component.
    //  The default version throws a LogicalError.
    virtual void trackMap(FVps<double, 6>& map, const PartData&, bool revBeam, bool revTrack) const;
 
    void setExitFaceSlope(const double&);
    /* ========================================================================== */
protected:
    // Aperture - Needs to be changed to Kokkos::View
    static const std::vector<double> defaultAperture_m;
    double exit_face_slope_m;
 
    // The reference bunch
    PartBunch_t* RefPartBunch_m;
    bool online_m;
};
 
// Inline access functions to fields.
// ------------------------------------------------------------------------
 
inline EVector Component::Efield(const Point3D& P) const { return getField().Efield(P); }
 
inline BVector Component::Bfield(const Point3D& P) const { return getField().Bfield(P); }
 
inline EVector Component::Efield(const Point3D& P, double t) const {
    return getField().Efield(P, t);
}
 
inline BVector Component::Bfield(const Point3D& P, double t) const {
    return getField().Bfield(P, t);
}
 
inline EBVectors Component::EBfield(const Point3D& P) const { return getField().EBfield(P); }
 
inline EBVectors Component::EBfield(const Point3D& P, double t) const {
    return getField().EBfield(P, t);
}
 
inline void Component::setExitFaceSlope(const double& m) { exit_face_slope_m = m; }
 
inline void Component::setDesignEnergy(const double& /*energy*/, bool /*changeable*/) { return; }
 
inline double Component::getDesignEnergy() const { return -1.0; }
 
#endif  // OPALX_Component_HH