ParallelTracker.h

Go to the documentation of this file.

 
#ifndef OPALX_ParallelTracker_HH
#define OPALX_ParallelTracker_HH
 
#include "Algorithms/StepSizeConfig.h"
#include "Algorithms/Tracker.h"
#include "Steppers/BorisPusher.h"
#include "Steppers/SpinTBMTPusher.h"
#include "Structure/DataSink.h"
 
#include "BasicActions/Option.h"
#include "Utilities/Options.h"
 
#include "Physics/Physics.h"
 
#include "Algorithms/IndexMap.h"
#include "Algorithms/OrbitThreader.h"
 
#include "AbsBeamline/ConstantEFieldCavity.h"
#include "AbsBeamline/Drift.h"
#include "AbsBeamline/ElementBase.h"
#include "AbsBeamline/Laser.h"
#include "AbsBeamline/Marker.h"
#include "AbsBeamline/Monitor.h"
#include "AbsBeamline/Multipole.h"
#include "AbsBeamline/MultipoleT.h"
#include "AbsBeamline/RBend.h"
#include "AbsBeamline/RFCavity.h"
#include "AbsBeamline/SBend.h"
#include "AbsBeamline/ScalingFFAMagnet.h"
#include "AbsBeamline/Solenoid.h"
#include "AbsBeamline/TravelingWave.h"
#include "Beamlines/Beamline.h"
#include "Distribution/SamplingBase.hpp"
#include "Elements/OpalBeamline.h"
 
#include <list>
#include <memory>
#include <tuple>
#include <vector>
 
class ParticleMatterInteractionHandler;
class PluginElement;
 
class ParallelTracker : public Tracker {
private:
    DataSink* itsDataSink_m;         
    OpalBeamline itsOpalBeamline_m;  
    bool globalEOL_m;                
    double zstart_m;                 
 
    StepSizeConfig stepSizes_m;
 
    double dtCurrentTrack_m;          
    unsigned long long repartFreq_m;  
    std::vector<std::vector<std::shared_ptr<SamplingBase>>>
            emittingSamplers_m;  
 
    // --- Timers ---
    IpplTimings::TimerRef timeIntegrationTimer1_m;
    IpplTimings::TimerRef timeIntegrationTimer2_m;
    IpplTimings::TimerRef fieldEvaluationTimer_m;
    IpplTimings::TimerRef WakeFieldTimer_m;
    IpplTimings::TimerRef PluginElemTimer_m;
    IpplTimings::TimerRef BinRepartTimer_m;
    IpplTimings::TimerRef OrbThreader_m;
 
public:
    explicit ParallelTracker(const Beamline& bl, bool revBeam);
 
    explicit ParallelTracker(
            const Beamline& bl, PartBunch_t& bunch, DataSink* ds, bool revBeam,
            const std::vector<unsigned long long>& maxSTEPS, double zstart,
            const std::vector<double>& zstop, const std::vector<double>& dt,
            const std::vector<std::vector<std::shared_ptr<SamplingBase>>>& emittingSamplers = {});
 
    virtual ~ParallelTracker();
 
    virtual void visitBeamline(const Beamline&);
 
    virtual void visitComponent(const Component&);
 
    virtual void visitConstantEFieldCavity(const ConstantEFieldCavity&);
 
    virtual void visitDrift(const Drift&);
 
    virtual void visitLaser(const Laser&);
 
    virtual void visitMonitor(const Monitor&);
 
    virtual void visitMarker(const Marker&);
 
    virtual void visitMultipole(const Multipole&);
 
    virtual void visitMultipoleT(const MultipoleT&);
 
    virtual void visitRBend(const RBend&);
 
    virtual void visitRFCavity(const RFCavity&);
 
    virtual void visitSBend(const SBend&);
 
    virtual void visitTravelingWave(const TravelingWave&);
 
    virtual void visitSolenoid(const Solenoid&);
 
    virtual void execute();
 
    void kickParticles(const BorisPusher& pusher, PartBunch_t::ParticleContainer_t& pc);
 
    void pushParticles(const BorisPusher& pusher, PartBunch_t::ParticleContainer_t& pc);
 
    void timeIntegration1(BorisPusher& pusher);
 
    void timeIntegration2(BorisPusher& pusher);
 
    void evolveSpinTBMT();
 
    void computeSpaceChargeFields(unsigned long long step);
 
    void computeExternalFields(OrbitThreader& oth);
 
    void emitFromEmissionSources(double t, double dt);
 
    size_t applyGlobalProcesses(double dt);
 
    void resetFields();
 
    void changeDT();
 
    void setTime();
 
private:
    void updateReference(const BorisPusher& pusher);
 
    void updateReferenceParticles(const BorisPusher& pusher);
 
    void updateRefToLabCSTrafo();
 
    void writePhaseSpace(const long long step, bool psDump, bool statDump);
 
    void dumpStats(long long step, bool psDump, bool statDump);
 
    void prepareSections();
 
    void selectDT();
 
    void setOptionalVariables();
 
    bool hasEndOfLineReached(const BoundingBox& globalBoundingBox);
 
    void doBinaryRepartition();
 
    size_t deleteInvalidParticles(bool activeOnly, Inform& m, const std::string& reason);
 
public:
    size_t markBackwardParticlesAtSourcePlane();
 
private:
    void activateEmittingContainers(double t);
 
    void computeInitialBounds(Vector_t<double, 3>& rmin, Vector_t<double, 3>& rmax);
 
    void printInitialContainerRefs(Inform& m) const;
 
    void findStartPositions(const BorisPusher& pusher);
 
    void autophaseCavities(const BorisPusher& pusher);
 
    void updateRFElement(std::string elName, double maxPhi);
 
    void printRFPhases();
 
    void saveCavityPhases();
 
    void restoreCavityPhases();
};
 
inline void ParallelTracker::visitConstantEFieldCavity(const ConstantEFieldCavity& cav) {
    itsOpalBeamline_m.visit(cav, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitDrift(const Drift& drift) {
    itsOpalBeamline_m.visit(drift, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitMonitor(const Monitor& monitor) {
    itsOpalBeamline_m.visit(monitor, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitMarker(const Marker& marker) {
    itsOpalBeamline_m.visit(marker, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitMultipole(const Multipole& mult) {
    itsOpalBeamline_m.visit(mult, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitMultipoleT(const MultipoleT& mult) {
    itsOpalBeamline_m.visit(mult, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitRBend(const RBend& bend) {
    itsOpalBeamline_m.visit(bend, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitRFCavity(const RFCavity& as) {
    itsOpalBeamline_m.visit(as, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitSBend(const SBend& bend) {
    itsOpalBeamline_m.visit(bend, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitTravelingWave(const TravelingWave& tw) {
    itsOpalBeamline_m.visit(tw, *this, *itsBunch_m);
}
 
inline void ParallelTracker::visitSolenoid(const Solenoid& so) {
    itsOpalBeamline_m.visit(so, *this, *itsBunch_m);
}
 
#endif  // OPALX_ParallelTracker_HH