ThickTracker.h 17.9 KB
Newer Older
gsell's avatar
gsell committed
1 2 3 4 5 6 7 8 9 10 11
#ifndef OPAL_ThickTracker_HH
#define OPAL_ThickTracker_HH

// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: ThickTracker
//
// ------------------------------------------------------------------------
//
snuverink_j's avatar
snuverink_j committed
12
// $Author: ganz_p $
gsell's avatar
gsell committed
13 14 15 16
//
// ------------------------------------------------------------------------

#include "Algorithms/Tracker.h"
17
#include "Structure/DataSink.h"
18

snuverink_j's avatar
snuverink_j committed
19
#include "Hamiltonian.h"
20

snuverink_j's avatar
snuverink_j committed
21
#include "MapAnalyser.h"
22

23 24
#include "Algorithms/IndexMap.h"
#include "AbsBeamline/BeamBeam.h"
25
#include "AbsBeamline/BeamStripping.h"
26
#include "AbsBeamline/CCollimator.h"
27
#include "AbsBeamline/Corrector.h"
snuverink_j's avatar
snuverink_j committed
28
#include "AbsBeamline/CyclotronValley.h"
29 30 31
#include "AbsBeamline/Diagnostic.h"
#include "AbsBeamline/Degrader.h"
#include "AbsBeamline/Drift.h"
32
#include "AbsBeamline/FlexibleCollimator.h"
33 34 35 36 37
#include "AbsBeamline/ElementBase.h"
#include "AbsBeamline/Lambertson.h"
#include "AbsBeamline/Marker.h"
#include "AbsBeamline/Monitor.h"
#include "AbsBeamline/Multipole.h"
snuverink_j's avatar
snuverink_j committed
38
#include "AbsBeamline/ParallelPlate.h"
39 40 41
#include "AbsBeamline/Probe.h"
#include "AbsBeamline/RFCavity.h"
#include "AbsBeamline/RFQuadrupole.h"
snuverink_j's avatar
snuverink_j committed
42 43
#include "AbsBeamline/RBend.h"
#include "AbsBeamline/RBend3D.h"
44 45 46 47
#include "AbsBeamline/SBend.h"
#include "AbsBeamline/Separator.h"
#include "AbsBeamline/Septum.h"
#include "AbsBeamline/Solenoid.h"
snuverink_j's avatar
snuverink_j committed
48
#include "AbsBeamline/TravelingWave.h"
49

50
#include "Elements/OpalBeamline.h"
gsell's avatar
gsell committed
51

snuverink_j's avatar
snuverink_j committed
52
#include "Structure/Beam.h"
53

snuverink_j's avatar
snuverink_j committed
54 55
//#include <array>
#include <cmath>
56

snuverink_j's avatar
snuverink_j committed
57
#include <tuple>
frey_m's avatar
frey_m committed
58

gsell's avatar
gsell committed
59
class BMultipoleField;
frey_m's avatar
frey_m committed
60 61 62 63

template <class T, unsigned Dim>
class PartBunchBase;

gsell's avatar
gsell committed
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95


// Class ThickTracker
// ------------------------------------------------------------------------
/// Track using thick-lens algorithm.
// [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]
// Approximations used:
// [ul]
snuverink_j's avatar
snuverink_j committed
96 97 98
// [li]
// [li]
// [li]
gsell's avatar
gsell committed
99 100 101 102 103 104 105
// [/ul]
//
// On going through an element, we use the following steps:
// To complete the map, we propagate the closed orbit and add that to the map.

class ThickTracker: public Tracker {

snuverink_j's avatar
snuverink_j committed
106 107 108 109 110 111 112 113 114
public:
    typedef Hamiltonian::series_t                       series_t;
    typedef MapAnalyser::fMatrix_t                      fMatrix_t;
    typedef MapAnalyser::cfMatrix_t                     cfMatrix_t;
    typedef FVps<double, 6>                             map_t;
    typedef FVector<double, 6>                          particle_t;
    typedef std::tuple<series_t, std::size_t, double>   tuple_t;
    typedef std::list<tuple_t>                          beamline_t;

gsell's avatar
gsell committed
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
public:

