Line1d.h

Go to the documentation of this file.

 
#ifndef FRICTIONQPOTSPRINGBLOCK_LINE1D_H
#define FRICTIONQPOTSPRINGBLOCK_LINE1D_H
 
#include "config.h"
#include "detail.h"
 
#include <prrng.h>
 
#include <GMatTensor/version.h>
 
namespace FrictionQPotSpringBlock {
 
namespace Line1d {
 
inline std::vector<std::string> version_dependencies()
{
    return GMatTensor::version_dependencies();
}
 
inline std::vector<std::string> version_compiler()
{
    return GMatTensor::version_compiler();
}
 
using Generator =
    prrng::pcg32_tensor_cumsum<array_type::tensor<double, 2>, array_type::tensor<ptrdiff_t, 1>, 1>;
 
class System_Cuspy_Laplace
    : public detail::System<1, detail::Cuspy<Generator>, Generator, detail::Laplace1d> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::Laplace1d m_int; 
 
public:
    System_Cuspy_Laplace(
        double m,
        double eta,
        double mu,
        double k_interactions,
        double k_frame,
        double dt,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Cuspy<Generator>(mu, &m_gen);
        m_int = detail::Laplace1d(k_interactions, shape[0]);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int);
    }
};
 
class System_Cuspy_Laplace_Nopassing : public detail::System<
                                           1,
                                           detail::Cuspy<Generator>,
                                           Generator,
                                           detail::Laplace1d,
                                           void,
                                           detail::Overdamped> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::Laplace1d m_int; 
 
public:
    System_Cuspy_Laplace_Nopassing(
        double mu,
        double k_interactions,
        double k_frame,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000,
        double eta = 0.0,
        double dt = 0.0
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Cuspy<Generator>(mu, &m_gen);
        m_int = detail::Laplace1d(k_interactions, shape[0]);
        this->initSystem(1.0, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int);
    }
 
protected:
    void timeStep();
    void timeSteps(size_t);
    size_t timeStepsUntilEvent(double, size_t, size_t);
    void flowSteps(size_t, double);
};
 
class System_Cuspy_Laplace_RandomForcing : public detail::System<
                                               1,
                                               detail::Cuspy<Generator>,
                                               Generator,
                                               detail::Laplace1d,
                                               detail::RandomNormalForcing<1>,
                                               detail::None> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::Laplace1d m_int; 
    detail::RandomNormalForcing<1> m_ext; 
 
public:
    System_Cuspy_Laplace_RandomForcing(
        double m,
        double eta,
        double mu,
        double k_interactions,
        double k_frame,
        double dt,
        double mean,
        double stddev,
        uint64_t seed_forcing,
        const array_type::tensor<ptrdiff_t, 1>& dinc_init,
        const array_type::tensor<ptrdiff_t, 1>& dinc,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Cuspy<Generator>(mu, &m_gen);
        m_int = detail::Laplace1d(k_interactions, shape[0]);
        m_ext = detail::RandomNormalForcing<1>(
            m_gen.generators().shape(), mean, stddev, seed_forcing, dinc_init, dinc
        );
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int, &m_ext);
    }
 
protected:
    size_t quasistaticActivityFirst() const;
    size_t quasistaticActivityLast() const;
    double eventDrivenStep(double, bool, int);
};
 
class System_SemiSmooth_Laplace
    : public detail::System<1, detail::SemiSmooth<Generator>, Generator, detail::Laplace1d> {
protected:
    Generator m_gen; 
    detail::SemiSmooth<Generator> m_pot; 
    detail::Laplace1d m_int; 
 
public:
    System_SemiSmooth_Laplace(
        double m,
        double eta,
        double mu,
        double kappa,
        double k_interactions,
        double k_frame,
        double dt,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::SemiSmooth<Generator>(mu, kappa, &m_gen);
        m_int = detail::Laplace1d(k_interactions, shape[0]);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int);
    }
};
 
