VariableRFCavity.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2014, Chris Rogers
 *  All rights reserved.
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *  3. Neither the name of STFC nor the names of its contributors may be used to
 *     endorse or promote products derived from this software without specific
 *     prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef CLASSIC_ABSBEAMLINE_VariableRFCavity_HH
#define CLASSIC_ABSBEAMLINE_VariableRFCavity_HH
 
#include "Algorithms/AbstractTimeDependence.h"
#include "Fields/EMField.h"
#include "BeamlineGeometry/StraightGeometry.h"
#include "AbsBeamline/Component.h"
 
class Fieldmap;
 
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(std::string amplitude)
    { amplitudeName_m = amplitude; }
 
    virtual void setPhaseName(std::string phase)
    { phaseName_m = phase; }
 
    virtual void setFrequencyName(std::string frequency)
    { frequencyName_m = frequency; }
 
    virtual StraightGeometry& getGeometry() override;
    virtual const StraightGeometry& getGeometry() const override;
 
    virtual EMField &getField() override;
    virtual const EMField &getField() const override;
  protected:
    void initNull();
    void initialise() const;
    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;
    StraightGeometry geometry;
    static constexpr double lengthUnit_m = 1e3;
 
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/lengthUnit_m;
}
 
double VariableRFCavity::getWidth() const {
    return halfWidth_m*2/lengthUnit_m;
}
 
double VariableRFCavity::getLength() const {
    return _length/lengthUnit_m;
}
 
void VariableRFCavity::setHeight(double fullHeight) {
    halfHeight_m = fullHeight/2*lengthUnit_m;
}
 
void VariableRFCavity::setWidth(double fullWidth) {
    halfWidth_m = fullWidth/2*lengthUnit_m;
}
 
 
 
 
#endif // CLASSIC_VirtualRFCavity_HH