[Richards&Transport] Change parameterization signatures

* Remove `Type`to structs of parameters and add `Param` to those parameterizations which clash with parameters structs
parent c449d80c
......@@ -200,7 +200,7 @@ public:
const auto& par =
std::get<std::shared_ptr<ParameterizationType>>(_cache);
const auto cond_f = par->conductivity_f();
using Saturation = typename ParameterizationType::SaturationType;
using Saturation = typename ParameterizationType::Saturation;
const auto& xi_cond = std::get<Scaling>(_cache).scale_cond;
......@@ -220,7 +220,7 @@ public:
const auto& par =
std::get<std::shared_ptr<ParameterizationType>>(_cache);
const auto sat_f = par->saturation_f();
using MatricHead = typename ParameterizationType::MatricHeadType;
using MatricHead = typename ParameterizationType::MatricHead;
const auto& scale_head = std::get<Scaling>(_cache).scale_head;
......@@ -244,7 +244,7 @@ public:
const auto& scale_por = std::get<Scaling>(_cache).scale_por;
const auto wc_f = par->water_content_f(scale_por);
using Saturation = typename ParameterizationType::SaturationType;
using Saturation = typename ParameterizationType::Saturation;
return [wc_f](const RF saturation) {
return wc_f(Saturation{saturation}).value;
};
......
......@@ -33,56 +33,56 @@ public:
// These are standard types for all parameterizations of Richards Equation
/// Type of water saturation
struct SaturationType
struct Saturation
{
RF value;
};
/// Type of volumetric water content
struct WaterContentType
struct WaterContent
{
RF value;
};
/// Type of hydraulic conductivity
struct ConductivityType
struct Conductivity
{
RF value;
};
/// Type of matric head
struct MatricHeadType
struct MatricHead
{
RF value;
};
/// Parameter defining the saturated hydraulic conductivity
struct SaturatedConductivityType
struct SaturatedConductivity
{
RF value;
inline static const std::string name = "k0";
};
/// Parameter defining the residual water content
struct ResidualWaterContentType
struct ResidualWaterContent
{
RF value;
inline static const std::string name = "theta_r";
};
/// Parameter defining the saturated water content
struct SaturatedWaterContentType
struct SaturatedWaterContent
{
RF value;
inline static const std::string name = "theta_s";
};
//! Value of the residual water content.
ResidualWaterContentType _theta_r;
ResidualWaterContent _theta_r;
//! Value of the saturated water content.
SaturatedWaterContentType _theta_s;
SaturatedWaterContent _theta_s;
//! Value of the saturated hydraulic conductivity.
SaturatedConductivityType _k0;
SaturatedConductivity _k0;
//! The name of this parameterization instance, associated with the layer.
const std::string _name;
......@@ -103,9 +103,9 @@ public:
template<typename... Args>
Richards (const std::string name,
const std::tuple<Args...> parameters) :
_theta_r(std::get<ResidualWaterContentType>(parameters)),
_theta_s(std::get<SaturatedWaterContentType>(parameters)),
_k0(std::get<SaturatedConductivityType>(parameters)),
_theta_r(std::get<ResidualWaterContent>(parameters)),
_theta_s(std::get<SaturatedWaterContent>(parameters)),
_k0(std::get<SaturatedConductivity>(parameters)),
_name(name)
{ }
......@@ -119,12 +119,12 @@ public:
/** \param scale_por Porosity scaling factor
* \return Function: Saturation -> Water content
*/
std::function<WaterContentType(const SaturationType)> water_content_f (
std::function<WaterContent(const Saturation)> water_content_f (
const RF& scale_por
) const
{
return [this, &scale_por](const SaturationType sat) {
return WaterContentType{
return [this, &scale_por](const Saturation sat) {
return WaterContent{
sat.value * (_theta_s.value - _theta_r.value + scale_por)
+ _theta_r.value
};
......@@ -134,13 +134,13 @@ public:
/// Return a bound version of the saturation function
/** \return Function: Matric Head -> Water content
*/
virtual std::function<SaturationType(const MatricHeadType)> saturation_f () const
virtual std::function<Saturation(const MatricHead)> saturation_f () const
= 0;
/// Return a bound version of the conductivity function
/** \return Function: Saturation -> Hydraulic conductivity
*/
virtual std::function<ConductivityType(const SaturationType)> conductivity_f ()
virtual std::function<Conductivity(const Saturation)> conductivity_f ()
const = 0;
/// Return a multimap referecing all parameters by their names.
......
......@@ -33,13 +33,13 @@ private:
public:
using SaturationType = typename Base::SaturationType;
using ConductivityType = typename Base::ConductivityType;
using MatricHeadType = typename Base::MatricHeadType;
using SaturatedConductivityType = typename Base::SaturatedConductivityType;
using Saturation = typename Base::Saturation;
using Conductivity = typename Base::Conductivity;
using MatricHead = typename Base::MatricHead;
using SaturatedConductivity = typename Base::SaturatedConductivity;
using ResidualWaterContentType = typename Base::ResidualWaterContentType;
using SaturatedWaterContentType = typename Base::SaturatedWaterContentType;
using ResidualWaterContent = typename Base::ResidualWaterContent;
using SaturatedWaterContent = typename Base::SaturatedWaterContent;
/// Parameter defining the value of alpha (air-entry value)
struct Alpha
......@@ -98,12 +98,12 @@ public:
/// Return a scaled conductivity function
/** Saturation -> Conductivity
*/
std::function<ConductivityType(const SaturationType)> conductivity_f () const
std::function<Conductivity(const Saturation)> conductivity_f () const
override
{
const auto m = 1.0 - 1.0 / _n.value;
return [this, m](const SaturationType sat) {
return ConductivityType {
return [this, m](const Saturation sat) {
return Conductivity {
this->_k0.value
* std::pow(sat.value, _tau.value)
* std::pow(1 - std::pow(1 - std::pow(sat.value, 1.0/m), m), 2)
......@@ -114,15 +114,15 @@ public:
/// Return a scaled saturation function
/** Matric head -> Saturation
*/
std::function<SaturationType(const MatricHeadType)> saturation_f () const
std::function<Saturation(const MatricHead)> saturation_f () const
override
{
const auto m = 1.0 - 1.0 / _n.value;
return [this, m](const MatricHeadType head) {
return [this, m](const MatricHead head) {
if (head.value >= 0.0) {
return SaturationType{1.0};
return Saturation{1.0};
}
return SaturationType {
return Saturation {
std::pow(1 + std::pow(_alpha.value * head.value, _n.value), -m)
};
};
......@@ -134,9 +134,9 @@ public:
std::multimap<std::string, double&> parameters () override
{
return {
{ResidualWaterContentType::name, this->_theta_r.value},
{SaturatedWaterContentType::name, this->_theta_s.value},
{SaturatedConductivityType::name, this->_k0.value},
{ResidualWaterContent::name, this->_theta_r.value},
{SaturatedWaterContent::name, this->_theta_s.value},
{SaturatedConductivity::name, this->_k0.value},
{Alpha::name, _alpha.value},
{Tau::name, _tau.value},
{N::name, _n.value}
......@@ -149,9 +149,9 @@ public:
std::multimap<std::string, const double&> parameters () const override
{
return {
{ResidualWaterContentType::name, this->_theta_r.value},
{SaturatedWaterContentType::name, this->_theta_s.value},
{SaturatedConductivityType::name, this->_k0.value},
{ResidualWaterContent::name, this->_theta_r.value},
{SaturatedWaterContent::name, this->_theta_s.value},
{SaturatedConductivity::name, this->_k0.value},
{Alpha::name, _alpha.value},
{Tau::name, _tau.value},
{N::name, _n.value}
......
......@@ -52,14 +52,14 @@ struct TransportFactory
try {
mu::Parser parser;
parser.DefineConst(ConstHydrodynamicDispersion<Traits>::type, 1);
parser.DefineConst(ConstHydrodynamicDispersionParam<Traits>::type, 1);
parser.DefineConst(PowerLawDispersion<Traits>::type, 2);
parser.DefineConst(ConstEffectiveDiffusion<Traits>::type, 10);
parser.DefineConst(ConstEffectiveDiffusionParam<Traits>::type, 10);
parser.DefineConst(MillingtonQuirk1<Traits>::type, 20);
parser.DefineConst(MillingtonQuirk2<Traits>::type, 30);
parser.DefineConst(ConstEffectiveHydromechanicDispersion<Traits>::type, 100);
parser.DefineConst(ConstEffectiveHydromechanicDispersionParam<Traits>::type, 100);
parser.DefineConst(IsotropicEffectiveHydromechanicDispersion<Traits>::type, 200);
parser.SetExpr(type_node["type"].as<std::string>());
......@@ -83,18 +83,18 @@ struct TransportFactory
{return (uint)(number*std::pow(10,-1*x))%10;};
if (type == 1) {
hd_dips = std::make_shared<ConstHydrodynamicDispersion<Traits>>(name);
hd_dips = std::make_shared<ConstHydrodynamicDispersionParam<Traits>>(name);
} else if (type == 2) {
hd_dips = std::make_shared<PowerLawDispersion<Traits>>(name);
} else if (get_digit(type,0) == 0) {
std::shared_ptr<EffectiveDiffusion<Traits>> eff_diff;
std::shared_ptr<EffectiveDiffusionParam<Traits>> eff_diff;
// Select effective diffusion according to digit 1 of 'type'
uint type_1 = get_digit(type,1);
// Build parametrization for effective diffusion
if (type_1 == 1) {
eff_diff = std::make_shared<ConstEffectiveDiffusion<Traits>>(name);
eff_diff = std::make_shared<ConstEffectiveDiffusionParam<Traits>>(name);
} else if (type_1 == 2) {
eff_diff = std::make_shared<MillingtonQuirk1<Traits>>(name);
} else if (type_1 == 3) {
......@@ -107,23 +107,23 @@ struct TransportFactory
}
// Select type for effective hydromechanic dispersion
std::shared_ptr<EffectiveHydromechanicDispersion<Traits>> eff_hm_disp;
std::shared_ptr<EffectiveHydromechanicDispersionParam<Traits>> eff_hm_disp;
// Select effective hydromechanic dispersion according to digit 2 of 'type'
uint type_2 = get_digit(type,2);
// Build parametrization for effective hydromechanic dispersion
if (type_2 == 1) {
eff_hm_disp = std::make_shared<ConstEffectiveHydromechanicDispersion<Traits>>(name);
eff_hm_disp = std::make_shared<ConstEffectiveHydromechanicDispersionParam<Traits>>(name);
} else if (type_2 == 2) {
// Select type for longitudinal and transverse dispersivity
std::shared_ptr<ConstLongitudinalDispersivity<Traits>> lambda_l;
std::shared_ptr<ConstTransverseDispersivity<Traits>> lambda_t;
std::shared_ptr<ConstLongitudinalDispersivityParam<Traits>> lambda_l;
std::shared_ptr<ConstTransverseDispersivityParam<Traits>> lambda_t;
// Build parametrization for longitudinal dispersivity
// if (...) {
lambda_l = std::make_shared<ConstLongitudinalDispersivity<Traits>>(name);
lambda_l = std::make_shared<ConstLongitudinalDispersivityParam<Traits>>(name);
// } else {
// log->error("Longitudinal Dispersivity parameterization '{}' "
// "has unknown type '{}'",
......@@ -133,7 +133,7 @@ struct TransportFactory
// Build parametrization for transverse dispersivity
// if (...) {
lambda_t = std::make_shared<ConstTransverseDispersivity<Traits>>(name);
lambda_t = std::make_shared<ConstTransverseDispersivityParam<Traits>>(name);
// } else {
// log->error("Transverse Dispersivity parameterization '{}' "
// "has unknown type '{}'",
......
......@@ -21,7 +21,7 @@ namespace Parameterization {
* @tparam Traits the base traits
*/
template <class Traits>
class ConstHydrodynamicDispersion :
class ConstHydrodynamicDispersionParam :
public Transport<Traits>
{
private:
......@@ -29,12 +29,12 @@ private:
using Base = Transport<Traits>;
public:
using HydrodynamicDispersionType = typename Base::HydrodynamicDispersionType;
using WaterFluxType = typename Base::WaterFluxType;
using WaterContentType = typename Base::WaterContentType;
using HydrodynamicDispersion = typename Base::HydrodynamicDispersion;
using WaterFlux = typename Base::WaterFlux;
using WaterContent = typename Base::WaterContent;
/// Parameter defining the constant hydrodynamic dispersion tensor
struct ConstHydrodynamicDispersionType
struct ConstHydrodynamicDispersion
{
Tensor value;
inline static const std::string name = "hydrodynamic_disp";
......@@ -43,14 +43,14 @@ public:
/// The name of this parameterization type (This is not the instance name)
static inline std::string type = "Dhd_const";
ConstHydrodynamicDispersionType _const_hydrodynamic_dispersion;
ConstHydrodynamicDispersion _const_hydrodynamic_dispersion;
public:
/// Construct with default-initialized parameters
/** \param name The name associated with this soil layer
*/
ConstHydrodynamicDispersion (const std::string name) :
ConstHydrodynamicDispersionParam (const std::string name) :
Transport<Traits>(name)
{ }
......@@ -59,24 +59,24 @@ public:
* \param parameters Tuple of parameters to use in this parameterization
*/
template<typename... Args>
ConstHydrodynamicDispersion (
ConstHydrodynamicDispersionParam (
const std::string name,
const std::tuple<Args...> parameters) :
Base(name, parameters),
_const_hydrodynamic_dispersion(std::get<ConstHydrodynamicDispersionType>(parameters))
_const_hydrodynamic_dispersion(std::get<ConstHydrodynamicDispersion>(parameters))
{ }
/// Add default destructor to clarify override
~ConstHydrodynamicDispersion () override = default;
~ConstHydrodynamicDispersionParam () override = default;
/// Return the hydrodynamic dispersion
/** {WaterFlux,WaterContent} -> HydrodynamicDispersion
*/
std::function<HydrodynamicDispersionType(const WaterFluxType, const WaterContentType)>
std::function<HydrodynamicDispersion(const WaterFlux, const WaterContent)>
hydrodynamic_dispersion_f () const override
{
return [this](const WaterFluxType, const WaterContentType) {
return HydrodynamicDispersionType{_const_hydrodynamic_dispersion.value};
return [this](const WaterFlux, const WaterContent) {
return HydrodynamicDispersion{_const_hydrodynamic_dispersion.value};
};
}
......@@ -91,7 +91,7 @@ public:
Map new_param;
Map compsite_map;
auto _const_type_name = ConstHydrodynamicDispersionType::name;
auto _const_type_name = ConstHydrodynamicDispersion::name;
if constexpr (Traits::dim == 2)
new_param = Map({
......@@ -133,7 +133,7 @@ public:
Map new_param;
Map compsite_map;
auto _const_type_name = ConstHydrodynamicDispersionType::name;
auto _const_type_name = ConstHydrodynamicDispersion::name;
if constexpr (Traits::dim == 2)
new_param = Map({
......@@ -169,7 +169,7 @@ public:
*/
std::unique_ptr<Transport<Traits>> clone () const override
{
using ThisType = ConstHydrodynamicDispersion<Traits>;
using ThisType = ConstHydrodynamicDispersionParam<Traits>;
return std::make_unique<ThisType>(*this);
}
};
......
......@@ -22,20 +22,20 @@ namespace Parameterization {
* @tparam Traits the base traits
*/
template <class Traits>
class ConstEffectiveDiffusion
: public EffectiveDiffusion<Traits>
class ConstEffectiveDiffusionParam
: public EffectiveDiffusionParam<Traits>
{
private:
using RangeField = typename Traits::RF;
using Base = EffectiveDiffusion<Traits>;
using Base = EffectiveDiffusionParam<Traits>;
public:
using EffectiveDiffusionType = typename Base::EffectiveDiffusionType;
using WaterFluxType = typename Base::WaterFluxType;
using WaterContentType = typename Base::WaterContentType;
using EffectiveDiffusion = typename Base::EffectiveDiffusion;
using WaterFlux = typename Base::WaterFlux;
using WaterContent = typename Base::WaterContent;
/// Parameter defining the constant effective diffusion
struct ConstEffectiveDiffusionType
struct ConstEffectiveDiffusion
{
RangeField value;
inline static const std::string name = "eff_diff";
......@@ -44,15 +44,15 @@ public:
/// The name of this parameterization type (This is not the instance name)
static inline std::string type = "Deff_const";
ConstEffectiveDiffusionType _const_eff_diff;
ConstEffectiveDiffusion _const_eff_diff;
public:
/// Construct with default-initialized parameters
/** \param name The name associated with this soil layer
*/
ConstEffectiveDiffusion (const std::string name) :
EffectiveDiffusion<Traits>(name)
ConstEffectiveDiffusionParam (const std::string name) :
EffectiveDiffusionParam<Traits>(name)
{ }
/// Construct from a tuple of parameters
......@@ -60,26 +60,26 @@ public:
* \param parameters Tuple of parameters to use in this parameterization
*/
template<typename... Args>
ConstEffectiveDiffusion (
ConstEffectiveDiffusionParam (
const std::string name,
const std::tuple<Args...> parameters) :
EffectiveDiffusion<Traits>(name, parameters),
EffectiveDiffusionParam<Traits>(name, parameters),
_const_eff_diff(std::get<ConstEffectiveDiffusion>(parameters))
{ }
/// Add default destructor to clarify override
~ConstEffectiveDiffusion () override = default;
~ConstEffectiveDiffusionParam () override = default;
public:
/// Return the effective diffusion
/** {WaterFlux,WaterContent} -> EffectiveDiffusion
*/
std::function<EffectiveDiffusionType(const WaterFluxType, const WaterContentType)>
std::function<EffectiveDiffusion(const WaterFlux, const WaterContent)>
effective_diffusion_f () const override
{
return [this](const WaterFluxType, const WaterContentType) {
return EffectiveDiffusionType{_const_eff_diff.value};
return [this](const WaterFlux, const WaterContent) {
return EffectiveDiffusion{_const_eff_diff.value};
};
}
......@@ -88,7 +88,7 @@ public:
*/
std::multimap<std::string, double&> parameters () override
{
const std::string _const_eff_diff_name = ConstEffectiveDiffusionType::name;
const std::string _const_eff_diff_name = ConstEffectiveDiffusion::name;
return {{_const_eff_diff_name, _const_eff_diff.value}};
}
......@@ -97,16 +97,16 @@ public:
*/
std::multimap<std::string, const double&> parameters () const override
{
const std::string _const_eff_diff_name = ConstEffectiveDiffusionType::name;
const std::string _const_eff_diff_name = ConstEffectiveDiffusion::name;
return {{_const_eff_diff_name, _const_eff_diff.value}};
}
/// Clone the plymorphic class
/** \return unique pointer to the cloned object
*/
std::unique_ptr<EffectiveDiffusion<Traits>> clone () const override
std::unique_ptr<EffectiveDiffusionParam<Traits>> clone () const override
{
using ThisType = ConstEffectiveDiffusion<Traits>;
using ThisType = ConstEffectiveDiffusionParam<Traits>;
return std::make_unique<ThisType>(*this);
}
};
......
......@@ -21,7 +21,7 @@ namespace Parameterization {
* @tparam Traits the base traits
*/
template <class Traits>
class EffectiveDiffusion
class EffectiveDiffusionParam
{
private:
using RangeField = typename Traits::RF;
......@@ -30,13 +30,13 @@ private:
public:
/// Type of the effective diffusion
struct EffectiveDiffusionType
struct EffectiveDiffusion
{
RangeField value;
};
using WaterFluxType = typename BaseP::WaterFluxType;
using WaterContentType = typename BaseP::WaterContentType;
using WaterFlux = typename BaseP::WaterFlux;
using WaterContent = typename BaseP::WaterContent;
//! The name of this parameterization instance, associated with the layer.
const std::string _name;
......@@ -45,7 +45,7 @@ public:
/// Construct with default-initialized parameters
/** \param name The name associated with this soil layer
*/
EffectiveDiffusion (const std::string name)
EffectiveDiffusionParam (const std::string name)
: _name(name)
{ }
......@@ -54,14 +54,14 @@ public:
* \param parameters Tuple of parameters to use in this parameterization
*/
template<typename... Args>
EffectiveDiffusion (
EffectiveDiffusionParam (
const std::string name,
const std::tuple<Args...> parameters)
: _name(name)
{ }
/// Default constructor (virtual).
virtual ~EffectiveDiffusion () = default;
virtual ~EffectiveDiffusionParam () = default;
/// Return the name of this parameterization instance.
const std::string& get_name() const { return _name; }
......@@ -70,7 +70,7 @@ public:
/** \return Function: {Water Flux, Water Content} -> Effective Diff.
*/
virtual std::function<
EffectiveDiffusionType(const WaterFluxType, const WaterContentType)>
EffectiveDiffusion(const WaterFlux, const WaterContent)>
effective_diffusion_f () const = 0;
/// Return a map referecing all parameters by their names.
......@@ -88,7 +88,7 @@ public:
/// Clone the plymorphic class
/** \return unique pointer to the cloned object
*/
virtual std::unique_ptr<EffectiveDiffusion<Traits>> clone () const = 0;
virtual std::unique_ptr<EffectiveDiffusionParam<Traits>> clone () const = 0;
};
......
......@@ -27,16 +27,16 @@ namespace Parameterization {
*/
template <class Traits>
class MillingtonQuirk1
: public EffectiveDiffusion<Traits>
: public EffectiveDiffusionParam<Traits>
{
private:
using RangeField = typename Traits::RF;
using Base = EffectiveDiffusion<Traits>;
using Base = EffectiveDiffusionParam<Traits>;
public:
using EffectiveDiffusionType = typename Base::EffectiveDiffusionType;
using WaterFluxType = typename Base::WaterFluxType;
using WaterContentType = typename Base::WaterContentType;
using EffectiveDiffusion = typename Base::EffectiveDiffusion;
using WaterFlux = typename Base::WaterFlux;
using WaterContent = typename Base::WaterContent;
/// Parameter defining molecular diffusion
struct ModelcularDiffusionType
......@@ -86,12 +86,12 @@ public:
/// Return the effective diffusion
/** {WaterFlux,WaterContent} -> EffectiveDiffusion
*/
std::function<EffectiveDiffusionType(const WaterFluxType, const WaterContentType)>
std::function<EffectiveDiffusion(const WaterFlux, const WaterContent)>
effective_diffusion_f () const override
{
return [this](const WaterFluxType water_flux, const WaterContentType water_content) {
return [this](const WaterFlux water_flux, const WaterContent water_content) {
auto val = _mol_diff.value*std::pow(water_content.value,7./3.)/std::pow(_porosity.value,2./3.);
return EffectiveDiffusionType{val};
return EffectiveDiffusion{val};
};
}
......@@ -120,7 +120,7 @@ public:
/// Return a map of parameter names and values for manipulation
/** \return Map: Parameter name, parameter value in this object
*/
std::unique_ptr<EffectiveDiffusion<Traits>> clone () const override
std::unique_ptr<EffectiveDiffusionParam<Traits>> clone () const override
{
using ThisType = MillingtonQuirk1<Traits>;
return std::make_unique<ThisType>(*this);
......
......@@ -27,16 +27,16 @@ namespace Parameterization {
*/
template <class Traits>
class MillingtonQuirk2
: public EffectiveDiffusion<Traits>
: public EffectiveDiffusionParam<Traits>
{
private:
using RangeField = typename Traits::RF;
using Base = EffectiveDiffusion<Traits>;
using Base = EffectiveDiffusionParam<Traits>;
public:
using EffectiveDiffusionType = typename Base::EffectiveDiffusionType;
using WaterFluxType = typename Base::WaterFluxType;
using WaterContentType = typename Base::WaterContentType;
using EffectiveDiffusion = typename Base::EffectiveDiffusion;
using WaterFlux = typename Base::WaterFlux;
using WaterContent = typename Base::WaterContent;
/// Parameter defining molecular diffusion
struct ModelcularDiffusionType
......@@ -86,12 +86,12 @@ public:
/// Return the effective diffusion
/** {WaterFlux,WaterContent} -> EffectiveDiffusion
*/
std::function<EffectiveDiffusionType(const WaterFluxType, const WaterContentType)>
std::function<EffectiveDiffusion(const WaterFlux, const WaterContent)>
effective_diffusion_f () const override
{
return [this](const WaterFluxType water_flux, const WaterContentType water_content) {
return [this](const WaterFlux water_flux, const WaterContent water_content) {
auto val = _mol_diff.value*water_content.value/std::pow(_porosity.value,2./3.);
return EffectiveDiffusionType{val};
return EffectiveDiffusion{val};
};
}
......@@ -120,7 +120,7 @@ public:
/// Return a map of parameter names and values for manipulation
/** \return Map: Parameter name, parameter value in this object
*/
std::unique_ptr<EffectiveDiffusion<Traits>> clone () const override
std::unique_ptr<EffectiveDiffusionParam<Traits>> clone () const override
{
using ThisType = MillingtonQuirk2<Traits>;
return std::make_unique<ThisType>(*this);
......
......@@ -21,20 +21,20 @@ namespace Parameterization {
* @tparam Traits the base traits
*/
template <class Traits>
class ConstEffectiveHydromechanicDispersion :
public EffectiveHydromechanicDispersion<Traits>