TBeamline.h

Go to the documentation of this file.

//
// Class TBeamline
//   Template class for beam lines.
//   Instantiation with different T types allows attachment of additional
//   data to each position in the line.
//
// Copyright (c) 200x - 2020, Paul Scherrer Institut, Villigen PSI, Switzerland
// 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_TBeamline_HH
#define CLASSIC_TBeamline_HH
 
#include "Beamlines/Beamline.h"
#include "AbsBeamline/BeamlineVisitor.h"
#include "Beamlines/BeamlineGeometry.h"
#include "Algorithms/Vektor.h"
#include "Algorithms/Quaternion.h"
#include <algorithm>
#include <string>
#include <list>
 
template <class T>
class TBeamline: public Beamline, public std::list<T> {
 
public:
 
    TBeamline();
 
    explicit TBeamline(const std::string &name);
 
    TBeamline(const TBeamline<T> &right);
    virtual ~TBeamline();
 
    virtual void accept(BeamlineVisitor &) const;
 
    //  If the parameter [b]r2l[/b] is true, the line is traversed from
    //  right (s=C) to left (s=0).
    //  If any error occurs, this method may throw an exception.
    virtual void iterate(BeamlineVisitor &, bool r2l) const;
 
    virtual TBeamline<T> *clone() const;
 
    virtual TBeamline<T> *copyStructure();
 
    //  The whole beamline and the elements depending on [b]this[/b] are
    //  marked as sharable.  After this call a [b]copyStructure()[/b] call
    //  reuses the element.
    virtual void makeSharable();
 
    //  Version for non-constant object.
    virtual BeamlineGeometry &getGeometry();
 
    //  Version for constant object.
    virtual const BeamlineGeometry &getGeometry() const;
 
    //  Return the length of the geometry, measured along the design orbit.
    virtual double getArcLength() const;
 
    //  Return the length of the geometry, measured along the design polygone.
    virtual double getElementLength() const;
 
    //  Return the arc length from the entrance to the origin of the
    //  geometry (non-negative).
    virtual double getOrigin() const;
 
    //  Return the arc length from the origin to the entrance of the
    //  geometry (non-positive).
    virtual double getEntrance() const;
 
    //  Return the arc length from the origin to the exit of the
    //  geometry (non-negative).
    virtual double getExit() const;
 
    //  Return the transform of the local coordinate system from the
    //  position [b]fromS[/b] to the position [b]toS[/b].
    virtual Euclid3D getTransform(double fromS, double toS) const;
 
    //  Equivalent to getTransform(0.0, s).
    //  Return the transform of the local coordinate system from the
    //  origin and [b]s[/b].
    virtual Euclid3D getTransform(double s) const;
 
    //  Equivalent to getTransform(getEntrance(), getExit()).
    //  Return the transform of the local coordinate system from the
    //  entrance to the exit of the element.
    virtual Euclid3D getTotalTransform() const;
 
    //  Equivalent to getTransform(0.0, getEntrance()).
    //  Return the transform of the local coordinate system from the
    //  origin to the entrance of the element.
    virtual Euclid3D getEntranceFrame() const;
 
    //  Equivalent to getTransform(0.0, getExit()).
    //  Return the transform of the local coordinate system from the
    //  origin to the exit of the element.
    virtual Euclid3D getExitFrame()     const;
 
    virtual ElementType getType() const;
 
    virtual void append(const T &);
 
    virtual void prepend(const T &);
 
    void setOrigin3D(const Vector_t& ori);
    Vector_t getOrigin3D() const;
    void setInitialDirection(const Quaternion& rot);
    Quaternion getInitialDirection() const;
 
    void setRelativeFlag(bool flag);
    bool getRelativeFlag() const;
    size_t size() const;
protected:
 
    //  Exists to match the interface for ElementBase.
    BeamlineGeometry itsGeometry;
 
    Vector_t itsOrigin_m;
    Quaternion itsCoordTrafoTo_m;
    bool relativePositions_m;
};
 
 
// Implementation of template class TBeamline
// ------------------------------------------------------------------------
 
