ParallelCyclotronTracker.h 20.1 KB
Newer Older
gsell's avatar
gsell committed
1 2
#ifndef OPAL_ParallelCyclotronTracker_HH
#define OPAL_ParallelCyclotronTracker_HH
3

gsell's avatar
gsell committed
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
// ------------------------------------------------------------------------
// $RCSfile: ParallelCyclotronTracker.h,v $
// ------------------------------------------------------------------------
// $Revision: 1.1.2.1 $
// ------------------------------------------------------------------------
// Copyright: see Copyright.readme
// ------------------------------------------------------------------------
//
// Class: ParallelCyclotron
//
// ------------------------------------------------------------------------
//
// $Date: 2004/11/12 20:10:11 $
// $Author: adelmann $
//
// ------------------------------------------------------------------------

#include "Algorithms/Tracker.h"
#include "Structure/DataSink.h"
23
#include "AbsBeamline/ElementBase.h"
gsell's avatar
gsell committed
24
#include <vector>
25
#include <tuple>
gsell's avatar
gsell committed
26

27
#include "Steppers/Steppers.h"
gsell's avatar
gsell committed
28

frey_m's avatar
frey_m committed
29 30
#include "Structure/MultiBunchDump.h"

gsell's avatar
gsell committed
31
class BMultipoleField;
frey_m's avatar
frey_m committed
32 33
template <class T, unsigned Dim>
class PartBunchBase;
gsell's avatar
gsell committed
34
class PlanarArcGeometry;
kraus's avatar
kraus committed
35
class Ring;
36
class SBend3D;
37
class VariableRFCavity;
38
class VariableRFCavityFringeField;
39
class Offset;
gsell's avatar
gsell committed
40 41 42 43 44

// Class ParallelCyclotronTracker
// ------------------------------------------------------------------------
enum CyclOperationModeT {SINGLEP, MULTIP, TUNECALC};

45 46 47 48 49 50 51
struct CavityCrossData {
    RFCavity * cavity;
    double sinAzimuth;
    double cosAzimuth;
    double perpenDistance;
};

gsell's avatar
gsell committed
52 53 54
class ParallelCyclotronTracker: public Tracker {

public:
55
    
56
    enum class MODE {
57 58 59 60 61
        UNDEFINED = -1,
        SINGLE = 0,
        SEO = 1,
        BUNCH = 2
    };
62 63 64 65 66 67 68
    
    // multi-bunch modes
    enum class MB_MODE {
        NONE   = 0,
        FORCE  = 1,
        AUTO   = 2
    };
69

gsell's avatar
gsell committed
70

71 72
    typedef std::vector<double> dvector_t;
    typedef std::vector<int> ivector_t;
73
    typedef std::pair<double[8], Component *>      element_pair;
74
    typedef std::pair<ElementBase::ElementType, element_pair>        type_pair;
gsell's avatar
gsell committed
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
    typedef std::list<type_pair *>                 beamline_list;
    /// 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 ParallelCyclotronTracker(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.
frey_m's avatar
frey_m committed
91
    explicit ParallelCyclotronTracker(const Beamline &bl, PartBunchBase<double, 3> *bunch, DataSink &ds,
gsell's avatar
gsell committed
92 93 94 95
                                      const PartData &data, bool revBeam, bool revTrack, int maxSTEPS, int timeIntegrator);

    virtual ~ParallelCyclotronTracker();

kraus's avatar
kraus committed
96 97
    /// Apply the algorithm to an Ring
    virtual void visitRing(const Ring &ring);
98

gsell's avatar
gsell committed
99 100 101 102 103 104 105 106 107 108
    /// Apply the algorithm to a Cyclotorn
    virtual void visitCyclotron(const Cyclotron &cycl);

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

    /// Apply the algorithm to a BeamBeam.
    virtual void visitBeamBeam(const BeamBeam &);

