FractureProperty.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <memory>
 
#include "BranchProperty.h"
#include "JunctionProperty.h"
#include "MaterialLib/FractureModels/Permeability/Permeability.h"
#include "MeshLib/ElementCoordinatesMappingLocal.h"
#include "MeshLib/Elements/Element.h"
 
namespace ParameterLib
{
template <typename T>
struct Parameter;
}
 
namespace ProcessLib
{
namespace LIE
{
struct FractureProperty
{
    int fracture_id = 0;
    int mat_id = 0;
    Eigen::Vector3d point_on_fracture;
    Eigen::Vector3d normal_vector;
    Eigen::MatrixXd R;
    ParameterLib::Parameter<double> const& aperture0;
    std::vector<BranchProperty> branches_master;
    std::vector<BranchProperty> branches_slave;
 
    FractureProperty(int const fracture_id_, int const material_id,
                     ParameterLib::Parameter<double> const& initial_aperture)
        : fracture_id(fracture_id_),
          mat_id(material_id),
          aperture0(initial_aperture)
    {
    }
 
    virtual ~FractureProperty() = default;
};
 
struct FracturePropertyHM : public FractureProperty
{
    FracturePropertyHM(int const fracture_id_, int const material_id,
                       ParameterLib::Parameter<double> const& initial_aperture,
                       ParameterLib::Parameter<double> const& specific_storage_,
                       ParameterLib::Parameter<double> const& biot_coefficient_)
        : FractureProperty(fracture_id_, material_id, initial_aperture),
          specific_storage(specific_storage_),
          biot_coefficient(biot_coefficient_)
    {
    }
    ParameterLib::Parameter<double> const& specific_storage;
    ParameterLib::Parameter<double> const& biot_coefficient;
 
    std::unique_ptr<MaterialLib::Fracture::Permeability::Permeability>
        permeability_model;
};
 
inline void setFractureProperty(int const dim, MeshLib::Element const& e,
                                FractureProperty& frac_prop)
{
    auto& n = frac_prop.normal_vector;
    // 1st node is used but using other node is also possible, because
    // a fracture is not curving
    for (int j = 0; j < 3; j++)
    {
        frac_prop.point_on_fracture[j] = getCenterOfGravity(e).data()[j];
    }
 
    const MeshLib::ElementCoordinatesMappingLocal ele_local_coord(e, dim);
 
    // Global to local rotation matrix:
    Eigen::MatrixXd const global2local_rotation =
        ele_local_coord.getRotationMatrixToGlobal().transpose();
    n = global2local_rotation.row(dim - 1);
 
    frac_prop.R = global2local_rotation.topLeftCorner(dim, dim);
 
    DBUG("Normal vector of the fracture element {:d}: [{:g}, {:g}, {:g}]",
         e.getID(), n[0], n[1], n[2]);
}
 
inline BranchProperty createBranchProperty(MeshLib::Node const& branchNode,
                                           FractureProperty const& master_frac,
                                           FractureProperty const& slave_frac)
{
    BranchProperty branch{branchNode, master_frac.fracture_id,
                          slave_frac.fracture_id};
 
    // set a normal vector from the master to the slave fracture
    Eigen::Vector3d branch_vector =
        slave_frac.point_on_fracture - branch.coords;
    double sign = (branch_vector.dot(master_frac.normal_vector) < 0) ? -1 : 1;
    branch.normal_vector_branch = sign * master_frac.normal_vector;
    return branch;
}
}  // namespace LIE
}  // namespace ProcessLib