StepSizeConfig.cpp

Go to the documentation of this file.

//
// Class StepSizeConfig
//
// This class stores tuples of time step sizes, path length range limits and limit of number of step sizes.
//
// Copyright (c) 2019 - 2021, Christof Metzger-Kraus
//
// 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/StepSizeConfig.h"
#include "Utilities/OpalException.h"

#include <algorithm>
#include <numeric>
#include <iterator>
#include <cmath>

void StepSizeConfig::sortAscendingZStop() {
    configurations_m.sort([] (const entry_t &a,
                              const entry_t &b) -> bool
                          {
                              return std::get<1>(a) < std::get<1>(b);
                          });
}

void StepSizeConfig::reverseDirection() {
    unsigned int posIterator = std::distance(it_m, configurations_m.end()) - 1;
    configurations_m.reverse();
    it_m = configurations_m.begin();
    std::advance(it_m, posIterator);
}

StepSizeConfig& StepSizeConfig::advanceToPos(double spos) {
    while (getZStop() < spos && std::next(it_m) != configurations_m.end()) {
        ++ it_m;
    }

    return *this;
}

StepSizeConfig& StepSizeConfig::operator++() {
    if (reachedEnd()) {
        throw OpalException("StepSizeConfig::operator++",
                            "iterator is at end of list of configurations");
    }

    ++ it_m;

    return *this;
}

StepSizeConfig& StepSizeConfig::operator--() {
    if (reachedStart()) {
        throw OpalException("StepSizeConfig::operator--",
                            "iterator is at begin of list of configurations");
    }

    -- it_m;

    return *this;
}

void StepSizeConfig::shiftZStopRight(double front) {
    auto it = configurations_m.begin();
    while (std::get<1>(*it) < front &&
           std::next(it) != configurations_m.end()) {
        ++ it;
    }

    double zstop = std::get<1>(*it);
    if (zstop < front) return;

    std::get<1>(*it) = front;
    for (++ it ;
         it != configurations_m.end();
         ++ it) {
        std::swap(zstop, std::get<1>(*it));
    }
}

void StepSizeConfig::shiftZStopLeft(double back) {
    auto it = configurations_m.rbegin();
    while (std::get<1>(*it) > back &&
           std::next(it) != configurations_m.rend()) {
        ++ it;
    }

    double zstop = std::get<1>(*it);
    if (zstop > back) return;

    std::get<1>(*it) = back;
    for (++ it ;
         it != configurations_m.rend();
         ++ it) {
        std::swap(zstop, std::get<1>(*it));
    }
}

double StepSizeConfig::getdT() const {
    if (reachedEnd()) {
        throw OpalException("StepSizeConfig::getdT",
                            "iterator is at end of list of configurations");
    }

    return std::get<0>(*it_m);
}

double StepSizeConfig::getZStop() const {
    if (reachedEnd()) {
        throw OpalException("StepSizeConfig::getZStop",
                            "iterator is at end of list of configurations");
    }

    return std::get<1>(*it_m);
}

unsigned long StepSizeConfig::getNumSteps() const {
    if (reachedEnd()) {
        throw OpalException("StepSizeConfig::getNumSteps",
                            "iterator is at end of list of configurations");
    }

    return std::get<2>(*it_m);
}

unsigned long long StepSizeConfig::getMaxSteps() const {
    unsigned long long maxSteps = 0;
    for (const auto& config: configurations_m) {
        maxSteps += std::get<2>(config);
    }

    return maxSteps;
}

unsigned long long StepSizeConfig::getNumStepsFinestResolution() const {
    double minTimeStep = std::get<0>(configurations_m.front());
    unsigned long long totalNumSteps = 0;

    for (const auto& config: configurations_m) {
        const double &dt = std::get<0>(config);
        const unsigned long &numSteps = std::get<2>(config);

        if (minTimeStep > dt) {
            totalNumSteps = std::ceil(totalNumSteps * minTimeStep / dt);
            minTimeStep = dt;
        }

        totalNumSteps += std::ceil(numSteps * dt / minTimeStep);
    }

    return totalNumSteps;
}

double StepSizeConfig::getMinTimeStep() const {
    double minTimeStep = std::get<0>(configurations_m.front());
    for (const auto& config: configurations_m) {
        if (minTimeStep > std::get<0>(config)) {
            minTimeStep = std::get<0>(config);
        }
    }

    return minTimeStep;
}

double StepSizeConfig::getFinalZStop() const {
    return std::get<1>(configurations_m.back());
}

void StepSizeConfig::print(Inform &out) const {
    out << std::scientific << "   "
        << std::setw(20) << "dt [ns] "
        << std::setw(20) << "zStop [m] "
        << std::setw(20) << "num Steps [1]"
        << endl;

    for (auto it = configurations_m.begin();
         it != configurations_m.end();
         ++ it) {
        if (it_m == it) {
            out << "-> ";
        } else {
            out << "   ";
        }

        out << std::setw(20) << std::get<0>(*it)
            << std::setw(20) << std::get<1>(*it)
            << std::setw(20) << std::get<2>(*it)
            << endl;
    }
}

ValueRange<double> StepSizeConfig::getPathLengthRange() const {
    ValueRange<double> result;
    for (const entry_t& entry : configurations_m) {
        result.enlargeIfOutside(std::get<1>(entry));
    }
    return result;
}