ThickTracker.h 17.9 KB
Newer Older
gsell's avatar
gsell committed
1 2
//
// Class: ThickTracker
3
//   Tracks using thick-lens algorithm.
gsell's avatar
gsell committed
4 5
// ------------------------------------------------------------------------
//
6 7
// Copyright (c) 2018, Philippe Ganz, ETH Zürich
// All rights reserved
gsell's avatar
gsell committed
8
//
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
// Implemented as part of the Master thesis
// "s-based maps from TPS & Lie-Series applied to Proton-Therapy Gantries"
//
// This file is part of OPAL.
//
// OPAL is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// You should have received a copy of the GNU General Public License
// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
//

#ifndef OPAL_ThickTracker_HH
#define OPAL_ThickTracker_HH
gsell's avatar
gsell committed
25 26

#include "Algorithms/Tracker.h"
27
#include "Structure/DataSink.h"
28

snuverink_j's avatar
snuverink_j committed
29
#include "Hamiltonian.h"
30

snuverink_j's avatar
snuverink_j committed
31
#include "MapAnalyser.h"
32

33 34
#include "Algorithms/IndexMap.h"
#include "AbsBeamline/BeamBeam.h"
35
#include "AbsBeamline/BeamStripping.h"
36
#include "AbsBeamline/CCollimator.h"
37 38 39 40
#include "AbsBeamline/Corrector.h"
#include "AbsBeamline/Diagnostic.h"
#include "AbsBeamline/Degrader.h"
#include "AbsBeamline/Drift.h"
41
#include "AbsBeamline/FlexibleCollimator.h"
42 43 44 45 46
#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
47
#include "AbsBeamline/ParallelPlate.h"
48 49 50
#include "AbsBeamline/Probe.h"
#include "AbsBeamline/RFCavity.h"
#include "AbsBeamline/RFQuadrupole.h"
snuverink_j's avatar
snuverink_j committed
51 52
#include "AbsBeamline/RBend.h"
#include "AbsBeamline/RBend3D.h"
53 54 55 56
#include "AbsBeamline/SBend.h"
#include "AbsBeamline/Separator.h"
#include "AbsBeamline/Septum.h"
#include "AbsBeamline/Solenoid.h"
snuverink_j's avatar
snuverink_j committed
57
#include "AbsBeamline/TravelingWave.h"
58

59
#include "Elements/OpalBeamline.h"
gsell's avatar
gsell committed
60

snuverink_j's avatar
snuverink_j committed
61
#include "Structure/Beam.h"
62

snuverink_j's avatar
snuverink_j committed
63 64
//#include <array>
#include <cmath>
65

snuverink_j's avatar
snuverink_j committed
66
#include <tuple>
frey_m's avatar
frey_m committed
67

gsell's avatar
gsell committed
68
class BMultipoleField;
frey_m's avatar
frey_m committed
69 70 71 72

template <class T, unsigned Dim>
class PartBunchBase;

gsell's avatar
gsell committed
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
/// 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
101 102 103
// [li]
// [li]
// [li]
gsell's avatar
gsell committed
104 105 106 107 108 109 110
// [/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
111 112 113 114 115 116 117 118 119
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
120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
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
137 138 139 140
    explicit ThickTracker(const Beamline &bl,
                          PartBunchBase<double, 3> *bunch,
                          Beam &beam,
                          DataSink &ds,
141
                          const PartData &data,
snuverink_j's avatar
snuverink_j committed
142 143 144 145 146
                          bool revBeam, bool revTrack,
                          const std::vector<unsigned long long> &maxSTEPS,
                          double zstart,
                          const std::vector<double> &zstop,
                          const std::vector<double> &dt,
147
                          const int& truncOrder);
snuverink_j's avatar
snuverink_j committed
148

gsell's avatar
gsell committed
149 150
    virtual ~ThickTracker();

151 152 153

    virtual void visitAlignWrapper(const AlignWrapper &);

gsell's avatar
gsell committed
154 155 156
    /// Apply the algorithm to a BeamBeam.
    virtual void visitBeamBeam(const BeamBeam &);

157 158 159
    /// Apply the algorithm to a BeamStripping.
    virtual void visitBeamStripping(const BeamStripping &);

gsell's avatar
gsell committed
160
    /// Apply the algorithm to a collimator.
161
    virtual void visitCCollimator(const CCollimator &);
gsell's avatar
gsell committed
162 163 164 165

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

adelmann's avatar
adelmann committed
166 167 168
    /// Apply the algorithm to a Degrader.
    virtual void visitDegrader(const Degrader &);

gsell's avatar
gsell committed
169 170 171 172 173 174
    /// Apply the algorithm to a Diagnostic.
    virtual void visitDiagnostic(const Diagnostic &);

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

175 176 177
    /// Apply the algorithm to a flexible collimator
    virtual void visitFlexibleCollimator(const FlexibleCollimator &);

gsell's avatar
gsell committed
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
    /// 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 &);

198 199 200
    /// Apply the algorithm to a RFCavity.
    virtual void visitTravelingWave(const TravelingWave &);

gsell's avatar
gsell committed
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
    /// 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 &);

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 &/*coll*/) {
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 &/*probe*/) {
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
#endif // OPAL_ThickTracker_HH