OpalWake.cpp

Go to the documentation of this file.

//
// Class OpalWake
//   The class for the OPAL WAKE command.
//
// Copyright (c) 2008 - 2022, 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 "Structure/OpalWake.h"
 
#include "AbsBeamline/ElementBase.h"
#include "AbstractObjects/OpalData.h"
#include "Attributes/Attributes.h"
#include "Solvers/GreenWakeFunction.h"
#include "Solvers/CSRWakeFunction.h"
#include "Solvers/CSRIGFWakeFunction.h"
#include "Utilities/OpalException.h"
#include "Utilities/OpalFilter.h"
 
#include <unordered_map>
 
extern Inform *gmsg;
 
// The attributes of class OpalWake.
namespace {
    enum {
        TYPE,         // The type of the wake
        NBIN,         // Number of bins for the line density
        CONST_LENGTH, // True if the length of the Bunch is considered as constant
        CONDUCT,      // Conductivity, either AC or DC
        Z0,
        RADIUS,       // Radius of the tube
        SIGMA,
        TAU,
        FILTERS,      // List of filters to apply on line density
        FNAME,
        SIZE
    };
}
 
OpalWake::OpalWake():
    Definition(SIZE, "WAKE",
               "The \"WAKE\" statement defines data for the wakefuction "
               "on an element."),
    wf_m(0) {
    itsAttr[TYPE] = Attributes::makePredefinedString
        ("TYPE", "Specifies the wake function.",
         {"1D-CSR", "1D-CSR-IGF", "LONG-SHORT-RANGE", "TRANSV-SHORT-RANGE"});
 
    itsAttr[NBIN] = Attributes::makeReal
        ("NBIN", "Number of bins for the line density calculation");
 
    itsAttr[CONST_LENGTH] = Attributes::makeBool
        ("CONST_LENGTH", "True if the length of the Bunch is considered as constant");
 
    itsAttr[CONDUCT] = Attributes::makePredefinedString
        ("CONDUCT", "Conductivity.", {"DC", "AC"});
 
    itsAttr[Z0] = Attributes::makeReal
        ("Z0", "Impedance of the beam pipe ");
 
    itsAttr[RADIUS] = Attributes::makeReal
        ("RADIUS", "The radius of the beam pipe [m]");
 
    itsAttr[SIGMA] = Attributes::makeReal
        ("SIGMA", "Material constant dependant on the beam pipe material");
 
    itsAttr[TAU] = Attributes::makeReal
        ("TAU", "Material constant dependant on the beam pipe material");
 
    itsAttr[FILTERS] = Attributes::makeStringArray
        ("FILTERS", "List of filters to apply on line density");
 
    itsAttr[FNAME] = Attributes::makeString
        ("FNAME", "Filename of the wakefield file");
 
    OpalWake* defWake = clone("UNNAMED_WAKE");
    defWake->builtin = true;
 
    try {
        defWake->update();
        OpalData::getInstance()->define(defWake);
    } catch(...) {
        delete defWake;
    }
 
    registerOwnership(AttributeHandler::STATEMENT);
}
 
 
OpalWake::OpalWake(const std::string& name, OpalWake* parent):
    Definition(name, parent),
    wf_m(parent->wf_m)
{}
 
 
OpalWake::~OpalWake() {
    delete wf_m;
}
 
 
bool OpalWake::canReplaceBy(Object* object) {
    // Can replace only by another WAKE.
    return dynamic_cast<OpalWake*>(object) != 0;
}
 
 
OpalWake* OpalWake::clone(const std::string& name) {
    return new OpalWake(name, this);
}
 
 
void OpalWake::execute() {
    update();
}
 
 
OpalWake* OpalWake::find(const std::string& name) {
    OpalWake* wake = dynamic_cast<OpalWake*>(OpalData::getInstance()->find(name));
    if (wake == 0) {
        throw OpalException("OpalWake::find()", "Wake \"" + name + "\" not found.");
    }
    return wake;
}
 
 
int OpalWake::getNumberOfBins() {
    return (int)Attributes::getReal(itsAttr[NBIN]);
}
 
 
void OpalWake::update() {
    // Set default name.
    if (getOpalName().empty()) setOpalName("UNNAMED_WAKE");
}
 
 
void OpalWake::initWakefunction(const ElementBase& element) {
    *gmsg << "* ************* W A K E ************************************************************\n";
    *gmsg << "OpalWake::initWakefunction ";
    *gmsg << "for element " << element.getName() << "\n";
    *gmsg << "* **********************************************************************************" << endl;
 
    std::vector<std::string> filters_str = Attributes::getStringArray(itsAttr[FILTERS]);
    std::vector<Filter*> filters;
 
    for (std::vector<std::string>::const_iterator fit = filters_str.begin(); fit != filters_str.end(); ++fit) {
        OpalFilter *f = OpalFilter::find(*fit);
        if (f) {
            f->initOpalFilter();
            filters.push_back(f->filter_m);
        }
    }
 
    static const std::unordered_map<std::string, OpalWakeType> stringOpalWakeType_s = {
        {"1D-CSR",             OpalWakeType::CSR},
        {"1D-CSR-IGF",         OpalWakeType::CSRIGF},
        {"LONG-SHORT-RANGE",   OpalWakeType::LONGSHORTRANGE},
        {"TRANSV-SHORT-RANGE", OpalWakeType::TRANSVSHORTRANGE}
    };
 
    if (!itsAttr[TYPE]) {
        throw OpalException("TrackRun::execute",
                            "The attribute \"TYPE\" isn't set for the \"WAKE\" statement");
    }
    OpalWakeType type = stringOpalWakeType_s.at(Attributes::getString(itsAttr[TYPE]));
    switch (type) {
        case OpalWakeType::CSR: {
            if (filters.size() == 0 && Attributes::getReal(itsAttr[NBIN]) <= 7) {
                throw OpalException("OpalWake::initWakeFunction",
                                    "At least 8 bins have to be used, ideally far more");
            }
 
            wf_m = new CSRWakeFunction(getOpalName(), filters,
                                       (int)(Attributes::getReal(itsAttr[NBIN])));
            break;
        }
        case OpalWakeType::CSRIGF: {
            if (filters.size() == 0 && Attributes::getReal(itsAttr[NBIN]) <= 7) {
                throw OpalException("OpalWake::initWakeFunction",
                                    "At least 8 bins have to be used, ideally far more");
            }
 
            wf_m = new CSRIGFWakeFunction(getOpalName(), filters,
                                          (int)(Attributes::getReal(itsAttr[NBIN])));
            break;
        }
        case OpalWakeType::LONGSHORTRANGE: {
            int acMode = Attributes::getString(itsAttr[CONDUCT]) == "DC"? 2: 1;
 
            wf_m = new GreenWakeFunction(getOpalName(), filters,
                                         (int)(Attributes::getReal(itsAttr[NBIN])),
                                         Attributes::getReal(itsAttr[Z0]),
                                         Attributes::getReal(itsAttr[RADIUS]),
                                         Attributes::getReal(itsAttr[SIGMA]),
                                         acMode,
                                         Attributes::getReal(itsAttr[TAU]),
                                         WakeDirection::LONGITUDINAL,
                                         Attributes::getBool(itsAttr[CONST_LENGTH]),
                                         Attributes::getString(itsAttr[FNAME]));
            break;
        }
        case OpalWakeType::TRANSVSHORTRANGE: {
            int acMode = Attributes::getString(itsAttr[CONDUCT]) == "DC" ? 2: 1;
 
            wf_m = new GreenWakeFunction(getOpalName(), filters,
                                         (int)(Attributes::getReal(itsAttr[NBIN])),
                                         Attributes::getReal(itsAttr[Z0]),
                                         Attributes::getReal(itsAttr[RADIUS]),
                                         Attributes::getReal(itsAttr[SIGMA]),
                                         acMode,
                                         Attributes::getReal(itsAttr[TAU]),
                                         WakeDirection::TRANSVERSAL,
                                         Attributes::getBool(itsAttr[CONST_LENGTH]),
                                         Attributes::getString(itsAttr[FNAME]));
           break;
        }
        default: {
            throw OpalException("OpalWake::initWakefunction",
                                "Invalid \"TYPE\" of \"WAKE\" statement");
        }
    }
}
 
void OpalWake::print(std::ostream& os) const {
    os << "* ************* W A K E ************************************************************ " << std::endl;
    os << "* WAKE         " << getOpalName() << '\n'
       << "* BINS         " << Attributes::getReal(itsAttr[NBIN]) << '\n'
       << "* CONST_LENGTH " << Attributes::getReal(itsAttr[CONST_LENGTH]) << '\n'
       << "* CONDUCT      " << Attributes::getReal(itsAttr[CONDUCT]) << '\n'
       << "* Z0           " << Attributes::getReal(itsAttr[Z0]) << '\n'
       << "* RADIUS       " << Attributes::getReal(itsAttr[RADIUS]) << '\n'
       << "* SIGMA        " << Attributes::getReal(itsAttr[SIGMA]) << '\n'
       << "* TAU          " << Attributes::getReal(itsAttr[TAU]) << '\n';
    os << "* ********************************************************************************** " << std::endl;
}