VariableRFCavityFringeField.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_VariableRFCavityFringeField_HH
#define CLASSIC_ABSBEAMLINE_VariableRFCavityFringeField_HH
 
#include <iostream>
#include "AbsBeamline/VariableRFCavity.h"
 
class Fieldmap;
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;
 
    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*1000.; // stored internally as mm
}
 
double VariableRFCavityFringeField::getCavityCentre() const {
    return zCentre_m/1000.; // stored internally as mm
}
 
void VariableRFCavityFringeField::setMaxOrder(size_t maxOrder) {
    maxOrder_m = maxOrder;
    initialiseCoefficients();
}
 
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