    /// Constructor.
    //  The beam line to be tracked is "bl".
    //  The particle reference data are taken from "data".
    //  The particle bunch tracked is initially empty.
    //  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.
    explicit ThickTracker(const Beamline &bl, const PartData &data,
                          bool revBeam, bool revTrack);

    /// Constructor.
    //  The beam line to be tracked is "bl".
    //  The particle reference data are taken from "data".
    //  The particle bunch tracked is taken from [b]bunch[/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.
snuverink_j's avatar
snuverink_j committed
132 133 134 135
    explicit ThickTracker(const Beamline &bl,
                          PartBunchBase<double, 3> *bunch,
                          Beam &beam,
                          DataSink &ds,
136
                          const PartData &data,
snuverink_j's avatar
snuverink_j committed
137 138 139 140 141
                          bool revBeam, bool revTrack,
                          const std::vector<unsigned long long> &maxSTEPS,
                          double zstart,
                          const std::vector<double> &zstop,
                          const std::vector<double> &dt,
142
                          const int& truncOrder);
snuverink_j's avatar
snuverink_j committed
143

gsell's avatar
gsell committed
144 145
    virtual ~ThickTracker();

146 147 148

    virtual void visitAlignWrapper(const AlignWrapper &);

gsell's avatar
gsell committed
149 150 151
    /// Apply the algorithm to a BeamBeam.
    virtual void visitBeamBeam(const BeamBeam &);

152 153 154
    /// Apply the algorithm to a BeamStripping.
    virtual void visitBeamStripping(const BeamStripping &);

gsell's avatar
gsell committed
155
    /// Apply the algorithm to a collimator.
156
    virtual void visitCCollimator(const CCollimator &);
gsell's avatar
gsell committed
157 158 159 160

    /// Apply the algorithm to a Corrector.
    virtual void visitCorrector(const Corrector &);

adelmann's avatar
adelmann committed
161 162 163
    /// Apply the algorithm to a Degrader.
    virtual void visitDegrader(const Degrader &);

gsell's avatar
gsell committed
164 165 166 167 168 169
    /// Apply the algorithm to a Diagnostic.
    virtual void visitDiagnostic(const Diagnostic &);

    /// Apply the algorithm to a Drift.
    virtual void visitDrift(const Drift &);

170 171 172
    /// Apply the algorithm to a flexible collimator
    virtual void visitFlexibleCollimator(const FlexibleCollimator &);

gsell's avatar
gsell committed
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
    /// Apply the algorithm to a Lambertson.
    virtual void visitLambertson(const Lambertson &);

    /// Apply the algorithm to a Marker.
    virtual void visitMarker(const Marker &);

    /// Apply the algorithm to a Monitor.
    virtual void visitMonitor(const Monitor &);

    /// Apply the algorithm to a Multipole.
    virtual void visitMultipole(const Multipole &);
    /// Apply the algorithm to a Probe.
    virtual void visitProbe(const Probe &);

    /// Apply the algorithm to a RBend.
    virtual void visitRBend(const RBend &);

    /// Apply the algorithm to a RFCavity.
    virtual void visitRFCavity(const RFCavity &);

193 194 195
    /// Apply the algorithm to a RFCavity.
    virtual void visitTravelingWave(const TravelingWave &);

gsell's avatar
gsell committed
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213
    /// Apply the algorithm to a RFQuadrupole.
    virtual void visitRFQuadrupole(const RFQuadrupole &);

    /// Apply the algorithm to a SBend.
    virtual void visitSBend(const SBend &);

    /// Apply the algorithm to a Separator.
    virtual void visitSeparator(const Separator &);

