VariableRFCavityFringeField.h

Go to the documentation of this file.

//
// Class VariableRFCavityFringeField
//   Defines the abstract interface for a soft-edged 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 CLASSIC_ABSBEAMLINE_VariableRFCavityFringeField_HH
#define CLASSIC_ABSBEAMLINE_VariableRFCavityFringeField_HH
 
#include "AbsBeamline/VariableRFCavity.h"
#include "Fields/Definitions.h"
 
#include <iostream>
 
namespace endfieldmodel {
    class EndFieldModel;
}
 
class VariableRFCavityFringeField: public VariableRFCavity {
 
public:
    explicit VariableRFCavityFringeField(const std::string& name);
    VariableRFCavityFringeField(const VariableRFCavityFringeField&);
    VariableRFCavityFringeField();
    VariableRFCavityFringeField& operator=(const VariableRFCavityFringeField&);
    virtual ~VariableRFCavityFringeField();
 
    virtual void accept(BeamlineVisitor&) const override;
 
    inline void initialise() const;
 
    virtual ElementBase* clone() const override;
 
    virtual bool apply(const size_t& i, const double& t,
                       Vector_t& E, Vector_t& B) override;
 
    virtual bool apply(const Vector_t& R, const Vector_t& P,
                       const double& t, Vector_t& E, Vector_t& B) override;
 
    virtual bool applyToReferenceParticle(const Vector_t& R, const Vector_t& P,
                                          const double& t, Vector_t& E, Vector_t& B) override;
 
    virtual void setEndField
                       (std::shared_ptr<endfieldmodel::EndFieldModel> endField);
 
    virtual inline std::shared_ptr<endfieldmodel::EndFieldModel>
                                                            getEndField() const;
 
    virtual void initialise(PartBunchBase<double, 3>* bunch,
                            double& startField, double& endField) override;
 
    virtual inline void setCavityCentre(double zCentre);
    virtual inline double getCavityCentre() const;
    virtual inline void setMaxOrder(size_t maxOrder);
    virtual inline size_t getMaxOrder() const;
    void initialiseCoefficients();
    void printCoefficients(std::ostream& out) const;
    inline std::vector<std::vector<double> > getEzCoefficients() const;
    inline std::vector<std::vector<double> > getEyCoefficients() const;
    inline std::vector<std::vector<double> > getBxCoefficients() const;
 
protected:
    double zCentre_m; // offsets this element
    size_t maxOrder_m;
    std::shared_ptr<endfieldmodel::EndFieldModel> endField_m;
    std::vector<std::vector<double> > f_m;
    std::vector<std::vector<double> > g_m;
    std::vector<std::vector<double> > h_m;
 
private:
    void initNull();
};
 
void VariableRFCavityFringeField::setCavityCentre(double zCentre) {
    zCentre_m = zCentre;
}
 
double VariableRFCavityFringeField::getCavityCentre() const {
    return zCentre_m;
}
 
void VariableRFCavityFringeField::setMaxOrder(size_t maxOrder) {
    maxOrder_m = maxOrder;
    initialiseCoefficients();
}
 
void VariableRFCavityFringeField::initialise() const {
    VariableRFCavity::initialise();
}
 
size_t VariableRFCavityFringeField::getMaxOrder() const {
    return maxOrder_m;
}
 
std::shared_ptr<endfieldmodel::EndFieldModel> VariableRFCavityFringeField::getEndField() const {
    return endField_m;
}
 
std::vector<std::vector<double> > VariableRFCavityFringeField::getEzCoefficients() const {
    return f_m;
}
 
std::vector<std::vector<double> > VariableRFCavityFringeField::getEyCoefficients() const {
    return g_m;
}
 
std::vector<std::vector<double> > VariableRFCavityFringeField::getBxCoefficients() const {
    return h_m;
}
 
#endif // #ifdef CLASSIC_VirtualRFCavityFringeField_HH