Offset.h

Go to the documentation of this file.

//
// Class Offset
//   Defines the abstract interface for offset of elements.
//
// 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 CLASSIC_ABSBEAMLINE_Offset_HH
#define CLASSIC_ABSBEAMLINE_Offset_HH
 
#include "AbsBeamline/Component.h"
#include "BeamlineGeometry/Euclid3DGeometry.h"
#include "Fields/EMField.h"
 
#include <string>

class Offset: public Component {
public:
    explicit Offset(const std::string& name);

    Offset();

    Offset(const std::string& name, const Offset&);

    Offset(const Offset&);

    Offset& operator=(const Offset&);

    static Offset localCylindricalOffset(const std::string& name,
                                         double theta_in,
                                         double theta_out,
                                         double displacement);

    static Offset globalCylindricalOffset(const std::string& name,
                                          double radius_out,
                                          double phi_out,
                                          double theta_out);

    static Offset localCartesianOffset(const std::string& name,
                                       Vector_t end_position,
                                       Vector_t end_direction);

    static Offset globalCartesianOffset(const 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;
};

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