    /// Apply the algorithm to a Septum.
    virtual void visitSeptum(const Septum &);

    /// Apply the algorithm to a Solenoid.
    virtual void visitSolenoid(const Solenoid &);

    /// Apply the algorithm to a ParallelPlate.
    virtual void visitParallelPlate(const ParallelPlate &);

214
    /// Apply the algorithm to a CyclotronValley.
gsell's avatar
gsell committed
215 216
    virtual void visitCyclotronValley(const CyclotronValley &);

217

218

219 220 221 222 223 224 225 226
    /// Apply the algorithm to a beam line.
    //  overwrite the execute-methode from DefaultVisitor
    virtual void visitBeamline(const Beamline &);

    /// Apply the algorithm to the top-level beamline.
    //  overwrite the execute-methode from DefaultVisitor
    virtual void execute();

227
    void prepareSections();
228

snuverink_j's avatar
snuverink_j committed
229 230 231 232
    /*
    void insertFringeField(SBend* pSBend, std::list<structMapTracking>& mBL, double& beta0,
             double& gamma0, double& P0, double& q, std::array<double,2>& entrFringe, std::string e);
     */
gsell's avatar
gsell committed
233 234
private:

snuverink_j's avatar
snuverink_j committed
235

gsell's avatar
gsell committed
236
    // Not implemented.
snuverink_j's avatar
snuverink_j committed
237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
    ThickTracker() = delete;
    ThickTracker(const ThickTracker &)   = delete;
    void operator=(const ThickTracker &) = delete;

    void throwElementError_m(std::string element) {
        throw LogicalError("ThickTracker::execute()",
                           "Element '" + element + "' not supported.");
    }



    /*!
     * Tests the order of the elements in the beam line according to their position
     */
    void checkElementOrder_m();

    /*!
     * Inserts Drift maps in undefined beam line sections
     */
    void fillGaps_m();

    /*!
     * Tracks itsBunch_m trough beam line
     */
    void track_m();

    particle_t particleToVector_m(const Vector_t& R,
                                  const Vector_t& P) const;

    void vectorToParticle_m(const particle_t& particle,
                            Vector_t& R,
                            Vector_t& P) const;

    /*!
     * Advances itsBunch_m trough map
     * @param map Map of slice
     */
    void advanceParticles_m(const map_t& map);

    /*!
     * Applies map on particle
     * @param particle tracked particle
     * @param map Map of slice
     */
    void updateParticle_m(particle_t& particle,
                          const map_t& map);

    /*!
     * Dumps bunch in .stat or .h5 files
     */
    void dump_m();


    /*!
     * Updates itsBunch_m
     * @param spos position of tracking
     * @param step stepsize of applied map
     */
    void update_m(const double& spos,
                  const std::size_t& step);


    /*!
     * Writes map (Transfermap) in .map file
     * @map text for .map file
     */
    void write_m(const map_t& map);

    /*!
     * Concatenate map x and y
     * \f[
     *  y = x \circ y
     * \f]
     * @param x
     * @param y is result
     */
    void concatenateMaps_m(const map_t& x, map_t& y);


    /*!
     * Tracks Dispersion along beam line
     * writes it in .dispersion file.
     *
     *  \f[
     *  \begin{pmatrix} \eta_{x} \\ \eta_{p_x} \end{pmatrix}_{s_1}
     *  =
     *  \begin{pmatrix} R_{11} & R_{12} \\ R_{21} & R_{22} \end{pmatrix}
     *  \cdot
     *  \begin{pmatrix} \eta_{x} \\ \eta_{p_x} \end{pmatrix}_{s_0}
     *  +
     *  \begin{pmatrix} R_{16} \\ R_{26} \end{pmatrix}
     *  \f]
     *
     * @param tempMatrix accumulated Transfer map \f$R\f$ at pos
     * @param initialVal initial Dispersion { \f$\eta_{x0},\, \eta_{p_x0},\, \eta_{y0},\, \eta_{p_y0} \f$}
     * @param pos position of tracking
     */
    void advanceDispersion_m(fMatrix_t tempMatrix,
                             FMatrix<double, 1, 4> initialVal,
                             double pos);