    /// Apply the algorithm to a collimator.
109
    virtual void visitCCollimator(const CCollimator &);
gsell's avatar
gsell committed
110 111 112 113

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

adelmann's avatar
adelmann committed
114 115 116
    /// Apply the algorithm to a Degrader
    virtual void visitDegrader(const Degrader &);

gsell's avatar
gsell committed
117 118 119 120 121 122
    /// Apply the algorithm to a Diagnostic.
    virtual void visitDiagnostic(const Diagnostic &);

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

123 124 125
    /// Apply the algorithm to a flexible collimator
    virtual void visitFlexibleCollimator(const FlexibleCollimator &);

gsell's avatar
gsell committed
126 127 128 129 130 131 132 133 134 135 136 137
    /// 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 &);

ext-rogers_c's avatar
ext-rogers_c committed
138 139
    /// Apply the algorithm to a MultipoleT
    virtual void visitMultipoleT (const MultipoleT &);
140 141 142 143 144 145 146 147 148

    /// Apply the algorithm to a MultipoleTStraight
    virtual void visitMultipoleTStraight (const MultipoleTStraight &);

    /// Apply the algorithm to a MultipoleTCurvedConstRadius
    virtual void visitMultipoleTCurvedConstRadius (const MultipoleTCurvedConstRadius &);

    /// Apply the algorithm to a MultipoleTCurvedVarRadius
    virtual void visitMultipoleTCurvedVarRadius (const MultipoleTCurvedVarRadius &);
ext-rogers_c's avatar
ext-rogers_c committed
149
    
150 151 152
    /// Apply the algorithm to a Offset.
    virtual void visitOffset(const Offset &);

gsell's avatar
gsell committed
153 154 155 156 157 158 159 160 161 162 163 164
    /// 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 RFQuadrupole.
    virtual void visitRFQuadrupole(const RFQuadrupole &);

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

165 166 167
    /// Apply the algorithm to a SBend3D.
    virtual void visitSBend3D(const SBend3D &);

168 169 170
    /// Apply the algorithm to a ScalingFFAGMagnet.
    virtual void visitScalingFFAGMagnet(const ScalingFFAGMagnet &bend);

gsell's avatar
gsell committed
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
    /// 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 charge stripper.
    virtual void visitStripper(const Stripper &);

    /// Apply the algorithm to a ParallelPlate, it is empty for cyclotrontracker .
    virtual void visitParallelPlate(const ParallelPlate &);

    /// Apply the algorithm to a CyclotronValley.it is empty for cyclotrontracker .
    virtual void visitCyclotronValley(const CyclotronValley &);

189 190 191
    /// Apply the algorithm to a VariabelRFCavity.
    virtual void visitVariableRFCavity(const VariableRFCavity &cav);

192 193 194 195
    /// Apply the algorithm to a VariabelRFCavity.
    virtual void visitVariableRFCavityFringeField
                                      (const VariableRFCavityFringeField &cav);

gsell's avatar
gsell committed
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
    /// Apply the algorithm to the top-level beamline.
    //  overwrite the execute-methode from DefaultVisitor
    virtual void execute();

    /// Apply the algorithm to a beam line.
    //  overwrite the execute-methode from DefaultVisitor
    virtual void visitBeamline(const Beamline &);

    /// set total number of tracked bunches
    inline void setNumBunch(int n) { numBunch_m = n; }

    /// get total number of tracked bunches
    inline int  getNumBunch() { return numBunch_m; }

    /// set the working sub-mode for multi-bunch mode: "FORCE" or "AUTO"
211
    void setMultiBunchMode(const std::string& mbmode);
frey_m's avatar
frey_m committed
212 213 214
    
    /// set the scale for binning in multi-bunch mode
    void setMultiBunchEta(const double& eta) { eta_m = eta; };
gsell's avatar
gsell committed
215 216 217 218 219 220

    /// set last dumped step
    inline void setLastDumpedStep(const int para) {lastDumpedStep_m = para ; }

