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 <cmath>
#include <iterator>
#include <numeric>
 
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));
    }
}
 
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()); }
 
Inform& 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;
    }
    return out;
}
 
void StepSizeConfig::printDirect(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;
}