    /*! :TODO:
     * Fringe fields for entrance of SBEND.
     *
     * @param edge
     * @param curve
     * @param field
     * @param scale
     */
gsell's avatar
gsell committed
346 347
    void applyEntranceFringe(double edge, double curve,
                             const BMultipoleField &field, double scale);
snuverink_j's avatar
snuverink_j committed
348 349 350 351 352 353 354 355 356

    /*! :TODO:
     * Fringe fields for exit of SBEND.
     *
     * @param edge
     * @param curve
     * @param field
     * @param scale
     */
gsell's avatar
gsell committed
357 358 359
    void applyExitFringe(double edge, double curve,
                         const BMultipoleField &field, double scale);

snuverink_j's avatar
snuverink_j committed
360 361 362 363 364

    Hamiltonian hamiltonian_m;
    MapAnalyser mapAnalyser_m;


365 366
    Vector_t RefPartR_m;
    Vector_t RefPartP_m;
367

368
    DataSink *itsDataSink_m;
369 370 371

    OpalBeamline itsOpalBeamline_m;

snuverink_j's avatar
snuverink_j committed
372 373 374 375
    double zstart_m;        ///< Start of beam line
    double zstop_m;         ///< End of beam line
    double threshold_m;     ///< Threshold for element overlaps and gaps
    beamline_t elements_m;  ///< elements in beam line
376

snuverink_j's avatar
snuverink_j committed
377
    CoordinateSystemTrafo referenceToLabCSTrafo_m;
378 379


snuverink_j's avatar
snuverink_j committed
380
    int truncOrder_m; ///< truncation order of map tracking
381

snuverink_j's avatar
snuverink_j committed
382 383 384
    IpplTimings::TimerRef mapCreation_m;    ///< creation of elements_m
    IpplTimings::TimerRef mapCombination_m; ///< map accumulation along elements_m -> Transfermap
    IpplTimings::TimerRef mapTracking_m;    ///< track particles trough maps of elements_m
385
};
386

387
inline void ThickTracker::visitAlignWrapper(const AlignWrapper &wrap) {
snuverink_j's avatar
snuverink_j committed
388 389
//     itsOpalBeamline_m.visit(wrap, *this, itsBunch_m);
    this->throwElementError_m("AlignWrapper");
390
}
391

392
inline void ThickTracker::visitBeamBeam(const BeamBeam &bb) {
snuverink_j's avatar
snuverink_j committed
393 394
//     itsOpalBeamline_m.visit(bb, *this, itsBunch_m);
    this->throwElementError_m("BeamBeam");
395
}
396

397 398 399
inline void ThickTracker::visitBeamStripping(const BeamStripping &bstp) {
    itsOpalBeamline_m.visit(bstp, *this, itsBunch_m);
}
400

401
inline void ThickTracker::visitCCollimator(const CCollimator &coll) {
snuverink_j's avatar
snuverink_j committed
402 403
//     itsOpalBeamline_m.visit(coll, *this, itsBunch_m);
    this->throwElementError_m("CCollimator");
404
}
405 406


407
inline void ThickTracker::visitCorrector(const Corrector &corr) {
snuverink_j's avatar
snuverink_j committed
408 409
//     itsOpalBeamline_m.visit(corr, *this, itsBunch_m);
    this->throwElementError_m("Corrector");
410 411 412 413
}


inline void ThickTracker::visitDegrader(const Degrader &deg) {
snuverink_j's avatar
snuverink_j committed
414 415
//     itsOpalBeamline_m.visit(deg, *this, itsBunch_m);
    this->throwElementError_m("Degrader");
416 417 418 419
}


