IdealMapper.h

Go to the documentation of this file.

#ifndef MAD_IdealMapper_HH
#define MAD_IdealMapper_HH

// ------------------------------------------------------------------------
// $RCSfile: IdealMapper.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: IdealMapper
//
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:33 $
// $Author: fci $
//
// ------------------------------------------------------------------------

#include "Algorithms/LinearMapper.h"

class BMultipoleField;
class Euclid3D;

template <class T, int M, int N> class FMatrix;

// Class IdealMapper
// ------------------------------------------------------------------------
// Ignores the following:
// [ul]
// [li]Any misalignments,
// [li]Any field errors,
// [li]Any momentum errors.
// [/ul]
// Phase space coordinates numbering:
// [tab 3 b]
// [row]number [&]name        [&]unit  [/row]
// [row]0      [&]x           [&]metres [/row]
// [row]1      [&]p_x/p_r     [&]1      [/row]
// [row]2      [&]y           [&]metres [/row]
// [row]3      [&]p_y/p_r     [&]1      [/row]
// [row]4      [&]v*delta_t   [&]metres [/row]
// [row]5      [&]delta_p/p_r [&]1      [/row]
// [/tab][p]
// Where $p_r$ is the constant reference momentum defining the reference
// frame velocity, $m$ is the rest mass of the particles, and $v$ is the
// instantaneous velocity of the particle.
// [p]
// Other units used:
// [tab 2 b]
// [row]quantity             [&]unit           [/row]
// [row]reference momentum   [&]electron-volts [/row]
// [row]velocity             [&]metres/second  [/row]
// [row]accelerating voltage [&]volts          [/row]
// [row]separator voltage    [&]volts          [/row]
// [row]frequencies          [&]hertz          [/row]
// [row]phase lags           [&]$2*pi$         [/row]
// [/tab][p]
// Approximations used:
// [ul]
// [li] All elements are represented by maps for finite-length elements.
// [li] Geometric transformations ignore rotations about transverse axes and
//   translations along the design orbit and truncate after first order.
// [li] Beam-beam elements are ignored.
// [/ul]

class IdealMapper: public LinearMapper {

public:

    //  The beam line to be tracked is [b]bl[/b].
    //  The particle reference data are taken from [b]data[/b].
    //  If [b]revBeam[/b] is true, the beam runs from s = C to s = 0.
    //  If [b]revTrack[/b] is true, we track against the beam.
    IdealMapper(const Beamline &beamline, const PartData &,
                bool revBeam, bool revTrack);

    virtual ~IdealMapper();

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

    virtual void setMatrix(const FMatrix<double, 6, 6> &);

    //  Override to ignore corrector kick.
    virtual void visitCorrector(const Corrector &);

    //  Override to ignore patch.
    virtual void visitPatch(const Patch &pat);

    //  Override to ignore separator kick.
    virtual void visitSeparator(const Separator &);

    //  Override to ignore misalignment.
    virtual void visitAlignWrapper(const AlignWrapper &);

    virtual void visitCorrectorWrapper(const CorrectorWrapper &);

    virtual void visitMultipoleWrapper(const MultipoleWrapper &);

    virtual void visitRBendWrapper(const RBendWrapper &);

    virtual void visitSBendWrapper(const SBendWrapper &);

protected:

    // Apply thin multipole kick (integrated over length) to ideal map.
    virtual void applyMultipoleBody
    (double length, double refLength, const BMultipoleField &field, double scale);

    // Apply thin multipole kick (integrated over length) to all particles.
    virtual void applySBendBody
    (double length, double refLength, double h,
     const BMultipoleField &field, double scale);

    //  Apply a thin multipole kick (integrated over length) to current map.
    virtual void applyThinMultipole
    (const BMultipoleField &field, double factor);

    //  Special kick routine for thin SBend.
    virtual void applyThinSBend
    (const BMultipoleField &field, double scale, double h);

    //  Propagate current map through a geometric transformation.
    virtual void applyTransform(const Euclid3D &, double refLength);

private:

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

    void applyLinearMap(double length, double kx, double ks, double ky);

    static void makeFocus(double k, double L, double &c, double &s);
};

#endif // MAD_IdealMapper_HH