Component.cpp

Go to the documentation of this file.

// ------------------------------------------------------------------------
// $RCSfile: Component.cpp,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. beamline members which are not themselves
//   beamlines.
//
// ------------------------------------------------------------------------
// Class category: AbsBeamline
// ------------------------------------------------------------------------
//
// $Date: 2000/03/27 09:32:31 $
// $Author: fci $
//c
// ------------------------------------------------------------------------

#include "AbsBeamline/Component.h"
#include "Utilities/LogicalError.h"
#include "Algorithms/PartBunchBase.h"

// Class Component
// ------------------------------------------------------------------------
//   Represents an arbitrary component in an accelerator.  A component is
//   the basic element in the accelerator model, and can be thought of as
//   acting as a leaf in the Composite pattern.  A Component is associated
//   with an electromagnetic field.
// 2017-03-20 (Rogers) set default aperture to something huge; else we get a
//         segmentation fault by default from NULL dereference during tracking

const std::vector<double> Component::defaultAperture_m =
                                std::vector<double>({1e6, 1e6, 1.0});


Component::Component():
    Component("")
{}


Component::Component(const Component &right):
    ElementBase(right),
    exit_face_slope_m(right.exit_face_slope_m),
    RefPartBunch_m(right.RefPartBunch_m),
    online_m(right.online_m) {
}


Component::Component(const std::string &name):
    ElementBase(name),
    exit_face_slope_m(0.0),
    RefPartBunch_m(NULL),
    online_m(false) {
    setAperture(ElementBase::ELLIPTICAL, defaultAperture_m);

}


Component::~Component()
{}


const ElementBase &Component::getDesign() const {
    return *this;
}

void Component::trackBunch(PartBunchBase<double, 3> *, const PartData &, bool, bool) const {
    throw LogicalError("Component::trackBunch()",
                       "Called for component \"" + getName() + "\".");
}


void Component::
trackMap(FVps<double, 6> &, const PartData &, bool, bool) const {
    throw LogicalError("Component::trackMap()",
                       "Called for component \"" + getName() + "\".");
}

void Component::goOnline(const double &) {
    online_m = true;
}

void Component::goOffline() {
    online_m = false;
}

bool Component::Online() {
    return online_m;
}

ElementBase::ElementType Component::getType() const {
    return ElementBase::ANY;
}

bool Component::apply(const size_t &i,
                      const double &t,
                      Vector_t &E,
                      Vector_t &B) {
    const Vector_t &R = RefPartBunch_m->R[i];
    if (R(2) >= 0.0 && R(2) < getElementLength()) {
        if (!isInsideTransverse(R)) return true;
    }
    return false;
}

bool Component::apply(const Vector_t &R,
                      const Vector_t &P,
                      const double &t,
                      Vector_t &E,
                      Vector_t &B) {
    if (R(2) >= 0.0 && R(2) < getElementLength()) {
        if (!isInsideTransverse(R)) return true;
    }
    return false;
}

bool Component::applyToReferenceParticle(const Vector_t &R,
                                         const Vector_t &P,
                                         const double &t,
                                         Vector_t &E,
                                         Vector_t &B) {
    if (R(2) >= 0.0 && R(2) < getElementLength()) {
        if (!isInsideTransverse(R)) return true;
    }
    return false;
}