OpalRingDefinition.cpp

Go to the documentation of this file.

//
// Class OpalRingDefinition
//   The Opal Ring element.
//
// Copyright (c) 2012 - 2023, Chris Rogers, STFC Rutherford Appleton Laboratory, Didcot, UK
// 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 "Elements/OpalRingDefinition.h"

#include "AbsBeamline/Ring.h"
#include "Attributes/Attributes.h"
#include "Physics/Units.h"
#include "Utilities/OpalException.h"

#include <cmath>
#include <limits>

OpalRingDefinition::OpalRingDefinition() :
    OpalElement(SIZE, "RINGDEFINITION",
                "The \"RINGDEFINITION\" element defines basic ring parameters.") {

    itsAttr[HARMONIC_NUMBER] = Attributes::makeReal
        ("HARMONIC_NUMBER", "The assumed harmonic number of the ring (i.e. number of bunches in the ring on a given turn) (default = 1).", 1.0);

    itsAttr[LAT_RINIT] = Attributes::makeReal
        ("LAT_RINIT", "The initial radius of the first element to be placed in the ring [m].");

    itsAttr[LAT_PHIINIT] = Attributes::makeReal
        ("LAT_PHIINIT", "The initial angle around the ring of the first element to be placed. [deg]");

    itsAttr[LAT_THETAINIT] = Attributes::makeReal
        ("LAT_THETAINIT", "The angle relative to the tangent of the ring for the first element to be placed [deg].");

    itsAttr[BEAM_PHIINIT] = Attributes::makeReal
        ("BEAM_PHIINIT", "The initial angle around the ring of the beam [deg].");

    itsAttr[BEAM_THETAINIT] = Attributes::makeReal
        ("BEAM_THETAINIT", "Defines an angular offset of the beam relative to the tangent vector, in the x-y plane [deg] (default = 0).", 0.0);

    itsAttr[BEAM_PRINIT] = Attributes::makeReal
        ("BEAM_PRINIT", "An initial pr momentum offset of the beam.");

    itsAttr[BEAM_RINIT] = Attributes::makeReal
        ("BEAM_RINIT", "The initial radius of the beam [m].");

    itsAttr[SYMMETRY] = Attributes::makeReal
        ("SYMMETRY", "The rotational symmetry of the lattice.", 1.0);

    itsAttr[SCALE] = Attributes::makeReal
        ("SCALE", "Scale the fields by a multiplicative factor", 1.0);

    // should be in RF cavity definition; this comes from cyclotron definition,
    // but not right
    itsAttr[RFFREQ] = Attributes::makeReal
        ("RFFREQ", "The nominal RF frequency of the ring [MHz].");

    // I see also makeBool, but dont know how it works; no registerBoolAttribute
    itsAttr[IS_CLOSED] = Attributes::makeBool
        ("IS_CLOSED", "Set to 'false' to disable checking for closure of the ring");

    itsAttr[MIN_R] = Attributes::makeReal
        ("MIN_R", "Minimum allowed radius during tracking [m]. If not defined, any radius is allowed. If MIN_R is defined, MAX_R must also be defined.");

    itsAttr[MAX_R] = Attributes::makeReal
        ("MAX_R", "Maximum allowed radius during tracking [m]. If not defined, any radius is allowed. If MAX_R is defined, MIN_R must also be defined.");

    registerOwnership();

    setElement(new Ring("RING"));
}

OpalRingDefinition* OpalRingDefinition::clone(const std::string& name) {
    return new OpalRingDefinition(name, this);
}

void OpalRingDefinition::print(std::ostream& out) const {
    OpalElement::print(out);
}

OpalRingDefinition::OpalRingDefinition(const std::string& name, OpalRingDefinition* parent):
    OpalElement(name, parent) {
    setElement(new Ring(name));
}

OpalRingDefinition::~OpalRingDefinition() {}

void OpalRingDefinition::update() {
    Ring* ring = dynamic_cast<Ring*>(getElement());

    ring->setBeamPhiInit(Attributes::getReal(itsAttr[BEAM_PHIINIT]) * Units::deg2rad);
    ring->setBeamThetaInit(Attributes::getReal(itsAttr[BEAM_THETAINIT]) * Units::deg2rad);
    ring->setBeamPRInit(Attributes::getReal(itsAttr[BEAM_PRINIT]));
    ring->setBeamRInit(Attributes::getReal(itsAttr[BEAM_RINIT]));
    ring->setLatticeRInit(Attributes::getReal(itsAttr[LAT_RINIT]));
    ring->setLatticePhiInit(Attributes::getReal(itsAttr[LAT_PHIINIT]) * Units::deg2rad);
    ring->setLatticeThetaInit(Attributes::getReal(itsAttr[LAT_THETAINIT]) * Units::deg2rad);

    ring->setSymmetry(Attributes::getReal(itsAttr[SYMMETRY]));
    ring->setScale(Attributes::getReal(itsAttr[SCALE]));

    ring->setHarmonicNumber(Attributes::getReal(itsAttr[HARMONIC_NUMBER]));
    ring->setRFFreq(Attributes::getReal(itsAttr[RFFREQ]));
    ring->setIsClosed(Attributes::getBool(itsAttr[IS_CLOSED]));

    if (itsAttr[MIN_R] && itsAttr[MAX_R]) {
        double minR = Attributes::getReal(itsAttr[MIN_R]);
        double maxR = Attributes::getReal(itsAttr[MAX_R]);
        ring->setRingAperture(minR, maxR);
    } else if (itsAttr[MIN_R] && !itsAttr[MAX_R]) {
        throw OpalException("OpalRingDefinition::update",
                            "If MIN_R is defined, MAX_R must also be defined.");
    } else if (!itsAttr[MIN_R] && itsAttr[MAX_R]) {
        throw OpalException("OpalRingDefinition::update",
                            "If MAX_R is defined, MIN_R must also be defined.");
    }

    setElement(ring);
}