ProcessLib::LIE Namespace Reference

Namespaces
	anonymous_namespace{MeshUtils.cpp}
	anonymous_namespace{PostUtils.cpp}
	HydroMechanics
	SmallDeformation

Classes
struct	BranchProperty
struct	FractureProperty
struct	FracturePropertyHM
struct	JunctionProperty
class	PostProcessTool

Functions
void	setFractureProperty (int const dim, MeshLib::Element const &e, FractureProperty &frac_prop)
BranchProperty	createBranchProperty (MeshLib::Node const &branchNode, FractureProperty const &master_frac, FractureProperty const &slave_frac)
bool	levelsetFracture (FractureProperty const &frac, Eigen::Vector3d const &x)
bool	levelsetBranch (BranchProperty const &branch, Eigen::Vector3d const &x)
std::vector< double >	uGlobalEnrichments (std::vector< FractureProperty * > const &frac_props, std::vector< JunctionProperty * > const &junction_props, std::unordered_map< int, int > const &fracID_to_local, Eigen::Vector3d const &x)
std::vector< double >	duGlobalEnrichments (std::size_t this_frac_id, std::vector< FractureProperty * > const &frac_props, std::vector< JunctionProperty * > const &junction_props, std::unordered_map< int, int > const &fracID_to_local, Eigen::Vector3d const &x)
void	getFractureMatrixDataInMesh (MeshLib::Mesh const &mesh, std::vector< MeshLib::Element * > &vec_matrix_elements, std::vector< int > &vec_fracture_mat_IDs, std::vector< std::vector< MeshLib::Element * >> &vec_fracture_elements, std::vector< std::vector< MeshLib::Element * >> &vec_fracture_matrix_elements, std::vector< std::vector< MeshLib::Node * >> &vec_fracture_nodes, std::vector< std::pair< std::size_t, std::vector< int >>> &vec_branch_nodeID_matIDs, std::vector< std::pair< std::size_t, std::vector< int >>> &vec_junction_nodeID_matIDs)
template<typename Derived >
MathLib::Point3d	computePhysicalCoordinates (MeshLib::Element const &e, Eigen::MatrixBase< Derived > const &shape)

Function Documentation

computePhysicalCoordinates()

template<typename Derived >

MathLib::Point3d ProcessLib::LIE::computePhysicalCoordinates	(	MeshLib::Element const &	e,
		Eigen::MatrixBase< Derived > const &	shape
	)

compute physical coordinates from the given shape vector, i.e. from the natural coordinates

Definition at line 24 of file Utils.h.

{
    MathLib::Point3d pt;
    for (unsigned i = 0; i < e.getNumberOfNodes(); i++)
    {
        MeshLib::Node const& node = *e.getNode(i);
        for (unsigned j = 0; j < 3; j++)
        {
            pt[j] += shape[i] * node[j];
        }
    }
    return pt;
}

References MeshLib::Element::getNode(), and MeshLib::Element::getNumberOfNodes().

Referenced by ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerFracture< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), and ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerFracture< ShapeFunction, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcreteWithVector().

createBranchProperty()

BranchProperty ProcessLib::LIE::createBranchProperty ( MeshLib::Node const &  branchNode, FractureProperty const &  master_frac, FractureProperty const &  slave_frac  )

inline

Definition at line 100 of file FractureProperty.h.

{
    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;
}

References ProcessLib::LIE::FractureProperty::fracture_id, ProcessLib::LIE::FractureProperty::normal_vector, and ProcessLib::LIE::FractureProperty::point_on_fracture.

Referenced by ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess().

duGlobalEnrichments()

std::vector< double > ProcessLib::LIE::duGlobalEnrichments	(	std::size_t	this_frac_id,
		std::vector< FractureProperty * > const &	frac_props,
		std::vector< JunctionProperty * > const &	junction_props,
		std::unordered_map< int, int > const &	fracID_to_local,
		Eigen::Vector3d const &	x
	)

calculate the enrichment function for fracture relative displacements Remarks:

• branch/junction intersections of two fractures are supported in 2D

Parameters

this_frac_id	the fracture ID
frac_props	fracture properties
junction_props	junction properties
fracID_to_local	a mapping table from a fracture ID to a local index in frac_props
x	evaluating point coordinates

Returns

a vector of enrichment values for fracture relative displacements

Definition at line 82 of file LevelSetFunction.cpp.

