Detailed Description

template<int GlobalDim>
class ProcessLib::EmbeddedAnchor< GlobalDim >

Definition at line 18 of file EmbeddedAnchor.h.

#include <EmbeddedAnchor.h>

Inheritance diagram for ProcessLib::EmbeddedAnchor< GlobalDim >:

Collaboration diagram for ProcessLib::EmbeddedAnchor< GlobalDim >:

Public Member Functions
	EmbeddedAnchor (MeshLib::Mesh const &bulk_mesh, NumLib::LocalToGlobalIndexMap const &dof_table_bulk, std::size_t const source_term_mesh_id, MeshLib::Mesh const &st_mesh, const int variable_id)

void	getShapeMatricesAndGlobalIndicesAndDisplacements (MeshLib::Element const const anchor_element, std::array< std::size_t, 2 > &nodes_per_element, std::vector< Eigen::RowVectorXd > &shape_matrices, std::vector< GlobalIndexType > &global_indices, Eigen::Vector< double, 2 GlobalDim > &local_x, GlobalVector const &x, ParameterLib::SpatialPosition &pos) const

void	integrate (const double t, GlobalVector const &x, GlobalVector &b, GlobalMatrix *jac) const override

Public Member Functions inherited from ProcessLib::SourceTermBase
virtual	~SourceTermBase ()=default

Private Attributes
NumLib::LocalToGlobalIndexMap const &	dof_table_bulk_

MeshLib::Mesh const &	bulk_mesh_

std::size_t const	source_term_mesh_id_

MeshLib::Mesh const &	st_mesh_

int const	variable_id_

std::array< int, GlobalDim > const	component_ids_

MeshLib::PropertyVector< std::size_t > const *	bulk_element_ids_ = nullptr

MeshLib::PropertyVector< double > const *	natural_coordinates_ = nullptr

MeshLib::PropertyVector< double > const *	maximum_anchor_stress_ = nullptr

MeshLib::PropertyVector< double > const *	initial_anchor_stress_ = nullptr

MeshLib::PropertyVector< double > const *	residual_anchor_stress_ = nullptr

MeshLib::PropertyVector< double > const *	cross_sectional_area_ = nullptr

MeshLib::PropertyVector< double > const *	anchor_stiffness_ = nullptr

Constructor & Destructor Documentation

◆ EmbeddedAnchor()

template<int GlobalDim>

ProcessLib::EmbeddedAnchor< GlobalDim >::EmbeddedAnchor	(	MeshLib::Mesh const &	bulk_mesh,
		NumLib::LocalToGlobalIndexMap const &	dof_table_bulk,
		std::size_t const	source_term_mesh_id,
		MeshLib::Mesh const &	st_mesh,
		const int	variable_id )

explicit

Definition at line 141 of file EmbeddedAnchor.cpp.

    : dof_table_bulk_(dof_table_bulk),
      bulk_mesh_(bulk_mesh),
      source_term_mesh_id_(source_term_mesh_id),
      st_mesh_(st_mesh),
      variable_id_(variable_id),
      component_ids_(
          []
          {
              std::array<int, GlobalDim> arr{};
              std::iota(arr.begin(), arr.end(), 0);
              return arr;
          }())
{
    DBUG("Create EmbeddedAnchor.");
    std::string_view const bulk_element_ids_string = "bulk_element_ids";
    bulk_element_ids_ =
        st_mesh_.getProperties().template getPropertyVector<std::size_t>(
            bulk_element_ids_string);
 
    std::string_view const natural_coordinates_string = "natural_coordinates";
    natural_coordinates_ =
        st_mesh_.getProperties().template getPropertyVector<double>(
            natural_coordinates_string);
 
    std::string_view const maximum_anchor_stress_string =
        "maximum_anchor_stress";
    maximum_anchor_stress_ =
        st_mesh_.getProperties().template getPropertyVector<double>(
            maximum_anchor_stress_string);
 
    std::string_view const initial_anchor_stress_string =
        "initial_anchor_stress";
    initial_anchor_stress_ =
        st_mesh_.getProperties().template getPropertyVector<double>(
            initial_anchor_stress_string);
 
    std::string_view const residual_anchor_stress_string =
        "residual_anchor_stress";
    residual_anchor_stress_ =
        st_mesh_.getProperties().template getPropertyVector<double>(
            residual_anchor_stress_string);
 
    std::string_view const anchor_cross_sectional_area_string =
        "anchor_cross_sectional_area";
    cross_sectional_area_ =
        st_mesh_.getProperties().template getPropertyVector<double>(
            anchor_cross_sectional_area_string);
 
    std::string_view const anchor_stiffness_string = "anchor_stiffness";
    anchor_stiffness_ =
        st_mesh_.getProperties().template getPropertyVector<double>(
            anchor_stiffness_string);
}

Member Function Documentation

◆ getShapeMatricesAndGlobalIndicesAndDisplacements()

template<int GlobalDim>

