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

Use unique_ptr instead of raw pointer

Browse Source
This commit is contained in:
Dominik Demuth
2026-03-08 11:28:02 +01:00
parent d44e762bf7
commit ef3cd31be6
27 changed files with 248 additions and 259 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/main.cpp
View File

@@ -41,13 +41,13 @@ int main (const int argc, char *argv[]) {
rng.seed(rd());
}
motions::BaseMotion *motion = motions::BaseMotion::createFromInput(args.motion_type, rng);
times::BaseDistribution *dist = times::BaseDistribution::createFromInput(args.distribution_type, rng);
auto motion = motions::BaseMotion::createFromInput(args.motion_type);
auto dist = times::BaseDistribution::createFromInput(args.distribution_type);
if (args.spectrum) {
run_spectrum(parameter, args.optional, *motion, *dist);
run_spectrum(parameter, args.optional, *motion, *dist, rng);
}
if (args.ste) {
run_ste(parameter, args.optional, *motion, *dist);
run_ste(parameter, args.optional, *motion, *dist, rng);
}
return 0;

34
src/motions/base.cpp
View File

@@ -11,19 +11,16 @@
#include "nsiteconejump.h"
#include "sixsitejump.h"
#include "rjoac.h"
#include "conewobble.h"
#include <stdexcept>
namespace motions {
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.);
}
BaseMotion::BaseMotion(std::string name, const double delta, const double eta) : m_name(std::move(name)), m_delta(delta), m_eta(eta) {}
BaseMotion::BaseMotion(std::string name, std::mt19937_64& rng) : m_name(std::move(name)), m_rng(rng) {
m_uni_dist = std::uniform_real_distribution(0., 1.);
}
BaseMotion::BaseMotion(std::string name) : m_name(std::move(name)) {}
double BaseMotion::omega_q(const double cos_theta, const double phi) const {
const double cos_theta_square = cos_theta * cos_theta;
@@ -38,34 +35,37 @@ namespace motions {
return omega_q(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);
coordinates::SphericalPos BaseMotion::draw_position(std::mt19937_64& rng) {
const double cos_theta = 1 - 2 * m_uni_dist(rng);
const double phi = 2.0 * M_PI * m_uni_dist(rng);
return {cos_theta, phi};
}
BaseMotion* BaseMotion::createFromInput(const std::string& input, std::mt19937_64& rng) {
std::unique_ptr<BaseMotion> BaseMotion::createFromInput(const std::string& input) {
if (input == "FourSiteTetrahedral")
return new FourSiteTetrahedron(rng);
return std::make_unique<FourSiteTetrahedron>();
if (input == "SixSiteOctahedralC3")
return new SixSiteOctahedronC3(rng);
return std::make_unique<SixSiteOctahedronC3>();
if (input == "IsotropicAngle")
return new SmallAngle(rng);
return std::make_unique<SmallAngle>();
if (input == "RandomJump")
return new RandomJump(rng);
return std::make_unique<RandomJump>();
if (input == "BimodalAngle")
return new BimodalAngle(rng);
return std::make_unique<BimodalAngle>();
if (input == "NSiteConeJump")
return new NSiteJumpOnCone(rng);
return std::make_unique<NSiteJumpOnCone>();
if (input == "RandomJumpOnCone")
return new RandomJumpOnCone(rng);
return std::make_unique<RandomJumpOnCone>();
if (input == "ConeWobble")
return std::make_unique<WobbleCone>();
throw std::invalid_argument("Invalid input " + input);
}

17
src/motions/base.h
View File

@@ -3,6 +3,7 @@
#include "coordinates.h"
#include <memory>
#include <random>
#include <unordered_map>
@@ -11,15 +12,16 @@ namespace motions {
public:
virtual ~BaseMotion() = default;
BaseMotion(std::string, double, double, std::mt19937_64&);
explicit BaseMotion(std::string, std::mt19937_64&);
BaseMotion(std::string, double, double);
explicit BaseMotion(std::string);
coordinates::SphericalPos draw_position();
coordinates::SphericalPos draw_position(std::mt19937_64& rng);
[[nodiscard]] double omega_q(double, double) const;
[[nodiscard]] double omega_q(const coordinates::SphericalPos&) const;
virtual void initialize() = 0;
virtual double jump() = 0;
virtual void initialize(std::mt19937_64& rng) = 0;
virtual double jump(std::mt19937_64& rng) = 0;
[[nodiscard]] virtual std::unique_ptr<BaseMotion> clone() const = 0;
virtual void setParameters(const std::unordered_map<std::string, double>&);
[[nodiscard]] virtual std::unordered_map<std::string, double> getParameters() const;
@@ -32,14 +34,13 @@ namespace motions {
[[nodiscard]] virtual std::string toString() const = 0;
static BaseMotion* createFromInput(const std::string& input, std::mt19937_64& rng);
static std::unique_ptr<BaseMotion> createFromInput(const std::string& input);
protected:
std::string m_name{"BaseMotion"};
double m_delta{1.};
double m_eta{0.};
std::mt19937_64& m_rng;
std::uniform_real_distribution<> m_uni_dist;
std::uniform_real_distribution<> m_uni_dist{0., 1.};
double m_initial_omega{0.};
};

20
src/motions/bimodalangle.cpp
View File

@@ -4,26 +4,30 @@
#include "coordinates.h"
namespace motions {
BimodalAngle::BimodalAngle(const double delta, const double eta, const double angle1, const double angle2, const double prob, std::mt19937_64 &rng) :
BaseMotion(std::string("BimodalAngle"), delta, eta, rng),
BimodalAngle::BimodalAngle(const double delta, const double eta, const double angle1, const double angle2, const double prob) :
BaseMotion(std::string("BimodalAngle"), delta, eta),
m_angle1(angle1 * M_PI / 180.0),
m_angle2(angle2 * M_PI / 180.0),
m_prob(prob) {}
BimodalAngle::BimodalAngle(std::mt19937_64 &rng) : BaseMotion(std::string("BimodalAngle"), rng) {}
BimodalAngle::BimodalAngle() : BaseMotion(std::string("BimodalAngle")) {}
void BimodalAngle::initialize() {
m_prev_pos = draw_position();
void BimodalAngle::initialize(std::mt19937_64& rng) {
m_prev_pos = draw_position(rng);
m_initial_omega = omega_q(m_prev_pos);
}
double BimodalAngle::jump() {
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)};
double BimodalAngle::jump(std::mt19937_64& rng) {
const double angle = m_uni_dist(rng) < m_prob ? m_angle1 : m_angle2;
const double gamma{2 * M_PI * m_uni_dist(rng)};
m_prev_pos = rotate(m_prev_pos, angle, gamma);
return omega_q(m_prev_pos);
}
std::unique_ptr<BaseMotion> BimodalAngle::clone() const {
return std::make_unique<BimodalAngle>(*this);
}
void BimodalAngle::setParameters(const std::unordered_map<std::string, double> &parameter) {
BaseMotion::setParameters(parameter);

9
src/motions/bimodalangle.h
View File

@@ -8,11 +8,12 @@
namespace motions {
class BimodalAngle final : public BaseMotion {
public:
BimodalAngle(double, double, double, double, double, std::mt19937_64& );
explicit BimodalAngle(std::mt19937_64&);
BimodalAngle(double, double, double, double, double);
BimodalAngle();
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const 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;

23
src/motions/conewobble.cpp
View File

@@ -2,23 +2,24 @@
#include "conewobble.h"
#include "coordinates.h"
#include <random>
#include <string>
namespace motions {
WobbleCone::WobbleCone(const double delta, const double eta, const double chi, std::mt19937_64 &rng) : BaseMotion("Wobble in Cone", delta, eta, rng), m_angle(chi) {}
WobbleCone::WobbleCone(std::mt19937_64 &rng) : BaseMotion("Wobble in Cone", rng) {}
WobbleCone::WobbleCone(const double delta, const double eta, const double chi) : BaseMotion("Wobble in Cone", delta, eta), m_angle(chi) {}
WobbleCone::WobbleCone() : BaseMotion("Wobble in Cone") {}
void WobbleCone::initialize() {
m_axis = draw_position();
void WobbleCone::initialize(std::mt19937_64& rng) {
m_axis = draw_position(rng);
}
double WobbleCone::jump() {
const double real_angle = m_uni_dist(m_rng) * m_angle;
const double phi = 2 * M_PI * m_uni_dist(m_rng);
double WobbleCone::jump(std::mt19937_64& rng) {
const double real_angle = m_uni_dist(rng) * m_angle;
const double phi = 2 * M_PI * m_uni_dist(rng);
return omega_q(rotate(m_axis, real_angle, phi));
}
std::unique_ptr<BaseMotion> WobbleCone::clone() const {
return std::make_unique<WobbleCone>(*this);
}
void WobbleCone::setParameters(const std::unordered_map<std::string, double> &parameters) {
BaseMotion::setParameters(parameters);
m_angle = parameters.at("angle");
@@ -34,4 +35,4 @@ namespace motions {
std::string WobbleCone::toString() const {
return std::string("ConeWobble/angle=") + std::to_string(m_angle);
}
}
}

14
src/motions/conewobble.h
View File

@@ -4,22 +4,18 @@
#include "base.h"
#include "coordinates.h"
#include <random>
namespace motions {
class WobbleCone final: public BaseMotion {
public:
WobbleCone(double, double, double, std::mt19937_64&);
explicit WobbleCone(std::mt19937_64&);
WobbleCone(double, double, double);
WobbleCone();
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const 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:

26
src/motions/foursitejump.cpp
View File

@@ -1,35 +1,37 @@
#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(const double delta, const double eta) :
BaseMotion(std::string{"FourSiteTetrahedral"}, delta, eta) {}
FourSiteTetrahedron::FourSiteTetrahedron(std::mt19937_64& rng) : BaseMotion(std::string{"FourSiteTetrahedral"}, rng) {}
FourSiteTetrahedron::FourSiteTetrahedron() : BaseMotion(std::string{"FourSiteTetrahedral"}) {}
void FourSiteTetrahedron::initialize() {
const auto pos = draw_position();
void FourSiteTetrahedron::initialize(std::mt19937_64& rng) {
const auto pos = draw_position(rng);
m_corners[0] = omega_q(pos);
const double alpha = 2. * M_PI * m_uni_dist(m_rng);
const double alpha = 2. * M_PI * m_uni_dist(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 = FourSiteTetrahedron::jump();
m_initial_omega = FourSiteTetrahedron::jump(rng);
}
double FourSiteTetrahedron::jump() {
m_corner_idx += m_chooser(m_rng);
double FourSiteTetrahedron::jump(std::mt19937_64& rng) {
m_corner_idx += m_chooser(rng);
m_corner_idx %= 4;
return m_corners[m_corner_idx];
}
std::unique_ptr<BaseMotion> FourSiteTetrahedron::clone() const {
return std::make_unique<FourSiteTetrahedron>(*this);
}
std::string FourSiteTetrahedron::toString() const {
return {"FourSiteTetrahedral"};
}
}
}

10
src/motions/foursitejump.h
View File

@@ -3,18 +3,18 @@
#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&);
FourSiteTetrahedron(double, double);
FourSiteTetrahedron();
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const override;
[[nodiscard]] std::string toString() const override;

20
src/motions/isosmallangle.cpp
View File

@@ -1,26 +1,28 @@
#include "isosmallangle.h"
#include "coordinates.h"
#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) :
BaseMotion(std::string("IsotropicAngle"), delta, eta), m_chi(chi * M_PI / 180.0) {}
SmallAngle::SmallAngle() : BaseMotion(std::string("IsotropicAngle")) {}
void SmallAngle::initialize() {
m_prev_pos = draw_position();
void SmallAngle::initialize(std::mt19937_64& rng) {
m_prev_pos = draw_position(rng);
m_initial_omega = omega_q(m_prev_pos);
}
double SmallAngle::jump() {
const double gamma{2 * M_PI * m_uni_dist(m_rng)};
double SmallAngle::jump(std::mt19937_64& rng) {
const double gamma{2 * M_PI * m_uni_dist(rng)};
m_prev_pos = rotate(m_prev_pos, m_chi, gamma);
return omega_q(m_prev_pos);
}
std::unique_ptr<BaseMotion> SmallAngle::clone() const {
return std::make_unique<SmallAngle>(*this);
}
void SmallAngle::setParameters(const std::unordered_map<std::string, double> &parameters) {
m_chi = parameters.at("angle") * M_PI / 180.0;
BaseMotion::setParameters(parameters);

9
src/motions/isosmallangle.h
View File

@@ -8,11 +8,12 @@
namespace motions {
class SmallAngle final : public BaseMotion {
public:
SmallAngle(double, double, double, std::mt19937_64& );
explicit SmallAngle(std::mt19937_64&);
SmallAngle(double, double, double);
SmallAngle();
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const 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;

27
src/motions/nsiteconejump.cpp
View File

@@ -1,43 +1,42 @@
//
// Created by dominik on 12/14/24.
//
#include "nsiteconejump.h"
#include "coordinates.h"
#include <cmath>
#include <iostream>
#include <ostream>
#include <vector>
namespace motions {
NSiteJumpOnCone::NSiteJumpOnCone(const double delta, const double eta, const int num_sites, const double chi, std::mt19937_64 &rng) :
BaseMotion("NSiteJumpOnCone", delta, eta, rng),
NSiteJumpOnCone::NSiteJumpOnCone(const double delta, const double eta, const int num_sites, const double chi) :
BaseMotion("NSiteJumpOnCone", delta, eta),
m_num_sites(num_sites),
m_chi(chi*M_PI/180.) {}
NSiteJumpOnCone::NSiteJumpOnCone(std::mt19937_64 &rng) : BaseMotion("NSiteJumpOnCone", rng) { }
NSiteJumpOnCone::NSiteJumpOnCone() : BaseMotion("NSiteJumpOnCone") { }
void NSiteJumpOnCone::initialize() {
void NSiteJumpOnCone::initialize(std::mt19937_64& rng) {
m_sites = std::vector<double>(m_num_sites);
m_chooser = std::uniform_int_distribution<>{1, m_num_sites - 1};
m_axis = draw_position();
m_axis = draw_position(rng);
const double alpha = m_uni_dist(m_rng) * 2 * M_PI;
const double alpha = m_uni_dist(rng) * 2 * M_PI;
const double steps = 2*M_PI / m_num_sites;
for (int i = 0; i < m_num_sites; i++) {
m_sites[i] = omega_q(rotate(m_axis, m_chi, i * steps + alpha));
}
}
double NSiteJumpOnCone::jump() {
m_cone_idx += m_chooser(m_rng);
double NSiteJumpOnCone::jump(std::mt19937_64& rng) {
m_cone_idx += m_chooser(rng);
m_cone_idx %= m_num_sites;
return m_sites[m_cone_idx];
}
std::unique_ptr<BaseMotion> NSiteJumpOnCone::clone() const {
return std::make_unique<NSiteJumpOnCone>(*this);
}
void NSiteJumpOnCone::setParameters(const std::unordered_map<std::string, double> &parameters) {
BaseMotion::setParameters(parameters);
m_num_sites = static_cast<int>(parameters.at("num_sites"));
@@ -56,4 +55,4 @@ namespace motions {
return std::to_string(m_num_sites) + "SiteJumpOnCone/angle=" + std::to_string(m_chi*180/M_PI);
}
} // motions
} // motions

10
src/motions/nsiteconejump.h
View File

@@ -3,17 +3,17 @@
#include "base.h"
#include <random>
#include <vector>
namespace motions {
class NSiteJumpOnCone final : public BaseMotion {
public:
NSiteJumpOnCone(double, double, int, double, std::mt19937_64&);
explicit NSiteJumpOnCone(std::mt19937_64&);
NSiteJumpOnCone(double, double, int, double);
NSiteJumpOnCone();
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const override;
[[nodiscard]] std::string toString() const override;

16
src/motions/random.cpp
View File

@@ -2,19 +2,23 @@
#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) : BaseMotion(std::string("RandomJump"), delta, eta) {}
RandomJump::RandomJump(std::mt19937_64 &rng) : BaseMotion(std::string("RandomJump"), rng) {}
RandomJump::RandomJump() : BaseMotion(std::string("RandomJump")) {}
std::string RandomJump::toString() const {
return {"RandomJump"};
}
void RandomJump::initialize() {
m_initial_omega = RandomJump::jump();
std::unique_ptr<BaseMotion> RandomJump::clone() const {
return std::make_unique<RandomJump>(*this);
}
double RandomJump::jump() {
return omega_q(draw_position());
void RandomJump::initialize(std::mt19937_64& rng) {
m_initial_omega = RandomJump::jump(rng);
}
double RandomJump::jump(std::mt19937_64& rng) {
return omega_q(draw_position(rng));
}
}

10
src/motions/random.h
View File

@@ -3,18 +3,18 @@
#include "base.h"
#include <random>
namespace motions {
class RandomJump final : public BaseMotion {
public:
RandomJump(double, double, std::mt19937_64&);
explicit RandomJump(std::mt19937_64&);
RandomJump(double, double);
RandomJump();
[[nodiscard]] std::string toString() const override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const override;
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
};
}

18
src/motions/rjoac.cpp
View File

@@ -2,18 +2,22 @@
#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) {}
RandomJumpOnCone::RandomJumpOnCone(const double delta, const double eta, const double chi) : BaseMotion("RJ on a Cone", delta, eta), m_angle(chi) {}
RandomJumpOnCone::RandomJumpOnCone() : BaseMotion("RJ on a Cone") {}
void RandomJumpOnCone::initialize() {
m_axis = draw_position();
void RandomJumpOnCone::initialize(std::mt19937_64& rng) {
m_axis = draw_position(rng);
}
double RandomJumpOnCone::jump() {
const double phi = 2 * M_PI * m_uni_dist(m_rng);
double RandomJumpOnCone::jump(std::mt19937_64& rng) {
const double phi = 2 * M_PI * m_uni_dist(rng);
return omega_q(rotate(m_axis, m_angle, phi));
}
std::unique_ptr<BaseMotion> RandomJumpOnCone::clone() const {
return std::make_unique<RandomJumpOnCone>(*this);
}
void RandomJumpOnCone::setParameters(const std::unordered_map<std::string, double> &parameters) {
BaseMotion::setParameters(parameters);
m_angle = parameters.at("angle");
@@ -29,4 +33,4 @@ namespace motions {
std::string RandomJumpOnCone::toString() const {
return std::string("RandomJumpOnCone/angle=") + std::to_string(m_angle);
}
}
}

14
src/motions/rjoac.h
View File

@@ -4,22 +4,18 @@
#include "base.h"
#include "coordinates.h"
#include <random>
namespace motions {
class RandomJumpOnCone final: public BaseMotion {
public:
RandomJumpOnCone(double, double, double, std::mt19937_64&);
explicit RandomJumpOnCone(std::mt19937_64&);
RandomJumpOnCone(double, double, double);
RandomJumpOnCone();
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const 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:

28
src/motions/sixsitejump.cpp
View File

@@ -1,21 +1,17 @@
#include "sixsitejump.h"
#include <iomanip>
#include <iostream>
#include "coordinates.h"
namespace motions {
SixSiteOctahedronC3::SixSiteOctahedronC3(const double delta, const double eta, const double chi, std::mt19937_64& rng) :
m_chi{chi*M_PI/180.},
BaseMotion(std::string{"SixSiteOctahedral"}, delta, eta, rng) {}
SixSiteOctahedronC3::SixSiteOctahedronC3(const double delta, const double eta, const double chi) :
BaseMotion(std::string{"SixSiteOctahedral"}, delta, eta),
m_chi{chi*M_PI/180.} {}
SixSiteOctahedronC3::SixSiteOctahedronC3(std::mt19937_64& rng) : BaseMotion(std::string{"SixSiteOctahedralC3"}, rng) {}
SixSiteOctahedronC3::SixSiteOctahedronC3() : BaseMotion(std::string{"SixSiteOctahedralC3"}) {}
void SixSiteOctahedronC3::initialize() {
const coordinates::SphericalPos c3_axis = draw_position();
const auto [x, y, z] = spherical_to_xyz(c3_axis);
const double alpha = 2. * M_PI * m_uni_dist(m_rng);
void SixSiteOctahedronC3::initialize(std::mt19937_64& rng) {
const coordinates::SphericalPos c3_axis = draw_position(rng);
const double alpha = 2. * M_PI * m_uni_dist(rng);
const double m_chi_opposite = M_PI - m_chi;
@@ -24,17 +20,21 @@ namespace motions {
m_corners[2*i+1] = omega_q(rotate(c3_axis, m_chi_opposite, alpha + i * 2./3.*M_PI + M_PI/3.));
}
m_initial_omega = SixSiteOctahedronC3::jump();
m_initial_omega = SixSiteOctahedronC3::jump(rng);
}
double SixSiteOctahedronC3::jump() {
m_corner_idx += m_chooser(m_rng);
double SixSiteOctahedronC3::jump(std::mt19937_64& rng) {
m_corner_idx += m_chooser(rng);
m_corner_idx %= 6;
return m_corners[m_corner_idx];
}
std::unique_ptr<BaseMotion> SixSiteOctahedronC3::clone() const {
return std::make_unique<SixSiteOctahedronC3>(*this);
}
std::string SixSiteOctahedronC3::toString() const {
return {"SixSiteOctahedral/angle=" + std::to_string(m_chi / M_PI * 180.)};
}

12
src/motions/sixsitejump.h
View File

@@ -4,23 +4,23 @@
#include "base.h"
#include <random>
#include <cmath>
#include <array>
namespace motions {
class SixSiteOctahedronC3 final : public BaseMotion {
public:
SixSiteOctahedronC3(double, double, double, std::mt19937_64&);
explicit SixSiteOctahedronC3(std::mt19937_64&);
SixSiteOctahedronC3(double, double, double);
SixSiteOctahedronC3();
void initialize() override;
double jump() override;
void initialize(std::mt19937_64& rng) override;
double jump(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseMotion> clone() const override;
[[nodiscard]] std::string toString() const override;
private:
const double m_chi{0.95531661812450927816385710251575775424341469501000549095969812932191204590}; // 54.74 deg
double m_chi{0.95531661812450927816385710251575775424341469501000549095969812932191204590}; // 54.74 deg
std::array<double, 6> m_corners{};
int m_corner_idx{0};

75
src/sims.cpp
View File

@@ -19,7 +19,8 @@ void run_spectrum(
std::unordered_map<std::string, double>& parameter,
std::unordered_map<std::string, double> optional,
motions::BaseMotion& motion,
times::BaseDistribution& dist
times::BaseDistribution& dist,
std::mt19937_64& rng
) {
const int num_walker = static_cast<int>(parameter["num_walker"]);
@@ -47,23 +48,19 @@ void run_spectrum(
// let the walker walk
for (int mol_i = 0; mol_i < num_walker; mol_i++){
std::vector<double> traj_time{};
std::vector<double> traj_phase{};
std::vector<double> traj_omega{};
make_trajectory(motion, dist, tmax, traj_time, traj_phase, traj_omega);
auto traj = make_trajectory(motion, dist, tmax, rng);
for (auto& [t_echo_j, fid_j] : fid_dict) {
// get phase at echo pulse
int current_pos = nearest_index(traj_time, t_echo_j, 0);
const double phase_techo = lerp(traj_time, traj_phase, t_echo_j, current_pos);
int current_pos = nearest_index(traj.time, t_echo_j, 0);
const double phase_techo = lerp(traj.time, traj.phase, t_echo_j, current_pos);
for (int acq_idx = 0; acq_idx < num_acq; acq_idx++) {
const double real_time = t_fid[acq_idx] + 2 * t_echo_j;
current_pos = nearest_index(traj_time, real_time, current_pos);
const double phase_acq = lerp(traj_time, traj_phase, real_time, current_pos);
current_pos = nearest_index(traj.time, real_time, current_pos);
const double phase_acq = lerp(traj.time, traj.phase, real_time, current_pos);
fid_j[acq_idx] += std::cos(phase_acq - 2 * phase_techo) / num_walker;
}
@@ -84,7 +81,8 @@ void run_ste(
std::unordered_map<std::string, double>& parameter,
std::unordered_map<std::string, double> optional,
motions::BaseMotion& motion,
times::BaseDistribution& dist
times::BaseDistribution& dist,
std::mt19937_64& rng
) {
const int num_walker = static_cast<int>(parameter[std::string("num_walker")]);
@@ -116,17 +114,13 @@ void run_ste(
// let the walker walk
for (int mol_i = 0; mol_i < num_walker; mol_i++){
std::vector<double> traj_time{};
std::vector<double> traj_phase{};
std::vector<double> traj_omega{};
make_trajectory(motion, dist, tmax, traj_time, traj_phase, traj_omega);
auto traj = make_trajectory(motion, dist, tmax, rng);
int f2_pos = 0;
for (int f2_idx=0; f2_idx < num_mix_times; f2_idx++) {
const double t_mix_f2 = mixing_times[f2_idx];
f2_pos = nearest_index(traj_time, t_mix_f2, f2_pos);
f2[f2_idx] += traj_omega[f2_pos] * motion.getInitOmega() / num_walker;
f2_pos = nearest_index(traj.time, t_mix_f2, f2_pos);
f2[f2_idx] += traj.omega[f2_pos] * motion.getInitOmega() / num_walker;
}
@@ -135,26 +129,26 @@ void run_ste(
auto& ss_j = ss_dict[t_evo_j];
// get phase at beginning of mixing time
int current_pos = nearest_index(traj_time, t_evo_j, 0);
const double dephased = lerp(traj_time, traj_phase, t_evo_j, current_pos);
int current_pos = nearest_index(traj.time, t_evo_j, 0);
const double dephased = lerp(traj.time, traj.phase, t_evo_j, current_pos);
const double cc_tevo = std::cos(dephased);
const double ss_tevo = std::sin(dephased);
for (int mix_idx = 0; mix_idx < num_mix_times; mix_idx++) {
// get phase at end of mixing time
const double time_end_mix = mixing_times[mix_idx] + t_evo_j;
current_pos = nearest_index(traj_time, time_end_mix, current_pos);
const double phase_mix_end = lerp(traj_time, traj_phase, time_end_mix, current_pos);
current_pos = nearest_index(traj.time, time_end_mix, current_pos);
const double phase_mix_end = lerp(traj.time, traj.phase, time_end_mix, current_pos);
// get phase at position of 4th pulse
const double time_pulse4 = time_end_mix + tpulse4;
current_pos = nearest_index(traj_time, time_pulse4, current_pos);
const double phase_4pulse = lerp(traj_time, traj_phase, time_pulse4, current_pos);
current_pos = nearest_index(traj.time, time_pulse4, current_pos);
const double phase_4pulse = lerp(traj.time, traj.phase, time_pulse4, current_pos);
// get phase at echo position
const double time_echo = time_pulse4 + tpulse4 + t_evo_j;
current_pos = nearest_index(traj_time, time_echo, current_pos);
double rephased = lerp(traj_time, traj_phase, time_echo, current_pos) + phase_mix_end - 2*phase_4pulse;
current_pos = nearest_index(traj.time, time_echo, current_pos);
double rephased = lerp(traj.time, traj.phase, time_echo, current_pos) + phase_mix_end - 2*phase_4pulse;
cc_j[mix_idx] += cc_tevo * std::cos(rephased) / num_walker;
ss_j[mix_idx] += ss_tevo * std::sin(rephased) / num_walker;
@@ -174,37 +168,38 @@ void run_ste(
}
void make_trajectory(
Trajectory make_trajectory(
motions::BaseMotion& motion,
times::BaseDistribution& dist,
const double t_max,
std::vector<double>& out_time,
std::vector<double>& out_phase,
std::vector<double>& out_omega
std::mt19937_64& rng
) {
// Starting position
double t_passed = 0;
double phase = 0;
motion.initialize();
dist.initialize();
motion.initialize(rng);
dist.initialize(rng);
double omega = motion.getInitOmega();
out_time.emplace_back(t_passed);
out_phase.emplace_back(phase);
out_omega.emplace_back(omega);
Trajectory traj;
traj.time.emplace_back(t_passed);
traj.phase.emplace_back(phase);
traj.omega.emplace_back(omega);
while (t_passed < t_max) {
const double t = dist.tau_wait();
const double t = dist.tau_wait(rng);
t_passed += t;
omega = motion.jump();
omega = motion.jump(rng);
phase += omega * t;
out_time.emplace_back(t_passed);
out_phase.emplace_back(phase);
out_omega.emplace_back(omega);
traj.time.emplace_back(t_passed);
traj.phase.emplace_back(phase);
traj.omega.emplace_back(omega);
}
return traj;
}

39
src/sims.h
View File

@@ -7,38 +7,19 @@
#include <unordered_map>
#include <string>
#include <chrono>
#include <vector>
/**
* @brief Run simulation for spectra
*
* @param parameter Dictionary of parameter for simulation
* @param optional Dictionary of parameter set via command line
* @param motion Motion model
* @param dist Distribution of correlation times
*/
void run_spectrum(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, motions::BaseMotion& motion, times::BaseDistribution& dist);
struct Trajectory {
std::vector<double> time;
std::vector<double> phase;
std::vector<double> omega;
};
/**
* @brief Run simulation for stimulated echoes
*
* @param parameter Dictionary of parameter for simulation
* @param optional Dictionary of parameter set via command line
* @param motion Motion model
* @param dist Distribution of correlation times
*/
void run_ste(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, motions::BaseMotion& motion, times::BaseDistribution& dist);
void run_spectrum(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, motions::BaseMotion& motion, times::BaseDistribution& dist, std::mt19937_64& rng);
/**
* @brief Create trajectory of a single walker
*
* @param motion Motion model
* @param dist Distribution of correlation times
* @param t_max Double that defines maximum time of trajectory
* @param out_time Vector of waiting times
* @param out_phase Vector of phase between waiting times
* @param out_omega Vector of omega at jump time
*/
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);
void run_ste(std::unordered_map<std::string, double>& parameter, std::unordered_map<std::string, double> optional, motions::BaseMotion& motion, times::BaseDistribution& dist, std::mt19937_64& rng);
Trajectory make_trajectory(motions::BaseMotion& motion, times::BaseDistribution& dist, double t_max, std::mt19937_64& rng);
std::chrono::system_clock::time_point printStart(std::unordered_map<std::string, double> &optional);
void printEnd(std::chrono::system_clock::time_point start);

16
src/times/base.cpp
View File

@@ -5,12 +5,12 @@
#include <stdexcept>
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) {}
BaseDistribution::BaseDistribution(std::string name, const double tau) : m_name(std::move(name)), m_tau(tau), m_tau_jump(tau) {}
BaseDistribution::BaseDistribution(std::string name, std::mt19937_64 &rng) : m_name(std::move(name)), m_rng(rng) {}
BaseDistribution::BaseDistribution(std::string name) : m_name(std::move(name)) {}
double BaseDistribution::tau_wait() const {
return std::exponential_distribution(1./m_tau_jump)(m_rng);
double BaseDistribution::tau_wait(std::mt19937_64& rng) const {
return std::exponential_distribution(1./m_tau_jump)(rng);
}
void BaseDistribution::setParameters(const std::unordered_map<std::string, double> &parameters) {
@@ -24,13 +24,13 @@ namespace times {
}
BaseDistribution* BaseDistribution::createFromInput(const std::string& input, std::mt19937_64& rng) {
std::unique_ptr<BaseDistribution> BaseDistribution::createFromInput(const std::string& input) {
if (input == "Delta")
return new DeltaDistribution(rng);
return std::make_unique<DeltaDistribution>();
if (input == "LogNormal")
return new LogNormalDistribution(rng);
return std::make_unique<LogNormalDistribution>();
throw std::invalid_argument("Invalid input " + input);
}
}
}

14
src/times/base.h
View File

@@ -1,6 +1,7 @@
#ifndef RWSIM_TIMESBASE_H
#define RWSIM_TIMESBASE_H
#include <memory>
#include <random>
#include <unordered_map>
@@ -9,8 +10,8 @@ namespace times {
public:
virtual ~BaseDistribution() = default;
BaseDistribution(std::string, double, std::mt19937_64&);
explicit BaseDistribution(std::string, std::mt19937_64&);
BaseDistribution(std::string, double);
explicit BaseDistribution(std::string);
[[nodiscard]] double getTau() const { return m_tau; }
void setTau(const double tau) { m_tau = tau; }
@@ -19,19 +20,18 @@ namespace times {
virtual void setParameters(const std::unordered_map<std::string, double>&);
[[nodiscard]] virtual std::unordered_map<std::string, double> getParameters() const;
virtual void initialize() = 0;
virtual void draw_tau() = 0;
[[nodiscard]] double tau_wait() const;
virtual void initialize(std::mt19937_64& rng) = 0;
[[nodiscard]] double tau_wait(std::mt19937_64& rng) const;
[[nodiscard]] virtual std::unique_ptr<BaseDistribution> clone() const = 0;
[[nodiscard]] virtual std::string toString() const = 0;
static BaseDistribution* createFromInput(const std::string& input, std::mt19937_64& rng);
static std::unique_ptr<BaseDistribution> createFromInput(const std::string& input);
protected:
std::string m_name{"BaseDistribution"};
double m_tau{1.};
double m_tau_jump{1.};
std::mt19937_64& m_rng;
};
}

10
src/times/delta.cpp
View File

@@ -1,14 +1,16 @@
#include "delta.h"
namespace times {
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) {}
DeltaDistribution::DeltaDistribution(const double tau) : BaseDistribution(std::string("Delta"), tau) {}
DeltaDistribution::DeltaDistribution() : BaseDistribution(std::string("Delta")) {}
void DeltaDistribution::initialize() {
void DeltaDistribution::initialize(std::mt19937_64&) {
m_tau_jump = m_tau;
}
void DeltaDistribution::draw_tau() {}
std::unique_ptr<BaseDistribution> DeltaDistribution::clone() const {
return std::make_unique<DeltaDistribution>(*this);
}
std::string DeltaDistribution::toString() const {
return {"Delta/tau=" + std::to_string(m_tau)};

8
src/times/delta.h
View File

@@ -6,11 +6,11 @@
namespace times {
class DeltaDistribution final : public BaseDistribution {
public:
DeltaDistribution(double, std::mt19937_64&);
explicit DeltaDistribution(std::mt19937_64 &rng);
explicit DeltaDistribution(double);
DeltaDistribution();
void initialize() override;
void draw_tau() override;
void initialize(std::mt19937_64& rng) override;
[[nodiscard]] std::unique_ptr<BaseDistribution> clone() const override;
[[nodiscard]] std::string toString() const override;
};

12
src/times/lognormal.cpp
View File

@@ -2,8 +2,8 @@
#include <cmath>
namespace times {
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) {}
LogNormalDistribution::LogNormalDistribution(const double tau, const double sigma) : BaseDistribution(std::string("LogNormal"), tau), m_sigma(sigma), m_distribution(std::log(tau), sigma) {}
LogNormalDistribution::LogNormalDistribution() : BaseDistribution(std::string("LogNormal")) {}
void LogNormalDistribution::setParameters(const std::unordered_map<std::string, double> &parameters) {
m_sigma = parameters.at("sigma");
@@ -16,13 +16,13 @@ namespace times {
return parameter;
}
void LogNormalDistribution::initialize() {
void LogNormalDistribution::initialize(std::mt19937_64& rng) {
m_distribution = std::lognormal_distribution(std::log(m_tau), m_sigma);
m_tau_jump = m_distribution(m_rng);
m_tau_jump = m_distribution(rng);
}
void LogNormalDistribution::draw_tau() {
m_tau_jump = m_distribution(m_rng);
std::unique_ptr<BaseDistribution> LogNormalDistribution::clone() const {
return std::make_unique<LogNormalDistribution>(*this);
}
std::string LogNormalDistribution::toString() const {

8
src/times/lognormal.h
View File

@@ -7,16 +7,16 @@
namespace times {
class LogNormalDistribution final : public BaseDistribution {
public:
LogNormalDistribution(double, double, std::mt19937_64&);
explicit LogNormalDistribution(std::mt19937_64 &rng);
LogNormalDistribution(double, double);
LogNormalDistribution();
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;
[[nodiscard]] std::unique_ptr<BaseDistribution> clone() const override;
void initialize() override;
void draw_tau() override;
void initialize(std::mt19937_64& rng) override;
private:
double m_sigma{1};