{
    auto this_frac_local_index = fracID_to_local.at(this_frac_id);
    auto const& this_frac = *frac_props[this_frac_local_index];
    // pre-calculate levelsets for all fractures
    std::vector<bool> levelsets(frac_props.size());
    for (std::size_t i = 0; i < frac_props.size(); i++)
    {
        levelsets[i] = levelsetFracture(*frac_props[i], x);
    }
 
    std::vector<double> enrichments(frac_props.size() + junction_props.size());
    enrichments[this_frac_local_index] = 1.0;
 
    // fractures possibly with branches
    if (frac_props.size() > 1)
    {
        for (auto const& branch : this_frac.branches_master)
        {
            if (branch.master_fracture_id != this_frac.fracture_id)
            {
                continue;
            }
 
            if (fracID_to_local.find(branch.slave_fracture_id) ==
                fracID_to_local.end())
            {
                continue;
            }
 
            double sign = boost::math::sign(
                this_frac.normal_vector.dot(branch.normal_vector_branch));
            auto slave_fid = fracID_to_local.at(branch.slave_fracture_id);
            double const enrich = levelsets[slave_fid] ? 1. : 0.;
            enrichments[slave_fid] = sign * enrich;
        }
    }
 
    // junctions
    for (unsigned i = 0; i < junction_props.size(); i++)
    {
        auto const* junction = junction_props[i];
        if (!BaseLib::contains(junction->fracture_ids, this_frac.fracture_id))
        {
            continue;
        }
 
        auto another_frac_id =
            (junction->fracture_ids[0] == this_frac.fracture_id)
                ? junction->fracture_ids[1]
                : junction->fracture_ids[0];
        auto fid = fracID_to_local.at(another_frac_id);
        double const enrich = levelsets[fid] ? 1. : 0.;
        enrichments[i + frac_props.size()] = enrich;
    }
 
    return enrichments;
}

References BaseLib::contains(), and levelsetFracture().

Referenced by ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerFracture< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), and ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerFracture< ShapeFunction, IntegrationMethod, DisplacementDim >::computeSecondaryVariableConcreteWithVector().

getFractureMatrixDataInMesh()

void ProcessLib::LIE::getFractureMatrixDataInMesh	(	MeshLib::Mesh const &	mesh,
		std::vector< MeshLib::Element * > &	vec_matrix_elements,
		std::vector< int > &	vec_fracture_mat_IDs,
		std::vector< std::vector< MeshLib::Element * >> &	vec_fracture_elements,
		std::vector< std::vector< MeshLib::Element * >> &	vec_fracture_matrix_elements,
		std::vector< std::vector< MeshLib::Node * >> &	vec_fracture_nodes,
		std::vector< std::pair< std::size_t, std::vector< int >>> &	vec_branch_nodeID_matIDs,
		std::vector< std::pair< std::size_t, std::vector< int >>> &	vec_junction_nodeID_matIDs
	)

get data about fracture and matrix elements/nodes from a mesh

Parameters

mesh	A mesh which includes fracture elements, i.e. lower-dimensional elements. It is assumed that elements forming a fracture have a distinct material ID.
vec_matrix_elements	a vector of matrix elements
vec_fracture_mat_IDs	fracture material IDs found in the mesh
vec_fracture_elements	a vector of fracture elements (grouped by fracture IDs)
vec_fracture_matrix_elements	a vector of fracture elements and matrix elements connecting to the fracture (grouped by fracture IDs)
vec_fracture_nodes	a vector of fracture element nodes (grouped by fracture IDs)
vec_branch_nodeID_matIDs	a vector of branch node IDs found in the mesh (and corresponding fracture material IDs)
vec_junction_nodeID_matIDs	a vector of junction node IDs found in the mesh (and corresponding fracture material IDs)

Definition at line 213 of file MeshUtils.cpp.