inline void ThickTracker::visitDiagnostic(const Diagnostic &diag) {
snuverink_j's avatar
snuverink_j committed
420 421
//     itsOpalBeamline_m.visit(diag, *this, itsBunch_m);
    this->throwElementError_m("Diagnostic");
422 423 424 425 426
}


inline void ThickTracker::visitDrift(const Drift &drift) {
    itsOpalBeamline_m.visit(drift, *this, itsBunch_m);
snuverink_j's avatar
snuverink_j committed
427 428 429 430 431 432 433 434 435


    double gamma = itsReference.getGamma();
    std::size_t nSlices = drift.getNSlices();
    double length       = drift.getElementLength();

    elements_m.push_back(std::make_tuple(hamiltonian_m.drift(gamma),
                                         nSlices,
                                         length));
436 437 438
}


439
inline void ThickTracker::visitFlexibleCollimator(const FlexibleCollimator &coll) {
snuverink_j's avatar
snuverink_j committed
440 441
//     itsOpalBeamline_m.visit(coll, *this, itsBunch_m);
    this->throwElementError_m("FlexibleCollimator");
442 443 444
}


445
inline void ThickTracker::visitLambertson(const Lambertson &lamb) {
snuverink_j's avatar
snuverink_j committed
446 447
//     itsOpalBeamline_m.visit(lamb, *this, itsBunch_m);
    this->throwElementError_m("Lambertson");
448 449 450 451
}


inline void ThickTracker::visitMarker(const Marker &marker) {
snuverink_j's avatar
snuverink_j committed
452 453
//     itsOpalBeamline_m.visit(marker, *this, itsBunch_m);
//     this->throwElementError_m("Marker");
454 455 456 457
}


inline void ThickTracker::visitMonitor(const Monitor &mon) {
snuverink_j's avatar
snuverink_j committed
458 459
//     itsOpalBeamline_m.visit(mon, *this, itsBunch_m);
    this->throwElementError_m("Monitor");
460 461 462 463 464
}


inline void ThickTracker::visitMultipole(const Multipole &mult) {
    itsOpalBeamline_m.visit(mult, *this, itsBunch_m);
snuverink_j's avatar
snuverink_j committed
465 466 467 468 469 470 471 472 473 474 475 476 477 478 479

    std::size_t nSlices = mult.getNSlices();
    double length       = mult.getElementLength();
    double gamma        = itsReference.getGamma();
    double p0           = itsReference.getP();
    double q            = itsReference.getQ(); // particle change [e]
    double gradB        = mult.getField().getNormalComponent(2) * ( Physics::c/ p0 ); // [T / m]
    //FIXME remove the next line
    gradB = std::round(gradB*1e6)*1e-6;

    double k1           = gradB * q *Physics::c / p0; // [1 / m^2]

    elements_m.push_back(std::make_tuple(hamiltonian_m.quadrupole(gamma, q, k1),
                                         nSlices,
                                         length));
480 481 482
}

inline void ThickTracker::visitProbe(const Probe &prob) {
snuverink_j's avatar
snuverink_j committed
483 484
//     itsOpalBeamline_m.visit(prob, *this, itsBunch_m);
    this->throwElementError_m("Probe");
485 486 487 488
}


inline void ThickTracker::visitRBend(const RBend &bend) {
snuverink_j's avatar
snuverink_j committed
489 490
//     itsOpalBeamline_m.visit(bend, *this, itsBunch_m);
    this->throwElementError_m("RBend");
491 492 493 494
}


inline void ThickTracker::visitRFCavity(const RFCavity &as) {
snuverink_j's avatar
snuverink_j committed
495 496
//     itsOpalBeamline_m.visit(as, *this, itsBunch_m);
    this->throwElementError_m("RFCavity");
497 498 499
}

inline void ThickTracker::visitTravelingWave(const TravelingWave &as) {
snuverink_j's avatar
snuverink_j committed
500 501
//     itsOpalBeamline_m.visit(as, *this, itsBunch_m);
    this->throwElementError_m("TravelingWave");
502 503 504 505
}


