MaterialLib/MPL/Property.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#include "Property.h"
 
#include <string>
 
#include "Component.h"
#include "Medium.h"
#include "Phase.h"
 
namespace MaterialPropertyLib
{
PropertyDataType fromVector(std::vector<double> const& values)
{
    switch (values.size())
    {
        case 1:
        {
            return values[0];
        }
        case 2:
        {
            return Eigen::Vector2d{values[0], values[1]};
        }
        case 3:
        {
            return Eigen::Vector3d{values[0], values[1], values[2]};
        }
        case 4:
        {
            using M = Eigen::Matrix2d;
            // the values vector is in row major order
            using MRM = Eigen::Matrix<double, 2, 2, Eigen::RowMajor>;
            return M{Eigen::Map<MRM const>{values.data(), 2, 2}};
        }
        case 6:
        {
            // Symmetric Tensor - xx, yy, zz, xy, xz, yz
            using M = Eigen::Matrix<double, 6, 1>;
            return M{Eigen::Map<M const>{values.data(), 6}};
        }
        case 9:
        {
            using M = Eigen::Matrix3d;
            // the values vector is in row major order
            using MRM = Eigen::Matrix<double, 3, 3, Eigen::RowMajor>;
            return M{Eigen::Map<MRM const>{values.data(), 3, 3}};
        }
        default:
        {
            OGS_FATAL(
                "Conversion of a {:d}-vector to PropertyDataType is not "
                "implemented.",
                values.size());
        }
    }
}
 
PropertyDataType Property::initialValue(
    ParameterLib::SpatialPosition const& pos, double const t) const
{
    return value(EmptyVariableArray, pos, t,
                 std::numeric_limits<double>::quiet_NaN());
}
 
PropertyDataType Property::value() const
{
#ifndef NDEBUG
    property_used = true;
#endif
    return value_;
}
 
PropertyDataType Property::value(VariableArray const& /*variable_array*/,
                                 VariableArray const& /*variable_array_prev*/,
                                 ParameterLib::SpatialPosition const& /*pos*/,
                                 double const /*t*/, double const /*dt*/) const
{
#ifndef NDEBUG
    property_used = true;
#endif
    return value_;
}
 
PropertyDataType Property::value(VariableArray const& variable_array,
                                 ParameterLib::SpatialPosition const& pos,
                                 double const t, double const dt) const
{
#ifndef NDEBUG
    property_used = true;
#endif
    return value(variable_array, EmptyVariableArray, pos, t, dt);
}
 
PropertyDataType Property::dValue(VariableArray const& /*variable_array*/,
                                  VariableArray const& /*variable_array_prev*/,
                                  Variable const /*variable*/,
                                  ParameterLib::SpatialPosition const& /*pos*/,
                                  double const /*t*/, double const /*dt*/) const
{
#ifndef NDEBUG
    property_used = true;
#endif
    return dvalue_;
}

PropertyDataType Property::dValue(VariableArray const& variable_array,
                                  Variable const variable,
                                  ParameterLib::SpatialPosition const& pos,
                                  double const t, double const dt) const
{
#ifndef NDEBUG
    property_used = true;
#endif
    return dValue(variable_array, EmptyVariableArray, variable, pos, t, dt);
}

PropertyDataType Property::d2Value(VariableArray const& /*variable_array*/,
                                   Variable const /*variable*/,
                                   Variable const /*variable*/,
                                   ParameterLib::SpatialPosition const& /*pos*/,
                                   double const /*t*/,
                                   double const /*dt*/) const
{
#ifndef NDEBUG
    property_used = true;
#endif
    return 0.0;
}

void Property::setProperties(
    std::vector<std::unique_ptr<Phase>> const& /*phases*/)
{
    // empty
}
 
std::string Property::description() const
{
    return "property '" + name_ + "' defined for " +
           std::visit(
               [](auto&& scale) -> std::string
               {
                   if (scale == nullptr)
                   {
                       return "unknown scale";
                   }
                   return scale->description();
               },
               scale_);
}
}  // namespace MaterialPropertyLib