    /// set the control parameter for "AUTO" sub-mode
    inline void  setParaAutoMode(const double para) {CoeffDBunches_m = para; }
221

222
    inline void setPr(double x) {referencePr = x;}
223 224
    inline void setPt(double x) {referencePt = x;}
    inline void setPz(double x) {referencePz = x;}
225 226
    inline void setR(double x) {referenceR = x;}
    inline void setTheta(double x) {referenceTheta = x;}
227
    inline void setZ(double x) {referenceZ = x;}
228
    inline void setBeGa(double x) {bega = x;}
229 230 231
    inline void setPhi(double x) {referencePhi = x;}
    inline void setPsi(double x) {referencePsi = x;}
    inline void setPreviousH5Local(bool x) {previousH5Local = x;}
232 233 234

    void bgf_main_collision_test();
    void initializeBoundaryGeometry();
235

gsell's avatar
gsell committed
236 237 238 239 240 241 242 243 244 245 246 247 248
private:

    // Not implemented.
    ParallelCyclotronTracker();
    ParallelCyclotronTracker(const ParallelCyclotronTracker &);
    void operator=(const ParallelCyclotronTracker &);

    beamline_list FieldDimensions;
    std::list<Component *> myElements;
    int LastVisited;
    Beamline *itsBeamline;

    DataSink *itsDataSink;
frey_m's avatar
frey_m committed
249 250
    
    std::unique_ptr<MultiBunchDump> itsMBDump_m;
gsell's avatar
gsell committed
251

252 253
    BoundaryGeometry *bgf_m;

gsell's avatar
gsell committed
254 255 256
    /// The maximal number of steps the system is integrated
    int maxSteps_m;

257
    /// The positive axes unit vectors
258 259 260
    static Vector_t const xaxis;
    static Vector_t const yaxis;
    static Vector_t const zaxis;
261

gsell's avatar
gsell committed
262 263
    /// The scale factor for dimensionless variables
    double scaleFactor_m;
Daniel Winklehner's avatar
Daniel Winklehner committed
264 265

    /// The reference variables
266
    double bega;
gsell's avatar
gsell committed
267 268
    double referenceR;
    double referenceTheta;
Daniel Winklehner's avatar
Daniel Winklehner committed
269
    double referenceZ = 0.0;
gsell's avatar
gsell committed
270 271 272

    double referencePr;
    double referencePt;
Daniel Winklehner's avatar
Daniel Winklehner committed
273
    double referencePz = 0.0;
gsell's avatar
gsell committed
274 275
    double referencePtot;

276 277 278
    double referencePsi;
    double referencePhi;

279 280
    bool spiral_flag = false;

281 282
    Vector_t PreviousMeanP;

283 284
    bool previousH5Local;

gsell's avatar
gsell committed
285 286
    double sinRefTheta_m;
    double cosRefTheta_m;
287

gsell's avatar
gsell committed
288 289 290 291 292 293
    /// The number of bunches specified in TURNS of RUN commond
    int numBunch_m;

    // 0 for single bunch (default),
    // 1 for FORCE,
    // 2 for AUTO
294
    MB_MODE multiBunchMode_m;
gsell's avatar
gsell committed
295 296 297 298 299 300 301 302

    // control parameter for AUTO multi-bunch mode
    double CoeffDBunches_m;

    int lastDumpedStep_m;

    double PathLength_m;

303
    void MtsTracker();
gsell's avatar
gsell committed
304

305
    void GenericTracker();
306 307
    bool getFieldsAtPoint(const double &t, const size_t &Pindex, Vector_t &Efield, Vector_t &Bfield);

gsell's avatar
gsell committed
308
    /*
309
      Local Variables both used by the integration methods
gsell's avatar
gsell committed
310 311 312 313 314
    */

    long long step_m;
    long long restartStep0_m;

315 316
    int turnnumber_m;

frey_m's avatar
frey_m committed
317
    double eta_m; // parameter for reset bin in multi-bunch run
318

gsell's avatar
gsell committed
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 346 347 348 349 350 351 352 353 354 355 356 357 358
    // temporal 6 phase space varibles of particle [x,y,z,px,py,pz]. Unit: mm & dimensionless
    double variable_m[6];
    // temporal 3 real space varibles of particle ID=0 [x,y,z]. for tune with SC.  Unit: mm
    Vector_t variable_tune0_m;
    // temporal 3 real space varibles of particle ID=1 [x,y,z]. for tune with SC.  Unit: mm
    Vector_t variable_tune1_m;