void ProcessLib::EmbeddedAnchor< GlobalDim >::getShapeMatricesAndGlobalIndicesAndDisplacements	(	MeshLib::Element const *const	anchor_element,
		std::array< std::size_t, 2 > &	nodes_per_element,
		std::vector< Eigen::RowVectorXd > &	shape_matrices,
		std::vector< GlobalIndexType > &	global_indices,
		Eigen::Vector< double, 2 *GlobalDim > &	local_x,
		GlobalVector const &	x,
		ParameterLib::SpatialPosition &	pos ) const

Definition at line 202 of file EmbeddedAnchor.cpp.

{
    for (auto&& [node_idx, anchor_node_id] : ranges::views::enumerate(
             anchor_element->nodes() | MeshLib::views::ids))
    {
        // used pos in integrate function will be of the last node in anchor
        // element, i,e, only one uniform stiffness is supported
        auto const bulk_element_id = (*bulk_element_ids_)[anchor_node_id];
        pos.setElementID(bulk_element_id);
 
        auto const& bulk_element = *bulk_mesh_.getElement(bulk_element_id);
        nodes_per_element[node_idx] = bulk_element.nodes().size();
 
        std::span<double const, 3> const nat_coords(
            &(*natural_coordinates_)[3 * anchor_node_id], 3);
        auto N = computeShapeMatrix<GlobalDim>(bulk_element, nat_coords);
        shape_matrices.push_back(std::move(N));
 
        for (int component = 0; component < GlobalDim; ++component)
        {
            auto const& global_indices_percomponent = getIndices(
                variable_id_, component, bulk_element_id, dof_table_bulk_);
 
            Eigen::VectorXd const local_x_element_percomponent =
                MathLib::toVector(x.get(global_indices_percomponent));
 
            global_indices.insert(global_indices.cend(),
                                  global_indices_percomponent.begin(),
                                  global_indices_percomponent.end());
 
            // this maps the displacement of each component of all nodes
            // of the element to the desired anchor location in that element
            // where all even local_x entries are for the first node and all odd
            // local_x entries are for the second node
            NumLib::shapeFunctionInterpolate(
                local_x_element_percomponent,
                shape_matrices[node_idx],
                local_x[nodeLocalIndices<GlobalDim>(node_idx)[component]]);
        }
    }
}

References ProcessLib::computeShapeMatrix(), MathLib::EigenVector::get(), MeshLib::views::ids, ProcessLib::nodeLocalIndices(), MeshLib::Element::nodes(), ParameterLib::SpatialPosition::setElementID(), NumLib::detail::shapeFunctionInterpolate(), and MathLib::toVector().

◆ integrate()

template<int GlobalDim>

void ProcessLib::EmbeddedAnchor< GlobalDim >::integrate	(	const double	t,
		GlobalVector const &	x,
		GlobalVector &	b,
		GlobalMatrix *	jac ) const

overridevirtual

Implements ProcessLib::SourceTermBase.

Definition at line 253 of file EmbeddedAnchor.cpp.

{
    DBUG("Assemble EmbeddedAnchor.");
 
    using GlobalDimVector = Eigen::Vector<double, GlobalDim>;
    using GlobalDimMatrix = Eigen::Matrix<double, GlobalDim, GlobalDim>;
 
    for (MeshLib::Element const* const anchor_element : st_mesh_.getElements())
    {
        auto const anchor_element_id = anchor_element->getID();
        std::vector<GlobalIndexType> global_indices;
        Eigen::Vector<double, 2 * GlobalDim> local_x;
        std::vector<Eigen::RowVectorXd> shape_matrices;
        std::array<std::size_t, 2> nodes_per_element;
        ParameterLib::SpatialPosition pos;
        getShapeMatricesAndGlobalIndicesAndDisplacements(
            anchor_element, nodes_per_element, shape_matrices, global_indices,
            local_x, x, pos);
 
        auto node_coords = [anchor_element](int const i)
        { return anchor_element->getNode(i)->asEigenVector3d(); };
        GlobalDimVector const l_original =
            (node_coords(1) - node_coords(0)).template head<GlobalDim>();
        double const l_original_norm = l_original.norm();
 
        // Displacement in the two nodes.
        auto u = [&local_x](int const i)
        { return local_x(nodeLocalIndices<GlobalDim>(i)); };
        GlobalDimVector const l = l_original + u(1) - u(0);
 
        double const K = (*cross_sectional_area_)[anchor_element_id] *
                         (*anchor_stiffness_)[anchor_element_id];
        double const initial_force =
            (*cross_sectional_area_)[anchor_element_id] *
            (*initial_anchor_stress_)[anchor_element_id];
        double const max_force = (*cross_sectional_area_)[anchor_element_id] *
                                 (*maximum_anchor_stress_)[anchor_element_id];
        double const residual_force =
            (*cross_sectional_area_)[anchor_element_id] *
            (*residual_anchor_stress_)[anchor_element_id];
 
        double const strain = (l.norm() - l_original_norm) / l_original_norm;
 
        GlobalDimVector const f_friction =
            residual_force * l_original / l_original_norm;
        GlobalDimVector const f_elastic =
            l_original / l_original_norm * (initial_force + K * strain);
        GlobalDimVector const f =
            ((f_elastic.norm() < max_force)) ? f_elastic : f_friction;
 
        GlobalDimMatrix const Df_friction = GlobalDimMatrix::Zero();
        GlobalDimMatrix const Df_elastic = l_original / l_original_norm * K *
                                           l.transpose() / l.norm() /
                                           l_original_norm;
        GlobalDimMatrix const Df =
            (f_elastic.norm() < max_force) ? Df_elastic : Df_friction;
 
        auto const& [local_rhs, local_Jac] = assembleLocalBJac<GlobalDim>(
            f, Df, shape_matrices, global_indices.size(), nodes_per_element);
 
        b.add(global_indices, local_rhs);
        if (jac)
        {
            jac->add({global_indices, global_indices}, local_Jac);
        }
    }
}

