Twiss.h

Go to the documentation of this file.

#ifndef OPAL_Twiss_HH
#define OPAL_Twiss_HH

// ------------------------------------------------------------------------
// $RCSfile: Twiss.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.2 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Twiss
//
// ------------------------------------------------------------------------
//
// $Date: 2001/08/13 15:25:22 $
// $Author: jowett $
//
// ------------------------------------------------------------------------

#include "AbstractObjects/Table.h"
#include "AbstractObjects/Expressions.h"
#include "Beamlines/FlaggedElmPtr.h"
#include "Beamlines/TBeamline.h"
#include "FixedAlgebra/FMatrix.h"
#include "FixedAlgebra/FVector.h"
#include <iosfwd>
#include <vector>

class AbstractMapper;
class Beam;
class PartData;
class PlaceRep;
class RangeRep;


// ------------------------------------------------------------------------

class Twiss: public Table {

    friend class Insertion;
    friend class Period;

public:

    class Row: public FlaggedElmPtr {

        friend class Insertion;
        friend class Period;
        friend class Twiss;

    public:

        Row(ElementBase *, int);
        explicit Row(const FlaggedElmPtr &);
        ~Row();

        const FVector<double, 6> &getCO() const;

        const FMatrix<double, 6, 6> &getMatrix() const;

        double getS() const;

        double getMUi(int i) const;

    private:

        FVector<double, 6> orbit;

        FMatrix<double, 6, 6> matrix;

        double arc;

        double mu[3];
    };

    // The contained beamline type.
    typedef TBeamline<Row> TLine;

    virtual ~Twiss();

    //  Version for constant table.
    TLine::const_iterator begin() const;

    //  Version for non-constant table.
    TLine::iterator begin();

    //  Version for constant table.
    TLine::const_iterator end() const;

    //  Version for non-constant table.
    TLine::iterator end();

    virtual void execute();

    virtual double getCell(const PlaceRep &row, const std::string &col);

    virtual CellArray getDefault() const;

    virtual std::vector<double>
    getColumn(const RangeRep &range, const std::string &col);

    const Row &getCurrent() const;

    double getEX() const;

    double getEY() const;

    double getET() const;

    virtual double getLength();

    virtual const Beamline *getLine() const;

    virtual std::vector<double>
    getRow(const PlaceRep &, const std::vector<std::string> &);

    //  Return true, if this table depends on the named object.
    virtual bool isDependent(const std::string &name) const;

    //  Return an expression which denotes a column of the twiss table,
    //  identified by its name.
    virtual Expressions::PtrToScalar<double>
    makeColumnExpression(const std::string &colName) const;

    //  True, if [b]rhs[/b] is derived from [b]Twiss[/b].
    virtual bool matches(Table *rhs) const;

    void printTableBody(std::ostream &, const CellArray &) const;

    void printTableTitle(std::ostream &, const char *title) const;

    // Access to items in the table.
    // ----------------------------------------------------------------------
    FMatrix<double, 6, 6> getCurlyA() const;

    FMatrix<double, 6, 6> getCurlyA(const Row &) const;

    FMatrix<double, 6, 6> getMatrix(const Row &) const;

    FVector<double, 6> getOrbit() const;

    FVector<double, 6> getOrbit(const Row &) const;

    FMatrix<double, 6, 6> getSigma() const;

    FMatrix<double, 6, 6> getSigma(const Row &) const;


    double getS(const Row &, int = 0, int = 0) const;

    //  Index (0 ... 2) is mode.
    double getMUi(const Row &, int i1, int = 0) const;
    double getBETi(const Row &, int i1, int = 0) const;
    double getALFi(const Row &, int i1, int = 0) const;

    //  First index (0 ... 2) is plane, second index (0 ... 2) is mode.
    double getBETik(const Row &, int i1, int i2) const;

    //  First index (0 ... 2) is plane, second index (0 ... 2) is mode.
    double getALFik(const Row &, int i1, int i2) const;

    //  First index (0 ... 2) is plane, second index (0 ... 2) is mode.
    double getGAMik(const Row &, int i1, int i2) const;

    //  Index (0 ... 5) is plane.
    double getCO(const Row &, int i1, int = 0) const;

    //  Index (0 ... 5) is plane.
    double getDisp(const Row &, int i1, int = 0) const;

    //  First index (0 ... 5) is plane, second index (0 ... 5) is column.
    double getEigen(const Row &, int i1, int i2) const;

    //  Both indices (0 ... 5) refer to planes.
    double getSigma(const Row &, int i1, int i2) const;

    //  First index (0 ... 5) is row, second index (0 ... 5) is column.
    double getMatrix(const Row &, int i1, int i2) const;

protected:

    //  Must be accessible to classes Insertion and Period.
    enum {
        // User-definable attributes:
        LINE,        // The beam line for the table,
        BEAM,        // The beam to be used.
        RANGE,       // The range in the lattice.
        ORDER,       // The order for the calculation.
        STATIC,      // The flag for suppressing recalculation.
        METHOD,      // the algorithm for filling
        REVBEAM,     // If true, beam runs backwrads.
        REVTRACK,    // If true, track lattice functions against the beam.

        // Read-only attributes:
        BETXMAX,     // Maximum beta functions
        BETYMAX,
        XCMAX,       // Maximum closed orbit excursion
        YCMAX,
        XCRMS,       // R.M.S. closed orbit excursion
        YCRMS,
        DXMAX,       // Maximum dispersion
        DYMAX,
        DXRMS,       // R.M.S. dispersion
        DYRMS,
        SIZE
    };

    Twiss(int size, const char *name, const char *help);

    Twiss(const std::string &name, Twiss *parent);


    static const int numColumns = 11;

    FVector<double, 6> orbit;

    FMatrix<double, 6, 6> curly_A;

private:

    // Not implemented.
    Twiss(const Twiss &);
    void operator=(const Twiss &);

    // Return the table row.
    Row &findRow(const PlaceRep &row);

    // This method is called to fill the table after initialising.
    void put();

    // Access to current table row.
    mutable TLine::const_iterator current;

    // The table contents.
    TLine *itsTable;

    // Pointer to the filling algorithm.
    AbstractMapper *itsMapper;

    // The attached beam.
    const Beam *beam;

    // The particle reference data.
    const PartData *reference;

    // The truncation order (1 for LINEAR, 2 for all other).
    int order;

    // The direction flags.
    bool revBeam;   // true, if beam runs from right (s=C) to left (s=0).
    bool revTrack;  // true, if tracking against the beam.
    bool revPath;   // true, if tracking from right (s=C) to left (s=0).

    // The name of the analysed line.
    std::string itsLine;
};

#endif // OPAL_Twiss_HH