ProcessLib::EmbeddedAnchor< GlobalDim > Class Template Reference

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, ParameterLib::Parameter< double > const &parameter)
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_
ParameterLib::Parameter< double > const &	parameter_
MeshLib::PropertyVector< std::size_t > const *	bulk_element_ids_ = nullptr
MeshLib::PropertyVector< double > const *	natural_coordinates_ = 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, ParameterLib::Parameter< double > const & parameter )

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;
          }()),
      parameter_(parameter)
{
    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);
    assert(bulk_element_ids_ != nullptr);
 
    std::string_view const natural_coordinates_string = "natural_coordinates";
    natural_coordinates_ =
        st_mesh_.getProperties().template getPropertyVector<double>(
            natural_coordinates_string);
    assert(natural_coordinates_ != nullptr);
}

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 177 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 228 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())
    {
        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 = parameter_(t, pos)[0];
        GlobalDimVector const f = l_original / l_original_norm * K *
                                  (l.norm() - l_original_norm) /
                                  l_original_norm;
 
        GlobalDimMatrix const Df = l_original / l_original_norm * K *
                                   l.transpose() / l.norm() / l_original_norm;
 
        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

bulk_element_ids_

template<int GlobalDim>

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

private

Definition at line 47 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.

dof_table_bulk_

template<int GlobalDim>

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

private

Definition at line 40 of file EmbeddedAnchor.h.

natural_coordinates_

template<int GlobalDim>

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

private

Definition at line 48 of file EmbeddedAnchor.h.

parameter_

template<int GlobalDim>

ParameterLib::Parameter<double> const& ProcessLib::EmbeddedAnchor< GlobalDim >::parameter_

private

Definition at line 46 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