OPAL (Object Oriented Parallel Accelerator Library) 2024.2
OPAL
ParallelCyclotronTracker.h
Go to the documentation of this file.
1//
2// Class ParallelCyclotronTracker
3// Tracker for OPAL-Cycl
4//
5// Copyright (c) 2007 - 2014, Jianjun Yang, Andreas Adelmann and Matthias Toggweiler,
6// Paul Scherrer Institut, Villigen PSI, Switzerland
7// Copyright (c) 2014, Daniel Winklehner, MIT, Cambridge, MA, USA
8// Copyright (c) 2012 - 2022, Paul Scherrer Institut, Villigen PSI, Switzerland
9// All rights reserved
10//
11// Implemented as part of the PhD thesis
12// "Beam dynamics in high intensity cyclotrons including neighboring bunch effects"
13// and the paper
14// "Beam dynamics in high intensity cyclotrons including neighboring bunch effects:
15// Model, implementation, and application"
16// (https://journals.aps.org/prab/pdf/10.1103/PhysRevSTAB.13.064201)
17//
18// This file is part of OPAL.
19//
20// OPAL is free software: you can redistribute it and/or modify
21// it under the terms of the GNU General Public License as published by
22// the Free Software Foundation, either version 3 of the License, or
23// (at your option) any later version.
24//
25// You should have received a copy of the GNU General Public License
26// along with OPAL. If not, see <https://www.gnu.org/licenses/>.
27//
28#ifndef OPAL_ParallelCyclotronTracker_HH
29#define OPAL_ParallelCyclotronTracker_HH
30
33#include "AbsBeamline/Ring.h"
38#include "Algorithms/Tracker.h"
39#include "Physics/Physics.h"
40#include "Steppers/Stepper.h"
41#include "Utility/Inform.h"
42#include "Utility/IpplTimings.h"
43
44#include <cmath>
45#include <cstddef>
46#include <fstream>
47#include <functional>
48#include <list>
49#include <memory>
50#include <string>
51#include <tuple>
52#include <utility>
53#include <vector>
54
55namespace Steppers { enum TimeIntegrator : short; }
56template <class T> class ParticleAttrib;
57class DataSink;
58class PluginElement;
59class LossDataSink;
60
61template <class T, unsigned Dim>
62class PartBunchBase;
63
70
72
73public:
74 typedef std::vector<double> dvector_t;
75 typedef std::vector<int> ivector_t;
76 typedef std::pair<double[8], Component*> element_pair;
77 typedef std::pair<ElementType, element_pair> type_pair;
78 typedef std::list<type_pair*> beamline_list;
79
81 // The beam line to be tracked is "bl".
82 // The particle reference data are taken from "data".
83 // The particle bunch tracked is taken from [b]bunch[/b].
84 // If [b]revBeam[/b] is true, the beam runs from s = C to s = 0.
85 // If [b]revTrack[/b] is true, we track against the beam.
87 const PartData& data, bool revBeam,
88 bool revTrack, int maxSTEPS,
89 Steppers::TimeIntegrator timeintegrator,
90 const int& numBunch,
91 const double& mbEta,
92 const double& mbPara,
93 const std::string& mbMode,
94 const std::string& mbBinning);
95
97
99 // overwrite the execute-methode from DefaultVisitor
100 virtual void execute();
101
103 // R - position
104 // P - momentum; note the field is returned in the lab frame
105 // t - time
106 // Efield - filled with values for the electric field
107 // Bfield - filled with values for the magnetic field
108 // Returns a boolean value, true if the particle was out of the nominal
109 // field map boundary, else false.
110 bool computeExternalFields_m(const Vector_t& R,
111 const Vector_t& P,
112 const double& t,
113 Vector_t& Efield,
114 Vector_t& Bfield);
115
117 // overwrite the execute-methode from DefaultVisitor
118 virtual void visitBeamline(const Beamline&);
119
121 virtual void visitCCollimator(const CCollimator&);
122
124 virtual void visitCorrector(const Corrector&);
125
127 virtual void visitCyclotron(const Cyclotron& cycl);
128
130 virtual void visitDegrader(const Degrader&);
131
133 virtual void visitDrift(const Drift&);
134
136 virtual void visitFlexibleCollimator(const FlexibleCollimator&);
137
139 virtual void visitMarker(const Marker&);
140
142 virtual void visitMonitor(const Monitor&);
143
145 virtual void visitMultipole(const Multipole&);
146
148 virtual void visitMultipoleT(const MultipoleT&);
149
151 virtual void visitOffset(const Offset&);
152
154 virtual void visitOutputPlane(const OutputPlane&);
155
157 virtual void visitProbe(const Probe&);
158
160 virtual void visitRBend(const RBend&);
161
163 virtual void visitRFCavity(const RFCavity&);
164
166 virtual void visitRing(const Ring& ring);
167
169 virtual void visitSBend(const SBend&);
170
172 virtual void visitSBend3D(const SBend3D&);
173
175 virtual void visitScalingFFAMagnet(const ScalingFFAMagnet& bend);
176
178 virtual void visitSeptum(const Septum&);
179
181 virtual void visitSolenoid(const Solenoid&);
182
184 virtual void visitStripper(const Stripper&);
185
187 virtual void visitVacuum(const Vacuum&);
188
190 virtual void visitVariableRFCavity(const VariableRFCavity& cav);
191
194
196 virtual void visitVerticalFFAMagnet(const VerticalFFAMagnet& bend);
197
199 inline void setLastDumpedStep(const int para) { lastDumpedStep_m = para; }
200
202 inline void setPr(double x) {referencePr = x;}
203 inline void setPt(double x) {referencePt = x;}
204 inline void setPz(double x) {referencePz = x;}
205 inline void setR(double x) {referenceR = x;}
206 inline void setTheta(double x) {referenceTheta = x;}
207 inline void setZ(double x) {referenceZ = x;}
208 inline void setBeGa(double x) {bega = x;}
209 inline void setPhi(double x) {referencePhi = x;}
210 inline void setPsi(double x) {referencePsi = x;}
211 inline void setPreviousH5Local(bool x) {previousH5Local = x;}
215
216 Ring* getRing() const {return opalRing_m;}
217private:
218 enum class TrackingMode: unsigned short {
219 UNDEFINED,
220 SINGLE,
221 SEO,
222 BUNCH
223 };
224
225 // Not implemented.
229
231 std::list<Component*> myElements;
233 std::vector<PluginElement*> pluginElements_m;
234 std::vector<CavityCrossData> cavCrossDatas_m;
235
237
239
241
244
246 static Vector_t const xaxis;
247 static Vector_t const yaxis;
248 static Vector_t const zaxis;
249
251 double bega;
255 double referenceZ = 0.0;
256
259 double referencePz = 0.0;
261
264
265 bool spiral_flag = false;
266
268
270
273
274 // only used for multi-bunch mode
275 std::unique_ptr<MultiBunchHandler> mbHandler_m;
276
278
279 // for each bunch we have a path length
281 // Multi time step tracker
282 void MtsTracker();
283
284 void GenericTracker();
285 bool getFieldsAtPoint(const double& t, const size_t& Pindex, Vector_t& Efield, Vector_t& Bfield);
286
287 /*
288 Local Variables both used by the integration methods
289 */
290
291 long long step_m;
292 long long restartStep0_m;
293
295
296 // only for dumping
297 double azimuth_m;
299
300 /* only for dumping to stat-file --> make azimuth monotonically increasing
301 * @param theta computed azimuth [deg]
302 * @param prevAzimuth previous angle [deg]
303 * @param azimuth to be updated [deg]
304 * @param bunchNr in restart mode only --> to compute initial azimuth
305 */
306 void dumpAngle(const double& theta,
307 double& prevAzimuth,
308 double& azimuth,
309 const short& bunchNr = 0);
310
311 double computeRadius(const Vector_t& meanR) const;
312
313 void computePathLengthUpdate(std::vector<double>& dl, const double& dt);
314
315 // external field arrays for dumping: {B-head, E-head, B-ref, E-ref, B-tail, E-tail} in the
316 // order H5Writer::writePhaseSpace() reads them; the stat file reads only the first two
318
319 const int myNode_m;
320 const size_t initialLocalNum_m;
321 const size_t initialTotalNum_m;
322
324 std::vector<std::unique_ptr<std::ofstream> > outfTheta_m;
326 std::vector<double> azimuth_angle_m;
328 void openFiles(size_t numFiles, std::string fn);
329 void closeFiles();
332 std::ofstream outfTrackOrbit_m;
333
334 void buildupFieldList(double BcParameter[], ElementType elementType, Component* elptr);
335
336 // angle range [0~2PI) degree
337 double calculateAngle(double x, double y);
338 // angle range [-PI~PI) degree
339 double calculateAngle2(double x, double y);
340
341 bool checkGapCross(Vector_t Rold, Vector_t Rnew, RFCavity* rfcavity, double& DistOld);
342 bool RFkick(RFCavity* rfcavity, const double t, const double dt, const int Pindex);
343
344 bool getTunes(dvector_t& t, dvector_t& r, dvector_t& z, int lastTurn, double& nur, double& nuz);
345
352
353 /*
354 * @param bunchNr if <= -1 --> take all particles in simulation, if bunchNr > -1,
355 * take only particles of *this* bunch
356 */
357 Vector_t calcMeanR(short bunchNr = -1) const;
358
359 Vector_t calcMeanP() const;
360
361 // Do repartition between nodes if step_m is multiple of Options::repartFreq, or if forced
362 void repartition(bool force = false);
363
364 // Transform the x- and y-parts of a particle attribute (position, momentum, fields) from the
365 // global reference frame to the local reference frame.
366
367 // phi is the angle of the bunch measured counter-clockwise from the positive x-axis.
368 void globalToLocal(ParticleAttrib<Vector_t>& vectorArray,
369 double phi, Vector_t const translationToGlobal = 0);
370
371 // Transform the x- and y-parts of a particle attribute (position, momentum, fields) from the
372 // local reference frame to the global reference frame.
373 void localToGlobal(ParticleAttrib<Vector_t>& vectorArray,
374 double phi, Vector_t const translationToGlobal = 0);
375
376 // Overloaded version of globalToLocal using a quaternion for 3D rotation
377 inline void globalToLocal(ParticleAttrib<Vector_t>& vectorArray,
378 Quaternion_t const quaternion,
379 Vector_t const meanR = Vector_t(0.0));
380
381 // Overloaded version of localToGlobal using a quaternion for 3D rotation
382 inline void localToGlobal(ParticleAttrib<Vector_t>& vectorArray,
383 Quaternion_t const quaternion,
384 Vector_t const meanR = Vector_t(0.0));
385
386 // Overloaded version of globalToLocal using phi and theta for pseudo 3D rotation
387 inline void globalToLocal(ParticleAttrib<Vector_t>& particleVectors,
388 double const phi, double const psi,
389 Vector_t const meanR = Vector_t(0.0));
390
391 // Overloaded version of localToGlobal using phi and theta for pseudo 3D rotation
392 inline void localToGlobal(ParticleAttrib<Vector_t>& particleVectors,
393 double const phi, double const psi,
394 Vector_t const meanR = Vector_t(0.0));
395
396 // Overloaded version of globalToLocal using phi and theta for pseudo 3D rotation, single vector
397 inline void globalToLocal(Vector_t& myVector,
398 double const phi, double const psi,
399 Vector_t const meanR = Vector_t(0.0));
400
401 // Overloaded version of localToGlobal using phi and theta for pseudo 3D rotation, single vector
402 inline void localToGlobal(Vector_t& myVector,
403 double const phi, double const psi,
404 Vector_t const meanR = Vector_t(0.0));
405
406 // Rotate the particles by an angle and axis defined in the quaternion (4-vector w,x,y,z)
407 inline void rotateWithQuaternion(ParticleAttrib<Vector_t>& vectorArray, Quaternion_t const quaternion);
408
409 // Returns the quaternion of the rotation from vector u to vector v
410 inline void getQuaternionTwoVectors(Vector_t u, Vector_t v, Quaternion_t& quaternion);
411
412 // Normalization of a quaternion
413 inline void normalizeQuaternion(Quaternion_t& quaternion);
414
415 // Normalization of a quaternion
416 inline void normalizeVector(Vector_t& vector);
417
418 // Some rotations
419 inline void rotateAroundZ(ParticleAttrib<Vector_t>& particleVectors, double const phi);
420 inline void rotateAroundX(ParticleAttrib<Vector_t>& particleVectors, double const psi);
421 inline void rotateAroundZ(Vector_t& myVector, double const phi);
422 inline void rotateAroundX(Vector_t& myVector, double const psi);
423
424 // Push particles for time h.
425 // Apply effects of RF Gap Crossings.
426 // Unit assumptions: [itsBunch_m->R] = m, [itsBunch_m->P] = 1, [h] = s, [c] = m/s, [itsBunch_m->getT()] = s
427 bool push(double h);
428 // Kick particles for time h
429 // The fields itsBunch_m->Bf, itsBunch_m->Ef are used to calculate the forces
430 bool kick(double h);
431
432 // Apply the trilogy half push - kick - half push,
433 // considering only external fields
434 void borisExternalFields(double h);
435
436 // apply the plugin elements: probe, collimator, stripper, septum
437 bool applyPluginElements(const double dt);
438
439 // destroy particles if they are marked as Bin=-1 in the plugin elements or out of global aperture
440 bool deleteParticle(bool = false);
441
442 void initTrackOrbitFile();
443
444 void singleParticleDump();
445
446 void bunchDumpStatData();
447
454 bool getReferenceParticle(Vector_t& refR, Vector_t& refP) const;
455
459 bool setRefPartForDump_m(Vector_t& refR, Vector_t& refP);
460
462 bool refLostWarned_m = false;
463
465
467
469
470 void setTimeStep();
471
472 void checkFileMomentum();
473
474 void checkNumPart(std::string s);
475
476 // we store a pointer explicitly to the Ring
478
479 // to save geometry losses
480 std::unique_ptr<LossDataSink> lossDs_m;
481
482 // If Ring is defined take the harmonic number from Ring; else use
483 // cyclotron
484 double getHarmonicNumber() const;
485
486 typedef std::function<bool(const double&,
487 const size_t&,
488 Vector_t&,
490
491 std::unique_ptr< Stepper<function_t> > itsStepper_mp;
492
499
501
503
504 // for change of coordinates
506
508 bool isTurnDone();
509
512 bool statDumpBeforeNextSolve_m() const;
513
515 unsigned int numRFCavities_m = 0;
516
518 void update_m(double& t, const double& dt, const bool& finishedTurn);
519
523 std::tuple<double, double, double> initializeTracking_m();
524
525 void finalizeTracking_m(dvector_t& Ttime,
526 dvector_t& Tdeltr,
527 dvector_t& Tdeltz,
528 ivector_t& TturnNumber);
529
530 void setTrackingMode();
531
532 void seoMode_m(double& t, const double dt, bool& finishedTurn,
533 dvector_t& Ttime, dvector_t& Tdeltr,
534 dvector_t& Tdeltz, ivector_t& TturnNumber);
535
536 void singleMode_m(double& t, const double dt, bool& finishedTurn, double& oldReferenceTheta);
537
538 void bunchMode_m(double& t, const double dt, bool& finishedTurn);
539
540 void gapCrossKick_m(size_t i, double t, double dt,
541 const Vector_t& Rold, const Vector_t& Pold);
542
543
544 inline void dumpAzimuthAngles_m(const double& t,
545 const Vector_t& R,
546 const Vector_t& P,
547 const double& oldReferenceTheta,
548 const double& temp_meanTheta);
549
550 inline void dumpThetaEachTurn_m(const double& t,
551 const Vector_t& R,
552 const Vector_t& P,
553 const double& temp_meanTheta,
554 bool& finishedTurn);
555
557
560 void printMeshFit_m();
561
562 bool computeExternalFields_m(const size_t& i,
563 const double& t,
564 Vector_t& Efield,
565 Vector_t& Bfield);
566
567 void injectBunch(bool& flagTransition);
568
569 void saveInjectValues();
570
571 bool isMultiBunch() const;
572
573 bool hasMultiBunch() const;
574
575 /*
576 * @param dt time step in s
577 */
578 void updatePathLength(const double& dt);
579
580 /*
581 * @param dt time step in s
582 */
583 void updateTime(const double& dt);
584
586
594 void initPathLength();
595};
596
603inline
605 double thetaXY = std::atan2(y, x);
606
607 if (thetaXY < 0) return thetaXY + Physics::two_pi;
608 return thetaXY;
609}
610
617inline
619 return std::atan2(y,x);
620}
621
622
623inline
625 return ( (mbHandler_m != nullptr) && itsBunch_m->weHaveBins() );
626}
627
628
629inline
631 return ( isMultiBunch() && mbHandler_m->getNumBunch() > 1 );
632}
633
634#endif // OPAL_ParallelCyclotronTracker_HH
ElementType
Definition ElementBase.h:89
boost::numeric::ublas::matrix< double > matrix_t
Definition BoostMatrix.h:23
TimeIntegrator
Definition Steppers.h:25
constexpr double two_pi
The value of.
Definition Physics.h:33
bool weHaveBins() const
void computePathLengthUpdate(std::vector< double > &dl, const double &dt)
void setLastDumpedStep(const int para)
set last dumped step
std::vector< PluginElement * > pluginElements_m
void dumpAzimuthAngles_m(const double &t, const Vector_t &R, const Vector_t &P, const double &oldReferenceTheta, const double &temp_meanTheta)
unsigned int numRFCavities_m
RFCAVITY entries in FieldDimensions; gapCrossKick_m() has nothing to do without them.
IpplTimings::TimerRef IntegrationTimer_m
IpplTimings::TimerRef PluginElemTimer_m
virtual void visitDegrader(const Degrader &)
Apply the algorithm to a degrader.
virtual void visitRBend(const RBend &)
Apply the algorithm to a rectangular bend.
static Vector_t const xaxis
The positive axes unit vectors.
virtual void visitProbe(const Probe &)
Apply the algorithm to a probe.
virtual void visitVacuum(const Vacuum &)
Apply the algorithm to a vacuum space.
void setPr(double x)
Method for restart.
void operator=(const ParallelCyclotronTracker &)
std::function< bool(const double &, const size_t &, Vector_t &, Vector_t &)> function_t
bool computeExternalFields_m(const Vector_t &R, const Vector_t &P, const double &t, Vector_t &Efield, Vector_t &Bfield)
Calculate the field map at an arbitrary point.
std::vector< double > azimuth_angle_m
the different azimuthal angles for the outfTheta_m output files
bool setRefPartForDump_m(Vector_t &refR, Vector_t &refP)
std::unique_ptr< MultiBunchHandler > mbHandler_m
void injectBunch(bool &flagTransition)
std::pair< double[8], Component * > element_pair
void rotateAroundZ(ParticleAttrib< Vector_t > &particleVectors, double const phi)
virtual void visitStripper(const Stripper &)
Apply the algorithm to a particle stripper.
void normalizeQuaternion(Quaternion_t &quaternion)
virtual void visitCCollimator(const CCollimator &)
Apply the algorithm to a collimator.
void singleMode_m(double &t, const double dt, bool &finishedTurn, double &oldReferenceTheta)
void update_m(double &t, const double &dt, const bool &finishedTurn)
Update time and path length, write to output files.
std::vector< std::unique_ptr< std::ofstream > > outfTheta_m
output coordinates at different azimuthal angles and one after every turn
void rotateAroundX(ParticleAttrib< Vector_t > &particleVectors, double const psi)
double calculateAngle(double x, double y)
bool isTurnDone()
Check if turn done.
virtual void visitBeamline(const Beamline &)
Apply the algorithm to a beam line.
bool checkGapCross(Vector_t Rold, Vector_t Rnew, RFCavity *rfcavity, double &DistOld)
virtual void visitOffset(const Offset &)
Apply the algorithm to a offset (placement).
IpplTimings::TimerRef DelParticleTimer_m
bool RFkick(RFCavity *rfcavity, const double t, const double dt, const int Pindex)
virtual void visitScalingFFAMagnet(const ScalingFFAMagnet &bend)
Apply the algorithm to a scaling FFA magnet.
double computeRadius(const Vector_t &meanR) const
void updatePathLength(const double &dt)
void openFiles(size_t numFiles, std::string fn)
@ open / close output coordinate files
virtual void visitSBend3D(const SBend3D &)
Apply the algorithm to a sector bend with 3D field map.
double bega
The reference variables.
void dumpAngle(const double &theta, double &prevAzimuth, double &azimuth, const short &bunchNr=0)
bool applyPluginElements(const double dt)
std::list< type_pair * > beamline_list
virtual void visitCorrector(const Corrector &)
Apply the algorithm to a closed orbit corrector.
std::tuple< double, double, double > initializeTracking_m()
std::pair< ElementType, element_pair > type_pair
virtual void visitRing(const Ring &ring)
Apply the algorithm to a ring.
IpplTimings::TimerRef BinRepartTimer_m
void globalToLocal(ParticleAttrib< Vector_t > &vectorArray, double phi, Vector_t const translationToGlobal=0)
bool getFieldsAtPoint(const double &t, const size_t &Pindex, Vector_t &Efield, Vector_t &Bfield)
std::vector< CavityCrossData > cavCrossDatas_m
virtual void visitDrift(const Drift &)
Apply the algorithm to a drift space.
std::unique_ptr< Stepper< function_t > > itsStepper_mp
struct ParallelCyclotronTracker::settings setup_m
bool refLostWarned_m
setRefPartForDump_m() has reported the loss of ID 0 in this run
void finalizeTracking_m(dvector_t &Ttime, dvector_t &Tdeltr, dvector_t &Tdeltz, ivector_t &TturnNumber)
virtual void visitVariableRFCavityFringeField(const VariableRFCavityFringeField &cav)
Apply the algorithm to a variable RF cavity with Fringe Field.
void gapCrossKick_m(size_t i, double t, double dt, const Vector_t &Rold, const Vector_t &Pold)
void getQuaternionTwoVectors(Vector_t u, Vector_t v, Quaternion_t &quaternion)
virtual void visitSBend(const SBend &)
Apply the algorithm to a sector bend.
virtual void visitMarker(const Marker &)
Apply the algorithm to a marker.
virtual void execute()
Apply the algorithm to the top-level beamline.
void dumpThetaEachTurn_m(const double &t, const Vector_t &R, const Vector_t &P, const double &temp_meanTheta, bool &finishedTurn)
void bunchMode_m(double &t, const double dt, bool &finishedTurn)
std::list< Component * > myElements
std::unique_ptr< LossDataSink > lossDs_m
virtual void visitMultipoleT(const MultipoleT &)
Apply the algorithm to an arbitrary multipole.
virtual void visitVariableRFCavity(const VariableRFCavity &cav)
Apply the algorithm to a variabel RF cavity.
bool getReferenceParticle(Vector_t &refR, Vector_t &refP) const
void buildupFieldList(double BcParameter[], ElementType elementType, Component *elptr)
void rotateWithQuaternion(ParticleAttrib< Vector_t > &vectorArray, Quaternion_t const quaternion)
virtual void visitMultipole(const Multipole &)
Apply the algorithm to a multipole.
virtual void visitSolenoid(const Solenoid &)
Apply the algorithm to a solenoid.
Steppers::TimeIntegrator stepper_m
IpplTimings::TimerRef TransformTimer_m
ParallelCyclotronTracker(const ParallelCyclotronTracker &)
Vector_t calcMeanR(short bunchNr=-1) const
double calculateAngle2(double x, double y)
virtual void visitCyclotron(const Cyclotron &cycl)
Apply the algorithm to a cyclotron.
void localToGlobal(ParticleAttrib< Vector_t > &vectorArray, double phi, Vector_t const translationToGlobal=0)
virtual void visitRFCavity(const RFCavity &)
Apply the algorithm to a RF cavity.
bool getTunes(dvector_t &t, dvector_t &r, dvector_t &z, int lastTurn, double &nur, double &nuz)
virtual void visitFlexibleCollimator(const FlexibleCollimator &)
Apply the algorithm to a flexible collimator.
virtual void visitVerticalFFAMagnet(const VerticalFFAMagnet &bend)
Apply the algorithm to a vertical FFA magnet.
virtual void visitSeptum(const Septum &)
Apply the algorithm to a septum.
void seoMode_m(double &t, const double dt, bool &finishedTurn, dvector_t &Ttime, dvector_t &Tdeltr, dvector_t &Tdeltz, ivector_t &TturnNumber)
int maxSteps_m
The maximal number of steps the system is integrated.
virtual void visitOutputPlane(const OutputPlane &)
Apply the algorithm to a outputplane.
virtual void visitMonitor(const Monitor &)
Apply the algorithm to a beam position monitor.
Interface for a single beam element.
Definition Component.h:50
Interface for general corrector.
Definition Corrector.h:35
Interface for drift space.
Definition Drift.h:33
Interface for a marker.
Definition Marker.h:32
Interface for general multipole.
Definition Multipole.h:47
Definition Probe.h:31
Definition RBend.h:58
Ring describes a ring type geometry for tracking.
Definition Ring.h:53
Definition SBend.h:68
Interface for solenoids.
Definition Solenoid.h:36
PartBunchBase< double, 3 > * itsBunch_m
The bunch of particles to be tracked.
Definition Tracker.h:151
An abstract sequence of beam line components.
Definition Beamline.h:34
Timing::TimerRef TimerRef
Vektor< double, 3 > Vector_t
Definition Vektor.h:6