OrbitTracker.h

Go to the documentation of this file.

#ifndef CLASSIC_OrbitTracker_HH
#define CLASSIC_OrbitTracker_HH

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

#include "Algorithms/AbstractTracker.h"
#include "FixedAlgebra/FVector.h"

class BMultipoleField;
class Euclid3D;

template <class T, int N> class FTps;


// Class OrbitTracker
// ------------------------------------------------------------------------
//  Uses a thick lens method to find the orbit for each element.

class OrbitTracker: public AbstractTracker {

public:

    // Particle coordinate numbers.
    enum { X, PX, Y, PY, T, PT };

    //  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.
    OrbitTracker(const Beamline &, const PartData &,
                 bool backBeam, bool backTrack);

    virtual ~OrbitTracker();


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

    void setOrbit(const FVector<double, 6> orbit);

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

    virtual void visitProbe(const Probe &prob);

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

    virtual void visitAlignWrapper(const AlignWrapper &);

private:

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

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

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


    // The current orbit.
    FVector<double, 6> itsOrbit;
};

#endif // CLASSIC_OrbitTracker_HH