CreateEmbeddedFracturePermeability.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#include "BaseLib/ConfigTree.h"
#include "EmbeddedFracturePermeability.h"
#include "ParameterLib/Utils.h"
 
namespace MaterialPropertyLib
{
std::unique_ptr<Property> createEmbeddedFracturePermeability(
    int const geometry_dimension, BaseLib::ConfigTree const& config,
    std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters)
{
    if ((geometry_dimension != 2) && (geometry_dimension != 3))
    {
        OGS_FATAL(
            "The EmbeddedFracturePermeability is implemented only for 2D or 3D "
            "problems");
    }

    config.checkConfigParameter("type", "EmbeddedFracturePermeability");
 
    // Second access for storage.
    auto property_name = config.peekConfigParameter<std::string>("name");
 
    DBUG("Create EmbeddedFracturePermeability medium property");
 
    auto const k =
        config.getConfigParameter<double>("intrinsic_permeability");
 
    auto const b0 =
        config.getConfigParameter<double>("initial_aperture");
 
    auto const a =
        config.getConfigParameter<double>("mean_frac_distance");
 
    auto const e0 =
        config.getConfigParameter<double>("threshold_strain");
 
    bool n_const = false;
    Eigen::Matrix<double, 3, 1> n;
    if (auto const n_ptr =
        config.getConfigParameterOptional<std::vector<double>>(
            "fracture_normal"))
    {
        if ((*n_ptr).size() != 3)
        {
            OGS_FATAL(
                "The size of the fracture normal vector must be 3, but is %d.",
                (*n_ptr).size());
        }
        DBUG("Using constant fracture normal vector.");
        std::copy_n((*n_ptr).data(), 3, n.data());
        n_const = true;
        n /= n.norm();
    }
    else
    {
        DBUG(
            "No constant fracture normal was given. By default it will be "
            "determined as the third principal stress vector.");
    }
 
    std::string const fracture_rotation_xy_param_name =
        config.getConfigParameter<std::string>("fracture_rotation_xy");
 
    auto const& phi_xy = ParameterLib::findParameter<double>(
        fracture_rotation_xy_param_name, parameters, 0, nullptr);
 
    std::string const fracture_rotation_yz_param_name =
        config.getConfigParameter<std::string>("fracture_rotation_yz");
 
    auto const& phi_yz = ParameterLib::findParameter<double>(
        fracture_rotation_yz_param_name, parameters, 0, nullptr);
 
    auto const jf =
        config.getConfigParameter<double>("jacobian_factor", 0.);
 
    if (geometry_dimension == 2)
    {
        return std::make_unique<EmbeddedFracturePermeability<2>>(
            std::move(property_name), n, n_const, k, b0, a, e0, phi_xy, phi_yz,
            jf);
    }
    return std::make_unique<EmbeddedFracturePermeability<3>>(
        std::move(property_name), n, n_const, k, b0, a, e0, phi_xy, phi_yz, jf);
}
}  // namespace MaterialPropertyLib