Ring.h

Go to the documentation of this file.

//
// Class Ring
//   Defines the abstract interface for a ring type geometry.
//
// Copyright (c) 2012 - 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 RING_H
#define RING_H
 
#include "AbsBeamline/Component.h"
#include "BeamlineGeometry/PlanarArcGeometry.h"
#include "Utilities/GeneralClassicException.h"
#include "Utilities/RingSection.h"
 
#include <cmath>
#include <string>
 
class LossDataSink;
template <class T, unsigned Dim>
class PartBunchBase;
class FieldMap;
 
class Ring: public Component {
 
public:
    Ring(const std::string& ring);
 
    Ring(const Ring& ring);
 
    virtual ~Ring();
 
    virtual bool apply(const size_t& id, 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 void initialise(PartBunchBase<double, 3>* bunch, double& startField,
                            double& endField) override;
 
    virtual void initialise(PartBunchBase<double, 3>* bunch);
 
    virtual void finalise() override;
 
    virtual bool bends() const override {return true;}
 
    virtual void accept(BeamlineVisitor& visitor) const override;
 
    virtual void getDimensions(double& zBegin, double& zEnd) const override;
 
    virtual ElementBase* clone() const override {return new Ring(*this);}
 
    void appendElement(const Component& element);
 
    virtual EMField& getField() override {throw GeneralClassicException("Ring::getField", "Not implemented");}
 
    virtual const EMField& getField() const override {throw GeneralClassicException("Ring::getField", "Not implemented");}
 
    virtual PlanarArcGeometry& getGeometry() override {return planarArcGeometry_m;}
 
    virtual const PlanarArcGeometry& getGeometry() const override {return planarArcGeometry_m;}
 
    void setLossDataSink(LossDataSink* sink);
 
    PartBunchBase<double, 3>* getLossDataSink() const;
 
    void setRefPartBunch(PartBunchBase<double, 3>* bunch);
 
    PartBunchBase<double, 3>* getRefPartBunch() const;
 
    void setHarmonicNumber(double cyclHarm) {cyclHarm_m = cyclHarm;}
 
    double getHarmonicNumber() {return cyclHarm_m;}
    // note this is not a const method to follow parent
 
    void setRFFreq(double rfFreq) {rfFreq_m = rfFreq;}
 
    double getRFFreq() const {return rfFreq_m;}
 
    void setBeamRInit(double rInit) {beamRInit_m = rInit;}
 
    double getBeamRInit() const {return beamRInit_m;}
 
    void setBeamPhiInit(double phiInit) {beamPhiInit_m = phiInit;}
 
    double getBeamPhiInit() const {return beamPhiInit_m;}
 
    void setBeamThetaInit(double thetaInit) {beamThetaInit_m = thetaInit;}
 
    double getBeamThetaInit() const {return beamThetaInit_m;}
 
    void setBeamPRInit(double pRInit) {beamPRInit_m = pRInit;}
 
    double getBeamPRInit() const {return beamPRInit_m;}
 
    void setLatticeRInit(double rInit) {latticeRInit_m = rInit;}
 
    double getLatticeRInit() const {return latticeRInit_m;}
 
    void setLatticePhiInit(double phiInit) {latticePhiInit_m = phiInit;}
 
    double getLatticePhiInit() const {return latticePhiInit_m;}
 
    Vector_t getNextPosition() const;
 
    Vector_t getNextNormal() const;
 
    void setLatticeThetaInit(double thetaInit) {latticeThetaInit_m = thetaInit;}
 
    double getLatticeThetaInit() const {return latticeThetaInit_m;}
 
    void setSymmetry(double symmetry) {symmetry_m = symmetry;}
 
    void setScale(double scale) {scale_m = scale;}
 
    double getSymmetry() const {return symmetry_m;}
 
    void setIsClosed(bool isClosed) {isClosed_m = isClosed;}
 
    double getIsClosed() const {return isClosed_m;}
 
    void setRingAperture(double minR, double maxR);
 
    double getRingMinR() const {return std::sqrt(minR2_m);}
 
    double getRingMaxR() const {return std::sqrt(maxR2_m);}
 
    void lockRing();
 
    RingSection* getSection(int i) const;
 
    RingSection* getLastSectionPlaced() const;
 
    size_t getNumberOfRingSections() const;
 
    std::vector<RingSection*> getSectionsAt(const Vector_t& pos);
 
    static inline Vector_t convert(const Vector3D& vec);
 
    static inline Vector3D convert(const Vector_t& vec);
 
private:
    // Force end to have azimuthal angle > start unless crossing phi = pi/-pi
    void resetAzimuths();
 
    // check for closure; throw an exception is ring is not closed within
    // tolerance; enforce closure to floating point precision
    void checkAndClose();
 
    // build a map that maps section to sections that overlap it
    void buildRingSections();
 
    void rotateToCyclCoordinates(Euclid3D& euclid3d) const;
 
    // get the initial position
    Vector_t getStartPosition() const;
 
    // get the initial normal
    Vector_t getStartNormal() const;
 
    // predicate for sorting
    static bool sectionCompare(RingSection const* const sec1,
                               RingSection const* const sec2);
 
    Ring();
 
    Ring& operator=(const Ring& ring);
 
    void checkMidplane(Euclid3D delta) const;
    Rotation3D getRotationStartToEnd(Euclid3D delta) const;
 
    PlanarArcGeometry planarArcGeometry_m;
 
    // points to same location as RefPartBunch_m on the child bunch, but we
    // rename to keep in line with style guide
    //
    // Ring borrows this memory
    PartBunchBase<double, 3> *refPartBunch_m;
 
    // store for particles out of the aperture
    //
    // Ring owns this memory
    LossDataSink* lossDS_m;
 
    // initial position of the beam
    double beamRInit_m;
    double beamPRInit_m;
    double beamPhiInit_m;
    double beamThetaInit_m;
 
    // position, orientation of the first lattice element
    double latticeRInit_m;
    double latticePhiInit_m;
    double latticeThetaInit_m;
 
    // aperture cut on the ring (before any field maps tracking)
    // note we store r^2
    bool willDoAperture_m = false;
    double minR2_m;
    double maxR2_m;
 
    // Ring is locked - new elements cannot be added
    bool isLocked_m;
 
    // Set to false to enable a non-circular ring (e.g. some weird spiral
    // geometry)
    bool isClosed_m;
 
    // number of cells/rotational symmetry of the ring
    int symmetry_m;
 
    double scale_m = 1.;
 
    // rf harmonic number
    double cyclHarm_m;
 
    // nominal rf frequency
    double rfFreq_m;
 
    // vector of RingSection sorted by phi (Component placement)
    double phiStep_m;
    std::vector<RingSectionList> ringSections_m;
    RingSectionList section_list_m;
 
    // tolerance on checking for geometry consistency
    static const double lengthTolerance_m;
    static const double angleTolerance_m;
};
 
Vector_t Ring::convert(const Vector3D& vec_3d) {
    return Vector_t(vec_3d(0), vec_3d(1), vec_3d(2));
}
 
Vector3D Ring::convert(const Vector_t& vec_t) {
    return Vector3D(vec_t[0], vec_t[1], vec_t[2]);
}
 
#endif //#ifndef RING_H