DefaultVisitor.cpp

Go to the documentation of this file.

//
// Class DefaultVisitor
//   The default interface for a BeamlineVisitor.
//   A default implementation for all visitors that can iterate over a
//   beam line representation.
//   This abstract base class implements the default behaviour for the
//   structural classes Beamline and FlaggedElmPtr.
//   It also holds the data required for all visitors in a protected area.
//
// Copyright (c) 200x - 2020, Paul Scherrer Institut, Villigen PSI, Switzerland
// All rights reserved
//
// 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/>.
//
#include "Algorithms/DefaultVisitor.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/Probe.h"
#include "AbsBeamline/RBend.h"
#include "AbsBeamline/RFCavity.h"
#include "AbsBeamline/Ring.h"
#include "AbsBeamline/SBend.h"
#include "AbsBeamline/ScalingFFAMagnet.h"
#include "AbsBeamline/Solenoid.h"
#include "AbsBeamline/TravelingWave.h"
#include "AbsBeamline/VariableRFCavity.h"
#include "AbsBeamline/VerticalFFAMagnet.h"
 
#include "Beamlines/Beamline.h"
#include "Beamlines/FlaggedElmPtr.h"
 
DefaultVisitor::DefaultVisitor(const Beamline& beamline, bool backBeam, bool backTrack)
    : itsLine(beamline), back_beam(backBeam), back_track(backTrack) {
    local_flip = back_path = (back_beam && !back_track) || (back_track && !back_beam);
    flip_B                 = back_beam ? -1.0 : 1.0;
    flip_s                 = back_path ? -1.0 : 1.0;
}
 
void DefaultVisitor::execute() {
    local_flip = (back_beam && !back_track) || (back_track && !back_beam);
    itsLine.accept(*this);
}
 
void DefaultVisitor::visitComponent(const Component& comp) { applyDefault(comp); }
 
void DefaultVisitor::visitConstantEFieldCavity(const ConstantEFieldCavity& cav) {
    applyDefault(cav);
}
 
void DefaultVisitor::visitDrift(const Drift& drf) { applyDefault(drf); }
 
void DefaultVisitor::visitLaser(const Laser& laser) { applyDefault(laser); }
 
void DefaultVisitor::visitMarker(const Marker& mark) { applyDefault(mark); }
 
void DefaultVisitor::visitMonitor(const Monitor& mon) { applyDefault(mon); }
 
void DefaultVisitor::visitMultipole(const Multipole& mult) { applyDefault(mult); }
 
void DefaultVisitor::visitMultipoleT(const MultipoleT& multT) { applyDefault(multT); }
 
void DefaultVisitor::visitRBend(const RBend& bend) { applyDefault(bend); }
 
void DefaultVisitor::visitRing(const Ring& ring) { applyDefault(ring); }
 
void DefaultVisitor::visitRFCavity(const RFCavity& cav) { applyDefault(cav); }
 
void DefaultVisitor::visitSBend(const SBend& bend) { applyDefault(bend); }
 
void DefaultVisitor::visitSolenoid(const Solenoid& so) { applyDefault(so); }
 
void DefaultVisitor::visitTravelingWave(const TravelingWave& trw) { applyDefault(trw); }
 
void DefaultVisitor::visitScalingFFAMagnet(const ScalingFFAMagnet& spiral) { applyDefault(spiral); }
 
void DefaultVisitor::visitVerticalFFAMagnet(const VerticalFFAMagnet& mag) { applyDefault(mag); }
 
void DefaultVisitor::visitVariableRFCavity(const VariableRFCavity& cavity) { applyDefault(cavity); }
 
void DefaultVisitor::visitProbe(const Probe& probe) { applyDefault(probe); }
 
void DefaultVisitor::visitBeamline(const Beamline& bl) {
    // Default behaviour: Apply algorithm to all beamline members.
    // If flip_local is true, track from right to left.
    bl.iterate(*this, local_flip);
}
 
void DefaultVisitor::visitFlaggedElmPtr(const FlaggedElmPtr& fep) {
    if (fep.getReflectionFlag()) {
        local_flip = !local_flip;
        fep.getElement()->accept(*this);
        local_flip = !local_flip;
    } else {
        fep.getElement()->accept(*this);
    }
}
 
void DefaultVisitor::applyDefault(const ElementBase&) {}