NMRRWSims/cpp
1
0
Fork 0
Code Issues 3 Pull Requests Actions Packages Projects Releases Wiki Activity

add namespaces and cmakelists for sub-dirs

Browse Source
This commit is contained in:
Dominik Demuth 2024-12-13 14:03:33 +01:00
parent e90c4c9543
commit e6331749b2
32 changed files with 604 additions and 440 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
src/CMakeLists.txt
View File

@ -1,35 +1,17 @@
cmake_minimum_required(VERSION 3.18)
set(CMAKE_CXX_STANDARD 17) add_subdirectory(times)
add_subdirectory(motions)
add_subdirectory(utils)
add_library(simulation STATIC sims.cpp sims.h)
target_link_libraries(simulation PRIVATE utils)
add_executable(rwsim main.cpp add_executable(
utils/functions.h rwsim
utils/functions.cpp main.cpp
utils/io.cpp
utils/io.h
motions/base.cpp
motions/base.h
motions/random.cpp
motions/random.h
times/base.cpp
times/base.h
times/delta.cpp
times/delta.h
simulation/sims.cpp
simulation/sims.h
utils/ranges.cpp
utils/ranges.h
motions/tetrahedral.cpp
motions/tetrahedral.h
motions/isosmallangle.cpp
motions/isosmallangle.h
motions/coordinates.cpp
motions/coordinates.h
motions/bimodalangle.cpp
motions/bimodalangle.h
times/lognormal.cpp
times/lognormal.h
) )
target_link_libraries(rwsim PUBLIC RWMotion RWTime utils simulation)
target_compile_options(rwsim PUBLIC -Werror -Wall -Wextra -Wconversion -O2) target_compile_options(rwsim PUBLIC -Werror -Wall -Wextra -Wconversion -O2)

7
src/main.cpp
View File

