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;
    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