include/pops/runtime/dynamic/dynamic_model.hpp Source File

adc_cpp 0.3.0 Model-free C++23 core for coupled hyperbolic-elliptic systems on adaptive (AMR) meshes, with MPI and GPU (Kokkos) backends

• include
• pops
• runtime
• dynamic

dynamic_model.hpp

Go to the documentation of this file.

1#pragma once

2

3#include <pops/core/model/physical_model.hpp> // aux_comps<M>: aux width of the wrapped model

4#include <pops/core/state/state.hpp>

5#include <pops/core/foundation/types.hpp>

6

7#include <memory>

8

22

23namespace pops {

24

26template <int NV>

27struct IModel {

28 using State = StateVec<NV>;

29 static constexpr int n_vars = NV;

30

31 virtual ~IModel() = default;

32 virtual State flux(const State& u, const Aux& a, int dir) const = 0;

33 virtual Real max_wave_speed(const State& u, const Aux& a, int dir) const = 0;

35 virtual State source(const State&, const Aux&) const { return State{}; }

37 virtual Real elliptic_rhs(const State&) const { return Real(0); }

42 virtual State to_primitive(const State& u) const { return u; }

45 virtual State to_conservative(const State& p) const { return p; }

49 virtual int n_aux() const { return kAuxBaseComps; }

50};

51

56template <class M>

57struct ModelAdapter final : IModel<M::n_vars> {

58 using State = StateVec<M::n_vars>;

59 M model{};

60

61 ModelAdapter() = default;

62 explicit ModelAdapter(M m) : model(m) {}

63

64 State flux(const State& u, const Aux& a, int dir) const override { return model.flux(u, a, dir); }

65 Real max_wave_speed(const State& u, const Aux& a, int dir) const override {

66 return model.max_wave_speed(u, a, dir);

67 }

68 State source(const State& u, const Aux& a) const override {

69 if constexpr (requires(const M& mm, const State& s, const Aux& aa) { mm.source(s, aa); })

70 return model.source(u, a);

71 else

72 return State{};

73 }

74 Real elliptic_rhs(const State& u) const override {

75 if constexpr (requires(const M& mm, const State& s) { mm.elliptic_rhs(s); })

76 return model.elliptic_rhs(u);

77 else

78 return Real(0);

79 }

80 // Conversions cons <-> prim forwarded WHEN M exposes them (hyperbolic brick: to_primitive /

81 // to_conservative). M::Prim shares the NV width of State (HyperbolicPhysicalModel contract), so

82 // the return aligns directly on State. Model without conversion (scalar) -> identity (default),

83 // exact for scalar transport (prim == cons).

84 State to_primitive(const State& u) const override {

85 if constexpr (requires(const M& mm, const State& s) { mm.to_primitive(s); })

86 return model.to_primitive(u);

87 else

88 return u;

89 }

90 State to_conservative(const State& p) const override {

91 if constexpr (requires(const M& mm, const State& s) { mm.to_conservative(s); })

92 return model.to_conservative(p);

93 else

94 return p;

95 }

96 int n_aux() const override { return aux_comps<M>(); } // e.g. 4 if a brick reads B_z

97};

98

100template <class M>

101std::unique_ptr<IModel<M::n_vars>> make_dynamic(M model = {}) {

102 return std::make_unique<ModelAdapter<M>>(model);

103}

104

105} // namespace pops

pops

Definition amr_hierarchy.hpp:29

pops::kAuxBaseComps

constexpr int kAuxBaseComps

Definition state.hpp:147

pops::Real

double Real

Definition types.hpp:30

pops::make_dynamic

std::unique_ptr< IModel< M::n_vars > > make_dynamic(M model={})

Factory: wraps a static model in an owned IModel (unique_ptr).

Definition dynamic_model.hpp:101

physical_model.hpp

C++20 concepts defining the contract of the physics layer.

state.hpp

Pointwise types of the physics layer: StateVec<N> (conserved state) and Aux (auxiliary fields from th...

pops::Aux

POINTWISE auxiliary fields shared with the physics: single coupling channel.

Definition state.hpp:123

pops::IModel

Hyperbolic model seen behind a virtual interface (runtime dispatch).

Definition dynamic_model.hpp:27

pops::IModel::n_vars

static constexpr int n_vars

Definition dynamic_model.hpp:29

pops::IModel::source

virtual State source(const State &, const Aux &) const

Source term S(U, aux) (default: zero, model without source).

Definition dynamic_model.hpp:35

pops::IModel::to_conservative

virtual State to_conservative(const State &p) const

Primitive -> conservative conversion (U = M.to_conservative(P)).

Definition dynamic_model.hpp:45

pops::IModel::max_wave_speed

virtual Real max_wave_speed(const State &u, const Aux &a, int dir) const =0

pops::IModel::elliptic_rhs

virtual Real elliptic_rhs(const State &) const

Elliptic right-hand side f(U) of the system Poisson (default: zero, no coupling).

Definition dynamic_model.hpp:37

pops::IModel::flux

virtual State flux(const State &u, const Aux &a, int dir) const =0

pops::IModel::~IModel

virtual ~IModel()=default

pops::IModel::n_aux

virtual int n_aux() const

Width of the aux channel that the model READS (cf.

Definition dynamic_model.hpp:49

pops::IModel::to_primitive

virtual State to_primitive(const State &u) const

Conservative -> primitive conversion (P = M.to_primitive(U)).

Definition dynamic_model.hpp:42

pops::ModelAdapter

Adapts a STATIC model M into IModel<M::n_vars>.

Definition dynamic_model.hpp:57

pops::ModelAdapter::n_aux

int n_aux() const override

Width of the aux channel that the model READS (cf.

Definition dynamic_model.hpp:96

pops::ModelAdapter::max_wave_speed

Real max_wave_speed(const State &u, const Aux &a, int dir) const override

Definition dynamic_model.hpp:65

pops::ModelAdapter::flux

State flux(const State &u, const Aux &a, int dir) const override

Definition dynamic_model.hpp:64

pops::ModelAdapter::ModelAdapter

ModelAdapter()=default

pops::ModelAdapter::elliptic_rhs

Real elliptic_rhs(const State &u) const override

Definition dynamic_model.hpp:74

pops::ModelAdapter::to_conservative

State to_conservative(const State &p) const override

Definition dynamic_model.hpp:90

pops::ModelAdapter::model

M model

Definition dynamic_model.hpp:59

pops::ModelAdapter::ModelAdapter

ModelAdapter(M m)

Definition dynamic_model.hpp:62

pops::ModelAdapter::source

State source(const State &u, const Aux &a) const override

Definition dynamic_model.hpp:68

pops::ModelAdapter::to_primitive

State to_primitive(const State &u) const override

Definition dynamic_model.hpp:84

pops::StateVec

Conserved state vector of fixed size, known at compile time.

Definition state.hpp:29

types.hpp

Base scalar types and the POPS_HD macro (host+device portability).

---

Generated by  1.9.8