Ring.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2012-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 RING_H
#define RING_H
 
#include <string>
 
#include "AbsBeamline/Component.h"
 
#include "BeamlineGeometry/PlanarArcGeometry.h"
 
#include "Utilities/GeneralOpalException.h"
#include "Utilities/RingSection.h"
 
class LossDataSink;
class FieldMap;
 
class Ring : public Component {
public:
    Ring(std::string ring);
 
    Ring(const Ring& ring);
 
    virtual ~Ring();
 
    virtual bool apply(const std::shared_ptr<ParticleContainer_t>& pc) override;
 
    virtual bool apply(
            const size_t& id, const double& t, Vector_t<double, 3>& E,
            Vector_t<double, 3>& B) override;
 
    virtual bool apply(
            const Vector_t<double, 3>& R, const Vector_t<double, 3>& P, const double& t,
            Vector_t<double, 3>& E, Vector_t<double, 3>& B) override;
 
    virtual void initialise(PartBunch_t* bunch, double& startField, double& endField) override;
 
    virtual void initialise(PartBunch_t* bunch);
 
    virtual void finalise() override;
 
    virtual bool bends() const override { return true; }
 
    virtual void accept(BeamlineVisitor& visitor) const override;
 
    virtual void getFieldExtend(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 GeneralOpalException("Ring::getField", "Not implemented");
    }
 
    virtual const EMField& getField() const override {
        throw GeneralOpalException("Ring::getField", "Not implemented");
    }
 
    virtual PlanarArcGeometry& getGeometry() override { return planarArcGeometry_m; }
 
    virtual const PlanarArcGeometry& getGeometry() const override { return planarArcGeometry_m; }
 
    void setLossDataSink(LossDataSink* sink);
 
    PartBunch_t* getLossDataSink() const;
 
    void setRefPartBunch(PartBunch_t* bunch);
 
    PartBunch_t* 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 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<double, 3> getNextPosition() const;
 
    Vector_t<double, 3> 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* getLastSectionPlaced() const;
 
    std::vector<RingSection*> getSectionsAt(const Vector_t<double, 3>& pos);
 
    static inline Vector_t<double, 3> convert(const Vector3D& vec);
 
    static inline Vector3D convert(const Vector_t<double, 3>& 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;
 
    // 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
    PartBunch_t* 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;
 
    // 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<double, 3> Ring::convert(const Vector3D& vec_3d) {
    return Vector_t<double, 3>({vec_3d(0), vec_3d(1), vec_3d(2)});
}
 
Vector3D Ring::convert(const Vector_t<double, 3>& vec_t) {
    return Vector3D({vec_t[0], vec_t[1], vec_t[2]});
}
 
#endif  // #ifndef RING_H