{
    IsCrackTip isCrackTip(mesh);
 
    // get vectors of matrix elements and fracture elements
    vec_matrix_elements.reserve(mesh.getNumberOfElements());
    std::vector<MeshLib::Element*> all_fracture_elements;
    for (MeshLib::Element* e : mesh.getElements())
    {
        if (e->getDimension() == mesh.getDimension())
        {
            vec_matrix_elements.push_back(e);
        }
        else
        {
            all_fracture_elements.push_back(e);
        }
    }
    DBUG("-> found total {:d} matrix elements and {:d} fracture elements",
         vec_matrix_elements.size(), all_fracture_elements.size());
 
    // get fracture material IDs
    auto const material_ids = materialIDs(mesh);
    if (!material_ids)
    {
        OGS_FATAL("Could not access MaterialIDs property from mesh.");
    }
    transform(cbegin(all_fracture_elements), cend(all_fracture_elements),
              back_inserter(vec_fracture_mat_IDs),
              [&material_ids](auto const* e)
              { return (*material_ids)[e->getID()]; });
 
    BaseLib::makeVectorUnique(vec_fracture_mat_IDs);
    DBUG("-> found {:d} fracture material groups", vec_fracture_mat_IDs.size());
 
    // create a vector of fracture elements for each material
    vec_fracture_elements.resize(vec_fracture_mat_IDs.size());
    for (unsigned frac_id = 0; frac_id < vec_fracture_mat_IDs.size(); frac_id++)
    {
        const auto frac_mat_id = vec_fracture_mat_IDs[frac_id];
        std::vector<MeshLib::Element*>& vec_elements =
            vec_fracture_elements[frac_id];
        std::copy_if(all_fracture_elements.begin(), all_fracture_elements.end(),
                     std::back_inserter(vec_elements),
                     [&](MeshLib::Element* e)
                     { return (*material_ids)[e->getID()] == frac_mat_id; });
        DBUG("-> found {:d} elements on the fracture {:d}", vec_elements.size(),
             frac_id);
    }
 
    // get a vector of fracture nodes for each material
    vec_fracture_nodes.resize(vec_fracture_mat_IDs.size());
    for (unsigned frac_id = 0; frac_id < vec_fracture_mat_IDs.size(); frac_id++)
    {
        std::vector<MeshLib::Node*>& vec_nodes = vec_fracture_nodes[frac_id];
        for (MeshLib::Element* e : vec_fracture_elements[frac_id])
        {
            for (unsigned i = 0; i < e->getNumberOfNodes(); i++)
            {
                if (isCrackTip(*e->getNode(i)))
                {
                    continue;
                }
                vec_nodes.push_back(const_cast<MeshLib::Node*>(e->getNode(i)));
            }
        }
        BaseLib::makeVectorUnique(vec_nodes,
                                  [](MeshLib::Node* node1, MeshLib::Node* node2)
                                  { return node1->getID() < node2->getID(); });
        DBUG("-> found {:d} nodes on the fracture {:d}", vec_nodes.size(),
             frac_id);
    }
 
    // find branch/junction nodes which connect to multiple fractures
    std::vector<std::vector<MeshLib::Element*>> intersected_fracture_elements;
    findFracutreIntersections(mesh, vec_fracture_mat_IDs, vec_fracture_nodes,
                              intersected_fracture_elements,
                              vec_branch_nodeID_matIDs,
                              vec_junction_nodeID_matIDs);
 
    // create a vector fracture elements and connected matrix elements,
    // which are passed to a DoF table
    for (unsigned fid = 0; fid < vec_fracture_elements.size(); fid++)
    {
        auto const& fracture_elements = vec_fracture_elements[fid];
        std::vector<MeshLib::Element*> vec_ele;
        // first, collect matrix elements
        for (MeshLib::Element* e : fracture_elements)
        {
            // it is sufficient to iterate over base nodes, because they are
            // already connected to all neighbours
            for (unsigned i = 0; i < e->getNumberOfBaseNodes(); i++)
            {
                MeshLib::Node const* node = e->getNode(i);
                if (isCrackTip(*node))
                {
                    continue;
                }
                auto const& elements_connected_to_node =
                    mesh.getElementsConnectedToNode(*node);
                for (unsigned j = 0; j < elements_connected_to_node.size(); j++)
                {
                    // only matrix elements
                    if (elements_connected_to_node[j]->getDimension() <
                        mesh.getDimension())
                    {
                        continue;
                    }
                    vec_ele.push_back(const_cast<MeshLib::Element*>(
                        elements_connected_to_node[j]));
                }
            }
        }
        BaseLib::makeVectorUnique(vec_ele,
                                  [](MeshLib::Element* e1, MeshLib::Element* e2)
                                  { return e1->getID() < e2->getID(); });
 
        // second, append fracture elements
        std::copy(fracture_elements.begin(), fracture_elements.end(),
                  std::back_inserter(vec_ele));
        // thirdly, append intersected fracture elements
        std::copy(intersected_fracture_elements[fid].begin(),
                  intersected_fracture_elements[fid].end(),
                  std::back_inserter(vec_ele));
 
        vec_fracture_matrix_elements.push_back(vec_ele);
    }
}

References MathLib::LinAlg::copy(), DBUG(), ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::findFracutreIntersections(), MeshLib::Mesh::getDimension(), anonymous_namespace{generateStructuredMesh.cpp}::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getElementsConnectedToNode(), MathLib::Point3dWithID::getID(), MeshLib::Element::getID(), MeshLib::Mesh::getNumberOfElements(), BaseLib::makeVectorUnique(), MeshLib::materialIDs(), and OGS_FATAL.

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::HydroMechanicsProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess(), and anonymous_namespace{postLIE.cpp}::postVTU().

