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/Drift.h"
#include "AbsBeamline/ElementBase.h"
#include "AbsBeamline/Marker.h"
#include "AbsBeamline/Monitor.h"
#include "AbsBeamline/Multipole.h"
#include "AbsBeamline/MultipoleT.h"
#include "AbsBeamline/MultipoleTCurvedConstRadius.h"
#include "AbsBeamline/MultipoleTCurvedVarRadius.h"
#include "AbsBeamline/MultipoleTStraight.h"
#include "AbsBeamline/Offset.h"
#include "AbsBeamline/Probe.h"
#include "AbsBeamline/RFCavity.h"
#include "AbsBeamline/Ring.h"
#include "AbsBeamline/ScalingFFAMagnet.h"
#include "AbsBeamline/Solenoid.h"
#include "AbsBeamline/TravelingWave.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;
}
 
DefaultVisitor::~DefaultVisitor() {
}
 
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::visitDrift(const Drift& drf) {
    applyDefault(drf);
}
 
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::visitMultipoleTStraight(const MultipoleTStraight& multTstraight) {
    applyDefault(multTstraight);
}
 
void DefaultVisitor::visitMultipoleTCurvedConstRadius(
    const MultipoleTCurvedConstRadius& multTccurv) {
    applyDefault(multTccurv);
}
 
void DefaultVisitor::visitMultipoleTCurvedVarRadius(const MultipoleTCurvedVarRadius& multTvcurv) {
    applyDefault(multTvcurv);
}
 
void DefaultVisitor::visitOffset(const Offset& off) {
    applyDefault(off);
}
 
void DefaultVisitor::visitRing(const Ring& ring) {
    applyDefault(ring);
}
 
void DefaultVisitor::visitRFCavity(const RFCavity& cav) {
    applyDefault(cav);
}
 
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::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&) {
}