Particles.h

Go to the documentation of this file.

 
#ifndef FRICTIONQPOTSPRINGBLOCK_PARTICLES_H
#define FRICTIONQPOTSPRINGBLOCK_PARTICLES_H
 
#include "config.h"
#include "detail.h"
 
#include <prrng.h>
 
#include <GMatTensor/version.h>
 
namespace FrictionQPotSpringBlock {
 
namespace Particles {
 
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 : public detail::System<1, detail::Cuspy<Generator>, Generator> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
 
public:
    System_Cuspy(
        double m,
        double eta,
        double mu,
        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);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen);
    }
};
 
class System_Cuspy_RandomForcing : public detail::System<
                                       1,
                                       detail::Cuspy<Generator>,
                                       Generator,
                                       void,
                                       detail::RandomNormalForcing<1>,
                                       detail::None> {
protected:
    Generator m_gen; 
    detail::Cuspy<Generator> m_pot; 
    detail::RandomNormalForcing<1> m_ext; 
 
public:
    System_Cuspy_RandomForcing(
        double m,
        double eta,
        double mu,
        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_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, nullptr, &m_ext);
    }
 
protected:
    size_t quasistaticActivityFirst() const;
    size_t quasistaticActivityLast() const;
    double eventDrivenStep(double, bool, int);
};
 
class System_SemiSmooth : public detail::System<1, detail::SemiSmooth<Generator>, Generator> {
protected:
    Generator m_gen; 
    detail::SemiSmooth<Generator> m_pot; 
 
public:
    System_SemiSmooth(
        double m,
        double eta,
        double mu,
        double kappa,
        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);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen);
    }
};
 
class System_Smooth : public detail::System<1, detail::Smooth<Generator>, Generator> {
protected:
    Generator m_gen; 
    detail::Smooth<Generator> m_pot; 
 
public:
    System_Smooth(
        double m,
        double eta,
        double mu,
        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);
        this->initSystem(m, eta, k_frame, mu, dt, &m_pot, &m_gen);
    }
};
 
} // namespace Particles
} // namespace FrictionQPotSpringBlock
 
#endif