levelsetBranch()

bool ProcessLib::LIE::levelsetBranch	(	BranchProperty const &	branch,
		Eigen::Vector3d const &	x
	)

Definition at line 39 of file LevelSetFunction.cpp.

{
    return branch.normal_vector_branch.dot(x - branch.coords) > 0;
}

References ProcessLib::LIE::BranchProperty::coords, and ProcessLib::LIE::BranchProperty::normal_vector_branch.

levelsetFracture()

bool ProcessLib::LIE::levelsetFracture	(	FractureProperty const &	frac,
		Eigen::Vector3d const &	x
	)

Definition at line 34 of file LevelSetFunction.cpp.

{
    return frac.normal_vector.dot(x - frac.point_on_fracture) > 0;
}

References ProcessLib::LIE::FractureProperty::normal_vector, and ProcessLib::LIE::FractureProperty::point_on_fracture.

Referenced by duGlobalEnrichments(), and uGlobalEnrichments().

setFractureProperty()

void ProcessLib::LIE::setFractureProperty ( int const  dim, MeshLib::Element const &  e, FractureProperty &  frac_prop  )

inline

configure fracture property based on a fracture element assuming a fracture is a straight line/flat plane

Definition at line 76 of file FractureProperty.h.

{
    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).getCoords()[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]);
}

References DBUG(), MeshLib::getCenterOfGravity(), MathLib::TemplatePoint< T, DIM >::getCoords(), MeshLib::Element::getID(), MeshLib::ElementCoordinatesMappingLocal::getRotationMatrixToGlobal(), ProcessLib::LIE::FractureProperty::normal_vector, ProcessLib::LIE::FractureProperty::point_on_fracture, and ProcessLib::LIE::FractureProperty::R.

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::HydroMechanicsProcess(), and ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::SmallDeformationProcess().

uGlobalEnrichments()

std::vector< double > ProcessLib::LIE::uGlobalEnrichments	(	std::vector< FractureProperty * > const &	frac_props,
		std::vector< JunctionProperty * > const &	junction_props,
		std::unordered_map< int, int > const &	fracID_to_local,
		Eigen::Vector3d const &	x
	)

calculate the enrichment function for displacements at the given point Remarks:

• branch/junction intersections of two fractures are supported in 2D

Parameters

frac_props	fracture properties
junction_props	junction properties
fracID_to_local	a mapping table from a fracture ID to a local index in frac_props
x	evaluating point coordinates

Returns

a vector of enrichment values for displacements

Definition at line 44 of file LevelSetFunction.cpp.

{
    // pre-calculate levelsets for all fractures
    std::vector<bool> levelsets(frac_props.size());
    for (std::size_t i = 0; i < frac_props.size(); i++)
    {
        levelsets[i] = levelsetFracture(*frac_props[i], x);
    }
 
    std::vector<double> enrichments(frac_props.size() + junction_props.size());
    // fractures possibly with branches
    for (std::size_t i = 0; i < frac_props.size(); i++)
    {
        auto const* frac = frac_props[i];
        enrichments[i] = Heaviside(
            std::accumulate(cbegin(frac->branches_slave),
                            cend(frac->branches_slave), levelsets[i],
                            [&](bool const enrich, auto const& branch)
                            { return enrich & levelsetBranch(branch, x); }));
    }
 
    // junctions
    for (std::size_t i = 0; i < junction_props.size(); i++)
    {
        auto const* junction = junction_props[i];
        auto fid1 = fracID_to_local.at(junction->fracture_ids[0]);
        auto fid2 = fracID_to_local.at(junction->fracture_ids[1]);
        bool const enrich = levelsets[fid1] & levelsets[fid2];
        enrichments[i + frac_props.size()] = Heaviside(enrich);
    }
 
    return enrichments;
}

References anonymous_namespace{LevelSetFunction.cpp}::Heaviside(), and levelsetFracture().

Referenced by ProcessLib::LIE::SmallDeformation::SmallDeformationLocalAssemblerMatrixNearFracture< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrixNearFracture< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::assembleWithJacobianConcrete(), ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< GlobalDim >::initializeConcreteProcess(), ProcessLib::LIE::SmallDeformation::SmallDeformationProcess< DisplacementDim >::initializeConcreteProcess(), and ProcessLib::LIE::HydroMechanics::HydroMechanicsLocalAssemblerMatrixNearFracture< ShapeFunctionDisplacement, ShapeFunctionPressure, IntegrationMethod, GlobalDim >::postTimestepConcreteWithVector().