Offset.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_Offset_HH
#define CLASSIC_ABSBEAMLINE_Offset_HH
 
#include "Fields/EMField.h"
#include "BeamlineGeometry/Euclid3DGeometry.h"
#include "AbsBeamline/Component.h"
 
#include <string>
 
class Offset : public Component {
  public:
    explicit Offset(const std::string &name);
 
    Offset();
 
    Offset(std::string name, const Offset &);
 
    Offset(const Offset &);
 
    Offset& operator=(const Offset &);
 
    static Offset localCylindricalOffset(std::string name,
                                         double theta_in,
                                         double theta_out,
                                         double displacement);
 
    static Offset globalCylindricalOffset(std::string name,
                                          double radius_out,
                                          double phi_out,
                                          double theta_out);
 
    static Offset localCartesianOffset(std::string name,
                                       Vector_t end_position,
                                       Vector_t end_direction);
 
    static Offset globalCartesianOffset(std::string name,
                                        Vector_t end_position,
                                        Vector_t end_direction);
 
    ~Offset();
 
    void accept(BeamlineVisitor &) const override;
 
    ElementBase* clone() const override;
 
    bool bends() const override;
 
    void initialise(PartBunchBase<double, 3> *bunch, double &startField,
                            double &endField) override;
    void finalise() override;
    void getDimensions(double &/*zBegin*/, double &/*zEnd*/) const override {}
 
    void setEndPosition(Vector_t position);
    Vector_t getEndPosition() const;
 
    void setEndDirection(Vector_t direction);
    Vector_t getEndDirection() const;
 
    void setIsLocal(bool isLocal);
 
    bool getIsLocal() const;
 
    Euclid3DGeometry& getGeometry() override;
    const Euclid3DGeometry& getGeometry() const override;
    void updateGeometry(Vector_t startPosition, Vector_t startDirection);
    void updateGeometry();
    bool isGeometryAllocated() const;
 
    EMField &getField() override;
    const EMField &getField() const override;
    static double getTheta(Vector_t vec1, Vector_t vec2);
 
    static Vector_t rotate(Vector_t vec, double theta);
 
    static double float_tolerance;
  private:
    Vector_t _end_position;
    Vector_t _end_direction;
    bool     _is_local;
    // The offset's geometry.
    Euclid3DGeometry* geometry_m = nullptr;
    static const double lengthUnits_m;
};
 
bool operator==(const Offset& off1, const Offset& off2);
 
bool operator!=(const Offset& off1, const Offset& off2);
 
std::ostream& operator<<(std::ostream& out, const Offset& off1);
 
#endif  // CLASSIC_ABSBEAMLINE_Offset_HH