class System_Smooth_Laplace
    : public detail::System<1, detail::Smooth<Generator>, Generator, detail::Laplace1d> {
protected:
    Generator m_gen; 
    detail::Smooth<Generator> m_pot; 
    detail::Laplace1d m_int; 
 
public:
    System_Smooth_Laplace(
        double m,
        double eta,
        double mu,
        double k_interactions,
        double k_frame,
        double dt,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Smooth<Generator>(mu, &m_gen);
        m_int = detail::Laplace1d(k_interactions, shape[0]);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int);
    }
};
 
class System_Cuspy_Quartic
    : public detail::System<1, detail::Cuspy<Generator>, Generator, detail::Quartic1d> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::Quartic1d m_int; 
 
public:
    System_Cuspy_Quartic(
        double m,
        double eta,
        double mu,
        double a1,
        double a2,
        double k_frame,
        double dt,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Cuspy<Generator>(mu, &m_gen);
        m_int = detail::Quartic1d(a1, a2, shape[0]);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int);
    }
};
 
class System_Cuspy_Quartic_RandomForcing : public detail::System<
                                               1,
                                               detail::Cuspy<Generator>,
                                               Generator,
                                               detail::Quartic1d,
                                               detail::RandomNormalForcing<1>,
                                               detail::None> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::Quartic1d m_int; 
    detail::RandomNormalForcing<1> m_ext; 
 
public:
    System_Cuspy_Quartic_RandomForcing(
        double m,
        double eta,
        double mu,
        double a1,
        double a2,
        double k_frame,
        double dt,
        double mean,
        double stddev,
        uint64_t seed_forcing,
        const array_type::tensor<ptrdiff_t, 1>& dinc_init,
        const array_type::tensor<ptrdiff_t, 1>& dinc,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Cuspy<Generator>(mu, &m_gen);
        m_int = detail::Quartic1d(a1, a2, shape[0]);
        m_ext = detail::RandomNormalForcing<1>(
            m_gen.generators().shape(), mean, stddev, seed_forcing, dinc_init, dinc
        );
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int, &m_ext);
    }
 
protected:
    size_t quasistaticActivityFirst() const;
    size_t quasistaticActivityLast() const;
    double eventDrivenStep(double, bool, int);
};
 
class System_Cuspy_QuarticGradient
    : public detail::System<1, detail::Cuspy<Generator>, Generator, detail::QuarticGradient1d> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::QuarticGradient1d m_int; 
 
public:
    System_Cuspy_QuarticGradient(
        double m,
        double eta,
        double mu,
        double k2,
        double k4,
        double k_frame,
        double dt,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Cuspy<Generator>(mu, &m_gen);
        m_int = detail::QuarticGradient1d(k2, k4, shape[0]);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int);
    }
};
 
class System_Cuspy_LongRange
    : public detail::System<1, detail::Cuspy<Generator>, Generator, detail::LongRange1d> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::LongRange1d m_int; 
 
public:
    System_Cuspy_LongRange(
        double m,
        double eta,
        double mu,
        double k_interactions,
        double alpha,
        double k_frame,
        double dt,
        const std::array<size_t, 1>& shape,
        uint64_t seed,
        const std::string& distribution,
        const std::vector<double>& parameters,
        double offset = -100.0,
        size_t nchunk = 5000
    )
        : m_gen(
              std::array<size_t, 1>{nchunk},
              xt::eval(seed + xt::arange<uint64_t>(shape[0])),
              xt::eval(xt::zeros<uint64_t>(shape)),
              detail::string_to_distribution(distribution),
              parameters,
              prrng::alignment(/*buffer*/ 2, /*margin*/ 30, /*min_margin*/ 6, /*strict*/ false)
          )
    {
        m_gen += offset;
        m_pot = detail::Cuspy<Generator>(mu, &m_gen);
        m_int = detail::LongRange1d(k_interactions, alpha, shape[0]);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen, &m_int);
    }
};
 
} // namespace Line1d
} // namespace FrictionQPotSpringBlock
 
#endif