    // vector of [angle, x, y] of SEO read in from external file for tune with SC. Unit : rad, mm
    std::vector<Vector_t> variable_SEO_m;

    // record how many bunches has already been injected. ONLY FOR MPM
    int BunchCount_m;

    // decide how many energy bins. ONLY FOR MPM
    // For the time being, we set bin number equal to bunch number.
    int BinCount_m;

    // used for automatic injection in multi-bunch mode
    double RLastTurn_m , RThisTurn_m;

    // start time to record tune data
    double StartTime_m;

    // external field arrays for dumping
    Vector_t FDext_m[2], extE_m, extB_m;

    // mark the dumpstep to inject new bunch from here for AUTO mode of restart run of multibunch
    int backupDumpStep_m;

    const int myNode_m;
    const size_t initialLocalNum_m;
    const size_t initialTotalNum_m;

    std::ofstream outfTheta0_m;
    std::ofstream outfTheta1_m;
    std::ofstream outfTheta2_m;
    std::ofstream outfThetaEachTurn_m;


    //store the data of the beam which are required for injecting a new bunch for multibunch
359 360 361
    /// filename
    std::string onebunch_m;
    
362
    void openFiles(std::string fn);
gsell's avatar
gsell committed
363 364 365 366 367 368 369 370
    void closeFiles();

    // Fringe fields for entrance and exit of magnetic elements.
    void applyEntranceFringe(double edge, double curve,
                             const BMultipoleField &field, double scale);
    void applyExitFringe(double edge, double curve,
                         const BMultipoleField &field, double scale);

371
    void buildupFieldList(double BcParameter[], ElementBase::ElementType elementType, Component *elptr);
gsell's avatar
gsell committed
372

373
    bool derivate(double *y, const double &t, double *yp, const size_t &Pindex);
gsell's avatar
gsell committed
374

375
    bool rk4(double x[], const double &t, const double &tau, const size_t &Pindex);
gsell's avatar
gsell committed
376 377 378 379 380 381 382 383 384 385 386 387

    // angle range [0~2PI) degree
    double calculateAngle(double x, double y);
    // angle range [-PI~PI) degree
    double calculateAngle2(double x, double y);

    bool readOneBunchFromFile(const size_t BeamCount);
    void saveOneBunch();

    bool checkGapCross(Vector_t Rold, Vector_t Rnew, RFCavity * rfcavity, double &DistOld);
    bool RFkick(RFCavity * rfcavity, const double t, const double dt, const int Pindex);

388
    bool getTunes(dvector_t &t,  dvector_t &r,  dvector_t &z, int lastTurn, double &nur, double &nuz);
gsell's avatar
gsell committed
389 390 391 392 393 394 395

    IpplTimings::TimerRef IntegrationTimer_m;
    IpplTimings::TimerRef DumpTimer_m ;
    IpplTimings::TimerRef TransformTimer_m;
    IpplTimings::TimerRef BinRepartTimer_m;

    Vector_t calcMeanR() const;
396

gsell's avatar
gsell committed
397
    Vector_t calcMeanP() const;
398

gsell's avatar
gsell committed
399
    void repartition(); // Do repartition between nodes if step_m is multiple of Options::repartFreq
400 401

    // Transform the x- and y-parts of a particle attribute (position, momentum, fields) from the
gsell's avatar
gsell committed
402
    // global reference frame to the local reference frame.
403

gsell's avatar
gsell committed
404
    // phi is the angle of the bunch measured counter-clockwise from the positive x-axis.
405 406
    void globalToLocal(ParticleAttrib<Vector_t> & vectorArray,
                       double phi, Vector_t const translationToGlobal = 0);
407 408

