LieMapper.h

Go to the documentation of this file.

#ifndef OPAL_LieMapper_HH
#define OPAL_LieMapper_HH

// ------------------------------------------------------------------------
// $RCSfile: LieMapper.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: LieMapper
//
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:33:36 $
// $Author: Andreas Adelmann $
//
// ------------------------------------------------------------------------

#include "Algorithms/Mapper.h"
#include "FixedAlgebra/DragtFinnMap.h"

class BMultipoleField;
class PlanarArcGeometry;


// Class LieMapper
// ------------------------------------------------------------------------
//  All maps are factored in ascending Dragt-Finn order.
// [p]
// 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]
// All elements are represented by maps for finite-length elements.
// Several important pieces are still MISSING from this algorithm.

class LieMapper: public AbstractMapper {

public:

    //  The beam line to be tracked is "bl".
    //  The particle reference data are taken from "data".
    //  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.
    LieMapper(const Beamline &bl, const PartData &data,
              bool backBeam, bool backTrack, int order);

    virtual ~LieMapper();

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

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

    virtual void getMap(DragtFinnMap<3> &) const;

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

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

    virtual void setMap(const DragtFinnMap<3> &);


    virtual void visitBeamBeam(const BeamBeam &);

    virtual void visitBeamStripping(const BeamStripping &);

    virtual void visitCCollimator(const CCollimator &);

    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 &);

    virtual void visitProbe(const Probe &);

    virtual void visitRBend(const RBend &);

    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 visitParallelPlate(const ParallelPlate &);

    virtual void visitCyclotronValley(const CyclotronValley &);

private:

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

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

    // Transforms fringing fields.
    void applyEntranceFringe(double edge, double curve,
                             const BMultipoleField &field, double scale);
    void applyExitFringe(double edge, double curve,
                         const BMultipoleField &field, double scale);

    //  Propagate current map through a geometric transformation.
    //  Linear approximation for the time being.
    virtual void applyTransform(const Euclid3D &, double refLength = 0.0);

    // The Lie map being accumulated.
    DragtFinnMap<3> itsMap;

    // The desired map order.
    int itsOrder;
};

#endif // OPAL_LieMapper_HH