template <class T>
TBeamline<T>::TBeamline():
    Beamline(),
    std::list<T>(),
    itsGeometry(*this),
    itsOrigin_m(0),
    itsCoordTrafoTo_m(1.0, 0.0, 0.0, 0.0),
    relativePositions_m(false)
{}
 
 
template <class T>
TBeamline<T>::TBeamline(const std::string &name):
    Beamline(name),
    std::list<T>(),
    itsGeometry(*this),
    itsOrigin_m(0),
    itsCoordTrafoTo_m(1.0, 0.0, 0.0, 0.0),
    relativePositions_m(false)
{}
 
 
template <class T>
TBeamline<T>::TBeamline(const TBeamline<T> &rhs):
    Beamline(rhs),
    std::list<T>(rhs),
    itsGeometry(*this),
    itsOrigin_m(rhs.itsOrigin_m),
    itsCoordTrafoTo_m(rhs.itsCoordTrafoTo_m),
    relativePositions_m(rhs.relativePositions_m)
{}
 
 
template <class T>
TBeamline<T>::~TBeamline()
{}
 
 
template <class T>
void TBeamline<T>::accept(BeamlineVisitor &visitor) const {
    visitor.visitBeamline(*this);
}
 
 
template <class T>
void TBeamline<T>::iterate(BeamlineVisitor &visitor, bool r2l) const {
    if(r2l) {
        for(typename std::list<T>::const_reverse_iterator op = this->rbegin();
            op != this->rend(); ++op) {
            op->accept(visitor);
        }
    } else {
        for(typename std::list<T>::const_iterator op = this->begin();
            op != this->end(); ++op) {
            op->accept(visitor);
        }
    }
}
 
 
template <class T>
TBeamline<T> *TBeamline<T>::clone() const {
    TBeamline<T> *line = new TBeamline(getName());
 
    for(typename std::list<T>::const_iterator op = this->begin();
        op != this->end(); ++op) {
        // Make copy of the T object containing a deep copy of its child.
        T newObj(*op);
        newObj.setElement(op->getElement()->clone());
        line->append(newObj);
    }
 
    line->itsOrigin_m = itsOrigin_m;
    line->itsCoordTrafoTo_m = itsCoordTrafoTo_m;
    line->relativePositions_m = relativePositions_m;
 
    return line;
}
 
// 21-6-2000 ada change iterator to const_iterator
template <class T>
TBeamline<T> *TBeamline<T>::copyStructure() {
    if(isSharable()) {
        return this;
    } else {
        TBeamline<T> *line = new TBeamline(getName());
 
        for(typename std::list<T>::const_iterator iter = this->begin();
            iter != this->end(); ++iter) {
            // The copy constructor ensures proper transmission of data.
            T newObj(*iter);
            newObj.setElement(iter->getElement()->copyStructure());
            line->append(newObj);
        }
 
        line->itsOrigin_m = itsOrigin_m;
        line->itsCoordTrafoTo_m = itsCoordTrafoTo_m;
        line->relativePositions_m = relativePositions_m;
 
        return line;
    }
}
 