    // Transform the x- and y-parts of a particle attribute (position, momentum, fields) from the
gsell's avatar
gsell committed
409
    // local reference frame to the global reference frame.
410
    void localToGlobal(ParticleAttrib<Vector_t> & vectorArray,
411
                       double phi, Vector_t const translationToGlobal = 0);
412

413
    // Overloaded version of globalToLocal using a quaternion for 3D rotation
414 415
    inline void globalToLocal(ParticleAttrib<Vector_t> & vectorArray,
                              Quaternion_t const quaternion,
416
                              Vector_t const meanR = Vector_t(0.0));
417

418
    // Overloaded version of localToGlobal using a quaternion for 3D rotation
419
    inline void localToGlobal(ParticleAttrib<Vector_t> & vectorArray,
420
                              Quaternion_t const quaternion,
421
                              Vector_t const meanR = Vector_t(0.0));
422

423
    // Overloaded version of globalToLocal using phi and theta for pseudo 3D rotation
424 425
    inline void globalToLocal(ParticleAttrib<Vector_t> & particleVectors,
                              double const phi, double const psi,
426
                              Vector_t const meanR = Vector_t(0.0));
427 428

    // Overloaded version of localToGlobal using phi and theta for pseudo 3D rotation
429 430
    inline void localToGlobal(ParticleAttrib<Vector_t> & particleVectors,
                              double const phi, double const psi,
431 432 433
                              Vector_t const meanR = Vector_t(0.0));

    // Overloaded version of globalToLocal using phi and theta for pseudo 3D rotation, single vector
434 435
    inline void globalToLocal(Vector_t & myVector,
                              double const phi, double const psi,
436 437 438
                              Vector_t const meanR = Vector_t(0.0));

    // Overloaded version of localToGlobal using phi and theta for pseudo 3D rotation, single vector
439 440
    inline void localToGlobal(Vector_t & myVector,
                              double const phi, double const psi,
441
                              Vector_t const meanR = Vector_t(0.0));
442 443

    // Rotate the particles by an angle and axis defined in the quaternion (4-vector w,x,y,z)
adelmann's avatar
adelmann committed
444
    inline void rotateWithQuaternion(ParticleAttrib<Vector_t> & vectorArray, Quaternion_t const quaternion);
445 446

    // Returns the quaternion of the rotation from vector u to vector v
adelmann's avatar
adelmann committed
447
    inline void getQuaternionTwoVectors(Vector_t u, Vector_t v, Quaternion_t & quaternion);
448 449

    // Normalization of a quaternion
adelmann's avatar
adelmann committed
450
    inline void normalizeQuaternion(Quaternion_t & quaternion);
451

452
    // Normalization of a quaternion
453
    inline void normalizeVector(Vector_t & vector);
454 455 456 457

    // Some rotations
    inline void rotateAroundZ(ParticleAttrib<Vector_t> & particleVectors, double const phi);
    inline void rotateAroundX(ParticleAttrib<Vector_t> & particleVectors, double const psi);
458 459
    inline void rotateAroundZ(Vector_t & myVector, double const phi);
    inline void rotateAroundX(Vector_t & myVector, double const psi);
460

461
    // Push particles for time h.
gsell's avatar
gsell committed
462 463
    // Apply effects of RF Gap Crossings.
    // Update time and path length.
frey_m's avatar
frey_m committed
464
    // Unit assumptions: [itsBunch_m->R] = m, [itsBunch_m->P] = 1, [h] = s, [c] = m/s, [itsBunch_m->getT()] = s
gsell's avatar
gsell committed
465 466
    void push(double h);

467
    // Kick particles for time h
frey_m's avatar
frey_m committed
468
    // The fields itsBunch_m->Bf, itsBunch_m->Ef are used to calculate the forces
469 470 471 472 473
    void kick(double h);

    // Apply the trilogy half push - kick - half push,
    // considering only external fields
    void borisExternalFields(double h);
474 475

    // apply the plugin elements: probe, collimator, stripper, septum
476
    void applyPluginElements(const double dt);
477

478 479
    // destroy particles if they are marked as Bin=-1 in the plugin elements or out of global apeture
    bool deleteParticle();
480

481 482 483 484 485 486
    std::ofstream outfTrackOrbit_m;