References MathLib::EigenMatrix::add(), MathLib::EigenVector::add(), ProcessLib::assembleLocalBJac(), DBUG(), and ProcessLib::nodeLocalIndices().

Member Data Documentation

◆ anchor_stiffness_

template<int GlobalDim>

MeshLib::PropertyVector<double> const* ProcessLib::EmbeddedAnchor< GlobalDim >::anchor_stiffness_ = nullptr

private

Definition at line 52 of file EmbeddedAnchor.h.

◆ bulk_element_ids_

template<int GlobalDim>

MeshLib::PropertyVector<std::size_t> const* ProcessLib::EmbeddedAnchor< GlobalDim >::bulk_element_ids_ = nullptr

private

Definition at line 46 of file EmbeddedAnchor.h.

◆ bulk_mesh_

template<int GlobalDim>

MeshLib::Mesh const& ProcessLib::EmbeddedAnchor< GlobalDim >::bulk_mesh_

private

Definition at line 41 of file EmbeddedAnchor.h.

◆ component_ids_

template<int GlobalDim>

std::array<int, GlobalDim> const ProcessLib::EmbeddedAnchor< GlobalDim >::component_ids_

private

Definition at line 45 of file EmbeddedAnchor.h.

◆ cross_sectional_area_

template<int GlobalDim>

MeshLib::PropertyVector<double> const* ProcessLib::EmbeddedAnchor< GlobalDim >::cross_sectional_area_ = nullptr

private

Definition at line 51 of file EmbeddedAnchor.h.

◆ dof_table_bulk_

template<int GlobalDim>

NumLib::LocalToGlobalIndexMap const& ProcessLib::EmbeddedAnchor< GlobalDim >::dof_table_bulk_

private

Definition at line 40 of file EmbeddedAnchor.h.

◆ initial_anchor_stress_

template<int GlobalDim>

MeshLib::PropertyVector<double> const* ProcessLib::EmbeddedAnchor< GlobalDim >::initial_anchor_stress_ = nullptr

private

Definition at line 49 of file EmbeddedAnchor.h.

◆ maximum_anchor_stress_

template<int GlobalDim>

MeshLib::PropertyVector<double> const* ProcessLib::EmbeddedAnchor< GlobalDim >::maximum_anchor_stress_ = nullptr

private

Definition at line 48 of file EmbeddedAnchor.h.

◆ natural_coordinates_

template<int GlobalDim>

MeshLib::PropertyVector<double> const* ProcessLib::EmbeddedAnchor< GlobalDim >::natural_coordinates_ = nullptr

private

Definition at line 47 of file EmbeddedAnchor.h.

◆ residual_anchor_stress_

template<int GlobalDim>

MeshLib::PropertyVector<double> const* ProcessLib::EmbeddedAnchor< GlobalDim >::residual_anchor_stress_ = nullptr

private

Definition at line 50 of file EmbeddedAnchor.h.

◆ source_term_mesh_id_

template<int GlobalDim>

std::size_t const ProcessLib::EmbeddedAnchor< GlobalDim >::source_term_mesh_id_

private

Definition at line 42 of file EmbeddedAnchor.h.

◆ st_mesh_

template<int GlobalDim>

MeshLib::Mesh const& ProcessLib::EmbeddedAnchor< GlobalDim >::st_mesh_

private

Definition at line 43 of file EmbeddedAnchor.h.

◆ variable_id_

template<int GlobalDim>

int const ProcessLib::EmbeddedAnchor< GlobalDim >::variable_id_

private

Definition at line 44 of file EmbeddedAnchor.h.

The documentation for this class was generated from the following files:

ProcessLib/BoundaryConditionAndSourceTerm/EmbeddedAnchor.h
ProcessLib/BoundaryConditionAndSourceTerm/EmbeddedAnchor.cpp

Detailed Description

Public Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ EmbeddedAnchor()

Member Function Documentation

◆ getShapeMatricesAndGlobalIndicesAndDisplacements()

◆ integrate()

Member Data Documentation

◆ anchor_stiffness_

◆ bulk_element_ids_

◆ bulk_mesh_

◆ component_ids_

◆ cross_sectional_area_

◆ dof_table_bulk_

◆ initial_anchor_stress_

◆ maximum_anchor_stress_

◆ natural_coordinates_

◆ residual_anchor_stress_

◆ source_term_mesh_id_

◆ st_mesh_

◆ variable_id_