Component.h

Go to the documentation of this file.

#ifndef CLASSIC_Component_HH
#define CLASSIC_Component_HH
 
// ------------------------------------------------------------------------
// $RCSfile: Component.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.1.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: Component
//   An abstract base class which defines the common interface for all
//   CLASSIC components, i.e. beam line members which are not themselves
//   beam lines.
//
// ------------------------------------------------------------------------
// Class category: AbsBeamline
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:31 $
// $Author: fci $
//
// ------------------------------------------------------------------------
 
#include "AbsBeamline/ElementBase.h"
#include "Fields/EMField.h"
 
class PartData;
 
template <class T, unsigned Dim>
class PartBunchBase;
 
template <class T, int N> class FVps;
 
struct Point
{
  double x;
  double y;
};
 
// Class Component
// ------------------------------------------------------------------------
//  Class Component defines the abstract interface for an arbitrary single
//  component in a beam line.  A component is the basic element in the
//  accelerator model, like a dipole, a quadrupole, etc.  It is normally
//  associated with an electro-magnetic field, which may be null.
 
class Component: public ElementBase {
 
public:
 
    explicit Component(const std::string &name);
 
    Component();
    Component(const Component &right);
    virtual ~Component();
 
    //  The representation of the electro-magnetic field of the component
    //  (version for non-constant object).
    virtual EMField &getField() = 0;
 
    //  The representation of the electro-magnetic field of the component
    //  (version for constant object).
    virtual const EMField &getField() const = 0;
 
    //  Return the value of the time-independent part of the electric
    //  field at point [b]P[/b].
    EVector Efield(const Point3D &P) const;
 
    //  Return the value of the time-independent part of the magnetic
    //  field at point [b]P[/b].
    BVector Bfield(const Point3D &P) const;
 
    //  Return the value of the time-dependent part of the electric
    //  field at point [b]P[/b] for time [b]t[/b].
    EVector Efield(const Point3D &P, double t) const;
 
    //  Return the value of the time-dependent part of the magnetic
    //  field at point [b]P[/b] for time [b]t[/b].
    BVector Bfield(const Point3D &P, double t) const;
 
    //  Return the value of the time-independent part of both electric
    //  and magnetic fields at point [b]P[/b].
    EBVectors EBfield(const Point3D &P) const;
 
    //  Return the value of the time-dependent part of both electric
    //  and magnetic fields at point [b]P[/b] for time [b]t[/b].
    EBVectors EBfield(const Point3D &P, double t) const;
 
    virtual bool apply(const size_t &i,
                       const double &t,
                       Vector_t &E,
                       Vector_t &B);
 
    virtual bool apply(const Vector_t &R,
                       const Vector_t &P,
                       const double &t,
                       Vector_t &E,
                       Vector_t &B);
 
    virtual bool applyToReferenceParticle(const Vector_t &R,
                                          const Vector_t &P,
                                          const double &t,
                                          Vector_t &E,
                                          Vector_t &B);
 
    virtual bool getPotential(const Vector_t &/*R*/,
                              const double &/*t*/,
                              Vector_t &/*A*/,
                              double &/*phi*/) {return false;}
 
    virtual double getDesignEnergy() const;
    virtual void setDesignEnergy(const double& energy, bool changeable = true);
 
    virtual void initialise(PartBunchBase<double, 3> *bunch, double &startField, double &endField) = 0;
 
    virtual void finalise() = 0;
 
    virtual bool bends() const = 0;
 
    //    virtual bool determineEntryPoint(const double &kineticEnergy, const double &tolerance) = 0;
 
    virtual void goOnline(const double &kineticEnergy);
 
    virtual void goOffline();
 
    virtual bool Online();
 
    // void getOrientation(Vector_t &, double &) const;  // first component is alpha, second is beta. the third component is always neglected.
    // // alpha is defined as the angle between projection of the normal of the face of the element onto
    // // the s-u plane and the s vector. for beta the following is valid:
    // // beta = arccos(|n_{parallel}|) where n_{parallel} is the projection of the normal onto the s-u
    // // plane
 
    // void setOrientation(const Vector_t &direction);
 
    virtual void getDimensions(double &zBegin, double &zEnd) const = 0;
 
    virtual ElementType getType() const;
 
    //  If this method returns a pointer to this component.
    //  The default version returns ``this''.
    virtual const ElementBase &getDesign() const;
 
    //  This catch-all method implements a hook for tracking a particle
    //  bunch through a non-standard component.
    //  The default version throws a LogicalError.
    virtual void trackBunch(PartBunchBase<double, 3> *bunch, const PartData &,
                            bool revBeam, bool revTrack) const;
 
    //  This catch-all method implements a hook for tracking a transfer
    //  map through a non-standard component.
    //  The default version throws a LogicalError.
    virtual void trackMap(FVps<double, 6> &map, const PartData &,
                          bool revBeam, bool revTrack) const;
 
    void setExitFaceSlope(const double &);
 
protected:
 
    static const std::vector<double> defaultAperture_m;
    // Vector_t Orientation_m;
    double exit_face_slope_m;
 
    PartBunchBase<double, 3> *RefPartBunch_m;
    bool online_m;
};
 
 
// Inline access functions to fields.
// ------------------------------------------------------------------------
 
inline EVector Component::Efield(const Point3D &P) const
{ return getField().Efield(P); }
 
inline BVector Component::Bfield(const Point3D &P) const
{ return getField().Bfield(P); }
 
inline EVector Component::Efield(const Point3D &P, double t) const
{ return getField().Efield(P, t); }
 
inline BVector Component::Bfield(const Point3D &P, double t) const
{ return getField().Bfield(P, t); }
 
inline EBVectors Component::EBfield(const Point3D &P) const
{ return getField().EBfield(P); }
 
inline EBVectors Component::EBfield(const Point3D &P, double t) const
{ return getField().EBfield(P, t); }
 
// inline void Component::getOrientation(Vector_t &ori, double &m) const {
//     ori = Orientation_m;
//     m = exit_face_slope_m;
// }
 
// inline void Component::setOrientation(const Vector_t &direction)
// { Orientation_m = direction; }
 
inline void Component::setExitFaceSlope(const double &m)
{ exit_face_slope_m = m; }
 
inline void Component::setDesignEnergy(const double &/*energy*/, bool /*changeable*/)
{ }
 
inline double Component::getDesignEnergy() const
{
    return -1.0;
}
 
#endif // CLASSIC_Component_HH