BeamBeamRep.h

Go to the documentation of this file.

#ifndef CLASSIC_BeamBeamRep_HH
#define CLASSIC_BeamBeamRep_HH

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

#include "AbsBeamline/BeamBeam.h"
#include "BeamlineGeometry/NullGeometry.h"
#include "Fields/NullField.h"


// Class BeamBeamRep
// ------------------------------------------------------------------------
//  A concrete representation for a beam-beam interaction.
//  The opposite bunch has a Gaussian distribution of the form
//  [P]
//  N(x,y,s) = c * exp(- transpose(z - delta) sigma**(-1) (z - delta)),
//  [P]
//  with the definitions
//  [DL]
//  [DT]z[DD]     position vector in space,
//  [DT]delta[DD] centroid of opposite bunch in global reference system,
//  [DT]sigma[DD] beam matrix in the TRANSPORT sense,
//  [DT]c[DD]     a normalising factor, such that the total charge is Q,
//  [DT]sigma(i,i)[DD] standard deviation sigma(i) in direction i,
//  [DT]r(i,j)[DD] = sigma(i,j)/sqrt(sigma(i,i)*sigma(i,j)),
//    correlations between phase space coordinates i and j.
//  [/DL]

class BeamBeamRep: public BeamBeam {

public:

    explicit BeamBeamRep(const std::string &name);

    BeamBeamRep();
    BeamBeamRep(const BeamBeamRep &);
    virtual ~BeamBeamRep();

    //  Return an identical deep copy of the element.
    virtual ElementBase *clone() const;

    //  This method constructs a Channel permitting read/write access to
    //  the attribute[b]aKey[/b] and returns it.
    //  If the attribute does not exist, it returns NULL.
    virtual Channel *getChannel(const std::string &aKey, bool = false);

    //  Return the number of particles times the particle charge in the
    //  opposite bunch.  Units are proton charges.
    virtual double getBunchCharge() const;

    //  Return the moment matrix for the opposite bunch (the matrix of
    //  second momenta).  Units are square metres.
    virtual const Matrix3D &getBunchMoment() const;

    //  Return the displacement vector for position of opposite bunch.
    //  Units are metres.
    virtual const Vector3D &getBunchDisplacement() const;

    //  Version for non-constant object.
    virtual NullField &getField();

    //  Version for constant object.
    virtual const NullField &getField() const;

    //  Version for non-constant object.
    virtual NullGeometry &getGeometry();

    //  Version for constant object.
    virtual const NullGeometry &getGeometry() const;

    //  Return the image of the element, containing the name and type string
    //  of the element, and a copy of the user-defined attributes.
    virtual ElementImage *getImage() const;

    //  Units are proton charges.
    void setBunchCharge(double);

    //  Assign the moment matrix for the opposite bunch
    //  (the matrix of second momenta).  Units are square metres.
    void setBunchMoment(const Matrix3D &);

    //  Assign the displacement vector for the opposite bunch.
    //  Units are metres.
    void setBunchDisplacement(const Vector3D &);

private:

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

    // Get a moment for the opposite bunch.
    double getMoment(int index) const;

    // Get the displacement vector for the opposite bunch.
    double getDisplacement(int index) const;

    // Set a moment for the opposite bunch.
    void setMoment(int index, double);

    // Set a displacement for the opposite bunch.
    void setDisplacement(int index, double);

    // The zero magnetic field.
    NullField field;

    // The geometry (a straight geometry with zero length).
    NullGeometry geometry;

    // Total charge of the opposite bunch in proton charges.
    double Q;

    // Displacement of the centre of gravity of the opposite bunch
    // with respect to the local frame for the affected bunch.
    Vector3D delta;

    // Second moments of the opposite bunch.
    Matrix3D sigma;
};

#endif // CLASSIC_BeamBeamRep_HH