// 21-6-2000 ada change iterator to const_iterator
template <class T> inline
void TBeamline<T>::makeSharable() {
    shareFlag = true;
 
    for(typename std::list<T>::const_iterator iter = this->begin();
        iter != this->end(); ++iter) {
        iter->getElement()->makeSharable();
    }
}
 
 
template <class T> inline
BeamlineGeometry &TBeamline<T>::getGeometry() {
    return itsGeometry;
}
 
 
template <class T> inline
const BeamlineGeometry &TBeamline<T>::getGeometry() const {
    return itsGeometry;
}
 
 
template <class T>
double TBeamline<T>::getArcLength() const {
    double length = 0.0;
 
    for(typename std::list<T>::const_iterator iter = this->begin();
        iter != this->end(); ++iter) {
        length += iter->getElement()->getArcLength();
    }
 
    return length;
}
 
 
template <class T>
double TBeamline<T>::getElementLength() const {
    double length = 0.0;
 
    for(typename std::list<T>::const_iterator iter = this->begin();
        iter != this->end(); ++iter) {
        length += iter->getElement()->getElementLength();
    }
 
    return length;
}
 
 
template <class T>
double TBeamline<T>::getOrigin() const {
    return (getArcLength() / 2.0);
}
 
 
template <class T>
double TBeamline<T>::getEntrance() const {
    return (- getOrigin());
}
 
 
template <class T>
double TBeamline<T>::getExit() const {
    return (getArcLength() / 2.0);
}
 
 
template <class T>
Euclid3D TBeamline<T>::getTransform(double fromS, double toS) const {
    Euclid3D transform;
 
    if(fromS < toS) {
        double s1 = getEntrance();
        typename std::list<T>::const_iterator iter = this->begin();
 
        while(iter != this->end()  &&  s1 <= toS) {
            const ElementBase &element = *iter->getElement();
            double l = element.getArcLength();
            double s2 = s1 + l;
 
            if(s2 > fromS) {
                double s0 = (s1 + s2) / 2.0;
                double arc1 = std::max(s1, fromS) - s0;
                double arc2 = std::min(s2, toS)   - s0;
                transform *= element.getTransform(arc1, arc2);
            }
 
            s1 = s2;
            ++iter;
        }
    } else {
        double s1 = getExit();
        typename std::list<T>::const_reverse_iterator iter = this->rbegin();
 
        while(iter != this->rend()  &&  s1 >= toS) {
            const ElementBase &element = *iter->getElement();
            double l = element.getArcLength();
            double s2 = s1 - l;
 
            if(s2 < fromS) {
                double s0 = (s1 + s2) / 2.0;
                double arc1 = std::min(s1, fromS) - s0;
                double arc2 = std::max(s2, toS)   - s0;
                transform *= element.getTransform(arc1, arc2);
            }
 
            s1 = s2;
            ++iter;
        }
    }
 
    return transform;
}
 
 
template <class T>
Euclid3D TBeamline<T>::getTotalTransform() const {
    Euclid3D transform;
 
    for(typename std::list<T>::const_iterator iter = this->begin();
        iter != this->end(); ++iter) {
        transform.dotBy(iter->getElement()->getTotalTransform());
    }
 
    return transform;
}
 
 
template <class T>
Euclid3D TBeamline<T>::getTransform(double s) const {
    return getTransform(0.0, s);
}
 
 
template <class T>
Euclid3D TBeamline<T>::getEntranceFrame() const {
    return getTransform(0.0, getEntrance());
}
 
 
template <class T>
Euclid3D TBeamline<T>::getExitFrame() const {
    return getTransform(0.0, getExit());
}
 
 
template <class T> inline
ElementType TBeamline<T>::getType() const {
    return ElementType::BEAMLINE;
}
 
 
template <class T> inline
void TBeamline<T>::append(const T &obj) {
    this->push_back(obj);
}
 
 
template <class T> inline
void TBeamline<T>::prepend(const T &obj) {
    this->push_front(obj);
}
 
template <class T> inline
void TBeamline<T>::setOrigin3D(const Vector_t& ori) {
    itsOrigin_m = ori;
}
 
template <class T> inline
Vector_t TBeamline<T>::getOrigin3D() const {
    return itsOrigin_m;
}
 
template <class T> inline
void TBeamline<T>::setInitialDirection(const Quaternion& trafoTo) {
    itsCoordTrafoTo_m = trafoTo;
}
 
template <class T> inline
Quaternion TBeamline<T>::getInitialDirection() const {
    return itsCoordTrafoTo_m;
}
 
template <class T> inline
void TBeamline<T>::setRelativeFlag(bool flag) {
    relativePositions_m = flag;
}
 
template <class T> inline
bool TBeamline<T>::getRelativeFlag() const {
    return relativePositions_m;
}
 
template <class T>
size_t TBeamline<T>::size() const {
    size_t blSize = 0;
    for(typename std::list<T>::const_iterator iter = this->begin();
        iter != this->end(); ++iter) {
        blSize++;
    }
 
    return blSize;
}
 
#endif // CLASSIC_TBeamline_HH