inline void ThickTracker::visitRFQuadrupole(const RFQuadrupole &rfq) {
snuverink_j's avatar
snuverink_j committed
506 507
//     itsOpalBeamline_m.visit(rfq, *this, itsBunch_m);
    this->throwElementError_m("RFQuadrupole");
508 509 510 511
}

inline void ThickTracker::visitSBend(const SBend &bend) {
    itsOpalBeamline_m.visit(bend, *this, itsBunch_m);
snuverink_j's avatar
snuverink_j committed
512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559

    double q     = itsReference.getQ(); // particle change [e]
    double ekin = bend.getDesignEnergy();

    double m     = itsReference.getM(); // eV / c^2
    double gamma = ekin / m + 1.0;
    double beta  = std::sqrt(1.0 - 1.0 / ( gamma * gamma ) );
    double p0    = gamma * beta * m; // eV / c

    double B     = bend.getB() * Physics::c / p0; // T = V * s / m^2
    double r     = std::abs(p0   / ( q * B * Physics::c )); // m

    double k0    = B * q * Physics::c / p0; // V * s * e * m / (m^2 * s * c )

    // [1/m]
    double h = 1.0 / r;

    double L = bend.getElementLength();

    if ( k0 < 0.0 )
        h *= -1.0;

    std::size_t nSlices = bend.getNSlices();

    double arclength    = 2.0 * r * std::asin( L / ( 2.0 * r ) ); //bend.getEffectiveLength();

    // Fringe fields currently not working
    //FIXME e1 not initialised
    //insert Entrance Fringefield
    double e1 = bend.getEntranceAngle();
    if (std::abs(e1) > 1e-6){
        elements_m.push_back(std::make_tuple(hamiltonian_m.fringeField(e1, h),
                                             1, 0.0));
    }

    //insert Dipole "body"
    elements_m.push_back(std::make_tuple(hamiltonian_m.sbend(gamma, h, k0),
                                         nSlices,
                                         arclength));

    //FIXME e2 not initialised
    //insert Exit Fringe field
    double e2 = bend.getExitAngle();
    if (std::abs(e2) > 1e-6){
        elements_m.push_back(std::make_tuple(hamiltonian_m.fringeField(e2, h),
                                             1, 0.0));
    }

560 561 562 563
}


inline void ThickTracker::visitSeparator(const Separator &sep) {
snuverink_j's avatar
snuverink_j committed
564 565
//     itsOpalBeamline_m.visit(sep, *this, itsBunch_m);
    this->throwElementError_m("Separator");
566 567 568 569
}


inline void ThickTracker::visitSeptum(const Septum &sept) {
snuverink_j's avatar
snuverink_j committed
570 571
//     itsOpalBeamline_m.visit(sept, *this, itsBunch_m);
    this->throwElementError_m("Septum");
572 573 574 575
}


inline void ThickTracker::visitSolenoid(const Solenoid &solenoid) {
snuverink_j's avatar
snuverink_j committed
576 577
//     itsOpalBeamline_m.visit(solenoid, *this, itsBunch_m);
    this->throwElementError_m("Solenoid");
578 579 580 581
}


inline void ThickTracker::visitParallelPlate(const ParallelPlate &pplate) {
snuverink_j's avatar
snuverink_j committed
582 583
//     itsOpalBeamline_m.visit(pplate, *this, itsBunch_m);
    this->throwElementError_m("ParallelPlate");
584 585 586
}

inline void ThickTracker::visitCyclotronValley(const CyclotronValley &cv) {
snuverink_j's avatar
snuverink_j committed
587 588
//     itsOpalBeamline_m.visit(cv, *this, itsBunch_m);
    this->throwElementError_m("CyclotronValley");
589
}
gsell's avatar
gsell committed
590

591
#endif // OPAL_ThickTracker_HH