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 CLASSIC_ABSBEAMLINE_VariableRFCavity_HH
#define CLASSIC_ABSBEAMLINE_VariableRFCavity_HH
 
#include "AbsBeamline/Component.h"
#include "Algorithms/AbstractTimeDependence.h"
#include "Algorithms/TimeDependenceCache.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "Fields/Definitions.h"
#include "Fields/EMField.h"
 
class VariableRFCavity: public Component {
 
public:
    explicit VariableRFCavity(const std::string& name);
    VariableRFCavity(const VariableRFCavity& );
    VariableRFCavity();
    VariableRFCavity& operator=(const VariableRFCavity&);
    virtual ~VariableRFCavity();
 
    virtual void accept(BeamlineVisitor&) const override;
 
    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 initialise(PartBunchBase<double, 3>* bunch, double& startField, double& endField) override;
 
    virtual void finalise() override;
 
    virtual bool bends() const override {return false;}
 
    virtual void getDimensions(double& /*zBegin*/, double& /*zEnd*/) const override {}
 
    virtual inline double getAmplitude(double time) const;
 
    virtual inline double getFrequency(double time) const;
 
    virtual inline double getPhase(double time) const;
 
    virtual inline double getHeight() const;
    virtual inline double getWidth() const;
    virtual inline double getLength() const;
    virtual inline void setHeight(double fullHeight);
    virtual inline void setWidth(double fullWidth);
    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> time_dep);
    virtual void setPhaseModel(std::shared_ptr<AbstractTimeDependence> time_dep);
    virtual void setFrequencyModel(std::shared_ptr<AbstractTimeDependence> time_dep);
 
    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; }
 
    virtual StraightGeometry& getGeometry() override;
    virtual const StraightGeometry& getGeometry() const override;
 
    void initialise() const;
 
    virtual EMField& getField() override;
    virtual const EMField& getField() const override;
 
protected:
    void initNull();
    std::shared_ptr<AbstractTimeDependence> phaseTD_m;
    std::shared_ptr<AbstractTimeDependence> amplitudeTD_m;
    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;
    TimeDependenceCache frequencyCache_m;
 
    StraightGeometry geometry;
 
private:
};
 
double VariableRFCavity::getAmplitude(double time) const {
    return amplitudeTD_m->getValue(time);
}
 
double VariableRFCavity::getPhase(double time) const {
    return phaseTD_m->getValue(time);
}
 
double VariableRFCavity::getFrequency(double time) const {
    return frequencyTD_m->getValue(time);
}
 
double VariableRFCavity::getHeight() const {
    return halfHeight_m * 2;
}
 
double VariableRFCavity::getWidth() const {
    return halfWidth_m * 2;
}
 
double VariableRFCavity::getLength() const {
    return length_m;
}
 
void VariableRFCavity::setHeight(double fullHeight) {
    halfHeight_m = fullHeight / 2;
}
 
void VariableRFCavity::setWidth(double fullWidth) {
    halfWidth_m = fullWidth / 2;
}
 
#endif // CLASSIC_VirtualRFCavity_HH