VariableRFCavity.h

Go to the documentation of this file.

//
// Class VariableRFCavity
//   Defines the abstract interface for a RF Cavity
//   with Time Dependent Parameters.
//
// Copyright (c) 2014 - 2023, Chris Rogers, STFC Rutherford Appleton Laboratory, Didcot, UK
// 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 Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//
#ifndef ABSBEAMLINE_VARIABLERFCAVITY_HH
#define ABSBEAMLINE_VARIABLERFCAVITY_HH
 
#include "AbsBeamline/Component.h"
#include "Algorithms/AbstractTimeDependence.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "Fields/EMField.h"
#include "Physics/Physics.h"
 
class VariableRFCavity : public Component {
public:
    explicit VariableRFCavity(const std::string& name);
    VariableRFCavity(const VariableRFCavity&);
    VariableRFCavity();
    VariableRFCavity& operator=(const VariableRFCavity&);
    ~VariableRFCavity() override = default;
 
    void accept(BeamlineVisitor&) const override;
 
    ElementBase* clone() const override;
 
    bool apply(const std::shared_ptr<ParticleContainer_t>& pc) override;
 
    bool apply(const size_t& i, const double& t, Vector_t<double, 3>& E, Vector_t<double, 3>& B)
            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 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;
 
    void initialise(PartBunch_t* bunch, double& startField, double& endField) override;
 
    void finalise() override;
 
    bool bends() const override { return false; }
 
    void getFieldExtend(double& zBegin, double& zEnd) const override {
        zBegin = 0.0;
        zEnd   = getElementLength();
    }
 
    virtual double getAmplitude(const double time) const { return amplitudeTD_m->getValue(time); }
 
    virtual double getFrequency(const double time) const { return frequencyTD_m->getValue(time); }
 
    virtual double getPhase(const double time) const { return phaseTD_m->getValue(time); }
 
    virtual double getHeight() const { return halfHeight_m * 2; }
    virtual double getWidth() const { return halfWidth_m * 2; }
    virtual double getLength() const { return length_m; }
    virtual void setHeight(const double fullHeight) { halfHeight_m = fullHeight / 2; }
    virtual void setWidth(const double fullWidth) { halfWidth_m = fullWidth / 2; }
    virtual void setLength(double length);
 
    virtual std::shared_ptr<AbstractTimeDependence> getAmplitudeModel() const;
    virtual std::shared_ptr<AbstractTimeDependence> getPhaseModel() const;
    virtual std::shared_ptr<AbstractTimeDependence> getFrequencyModel() const;
 
    virtual void setAmplitudeModel(std::shared_ptr<AbstractTimeDependence> amplitude_td);
    virtual void setPhaseModel(std::shared_ptr<AbstractTimeDependence> phase_td);
    virtual void setFrequencyModel(std::shared_ptr<AbstractTimeDependence> frequency_td);
 
    virtual void setAmplitudeName(const std::string& amplitude) { amplitudeName_m = amplitude; }
 
    virtual void setPhaseName(const std::string& phase) { phaseName_m = phase; }
 
    virtual void setFrequencyName(const std::string& frequency) { frequencyName_m = frequency; }
 
    StraightGeometry& getGeometry() override;
    const StraightGeometry& getGeometry() const override;
 
    void initialiseTimeDependencies() const;
 
    EMField& getField() override;
    const EMField& getField() const override;
 
protected:
    void initNull();
    mutable std::shared_ptr<AbstractTimeDependence> phaseTD_m;
    mutable std::shared_ptr<AbstractTimeDependence> amplitudeTD_m;
    mutable std::shared_ptr<AbstractTimeDependence> frequencyTD_m;
    std::string phaseName_m;
    std::string amplitudeName_m;
    std::string frequencyName_m;
    double halfWidth_m;
    double halfHeight_m;
    double length_m;
 
    StraightGeometry geometry;
 
    /* The host/device compute function */
    static KOKKOS_INLINE_FUNCTION bool computeField(
            const Vector_t<double, 3>& R, Vector_t<double, 3>& E, double E0, double integralF,
            double phi, double halfWidth, double halfHeight, double length);
};
 
KOKKOS_INLINE_FUNCTION bool VariableRFCavity::computeField(
        const Vector_t<double, 3>& R, Vector_t<double, 3>& E, const double E0,
        const double integralF, const double phi, const double halfWidth, const double halfHeight,
        const double length) {
    if (R[2] < 0.0 || R[2] >= length) {
        return false;
    }
    E[2] += E0 * Kokkos::sin(Physics::two_pi * integralF + phi);
    const bool outsideAperture = Kokkos::abs(R[0]) > halfWidth || Kokkos::abs(R[1]) > halfHeight;
    return outsideAperture;
}
 
#endif  // ABSBEAMLINE_VARIABLERFCAVITY_HH