    void initTrackOrbitFile();

    void singleParticleDump();

487
    void bunchDumpStatData();
frey_m's avatar
frey_m committed
488 489
    
    void bunchDumpStatDataPerBin();
490 491

    void bunchDumpPhaseSpaceData();
492

493 494
    void evaluateSpaceChargeField();

495 496
    void initDistInGlobalFrame();

Matthias Toggweiler's avatar
Matthias Toggweiler committed
497 498
    void checkNumPart(std::string s);

kraus's avatar
kraus committed
499 500
    // we store a pointer explicitly to the Ring
    Ring* opalRing_m;
501
    
502

kraus's avatar
kraus committed
503
    // If Ring is defined take the harmonic number from Ring; else use
504 505
    // cyclotron
    double getHarmonicNumber() const;
506
    
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
    typedef std::function<bool(const double&,
                               const size_t&,
                               Vector_t&,
                               Vector_t&)> function_t;
    
    std::unique_ptr< Stepper<function_t> > itsStepper_mp;
    
    struct settings {
        int scSolveFreq;
        int stepsPerTurn;
        double azimuth_angle0;
        double azimuth_angle1;
        double azimuth_angle2;
        double deltaTheta;
        int stepsNextCheck;
    } setup_m;
    
    MODE mode_m;
    
    stepper::INTEGRATOR stepper_m;
    
528 529
    void update_m(double& t, const double& dt, const bool& dumpEachTurn);
    
530 531 532
    /*!
     * @returns the time t [ns], time step dt [ns] and the azimuth angle [rad]
     */
533 534 535 536 537 538 539
    std::tuple<double, double, double> initializeTracking_m();
    
    void finalizeTracking_m(dvector_t& Ttime,
                            dvector_t& Tdeltr,
                            dvector_t& Tdeltz,
                            ivector_t& TturnNumber);
    
540
    void seoMode_m(double& t, const double dt, bool& dumpEachTurn,
541 542
                   dvector_t& Ttime, dvector_t& Tdeltr,
                   dvector_t& Tdeltz, ivector_t& TturnNumber);
543
    
544
    void singleMode_m(double& t, const double dt, bool& dumpEachTurn, double& oldReferenceTheta);
545
    
546
    void bunchMode_m(double& t, const double dt, bool& dumpEachTurn);
547
    
548 549
    void gapCrossKick_m(size_t i, double t, double dt,
                        const Vector_t& Rold, const Vector_t& Pold);
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
    
    
    inline void dumpAzimuthAngles_m(const double& t,
                                    const Vector_t& R,
                                    const Vector_t& P,
                                    const double& oldReferenceTheta,
                                    const double& temp_meanTheta);
    
    inline void dumpThetaEachTurn_m(const double& t,
                                    const Vector_t& R,
                                    const Vector_t& P,
                                    const double& temp_meanTheta,
                                    bool& dumpEachTurn);
    
    void computeSpaceChargeFields_m();
    
566 567 568 569 570
    bool computeExternalFields_m(const size_t& i,
                                 const double& t,
                                 Vector_t& Efield,
                                 Vector_t& Bfield);
    
571
    void injectBunch_m(bool& flagTransition);
572

gsell's avatar
gsell committed
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
};

/**
 * @param x
 * @param y
 *
 * @return angle range [0~2PI) degree
 */
inline
double ParallelCyclotronTracker::calculateAngle(double x, double y) {
    double thetaXY = atan2(y, x);

    if (thetaXY < 0) return thetaXY + Physics::two_pi;
    return thetaXY;
}

/**
 * @param x
 * @param y
 *
 * @return angle range [-PI~PI) degree
 */
inline
596
double ParallelCyclotronTracker::calculateAngle2(double x, double y)
gsell's avatar
gsell committed
597 598
{ return atan2(y,x); }

winklehner_d's avatar
winklehner_d committed
599
#endif // OPAL_ParallelCyclotronTracker_HH