LinearMapper.h

Go to the documentation of this file.

#ifndef MAD_LinearMapper_HH
#define MAD_LinearMapper_HH

// ------------------------------------------------------------------------
// $RCSfile: LinearMapper.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.3 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: LinearMapper
//
// ------------------------------------------------------------------------
//
// $Date: 2000/12/31 07:12:38 $
// $Author: mad $
//
// ------------------------------------------------------------------------

#include "Algorithms/AbstractMapper.h"
#include "FixedAlgebra/LinearMap.h"


class BMultipoleField;
class Euclid3D;

template <class T, int N> class FTps;
template <class T, int N> class FVps;


// Class LinearMapper
// ------------------------------------------------------------------------
// 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 second order.
// [li] Beam-beam elements are two-dimensional, and the second moment <x,y>
//   of the opposite bunches vanish.
// [/ul]

class LinearMapper: public AbstractMapper {

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.
    LinearMapper(const Beamline &beamline, const PartData &,
                 bool revBeam, bool revTrack);

    virtual ~LinearMapper();

    virtual void getMap(LinearMap<double, 6> &) const;

    virtual void getMap(FVps<double, 6> &) const;

    virtual void setMap(const LinearMap<double, 6> &);

    virtual void setMap(const FVps<double, 6> &);

    virtual void visitBeamBeam(const BeamBeam &);

    virtual void visitBeamStripping(const BeamStripping &);


    virtual void visitCCollimator(const CCollimator &);

    //  This override calls the component to track the map.
    virtual void visitComponent(const Component &);

    virtual void visitCorrector(const Corrector &);

    virtual void visitDegrader(const Degrader &);

    virtual void visitDiagnostic(const Diagnostic &);

    virtual void visitDrift(const Drift &);

    virtual void visitFlexibleCollimator(const FlexibleCollimator &);

    virtual void visitLambertson(const Lambertson &);

    virtual void visitMarker(const Marker &);

    virtual void visitMonitor(const Monitor &);

    virtual void visitMultipole(const Multipole &);

    virtual void visitPatch(const Patch &pat);

    virtual void visitProbe(const Probe &prob);

    virtual void visitRBend0(const RBend &);
    virtual void visitRBend(const RBend &);   // exp(:-H:) version
    virtual void visitRFCavity(const RFCavity &);

    virtual void visitRFQuadrupole(const RFQuadrupole &);

    virtual void visitSBend(const SBend &);

    virtual void visitSeparator(const Separator &);

    virtual void visitSeptum(const Septum &);

    virtual void visitSolenoid(const Solenoid &);

    virtual void visitAlignWrapper(const AlignWrapper &);

    virtual void visitParallelPlate(const ParallelPlate &);

    virtual void visitCyclotronValley(const CyclotronValley &);


    virtual void visitMapIntegrator(const MapIntegrator &);

protected:

    // Propagate current map through a drift.
    void applyDrift(double length);

    void applyEntranceFringe(double edge,
                             const BMultipoleField &field, double scale);
    void applyExitFringe(double edge,
                         const BMultipoleField &field, double scale);

    void applyLinearMap(double length, double refLength, double h,
                        const FTps<double, 2> &Fx, const FTps<double, 2> &Fy);

    void applyMultipoleBody(double length, double refLength,
                            const BMultipoleField &field, double scale);

    void applySBendBody(double length, double refLength, double h,
                        const BMultipoleField &field, double scale);

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

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

    FTps<double, 2>
    buildSBendVectorPotential(const BMultipoleField &, double h);


    // The linear map being accumulated.
    LinearMap <double, 6> itsMap;

private:

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

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

};

#endif // MAD_LinearMapper_HH