Astra1DElectroStatic_fast.cpp

Go to the documentation of this file.

#include "Fields/Astra1DElectroStatic_fast.h"
#include "Physics/Physics.h"
#include "Physics/Units.h"
#include "Utilities/GeneralClassicException.h"
#include "Utilities/Util.h"
 
#include <fstream>
#include <ios>
 
Astra1DElectroStatic_fast::Astra1DElectroStatic_fast(std::string aFilename)
    : Astra1D_fast(aFilename) {
    numHeaderLines_m = 2;
 
    onAxisField_m = nullptr;
 
    Type = TAstraElectroStatic;
 
    // open field map, parse it and disable element on error
    std::ifstream file(Filename_m.c_str());
    if (!file.good()) {
        noFieldmapWarning();
        zbegin_m = 0.0;
        zend_m   = -1e-3;
    }
 
    bool parsing_passed = readFileHeader(file);
    parsing_passed      = parsing_passed && determineNumSamplingPoints(file);
    file.close();
 
    if (!parsing_passed && !file.eof()) {
        disableFieldmapWarning();
        zend_m = zbegin_m - 1e-3;
        throw GeneralClassicException(
            "Astra1DElectroStatic_fast::Astra1DElectroStatic_fast",
            "An error occured when reading the fieldmap '" + Filename_m + "'");
    }
    hz_m     = (zend_m - zbegin_m) / (num_gridpz_m - 1);
    length_m = 2.0 * num_gridpz_m * hz_m;
}
 
Astra1DElectroStatic_fast::~Astra1DElectroStatic_fast() {
    freeMap();
}
 
void Astra1DElectroStatic_fast::readMap() {
    if (onAxisField_m == nullptr) {
        // declare variables and allocate memory
 
        onAxisField_m = new double[num_gridpz_m];
        zvals_m       = new double[num_gridpz_m];
 
        std::ifstream file(Filename_m.c_str());
        int accuracy = stripFileHeader(file);
        double maxEz = readFieldData(file);
        file.close();
 
        normalizeFieldData(maxEz * Units::Vpm2MVpm);
 
        std::vector<double> zvals             = getEvenlyDistributedSamplingPoints();
        std::vector<double> evenFieldSampling = interpolateFieldData(zvals);
        std::vector<double> fourierCoefs = computeFourierCoefficients(accuracy, evenFieldSampling);
 
        computeFieldDerivatives(fourierCoefs, accuracy);
 
        checkMap(
            accuracy, length_m, zvals, fourierCoefs, onAxisInterpolants_m[0], onAxisAccel_m[0]);
 
        *ippl::Info << level3 << typeset_msg("read in fieldmap '" + Filename_m + "'", "info")
                    << endl;
    }
}
 
bool Astra1DElectroStatic_fast::getFieldstrength(
    const Vector_t<double, 3>& R, Vector_t<double, 3>& E, Vector_t<double, 3>& /*B*/) const {
    // do fourier interpolation in z-direction
    const double RR2 = R(0) * R(0) + R(1) * R(1);
 
    double ez    = gsl_spline_eval(onAxisInterpolants_m[0], R(2) - zbegin_m, onAxisAccel_m[0]);
    double ezp   = gsl_spline_eval(onAxisInterpolants_m[1], R(2) - zbegin_m, onAxisAccel_m[1]);
    double ezpp  = gsl_spline_eval(onAxisInterpolants_m[2], R(2) - zbegin_m, onAxisAccel_m[2]);
    double ezppp = gsl_spline_eval(onAxisInterpolants_m[3], R(2) - zbegin_m, onAxisAccel_m[3]);
 
    // expand to off-axis
    const double EfieldR = -ezp / 2. + ezppp / 16. * RR2;
 
    E(0) += EfieldR * R(0);
    E(1) += EfieldR * R(1);
    E(2) += ez - ezpp * RR2 / 4.;
    return false;
}
 
bool Astra1DElectroStatic_fast::getFieldDerivative(
    const Vector_t<double, 3>& /*R*/, Vector_t<double, 3>& /*E*/, Vector_t<double, 3>& /*B*/,
    const DiffDirection& /*dir*/) const {
    return false;
}
 
void Astra1DElectroStatic_fast::getFieldDimensions(double& zBegin, double& zEnd) const {
    zBegin = zbegin_m;
    zEnd   = zend_m;
}
void Astra1DElectroStatic_fast::getFieldDimensions(
    double& /*xIni*/, double& /*xFinal*/, double& /*yIni*/, double& /*yFinal*/, double& /*zIni*/,
    double& /*zFinal*/) const {
}
 
void Astra1DElectroStatic_fast::swap() {
}
 
void Astra1DElectroStatic_fast::getInfo(Inform* msg) {
    (*msg) << Filename_m << " (1D electrostatic); zini= " << zbegin_m << " m; zfinal= " << zend_m
           << " m;" << endl;
}
 
double Astra1DElectroStatic_fast::getFrequency() const {
    return 0.0;
}
 
void Astra1DElectroStatic_fast::setFrequency(double /*freq*/) {
}
 
bool Astra1DElectroStatic_fast::readFileHeader(std::ifstream& file) {
    std::string tmpString;
    int tmpInt;
 
    bool passed;
    try {
        passed = interpretLine<std::string, int>(file, tmpString, tmpInt);
    } catch (GeneralClassicException& e) {
        passed = interpretLine<std::string, int, std::string>(file, tmpString, tmpInt, tmpString);
 
        tmpString = Util::toUpper(tmpString);
        if (tmpString != "TRUE" && tmpString != "FALSE")
            throw GeneralClassicException(
                "Astra1DDynamic_fast::readFileHeader",
                "The third string on the first line of 1D field "
                "maps has to be either TRUE or FALSE");
 
        normalize_m = (tmpString == "TRUE");
    }
 
    return passed;
}
 
int Astra1DElectroStatic_fast::stripFileHeader(std::ifstream& file) {
    std::string tmpString;
    int accuracy;
 
    try {
        interpretLine<std::string, int>(file, tmpString, accuracy);
    } catch (GeneralClassicException& e) {
        interpretLine<std::string, int, std::string>(file, tmpString, accuracy, tmpString);
    }
 
    return accuracy;
}