@ -1,10 +1,9 @@
#include "sims.h"
#include "utils/io.h" #include "utils/io.h"
#include "simulation/sims.h"
#include "motions/base.h" #include "motions/base.h"
#include "times/base.h" #include "times/base.h"
#include <iostream> #include <iostream>
#include <unordered_map> #include <unordered_map>
#include <random> #include <random>
@ -37,8 +36,8 @@ int main (const int argc, char *argv[]) {
std::random_device rd; std::random_device rd;
std::mt19937_64 rng(rd()); std::mt19937_64 rng(rd());
Motion *motion = Motion::createFromInput(args.motion_type, rng); motions::BaseMotion *motion = motions::BaseMotion::createFromInput(args.motion_type, rng);
Distribution *dist = Distribution::createFromInput(args.distribution_type, rng); times::BaseDistribution *dist = times::BaseDistribution::createFromInput(args.distribution_type, rng);
if (args.spectrum) { if (args.spectrum) {
run_spectrum(parameter, args.optional, *motion, *dist); run_spectrum(parameter, args.optional, *motion, *dist);
} }

23
src/motions/CMakeLists.txt Normal file
View File

@ -0,0 +1,23 @@
# Create a library target for motions
add_library(
RWMotion STATIC
conewobble.cpp
conewobble.h
coordinates.cpp
coordinates.h
base.cpp
base.h
random.cpp
random.h
isosmallangle.cpp
isosmallangle.h
foursitejump.cpp
foursitejump.h
rjoac.cpp
rjoac.h
bimodalangle.cpp
bimodalangle.h
sixsitejump.cpp
sixsitejump.h
)

98
src/motions/base.cpp
View File

@ -4,68 +4,74 @@
#include "bimodalangle.h" #include "bimodalangle.h"
#include "isosmallangle.h" #include "isosmallangle.h"
#include "random.h" #include "random.h"
#include "tetrahedral.h" #include "foursitejump.h"
#include <stdexcept> #include <stdexcept>
#include <map>
Motion::Motion(std::string name, const double delta, const double eta, std::mt19937_64& rng) : m_name(std::move(name)), m_delta(delta), m_eta(eta), m_rng(rng) { #include "sixsitejump.h"
m_uni_dist = std::uniform_real_distribution(0., 1.);
}
Motion::Motion(std::string name, std::mt19937_64& rng) : m_name(std::move(name)), m_rng(rng) { namespace motions {
m_uni_dist = std::uniform_real_distribution(0., 1.); BaseMotion::BaseMotion(std::string name, const double delta, const double eta, std::mt19937_64& rng) : m_name(std::move(name)), m_delta(delta), m_eta(eta), m_rng(rng) {
} m_uni_dist = std::uniform_real_distribution(0., 1.);
}
double Motion::omega_q(const double cos_theta, const double phi) const { BaseMotion::BaseMotion(std::string name, std::mt19937_64& rng) : m_name(std::move(name)), m_rng(rng) {
const double cos_theta_square = cos_theta * cos_theta; m_uni_dist = std::uniform_real_distribution(0., 1.);
const double sin_theta_square = 1. - cos_theta_square; }
return M_PI * m_delta * (3. * cos_theta_square - 1. - m_eta * sin_theta_square * std::cos(2.*phi)); double BaseMotion::omega_q(const double cos_theta, const double phi) const {
} const double cos_theta_square = cos_theta * cos_theta;
const double sin_theta_square = 1. - cos_theta_square;
double Motion::omega_q(const SphericalPos& pos) const { return M_PI * m_delta * (3. * cos_theta_square - 1. - m_eta * sin_theta_square * std::cos(2.*phi));
auto [cos_theta, phi] = pos; }
return omega_q(cos_theta, phi); double BaseMotion::omega_q(const coordinates::SphericalPos& pos) const {
} auto [cos_theta, phi] = pos;
SphericalPos Motion::draw_position() { return omega_q(cos_theta, phi);
const double cos_theta = 1 - 2 * m_uni_dist(m_rng); }
const double phi = 2.0 * M_PI * m_uni_dist(m_rng);
return {cos_theta, phi}; coordinates::SphericalPos BaseMotion::draw_position() {
} const double cos_theta = 1 - 2 * m_uni_dist(m_rng);
const double phi = 2.0 * M_PI * m_uni_dist(m_rng);
Motion* Motion::createFromInput(const std::string& input, std::mt19937_64& rng) { return {cos_theta, phi};
if (input == "TetrahedralJump") }
return new TetrahedralJump(rng);
if (input == "IsotropicAngle") BaseMotion* BaseMotion::createFromInput(const std::string& input, std::mt19937_64& rng) {
return new SmallAngle(rng); if (input == "FourSiteTetrahedral")
return new FourSiteTetrahedron(rng);
if (input == "RandomJump") if (input == "SixSiteOctahedral")
return new RandomJump(rng); return new SixSiteOctahedron(rng);
if (input == "BimodalAngle") if (input == "IsotropicAngle")
return new BimodalAngle(rng); return new SmallAngle(rng);
throw std::invalid_argument("Invalid input " + input); if (input == "RandomJump")
} return new RandomJump(rng);
void Motion::setParameters(const std::unordered_map<std::string, double> &parameters) { if (input == "BimodalAngle")
m_delta = parameters.at("delta"); return new BimodalAngle(rng);
m_eta = parameters.at("eta");
}
std::unordered_map<std::string, double> Motion::getParameters() const { throw std::invalid_argument("Invalid input " + input);
return std::unordered_map<std::string, double>{ }
{"delta", m_delta},
{"eta", m_eta}
};
}
std::ostream& operator<<(std::ostream& os, const Motion& m) { void BaseMotion::setParameters(const std::unordered_map<std::string, double> &parameters) {
os << m.getName(); m_delta = parameters.at("delta");
return os; m_eta = parameters.at("eta");
}
std::unordered_map<std::string, double> BaseMotion::getParameters() const {
return std::unordered_map<std::string, double>{
{"delta", m_delta},
{"eta", m_eta}
};
}
std::ostream& operator<<(std::ostream& os, const BaseMotion& m) {
os << m.getName();
return os;
}
} }

61
src/motions/base.h
View File

@ -6,42 +6,43 @@
#include <random> #include <random>
#include <unordered_map> #include <unordered_map>
class Motion { namespace motions {
public: class BaseMotion {
virtual ~Motion() = default; public:
virtual ~BaseMotion() = default;
Motion(std::string, double, double, std::mt19937_64&); BaseMotion(std::string, double, double, std::mt19937_64&);
explicit Motion(std::string, std::mt19937_64&); explicit BaseMotion(std::string, std::mt19937_64&);
SphericalPos draw_position(); coordinates::SphericalPos draw_position();
[[nodiscard]] double omega_q(double, double) const; [[nodiscard]] double omega_q(double, double) const;
[[nodiscard]] double omega_q(const SphericalPos&) const; [[nodiscard]] double omega_q(const coordinates::SphericalPos&) const;
virtual void initialize() = 0; virtual void initialize() = 0;
virtual double jump() = 0; virtual double jump() = 0;
virtual void setParameters(const std::unordered_map<std::string, double>&); virtual void setParameters(const std::unordered_map<std::string, double>&);
[[nodiscard]] virtual std::unordered_map<std::string, double> getParameters() const; [[nodiscard]] virtual std::unordered_map<std::string, double> getParameters() const;
[[nodiscard]] double getDelta() const { return m_delta; } [[nodiscard]] double getDelta() const { return m_delta; }
void setDelta(const double delta) { m_delta = delta; } void setDelta(const double delta) { m_delta = delta; }
[[nodiscard]] double getEta() const { return m_eta; } [[nodiscard]] double getEta() const { return m_eta; }
void setEta(const double eta) { m_eta = eta; } void setEta(const double eta) { m_eta = eta; }
[[nodiscard]] std::string getName() const { return m_name; } [[nodiscard]] std::string getName() const { return m_name; }
[[nodiscard]] double getInitOmega() const { return m_initial_omega; }; [[nodiscard]] double getInitOmega() const { return m_initial_omega; };
[[nodiscard]] virtual std::string toString() const = 0; [[nodiscard]] virtual std::string toString() const = 0;
static Motion* createFromInput(const std::string& input, std::mt19937_64& rng); static BaseMotion* createFromInput(const std::string& input, std::mt19937_64& rng);
protected: protected:
std::string m_name{"BaseMotion"}; std::string m_name{"BaseMotion"};
double m_delta{1.}; double m_delta{1.};
double m_eta{0.}; double m_eta{0.};
std::mt19937_64& m_rng; std::mt19937_64& m_rng;
std::uniform_real_distribution<> m_uni_dist; std::uniform_real_distribution<> m_uni_dist;
double m_initial_omega{0.}; double m_initial_omega{0.};
}; };
std::ostream& operator<<(std::ostream& os, const Motion& m);
std::ostream& operator<<(std::ostream& os, const BaseMotion& m);
}
#endif //RWSIM_MOTIONBASE_H #endif //RWSIM_MOTIONBASE_H

73
src/motions/bimodalangle.cpp
View File

@ -1,43 +1,46 @@
#include "bimodalangle.h" #include "bimodalangle.h"
#include "base.h" #include "base.h"
#include "coordinates.h"
BimodalAngle::BimodalAngle(const double delta, const double eta, const double angle1, const double angle2, const double prob, std::mt19937_64 &rng) : namespace motions {
Motion(std::string("BimodalAngle"), delta, eta, rng), BimodalAngle::BimodalAngle(const double delta, const double eta, const double angle1, const double angle2, const double prob, std::mt19937_64 &rng) :
m_angle1(angle1 * M_PI / 180.0), BaseMotion(std::string("BimodalAngle"), delta, eta, rng),
m_angle2(angle2 * M_PI / 180.0), m_angle1(angle1 * M_PI / 180.0),
m_prob(prob) {}; m_angle2(angle2 * M_PI / 180.0),
BimodalAngle::BimodalAngle(std::mt19937_64 &rng) : Motion(std::string("BimodalAngle"), rng) {} m_prob(prob) {};
BimodalAngle::BimodalAngle(std::mt19937_64 &rng) : BaseMotion(std::string("BimodalAngle"), rng) {}
void BimodalAngle::initialize() { void BimodalAngle::initialize() {
m_prev_pos = draw_position(); m_prev_pos = draw_position();
m_initial_omega = omega_q(m_prev_pos); m_initial_omega = omega_q(m_prev_pos);
}; };
double BimodalAngle::jump() { double BimodalAngle::jump() {
const double angle = m_uni_dist(m_rng) < m_prob ? m_angle1 : m_angle2; const double angle = m_uni_dist(m_rng) < m_prob ? m_angle1 : m_angle2;
const double gamma{2 * M_PI * m_uni_dist(m_rng)}; const double gamma{2 * M_PI * m_uni_dist(m_rng)};
m_prev_pos = rotate(m_prev_pos, angle, gamma); m_prev_pos = coordinates::rotate(m_prev_pos, angle, gamma);
return omega_q(m_prev_pos); return omega_q(m_prev_pos);
} }
void BimodalAngle::setParameters(const std::unordered_map<std::string, double> &parameter) { void BimodalAngle::setParameters(const std::unordered_map<std::string, double> &parameter) {
Motion::setParameters(parameter); BaseMotion::setParameters(parameter);
m_angle1 = parameter.at("angle1") * M_PI / 180.; m_angle1 = parameter.at("angle1") * M_PI / 180.;
m_angle2 = parameter.at("angle2") * M_PI / 180.; m_angle2 = parameter.at("angle2") * M_PI / 180.;
m_prob = parameter.at("probability1"); m_prob = parameter.at("probability1");
} }
std::unordered_map<std::string, double> BimodalAngle::getParameters() const { std::unordered_map<std::string, double> BimodalAngle::getParameters() const {
auto parameter = Motion::getParameters(); auto parameter = BaseMotion::getParameters();
parameter["angle1"] = m_angle1 * 180 / M_PI; parameter["angle1"] = m_angle1 * 180 / M_PI;
parameter["angle2"] = m_angle2 * 180 / M_PI; parameter["angle2"] = m_angle2 * 180 / M_PI;
parameter["probality1"] = m_prob; parameter["probality1"] = m_prob;
return parameter; return parameter;
} }
std::string BimodalAngle::toString() const { std::string BimodalAngle::toString() const {
return std::string{"BimodalAngle/angle1=" + std::to_string(m_angle1 * 180 / M_PI) + "/angle2=" + std::to_string(m_angle2 * 180 / M_PI) + "/probability1=" + std::to_string(m_prob)}; return std::string{"BimodalAngle/angle1=" + std::to_string(m_angle1 * 180 / M_PI) + "/angle2=" + std::to_string(m_angle2 * 180 / M_PI) + "/probability1=" + std::to_string(m_prob)};
}
} }

34
src/motions/bimodalangle.h
View File

@ -3,23 +3,25 @@
#define BIMODALANGLE_H #define BIMODALANGLE_H
#include "base.h" #include "base.h"
#include "coordinates.h"
class BimodalAngle : public Motion { namespace motions {
public: class BimodalAngle : public BaseMotion {
BimodalAngle(double, double, double, double, double, std::mt19937_64& ); public:
explicit BimodalAngle(std::mt19937_64&); BimodalAngle(double, double, double, double, double, std::mt19937_64& );
explicit BimodalAngle(std::mt19937_64&);
void initialize() override; void initialize() override;
double jump() override; double jump() override;
void setParameters(const std::unordered_map<std::string, double> &) override; void setParameters(const std::unordered_map<std::string, double> &) override;
[[nodiscard]] std::unordered_map<std::string, double> getParameters() const override; [[nodiscard]] std::unordered_map<std::string, double> getParameters() const override;
[[nodiscard]] std::string toString() const override; [[nodiscard]] std::string toString() const override;
protected:
double m_angle1{0};
double m_angle2{0};
double m_prob{0};
SphericalPos m_prev_pos{0., 0.};
};
protected:
double m_angle1{0};
double m_angle2{0};
double m_prob{0};
coordinates::SphericalPos m_prev_pos{0., 0.};
};
}
#endif //BIMODALANGLE_H #endif //BIMODALANGLE_H

58
src/motions/coordinates.cpp
View File

@ -3,37 +3,39 @@
#include <cmath> #include <cmath>
#include <iostream> #include <iostream>
SphericalPos rotate(const SphericalPos& old_pos, const double alpha, const double beta) { namespace coordinates {
const double sin_alpha{std::sin(alpha)}; SphericalPos rotate(const SphericalPos& old_pos, const double alpha, const double beta) {
const double cos_alpha{std::cos(alpha)}; const double sin_alpha{std::sin(alpha)};
const double cos_alpha{std::cos(alpha)};
const double sin_beta{std::sin(beta)}; const double sin_beta{std::sin(beta)};
const double cos_beta{std::cos(beta)}; const double cos_beta{std::cos(beta)};
const double cos_theta{old_pos.cos_theta}; const double cos_theta{old_pos.cos_theta};
if (std::abs(cos_theta) == 1) { if (std::abs(cos_theta) == 1) {
return xyz_to_spherical(CartesianPos{cos_alpha * cos_beta, cos_alpha * sin_beta, cos_alpha * cos_theta}); return xyz_to_spherical(CartesianPos{cos_alpha * cos_beta, cos_alpha * sin_beta, cos_alpha * cos_theta});
}
const double norm{std::sqrt(1 - cos_theta * cos_theta) + 1e-15};
auto [x, y , z] = spherical_to_xyz(old_pos);
const auto new_pos = CartesianPos{
cos_alpha * x + sin_alpha * (-x * z * sin_beta - y * cos_beta) / norm,
cos_alpha * y + sin_alpha * (-y * z * sin_beta + x * cos_beta) / norm,
cos_alpha * z + sin_alpha * norm * sin_beta
};
return xyz_to_spherical(new_pos);
} }
const double norm{std::sqrt(1 - cos_theta * cos_theta) + 1e-15}; CartesianPos spherical_to_xyz(const SphericalPos& pos) {
const double sin_theta = std::sin(std::acos(pos.cos_theta));
return {sin_theta * std::cos(pos.phi), sin_theta * std::sin(pos.phi), pos.cos_theta};
}
auto [x, y , z] = spherical_to_xyz(old_pos); SphericalPos xyz_to_spherical(const CartesianPos& pos) {
return {pos.z, std::atan2(pos.y, pos.x)};
const auto new_pos = CartesianPos{ }
cos_alpha * x + sin_alpha * (-x * z * sin_beta - y * cos_beta) / norm, }
cos_alpha * y + sin_alpha * (-y * z * sin_beta + x * cos_beta) / norm,
cos_alpha * z + sin_alpha * norm * sin_beta
};
return xyz_to_spherical(new_pos);
}
CartesianPos spherical_to_xyz(const SphericalPos& pos) {
const double sin_theta = std::sin(std::acos(pos.cos_theta));
return {sin_theta * std::cos(pos.phi), sin_theta * std::sin(pos.phi), pos.cos_theta};
}
SphericalPos xyz_to_spherical(const CartesianPos& pos) {
return {pos.z, std::atan2(pos.y, pos.x)};
}

26
src/motions/coordinates.h
View File

@ -2,19 +2,21 @@
#ifndef COORDINATES_H #ifndef COORDINATES_H
#define COORDINATES_H #define COORDINATES_H
struct SphericalPos { namespace coordinates {
double cos_theta; struct SphericalPos {
double phi; double cos_theta;
}; double phi;
};
struct CartesianPos { struct CartesianPos {
double x; double x;
double y; double y;
double z; double z;
}; };
SphericalPos rotate(const SphericalPos&, double, double); SphericalPos rotate(const SphericalPos&, double, double);
CartesianPos spherical_to_xyz(const SphericalPos&); CartesianPos spherical_to_xyz(const SphericalPos&);
SphericalPos xyz_to_spherical(const CartesianPos&); SphericalPos xyz_to_spherical(const CartesianPos&);
}
#endif //COORDINATES_H #endif //COORDINATES_H

35
src/motions/foursitejump.cpp Normal file
View File

@ -0,0 +1,35 @@
#include "foursitejump.h"
#include "coordinates.h"
#include <random>
namespace motions {
FourSiteTetrahedron::FourSiteTetrahedron(const double delta, const double eta, std::mt19937_64& rng) :
BaseMotion(std::string{"FourSiteTetrahedral"}, delta, eta, rng) {}
FourSiteTetrahedron::FourSiteTetrahedron(std::mt19937_64& rng) : BaseMotion(std::string{"FourSiteTetrahedral"}, rng) {}
void FourSiteTetrahedron::initialize() {
const auto pos = draw_position();
m_corners[0] = omega_q(pos);
const double alpha = 2. * M_PI * m_uni_dist(m_rng);
for (int i = 1; i<4; i++) {
auto corner_pos = coordinates::rotate(pos, m_beta, alpha + (i-1) * 2*M_PI/3.);
m_corners[i] = omega_q(corner_pos);
}
m_initial_omega = FourSiteTetrahedron::jump();
}
double FourSiteTetrahedron::jump() {
m_corner_idx += m_chooser(m_rng);
m_corner_idx %= 4;
return m_corners[m_corner_idx];
}
std::string FourSiteTetrahedron::toString() const {
return {"FourSiteTetrahedral"};
}
}

31
src/motions/foursitejump.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef RWSIM_MOTIONTETRAHEDRAL_H
#define RWSIM_MOTIONTETRAHEDRAL_H
#include "base.h"
#include <random>
#include <cmath>
#include <array>
namespace motions {
class FourSiteTetrahedron final : public BaseMotion {
public:
FourSiteTetrahedron(double, double, std::mt19937_64&);
explicit FourSiteTetrahedron(std::mt19937_64&);
void initialize() override;
double jump() override;
[[nodiscard]] std::string toString() const override;
private:
const double m_beta{std::acos(-1/3.)};
std::array<double, 4> m_corners{};
int m_corner_idx{0};
std::uniform_int_distribution<> m_chooser{1, 3};
};
}
#endif //RWSIM_MOTIONTETRAHEDRAL_H

53
src/motions/isosmallangle.cpp
View File

@ -4,34 +4,35 @@
#include <iostream> #include <iostream>
namespace motions {
SmallAngle::SmallAngle(const double delta, const double eta, const double chi, std::mt19937_64 &rng) :
BaseMotion(std::string("IsotropicAngle"), delta, eta, rng), m_chi(chi * M_PI / 180.0) {};
SmallAngle::SmallAngle(std::mt19937_64 &rng) : BaseMotion(std::string("IsotropicAngle"), rng) {}
SmallAngle::SmallAngle(const double delta, const double eta, const double chi, std::mt19937_64 &rng) : void SmallAngle::initialize() {
Motion(std::string("IsotropicAngle"), delta, eta, rng), m_chi(chi * M_PI / 180.0) {}; m_prev_pos = draw_position();
SmallAngle::SmallAngle(std::mt19937_64 &rng) : Motion(std::string("IsotropicAngle"), rng) {} m_initial_omega = omega_q(m_prev_pos);
};
void SmallAngle::initialize() { double SmallAngle::jump() {
m_prev_pos = draw_position(); const double gamma{2 * M_PI * m_uni_dist(m_rng)};
m_initial_omega = omega_q(m_prev_pos); m_prev_pos = coordinates::rotate(m_prev_pos, m_chi, gamma);
};
double SmallAngle::jump() { return omega_q(m_prev_pos);
const double gamma{2 * M_PI * m_uni_dist(m_rng)}; }
m_prev_pos = rotate(m_prev_pos, m_chi, gamma);
return omega_q(m_prev_pos); void SmallAngle::setParameters(const std::unordered_map<std::string, double> &parameters) {
} m_chi = parameters.at("angle") * M_PI / 180.0;
BaseMotion::setParameters(parameters);
void SmallAngle::setParameters(const std::unordered_map<std::string, double> &parameters) { }
m_chi = parameters.at("angle") * M_PI / 180.0;
Motion::setParameters(parameters); std::unordered_map<std::string, double> SmallAngle::getParameters() const {
} auto parameter = BaseMotion::getParameters();
parameter["angle"] = m_chi * 180 / M_PI;
std::unordered_map<std::string, double> SmallAngle::getParameters() const { return parameter;
auto parameter = Motion::getParameters(); }
parameter["angle"] = m_chi * 180 / M_PI;
return parameter; std::string SmallAngle::toString() const {
} return std::string{"IsotropicAngle/angle=" + std::to_string(m_chi * 180 / M_PI)};
}
std::string SmallAngle::toString() const {
return std::string{"IsotropicAngle/angle=" + std::to_string(m_chi * 180 / M_PI)};
} }

29
src/motions/isosmallangle.h
View File

@ -5,20 +5,21 @@
#include "base.h" #include "base.h"
#include "coordinates.h" #include "coordinates.h"
class SmallAngle final : public Motion { namespace motions {
public: class SmallAngle final : public BaseMotion {
SmallAngle(double, double, double, std::mt19937_64& ); public:
explicit SmallAngle(std::mt19937_64&); SmallAngle(double, double, double, std::mt19937_64& );
explicit SmallAngle(std::mt19937_64&);
void initialize() override; void initialize() override;
double jump() override; double jump() override;
void setParameters(const std::unordered_map<std::string, double> &) override; void setParameters(const std::unordered_map<std::string, double> &) override;
[[nodiscard]] std::unordered_map<std::string, double> getParameters() const override; [[nodiscard]] std::unordered_map<std::string, double> getParameters() const override;
[[nodiscard]] std::string toString() const override; [[nodiscard]] std::string toString() const override;
private:
double m_chi{0};
SphericalPos m_prev_pos{0., 0.};
};
private:
double m_chi{0};
coordinates::SphericalPos m_prev_pos{0., 0.};
};
}
#endif //RWSIM_MOTIONISOSMALLANGLE_H #endif //RWSIM_MOTIONISOSMALLANGLE_H

25
src/motions/random.cpp
View File

@ -1,19 +1,20 @@
#include "random.h" #include "random.h"
namespace motions {
RandomJump::RandomJump(const double delta, const double eta, std::mt19937_64 &rng) : BaseMotion(std::string("RandomJump"), delta, eta, rng) {}
RandomJump::RandomJump(const double delta, const double eta, std::mt19937_64 &rng) : Motion(std::string("RandomJump"), delta, eta, rng) {} RandomJump::RandomJump(std::mt19937_64 &rng) : BaseMotion(std::string("RandomJump"), rng) {}
RandomJump::RandomJump(std::mt19937_64 &rng) : Motion(std::string("RandomJump"), rng) {} std::string RandomJump::toString() const {
return {"RandomJump"};
}
std::string RandomJump::toString() const { void RandomJump::initialize() {
return {"RandomJump"}; m_initial_omega = RandomJump::jump();
} }
void RandomJump::initialize() { double RandomJump::jump() {
m_initial_omega = RandomJump::jump(); return omega_q(draw_position());
} }
double RandomJump::jump() {
return omega_q(draw_position());
} }

18
src/motions/random.h
View File

@ -5,15 +5,17 @@
#include "base.h" #include "base.h"
#include <random> #include <random>
class RandomJump final : public Motion { namespace motions {
public: class RandomJump final : public BaseMotion {
RandomJump(double, double, std::mt19937_64&); public:
explicit RandomJump(std::mt19937_64&); RandomJump(double, double, std::mt19937_64&);
explicit RandomJump(std::mt19937_64&);
[[nodiscard]] std::string toString() const override; [[nodiscard]] std::string toString() const override;
void initialize() override; void initialize() override;
double jump() override; double jump() override;
}; };
}
#endif //RWSIM_MOTIONRANDOMJUMP_H #endif //RWSIM_MOTIONRANDOMJUMP_H

32
src/motions/rjoac.cpp Normal file
View File

@ -0,0 +1,32 @@
#include "rjoac.h"
namespace motions {
RandomJumpOnCone::RandomJumpOnCone(const double delta, const double eta, const double chi, std::mt19937_64 &rng) : BaseMotion("RJ on a Cone", delta, eta, rng), m_angle(chi) {}
RandomJumpOnCone::RandomJumpOnCone(std::mt19937_64 &rng) : BaseMotion("RJ on a Cone", rng) {}
void RandomJumpOnCone::initialize() {
m_axis = draw_position();
}
double RandomJumpOnCone::jump() {
const double phi = 2 * M_PI * m_uni_dist(m_rng);
return omega_q(coordinates::rotate(m_axis, m_angle, phi));
}
void RandomJumpOnCone::setParameters(const std::unordered_map<std::string, double> &parameters) {
BaseMotion::setParameters(parameters);
m_angle = parameters.at("angle");
}
std::unordered_map<std::string, double> RandomJumpOnCone::getParameters() const {
auto parameter = BaseMotion::getParameters();
parameter["angle"] = m_angle;
return parameter;
}
std::string RandomJumpOnCone::toString() const {
return std::string("RandomJumpOnCone/angle=") + std::to_string(m_angle);
}
}

31
src/motions/rjoac.h Normal file
View File

@ -0,0 +1,31 @@
#ifndef RJOAC_H
#define RJOAC_H
#include "base.h"
#include "coordinates.h"
#include <random>
namespace motions {
class RandomJumpOnCone: public BaseMotion {
public:
RandomJumpOnCone(double, double, double, std::mt19937_64&);
explicit RandomJumpOnCone(std::mt19937_64&);
void initialize() override;
double jump() override;
void setParameters(const std::unordered_map<std::string, double> &) override;
[[nodiscard]] std::unordered_map<std::string, double> getParameters() const override;
[[nodiscard]] std::string toString() const override;
private:
double m_angle{0};
coordinates::SphericalPos m_axis{1, 0};
};
}
#endif //RJOAC_H

34
src/motions/sixsitejump.cpp Normal file
View File

@ -0,0 +1,34 @@
#include "sixsitejump.h"
#include "coordinates.h"
namespace motions {
SixSiteOctahedron::SixSiteOctahedron(const double delta, const double eta, std::mt19937_64& rng) :
BaseMotion(std::string{"SixSiteOctahedral"}, delta, eta, rng) {}
SixSiteOctahedron::SixSiteOctahedron(std::mt19937_64& rng) : BaseMotion(std::string{"SixSiteOctahedral"}, rng) {}
void SixSiteOctahedron::initialize() {
const auto pos = draw_position();
m_corners[0] = omega_q(pos);
m_corners[1] = omega_q(rotate(pos, M_PI, 0));
const double alpha = 2. * M_PI * m_uni_dist(m_rng);
for (int i = 2; i<6; i++) {
auto corner_pos = coordinates::rotate(pos, M_PI_2, alpha + (i-2) * M_PI_2);
m_corners[i] = omega_q(corner_pos);
}
m_initial_omega = SixSiteOctahedron::jump();
}
double SixSiteOctahedron::jump() {
m_corner_idx += m_chooser(m_rng);
m_corner_idx %= 6;
return m_corners[m_corner_idx];
}
std::string SixSiteOctahedron::toString() const {
return {"SixSiteOctahedral"};
}
}

32
src/motions/sixsitejump.h Normal file
View File

@ -0,0 +1,32 @@
#ifndef SIXSITEJUMP_H
#define SIXSITEJUMP_H
#include "base.h"
#include <random>
#include <cmath>
#include <array>
namespace motions {
class SixSiteOctahedron final : public BaseMotion {
public:
SixSiteOctahedron(double, double, std::mt19937_64&);
explicit SixSiteOctahedron(std::mt19937_64&);
void initialize() override;
double jump() override;
[[nodiscard]] std::string toString() const override;
private:
const double m_beta{std::acos(-1/3.)};
std::array<double, 6> m_corners{};
int m_corner_idx{0};
std::uniform_int_distribution<> m_chooser{1, 5};
};
}
#endif //SIXSITEJUMP_H

34
src/motions/tetrahedral.cpp
View File

@ -1,34 +0,0 @@
#include "tetrahedral.h"
#include <random>
#include "tetrahedral.h"
TetrahedralJump::TetrahedralJump(const double delta, const double eta, std::mt19937_64& rng) :
Motion(std::string{"FourSiteTetrahedral"}, delta, eta, rng) {}
TetrahedralJump::TetrahedralJump(std::mt19937_64& rng) : Motion(std::string{"FourSiteTetrahedral"}, rng) {}
void TetrahedralJump::initialize() {
const auto pos = draw_position();
m_corners[0] = omega_q(pos);
const double alpha = 2. * M_PI * m_uni_dist(m_rng);
for (int i = 1; i<4; i++) {
auto corner_pos = rotate(pos, m_beta, alpha + (i-1) * 2*M_PI/3.);
m_corners[i] = omega_q(corner_pos);
}
m_initial_omega = TetrahedralJump::jump();
}
double TetrahedralJump::jump() {
m_corner_idx += m_chooser(m_rng);
m_corner_idx %= 4;
return m_corners[m_corner_idx];
}
std::string TetrahedralJump::toString() const {
return {"FourSiteTetrahedral"};
}

29
src/motions/tetrahedral.h
View File

@ -1,29 +0,0 @@
#ifndef RWSIM_MOTIONTETRAHEDRAL_H
#define RWSIM_MOTIONTETRAHEDRAL_H
#include "base.h"
#include <random>
#include <cmath>
#include <array>
class TetrahedralJump final : public Motion {
public:
TetrahedralJump(double, double, std::mt19937_64&);
explicit TetrahedralJump(std::mt19937_64&);
void initialize() override;
double jump() override;
[[nodiscard]] std::string toString() const override;
private:
const double m_beta{std::acos(-1/3.)};
std::array<double, 4> m_corners{};
int m_corner_idx{0};
std::uniform_int_distribution<> m_chooser{1, 3};
};
#endif //RWSIM_MOTIONTETRAHEDRAL_H

26
src/simulation/sims.cpp → src/sims.cpp
View File

@ -1,9 +1,8 @@
#include "sims.h" #include "simulation/sims.h"
#include "../motions/base.h" #include "times/base.h"
#include "../times/base.h" #include "utils/functions.h"
#include "../utils/functions.h" #include "utils/ranges.h"
#include "../utils/ranges.h" #include "utils/io.h"
#include "../utils/io.h"
#include <iostream> #include <iostream>
#include <algorithm> #include <algorithm>
@ -15,11 +14,12 @@
#include <chrono> #include <chrono>
void run_spectrum( void run_spectrum(
std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double>& parameter,
std::unordered_map<std::string, double> optional, std::unordered_map<std::string, double> optional,
Motion& motion, motions::BaseMotion& motion,
Distribution& dist times::BaseDistribution& dist
) { ) {
const int num_walker = static_cast<int>(parameter["num_walker"]); const int num_walker = static_cast<int>(parameter["num_walker"]);
@ -83,15 +83,15 @@ void run_spectrum(
void run_ste( void run_ste(
std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double>& parameter,
std::unordered_map<std::string, double> optional, std::unordered_map<std::string, double> optional,
Motion& motion, motions::BaseMotion& motion,
Distribution& dist times::BaseDistribution& dist
) { ) {
const int num_walker = static_cast<int>(parameter[std::string("num_walker")]); const int num_walker = static_cast<int>(parameter[std::string("num_walker")]);
const int num_mix_times = static_cast<int>(parameter["tmix_steps"]); const int num_mix_times = static_cast<int>(parameter["tmix_steps"]);
const std::vector<double> evolution_times = linspace(parameter["tevo_start"], parameter["tevo_stop"], static_cast<int>(parameter["tevo_steps"])); const std::vector<double> evolution_times = linspace(parameter["tevo_start"], parameter["tevo_stop"], static_cast<int>(parameter["tevo_steps"]));
const std::vector<double> mixing_times = logspace(parameter["tmix_start"], parameter["tmix_stop"], num_mix_times); const std::vector<double> mixing_times = logspace(parameter["tmix_start"], parameter["tmix_stop"], num_mix_times);
const double tpulse4= parameter["tpulse4"]; const double tpulse4 = parameter["tpulse4"];
// make ste decay vectors and set them to zero // make ste decay vectors and set them to zero
std::map<double, std::vector<double>> cc_dict; std::map<double, std::vector<double>> cc_dict;
@ -175,8 +175,8 @@ void run_ste(
void make_trajectory( void make_trajectory(
Motion& motion, motions::BaseMotion& motion,
Distribution& dist, times::BaseDistribution& dist,
const double t_max, const double t_max,
std::vector<double>& out_time, std::vector<double>& out_time,
std::vector<double>& out_phase, std::vector<double>& out_phase,

10
src/simulation/sims.h → src/sims.h
View File

@ -1,8 +1,8 @@
#ifndef RWSIM_SIMS_H #ifndef RWSIM_SIMS_H
#define RWSIM_SIMS_H #define RWSIM_SIMS_H
#include "../motions/base.h" #include "motions/base.h"
#include "../times/base.h" #include "times/base.h"
#include <unordered_map> #include <unordered_map>
#include <string> #include <string>
@ -16,7 +16,7 @@
* @param motion Motion model * @param motion Motion model
* @param dist Distribution of correlation times * @param dist Distribution of correlation times
*/ */
void run_spectrum(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, Motion& motion, Distribution& dist); void run_spectrum(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, motions::BaseMotion& motion, times::BaseDistribution& dist);
/** /**
* @brief Run simulation for stimulated echoes * @brief Run simulation for stimulated echoes
@ -26,7 +26,7 @@ void run_spectrum(std::unordered_map<std::string, double>& parameter, std::unord
* @param motion Motion model * @param motion Motion model
* @param dist Distribution of correlation times * @param dist Distribution of correlation times
*/ */
void run_ste(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, Motion& motion, Distribution& dist); void run_ste(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, motions::BaseMotion& motion, times::BaseDistribution& dist);
/** /**
* @brief Create trajectory of a single walker * @brief Create trajectory of a single walker
@ -38,7 +38,7 @@ void run_ste(std::unordered_map<std::string, double>& parameter, std::unordered_
* @param out_phase Vector of phase between waiting times * @param out_phase Vector of phase between waiting times
* @param out_omega Vector of omega at jump time * @param out_omega Vector of omega at jump time
*/ */
void make_trajectory(Motion& motion, Distribution& dist, double t_max, std::vector<double>& out_time, std::vector<double>& out_phase, std::vector<double>& out_omega); void make_trajectory(motions::BaseMotion& motion, times::BaseDistribution& dist, double t_max, std::vector<double>& out_time, std::vector<double>& out_phase, std::vector<double>& out_omega);
std::chrono::system_clock::time_point printStart(std::unordered_map<std::string, double> &optional); std::chrono::system_clock::time_point printStart(std::unordered_map<std::string, double> &optional);
void printEnd(std::chrono::system_clock::time_point start); void printEnd(std::chrono::system_clock::time_point start);

40
src/times/base.cpp
View File

@ -4,31 +4,33 @@
#include <stdexcept> #include <stdexcept>
Distribution::Distribution(std::string name, const double tau, std::mt19937_64 &rng) : m_name(std::move(name)), m_tau(tau), m_tau_jump(tau), m_rng(rng) {} namespace times {
BaseDistribution::BaseDistribution(std::string name, const double tau, std::mt19937_64 &rng) : m_name(std::move(name)), m_tau(tau), m_tau_jump(tau), m_rng(rng) {}
Distribution::Distribution(std::string name, std::mt19937_64 &rng) : m_name(std::move(name)), m_rng(rng) {} BaseDistribution::BaseDistribution(std::string name, std::mt19937_64 &rng) : m_name(std::move(name)), m_rng(rng) {}
double Distribution::tau_wait() const { double BaseDistribution::tau_wait() const {
return std::exponential_distribution(1./m_tau_jump)(m_rng); return std::exponential_distribution(1./m_tau_jump)(m_rng);
} }
void Distribution::setParameters(const std::unordered_map<std::string, double> &parameters) { void BaseDistribution::setParameters(const std::unordered_map<std::string, double> &parameters) {
m_tau = parameters.at("tau"); m_tau = parameters.at("tau");
} }
std::unordered_map<std::string, double> Distribution::getParameters() const { std::unordered_map<std::string, double> BaseDistribution::getParameters() const {
return std::unordered_map<std::string, double>{ return std::unordered_map<std::string, double>{
{"tau", m_tau}, {"tau", m_tau},
}; };
} }
Distribution* Distribution::createFromInput(const std::string& input, std::mt19937_64& rng) { BaseDistribution* BaseDistribution::createFromInput(const std::string& input, std::mt19937_64& rng) {
if (input == "Delta") if (input == "Delta")
return new DeltaDistribution(rng); return new DeltaDistribution(rng);
if (input == "LogNormal") if (input == "LogNormal")
return new LogNormalDistribution(rng); return new LogNormalDistribution(rng);
throw std::invalid_argument("Invalid input " + input); throw std::invalid_argument("Invalid input " + input);
}
} }

44
src/times/base.h
View File

@ -4,33 +4,35 @@
#include <random> #include <random>
#include <unordered_map> #include <unordered_map>
class Distribution { namespace times {
public: class BaseDistribution {
virtual ~Distribution() = default; public:
virtual ~BaseDistribution() = default;
Distribution(std::string, double, std::mt19937_64&); BaseDistribution(std::string, double, std::mt19937_64&);
explicit Distribution(std::string, std::mt19937_64&); explicit BaseDistribution(std::string, std::mt19937_64&);
[[nodiscard]] double getTau() const { return m_tau; } [[nodiscard]] double getTau() const { return m_tau; }
void setTau(const double tau) { m_tau = tau; } void setTau(const double tau) { m_tau = tau; }
[[nodiscard]] std::string getName() const { return m_name; }; [[nodiscard]] std::string getName() const { return m_name; };
virtual void setParameters(const std::unordered_map<std::string, double>&); virtual void setParameters(const std::unordered_map<std::string, double>&);
[[nodiscard]] virtual std::unordered_map<std::string, double> getParameters() const; [[nodiscard]] virtual std::unordered_map<std::string, double> getParameters() const;
virtual void initialize() = 0; virtual void initialize() = 0;
virtual void draw_tau() = 0; virtual void draw_tau() = 0;
[[nodiscard]] double tau_wait() const; [[nodiscard]] double tau_wait() const;
[[nodiscard]] virtual std::string toString() const = 0; [[nodiscard]] virtual std::string toString() const = 0;
static Distribution* createFromInput(const std::string& input, std::mt19937_64& rng); static BaseDistribution* createFromInput(const std::string& input, std::mt19937_64& rng);
protected: protected:
std::string m_name{"BaseDistribution"}; std::string m_name{"BaseDistribution"};
double m_tau{1.}; double m_tau{1.};
double m_tau_jump{1.}; double m_tau_jump{1.};
std::mt19937_64& m_rng; std::mt19937_64& m_rng;
}; };
}
#endif //RWSIM_TIMESBASE_H #endif //RWSIM_TIMESBASE_H

23
src/times/delta.cpp
View File

@ -1,15 +1,16 @@
#include "delta.h" #include "delta.h"
DeltaDistribution::DeltaDistribution(const double tau, std::mt19937_64& rng) : Distribution(std::string("Delta"), tau, rng) {} namespace times {
DeltaDistribution::DeltaDistribution(std::mt19937_64& rng) : Distribution(std::string("Delta"), rng) {} DeltaDistribution::DeltaDistribution(const double tau, std::mt19937_64& rng) : BaseDistribution(std::string("Delta"), tau, rng) {}
DeltaDistribution::DeltaDistribution(std::mt19937_64& rng) : BaseDistribution(std::string("Delta"), rng) {}
void DeltaDistribution::initialize() { void DeltaDistribution::initialize() {
m_tau_jump = m_tau; m_tau_jump = m_tau;
}
void DeltaDistribution::draw_tau() {}
std::string DeltaDistribution::toString() const {
return {"Delta/tau=" + std::to_string(m_tau)};
}
} }
void DeltaDistribution::draw_tau() {}
std::string DeltaDistribution::toString() const {
return {"Delta/tau=" + std::to_string(m_tau)};
}

19
src/times/delta.h
View File

@ -3,15 +3,16 @@
#include "base.h" #include "base.h"
class DeltaDistribution final : public Distribution { namespace times {
public: class DeltaDistribution final : public BaseDistribution {
DeltaDistribution(double, std::mt19937_64&); public:
explicit DeltaDistribution(std::mt19937_64 &rng); DeltaDistribution(double, std::mt19937_64&);
explicit DeltaDistribution(std::mt19937_64 &rng);
void initialize() override; void initialize() override;
void draw_tau() override; void draw_tau() override;
[[nodiscard]] std::string toString() const override;
};
[[nodiscard]] std::string toString() const override;
};
}
#endif //RWSIM_TIMESDELTA_H #endif //RWSIM_TIMESDELTA_H

42
src/times/lognormal.cpp
View File

@ -1,29 +1,31 @@
#include "lognormal.h" #include "lognormal.h"
#include <cmath> #include <cmath>
LogNormalDistribution::LogNormalDistribution(const double tau, const double sigma, std::mt19937_64& rng) : Distribution(std::string("LogNormal"), tau, rng), m_sigma(sigma), m_distribution(std::log(tau), sigma) {} namespace times {
LogNormalDistribution::LogNormalDistribution(std::mt19937_64& rng) : Distribution(std::string("LogNormal"), rng) {} LogNormalDistribution::LogNormalDistribution(const double tau, const double sigma, std::mt19937_64& rng) : BaseDistribution(std::string("LogNormal"), tau, rng), m_sigma(sigma), m_distribution(std::log(tau), sigma) {}
LogNormalDistribution::LogNormalDistribution(std::mt19937_64& rng) : BaseDistribution(std::string("LogNormal"), rng) {}
void LogNormalDistribution::setParameters(const std::unordered_map<std::string, double> &parameters) { void LogNormalDistribution::setParameters(const std::unordered_map<std::string, double> &parameters) {
m_sigma = parameters.at("sigma"); m_sigma = parameters.at("sigma");
Distribution::setParameters(parameters); BaseDistribution::setParameters(parameters);
} }
std::unordered_map<std::string, double> LogNormalDistribution::getParameters() const { std::unordered_map<std::string, double> LogNormalDistribution::getParameters() const {
auto parameter = Distribution::getParameters(); auto parameter = BaseDistribution::getParameters();
parameter["sigma"] = m_sigma; parameter["sigma"] = m_sigma;
return parameter; return parameter;
} }
void LogNormalDistribution::initialize() { void LogNormalDistribution::initialize() {
m_distribution = std::lognormal_distribution(std::log(m_tau), m_sigma); m_distribution = std::lognormal_distribution(std::log(m_tau), m_sigma);
m_tau_jump = m_distribution(m_rng); m_tau_jump = m_distribution(m_rng);
} }
void LogNormalDistribution::draw_tau() { void LogNormalDistribution::draw_tau() {
m_tau_jump = m_distribution(m_rng); m_tau_jump = m_distribution(m_rng);
} }
std::string LogNormalDistribution::toString() const { std::string LogNormalDistribution::toString() const {
return {"LogNormal/tau=" + std::to_string(m_tau) + "/sigma=" + std::to_string(m_sigma)}; return {"LogNormal/tau=" + std::to_string(m_tau) + "/sigma=" + std::to_string(m_sigma)};
}
} }

28
src/times/lognormal.h
View File

@ -4,22 +4,24 @@
#include "base.h" #include "base.h"
#include <random> #include <random>
class LogNormalDistribution final : public Distribution { namespace times {
public: class LogNormalDistribution final : public BaseDistribution {
LogNormalDistribution(double, double, std::mt19937_64&); public:
explicit LogNormalDistribution(std::mt19937_64 &rng); LogNormalDistribution(double, double, std::mt19937_64&);
explicit LogNormalDistribution(std::mt19937_64 &rng);
void setParameters(const std::unordered_map<std::string, double> &) override; void setParameters(const std::unordered_map<std::string, double> &) override;
[[nodiscard]] std::unordered_map<std::string, double> getParameters() const override; [[nodiscard]] std::unordered_map<std::string, double> getParameters() const override;
[[nodiscard]] std::string toString() const override; [[nodiscard]] std::string toString() const override;
void initialize() override; void initialize() override;
void draw_tau() override; void draw_tau() override;
private: private:
double m_sigma{1}; double m_sigma{1};
std::lognormal_distribution<> m_distribution; std::lognormal_distribution<> m_distribution;
}; };
}
#endif //LOGNORMAL_H #endif //LOGNORMAL_H

3
src/utils/functions.cpp
View File

@ -1,9 +1,6 @@
#include <vector> #include <vector>
#include <array>
#include <chrono> #include <chrono>
#include <iostream> #include <iostream>
#include <cmath>
#include <utility>
int nearest_index(const std::vector<double> &x_ref, const double x, int start=0) { int nearest_index(const std::vector<double> &x_ref, const double x, int start=0) {

4
src/utils/io.cpp
View File

@ -129,8 +129,8 @@ std::unordered_map<std::string, double> read_parameter(const std::filesystem::pa
std::string make_directory( std::string make_directory(
const Motion& motion, const motions::BaseMotion& motion,
const Distribution& distribution const times::BaseDistribution& distribution
) { ) {
std::ostringstream path_name; std::ostringstream path_name;
path_name << motion.toString() << "/" << distribution.toString(); path_name << motion.toString() << "/" << distribution.toString();

2
src/utils/io.h
View File

@ -23,7 +23,7 @@ Arguments parse_args(int argc, char* argv[]);
std::pair<std::string, double> get_optional_parameter(std::vector<std::string>::const_iterator &it); std::pair<std::string, double> get_optional_parameter(std::vector<std::string>::const_iterator &it);
std::unordered_map<std::string, double> read_parameter(const std::filesystem::path&); std::unordered_map<std::string, double> read_parameter(const std::filesystem::path&);
std::string make_directory(const Motion&, const Distribution&); std::string make_directory(const motions::BaseMotion&, const times::BaseDistribution&);
void save_parameter_to_file(const std::string&, const std::string&, const std::unordered_map<std::string, double>&, const std::unordered_map<std::string, double>&); void save_parameter_to_file(const std::string&, const std::string&, const std::unordered_map<std::string, double>&, const std::unordered_map<std::string, double>&);
void save_data_to_file(const std::string&, const std::string&, const std::vector<double>&, const std::map<double, std::vector<double>>&, const std::unordered_map<std::string, double>&); void save_data_to_file(const std::string&, const std::string&, const std::vector<double>&, const std::map<double, std::vector<double>>&, const std::unordered_map<std::string, double>&);