Reference¶

Common¶

void akantu::initialize(const std::string &input_file, int &argc, char **&argv)¶: initialize the static part of akantu and read the global input_file

void akantu::initialize(int &argc, char **&argv)¶: initialize the static part of akantu

using akantu::UInt = unsigned int¶

using akantu::Int = int¶

using akantu::Real = double¶

enum akantu::ElementType¶

type of elements

Values:

enumerator _not_defined¶

enumerator _not_defined: For not defined cases.

enumerator _cohesive_1d_2¶

enumerator _cohesive_2d_4¶

enumerator _cohesive_2d_6¶

enumerator _cohesive_3d_12¶

enumerator _cohesive_3d_16¶

enumerator _cohesive_3d_6¶

enumerator _cohesive_3d_8¶

enumerator _point_1¶

enumerator _segment_2¶

enumerator _segment_3¶

enumerator _triangle_3¶

enumerator _triangle_6¶

enumerator _quadrangle_4¶

enumerator _quadrangle_8¶

enumerator _tetrahedron_4¶

enumerator _tetrahedron_10¶

enumerator _pentahedron_6¶

enumerator _pentahedron_15¶

enumerator _hexahedron_8¶

enumerator _hexahedron_20¶

enumerator _bernoulli_beam_2¶

enumerator _bernoulli_beam_3¶

enumerator _discrete_kirchhoff_triangle_18¶

enumerator _max_element_type¶

enum akantu::ModelType¶

Values:

enumerator model¶

enumerator solid_mechanics_model¶

enumerator solid_mechanics_model_cohesive¶

enumerator heat_transfer_model¶

enumerator structural_mechanics_model¶

enumerator embedded_model¶

enum akantu::AnalysisMethod¶

enum AnalysisMethod type of solving method used to solve the equation of motion

Values:

enumerator _static = 0¶

enumerator _implicit_dynamic = 1¶

enumerator _explicit_lumped_mass = 2¶

enumerator _explicit_lumped_capacity = 2¶

enumerator _explicit_consistent_mass = 3¶

enumerator _explicit_contact = 4¶

enumerator _implicit_contact = 5¶

enum akantu::SolveConvergenceCriteria¶

enum SolveConvergenceCriteria different convergence criteria

Values:

enumerator _residual¶: Use residual to test the convergence.

enumerator _solution¶: Use solution to test the convergence.

enumerator _residual_mass_wgh¶: Use residual weighted by inv. nodal mass to testb

class akantu::ArrayBase¶

class that afford to store vectors in static memory

Subclassed by akantu::ArrayDataLayer< akantu::ContactElement >, akantu::ArrayDataLayer< Element >, akantu::ArrayDataLayer< Entity >, akantu::ArrayDataLayer< Int >, akantu::ArrayDataLayer< PetscInt >, akantu::ArrayDataLayer< char >, akantu::ArrayDataLayer< bool >, akantu::ArrayDataLayer< NodeFlag >, akantu::ArrayDataLayer< UInt >, akantu::ArrayDataLayer< Real >, akantu::ArrayDataLayer< akantu::Element >, akantu::ArrayDataLayer< T, allocation_trait >

Public Functions

ArrayBase(const ID &id = "")¶

ArrayBase(const ArrayBase &other, const ID &id = "")¶

ArrayBase(ArrayBase &&other) = default¶

ArrayBase &operator=(const ArrayBase &other) = default¶

ArrayBase &operator=(ArrayBase &&other) noexcept = default¶

~ArrayBase() = default¶

UInt getMemorySize() const = 0¶: get the amount of space allocated in bytes

bool empty() const __attribute__((warn_unused_result))¶

void printself(std::ostream &stream, int indent = 0) const = 0¶: function to print the containt of the class

UInt size() const¶: Get the Size of the Array.

UInt getNbComponent() const¶: Get the number of components.

const ID &getID() const¶: Get the name of th array.

void setID(const ID &id)¶: Set the name of th array.

template<typename T, ArrayAllocationType allocation_trait = ArrayAllocationTrait<T>::value> class akantu::ArrayDataLayer : public akantu::ArrayBase ¶

Subclassed by akantu::Array< T >, akantu::Array< T, is_scal >

Public Types

using value_type = T ¶

using reference = value_type&¶

using pointer_type = value_type*¶

using const_reference = const value_type&¶

Public Functions

~ArrayDataLayer() override = default¶

ArrayDataLayer(UInt size = 0, UInt nb_component = 1, const ID &id = "")¶: Allocation of a new vector.

ArrayDataLayer(UInt size, UInt nb_component, const_reference value, const ID &id = "")¶: Allocation of a new vector with a default value.

ArrayDataLayer(const ArrayDataLayer &vect, const ID &id = "")¶: Copy constructor (deep copy)

ArrayDataLayer(const std::vector<value_type> &vect)¶: Copy constructor (deep copy)

ArrayDataLayer &operator=(const ArrayDataLayer &other)¶

ArrayDataLayer(ArrayDataLayer &&other) noexcept = default¶

ArrayDataLayer &operator=(ArrayDataLayer &&other) noexcept = default¶

void push_back(const_reference value)¶: append a tuple of size nb_component containing value

template<template<typename> class C, typename = std::enable_if_t<aka::is_tensor<C<T>>::value or aka::is_tensor_proxy<C<T>>::value>> void push_back(const C<T> &new_elem)¶

append a vector

append a Vector or a Matrix

void reserve(UInt size, UInt new_size = UInt(-1))¶: changes the allocated size but not the size, if new_size = 0, the size is set to min(current_size and reserve size)

void resize(UInt size)¶: change the size of the Array

void resize(UInt size, const T &val)¶: change the size of the Array and initialize the values

UInt getMemorySize() const override¶: get the amount of space allocated in bytes

UInt getAllocatedSize() const¶: Get the real size allocated in memory.

T *storage() const¶: give the address of the memory allocated for this vector

template<typename T, bool is_scal> class akantu::Array : public akantu::ArrayDataLayer<T>¶

Public Types

using value_type = typename parent::value_type¶

using reference = typename parent::reference¶

using pointer_type = typename parent::pointer_type¶

using const_reference = typename parent::const_reference¶

using array_type = Array<T>¶

using scalar_iterator = iterator<T>¶: iterator for Array of nb_component = 1

using const_scalar_iterator = const_iterator<T>¶: const_iterator for Array of nb_component = 1

using vector_iterator = iterator<Vector<T>>¶: iterator returning Vectors of size n on entries of Array with nb_component = n

using const_vector_iterator = const_iterator<Vector<T>>¶: const_iterator returning Vectors of n size on entries of Array with nb_component = n

using matrix_iterator = iterator<Matrix<T>>¶: iterator returning Matrices of size (m, n) on entries of Array with nb_component = m*n

using const_matrix_iterator = const_iterator<Matrix<T>>¶: const iterator returning Matrices of size (m, n) on entries of Array with nb_component = m*n

using tensor3_iterator = iterator<Tensor3<T>>¶: iterator returning Tensor3 of size (m, n, k) on entries of Array with nb_component = m*n*k

using const_tensor3_iterator = const_iterator<Tensor3<T>>¶: const iterator returning Tensor3 of size (m, n, k) on entries of Array with nb_component = m*n*k

Public Functions

~Array() override¶

Array()¶

Array(UInt size, UInt nb_component = 1, const ID &id = "")¶: Allocation of a new vector.

Array(UInt size, UInt nb_component, const_reference value, const ID &id = "")¶: Allocation of a new vector with a default value.

Array(const Array &vect, const ID &id = "")¶: Copy constructor.

Array(const std::vector<T> &vect)¶: Copy constructor (deep copy)

Array &operator=(const Array &other)¶

Array(Array &&other) noexcept = default¶

Array &operator=(Array &&other) noexcept = default¶

template<typename ...Ns> decltype(auto) begin(Ns&&... n)¶

template<typename ...Ns> decltype(auto) end(Ns&&... n)¶

template<typename ...Ns> decltype(auto) begin(Ns&&... n) const¶

template<typename ...Ns> decltype(auto) end(Ns&&... n) const¶

template<typename ...Ns> decltype(auto) begin_reinterpret(Ns&&... n)¶

template<typename ...Ns> decltype(auto) end_reinterpret(Ns&&... n)¶

template<typename ...Ns> decltype(auto) begin_reinterpret(Ns&&... n) const¶

template<typename ...Ns> decltype(auto) end_reinterpret(Ns&&... n) const¶

UInt find(const_reference elem) const¶: search elem in the vector, return the position of the first occurrence or -1 if not found

void push_back(const_reference value)¶

append a value to the end of the Array

See: Array::find(const_reference elem) const

template<template<typename> class C, typename = std::enable_if_t<aka::is_tensor<C<T>>::value or aka::is_tensor_proxy<C<T>>::value>> void push_back(const C<T> &new_elem)¶: append a Vector or a Matrix

template<typename Ret> void push_back(const iterator<Ret> &it)¶: append the content of the iterator at the end of the Array

void erase(UInt i)¶: erase the value at position i

template<typename R> iterator<R> erase(const iterator<R> &it)¶: ask Nico, clarify

template<template<typename> class C, typename = std::enable_if_t<aka::is_tensor<C<T>>::value or aka::is_tensor_proxy<C<T>>::value>> UInt find(const C<T> &elem)¶

See: Array::find(const_reference elem) const

void set(T t)¶

set all entries of the array to the value t

Parameters

t: value to fill the array with

void zero()¶: set the array to T{}

void clear()¶: resize the array to 0

template<template<typename> class C, typename = std::enable_if_t<aka::is_tensor<C<T>>::value or aka::is_tensor_proxy<C<T>>::value>> void set(const C<T> &vm)¶

set all tuples of the array to a given vector or matrix

Parameters

vm: Matrix or Vector to fill the array with

void append(const Array<T> &other)¶: Append the content of the other array to the current one.

void copy(const Array<T, is_scal> &other, bool no_sanity_check = false)¶: copy another Array in the current Array, the no_sanity_check allows you to force the copy in cases where you know what you do with two non matching Arrays in terms of n

void printself(std::ostream &stream, int indent = 0) const override¶: function to print the containt of the class

template<typename OT = T, std::enable_if_t<std::is_arithmetic<OT>::value>* = nullptr> bool isFinite() const noexcept¶: Tests if all elements are finite.

Array<T, is_scal> &operator-=(const Array<T, is_scal> &other)¶: substraction entry-wise

Array<T, is_scal> &operator+=(const Array<T, is_scal> &other)¶: addition entry-wise

Array<T, is_scal> &operator*=(const T &alpha)¶: multiply evry entry by alpha

bool operator==(const Array<T, is_scal> &other) const¶: check if the array are identical entry-wise

bool operator!=(const Array<T, is_scal> &other) const¶

See: Array::operator==(const Array<T, is_scal> & other) const

reference operator()(UInt i, UInt j = 0)¶: return a reference to the j-th entry of the i-th tuple

const_reference operator()(UInt i, UInt j = 0) const¶: return a const reference to the j-th entry of the i-th tuple

reference operator[](UInt i)¶: return a reference to the ith component of the 1D array

const_reference operator[](UInt i) const¶: return a const reference to the ith component of the 1D array

UInt find(const Real &elem) const¶

Array<ElementType> &operator*=(const ElementType&)¶

Array<ElementType> &operator-=(const Array<ElementType>&)¶

Array<ElementType> &operator+=(const Array<ElementType>&)¶

Array<char> &operator*=(const char&)¶

Array<char> &operator-=(const Array<char>&)¶

Array<char> &operator+=(const Array<char>&)¶

template<typename R = T> class const_iterator¶

template<typename R = T> class iterator¶

template<class R, class it, class IR = R, bool is_tensor_ = aka::is_tensor<std::decay_t<R>>::value> class iterator_internal¶

Todo:: protected: does not compile with intel check why

template<typename T, typename SupportType> class akantu::ElementTypeMapArray : public akantu::ElementTypeMap<std::unique_ptr<Array<T>>, SupportType>¶

Public Types

using value_type = T ¶

using array_type = Array<T>¶

using type_iterator = typename parent::type_iterator¶

Public Functions

auto operator=(const ElementTypeMapArray &other) -> ElementTypeMapArray&¶: standard assigment (copy) operator

ElementTypeMapArray(const ElementTypeMapArray &other)¶

void copy(const ElementTypeMapArray &other)¶: explicit copy

ElementTypeMapArray(const ID &id = "by_element_type_array", const ID &parent_id = "no_parent")¶

Constructor

Parameters

id: optional: identifier (string)
parent_id: optional: parent identifier. for organizational purposes only

Array<T> &alloc(UInt size, UInt nb_component, const SupportType &type, GhostType ghost_type, const T &default_value = T())¶

allocate memory for a new array

Return

a reference to the allocated array

Parameters

size: number of tuples of the new array
nb_component: tuple size
type: the type under which the array is indexed in the map
ghost_type: whether to add the field to the data map or the ghost_data map
default_value: the default value to use to fill the array

void alloc(UInt size, UInt nb_component, const SupportType &type, const T &default_value = T())¶

allocate memory for a new array in both the data and the ghost_data map

Parameters

size: number of tuples of the new array
nb_component: tuple size
type: the type under which the array is indexed in the map
default_value: the default value to use to fill the array

const Array<T> &operator()(const SupportType &type, GhostType ghost_type = _not_ghost) const¶

const T &operator()(const Element &element, UInt component = 0) const¶: access the data of an element, this combine the map and array accessor

T &operator()(const Element &element, UInt component = 0)¶: access the data of an element, this combine the map and array accessor

decltype(auto) get(const Element &element)¶: access the data of an element, this combine the map and array accessor

decltype(auto) get(const Element &element) const¶

Array<T> &operator()(const SupportType &type, GhostType ghost_type = _not_ghost)¶

void setArray(const SupportType &type, GhostType ghost_type, const Array<T> &vect)¶

insert data of a new type (not yet present) into the map.

Return

stored data corresponding to type.

Parameters

type: type of data (if this type is already present in the map, an exception is thrown).
ghost_type: optional: by default, the data map for non-ghost elements is searched
vect: the vector to include into the map

void free()¶: frees all memory related to the data

void clear()¶

bool empty() const __attribute__((warn_unused_result))¶

void zero()¶: set all values in the ElementTypeMap to zero

template<typename ST> void set(const ST &value)¶: set all values in the ElementTypeMap to value

void onElementsRemoved(const ElementTypeMapArray<UInt> &new_numbering)¶

deletes and reorders entries in the stored arrays

Parameters

new_numbering: a ElementTypeMapArray of new indices. UInt(-1) indicates deleted entries.

void printself(std::ostream &stream, int indent = 0) const override¶: text output helper

void setID(const ID &id)¶

set the id

Parameters

id: the new name

auto getID() const -> ID¶: return the id

ElementTypeMap<UInt> getNbComponents(UInt dim = _all_dimensions, GhostType requested_ghost_type = _not_ghost, ElementKind kind = _ek_not_defined) const¶

template<class Func> void initialize(const Func &f, const T &default_value, bool do_not_default)¶: initialize the arrays in accordance to a functor

template<typename ...pack> void initialize(const Mesh &mesh, pack&&... _pack)¶

initialize with sizes and number of components in accordance of a mesh content

All parameters are named optionals

Parameters

_nb_component: a functor giving the number of components per (ElementType, GhostType) pair or a scalar giving a unique number of components regardless of type
_spatial_dimension: a filter for the elements of a specific dimension
_element_kind: filter with element kind (_ek_regular, _ek_structural, …)
_with_nb_element: allocate the arrays with the number of elements for each type in the mesh
_with_nb_nodes_per_element: multiply the number of components by the number of nodes per element
_default_value: default inital value
_do_not_default: do not initialize the allocated arrays
_ghost_type: filter a type of ghost

template<typename ...pack> void initialize(const FEEngine &fe_engine, pack&&... _pack)¶

initialize with sizes and number of components in accordance of a fe engine content (aka integration points)

All parameters are named optionals

Parameters

_nb_component: a functor giving the number of components per (ElementType, GhostType) pair or a scalar giving a unique number of components regardless of type
_spatial_dimension: a filter for the elements of a specific dimension
_element_kind: filter with element kind (_ek_regular, _ek_structural, …)
_default_value: default inital value
_do_not_default: do not initialize the allocated arrays
_ghost_type: filter a specific ghost type
_all_ghost_types: get all ghost types

ID getName() const¶: get the name of the internal field

template<typename ...pack> UInt size(pack&&... _pack) const¶

get the size of the ElementTypeMapArray<T>

Parameters

[in] _pack:
optional arguments can be any of:
- _spatial_dimension the dimension to consider (default: _all_dimensions)
- _ghost_type (default: _not_ghost)
- _element_kind (default: _ek_not_defined)
- _all_ghost_types (default: false)

bool isNodal() const¶

void isNodal(bool is_nodal)¶

Warning

doxygenclass: Cannot find class “akantu::Vector” in doxygen xml output for project “Akantu” from directory: /builds/akantu/akantu/build/doc/dev-doc/xml

Warning

doxygenclass: Cannot find class “akantu::Matrix” in doxygen xml output for project “Akantu” from directory: /builds/akantu/akantu/build/doc/dev-doc/xml

Mesh¶

class akantu::Mesh : public akantu::EventHandlerManager<MeshEventHandler>, public akantu::GroupManager, public akantu::MeshData, public akantu::Dumpable ¶

This class contaisn the coordinates of the nodes in the Mesh.nodes akant::Array, and the connectivity. The connectivity are stored in by element types.

In order to loop on all element you have to loop on all types like this :

for(auto & type : mesh.elementTypes()) {
  UInt nb_element  = mesh.getNbElement(type);
  const Array<UInt> & conn = mesh.getConnectivity(type);
  for(UInt e = 0; e < nb_element; ++e) {
    ...
  }
}

or

for_each_element(mesh, [](Element & element) {
   std::cout << element << std::endl
 });

Public Types

using type_iterator = ElementTypeMapArray<UInt, ElementType>::type_iterator¶

using ElementTypesIteratorHelper = ElementTypeMapArray<UInt, ElementType>::ElementTypesIteratorHelper¶

Public Functions

Mesh(UInt spatial_dimension, const ID &id = "mesh")¶: constructor that create nodes coordinates array

Mesh(UInt spatial_dimension, Communicator &communicator, const ID &id = "mesh")¶: mesh not distributed and not using the default communicator

Mesh(UInt spatial_dimension, const std::shared_ptr<Array<Real>> &nodes, const ID &id = "mesh")¶: constructor that use an existing nodes coordinates array, by getting the vector of coordinates

~Mesh() override¶

void read(const std::string &filename, const MeshIOType &mesh_io_type = _miot_auto)¶: read the mesh from a file

void write(const std::string &filename, const MeshIOType &mesh_io_type = _miot_auto)¶: write the mesh to a file

template<typename ...pack> std::enable_if_t<are_named_argument<pack...>::value> distribute(pack&&... _pack)¶: with the arguments to pass to the partitionner

bool isDistributed() const¶: defines is the mesh is distributed or not

void makePeriodic(const SpatialDirection &direction)¶: set the periodicity in a given direction

void makePeriodic(const SpatialDirection &direction, const ID &list_1, const ID &list_2)¶

bool isPeriodic() const¶: defines if the mesh is periodic or not

bool isPeriodic(const SpatialDirection&) const¶

UInt getPeriodicMaster(UInt slave) const¶: get the master node for a given slave nodes, except if node not a slave

decltype(auto) getPeriodicSlaves(UInt master) const¶: get an iterable list of slaves for a given master node

void printself(std::ostream &stream, int indent = 0) const override¶: function to print the containt of the class

template<typename T> void extractNodalValuesFromElement(const Array<T> &nodal_values, T *local_coord, const UInt *connectivity, UInt n_nodes, UInt nb_degree_of_freedom) const¶: extract coordinates of nodes from an element

void addConnectivityType(ElementType type, GhostType ghost_type = _not_ghost)¶: add a Array of connectivity for the given ElementType and GhostType .

template<class Event> void sendEvent(Event &event)¶

void eraseElements(const Array<Element> &elements)¶: prepare the event to remove the elements listed

template<typename T> void removeNodesFromArray(Array<T> &vect, const Array<UInt> &new_numbering)¶

void initNormals()¶: initialize normals

Mesh &initMeshFacets(const ID &id = "mesh_facets")¶: init facets’ mesh

void defineMeshParent(const Mesh &mesh)¶: define parent mesh

void getGlobalConnectivity(ElementTypeMapArray<UInt> &global_connectivity)¶: get global connectivity array

void getAssociatedElements(const Array<UInt> &node_list, Array<Element> &elements) const¶

void getAssociatedElements(const UInt &node, Array<Element> &elements) const¶

void fillNodesToElements(UInt dimension = _all_dimensions)¶: fills the nodes_to_elements for given dimension elements

const ID &getID() const¶: get the id of the mesh

UInt getSpatialDimension() const¶: get the spatial dimension of the mesh = number of component of the coordinates

const Array<Real> &getNodes() const¶: get the nodes Array aka coordinates

Array<Real> &getNodes()¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Normals, normals, Real)¶: get the normals for the elements

UInt getNbNodes() const¶: get the number of nodes

const Array<UInt> &getGlobalNodesIds() const¶: get the Array of global ids of the nodes (only used in parallel)

UInt getNodeGlobalId(UInt local_id) const¶: get the global id of a node

UInt getNodeLocalId(UInt global_id) const¶: get the global id of a node

UInt getNbGlobalNodes() const¶: get the global number of nodes

const Array<NodeFlag> &getNodesFlags() const¶: get the nodes type Array

NodeFlag getNodeFlag(UInt local_id) const¶

Int getNodePrank(UInt local_id) const¶

bool isPureGhostNode(UInt n) const¶: say if a node is a pure ghost node

bool isLocalOrMasterNode(UInt n) const¶: say if a node is pur local or master node

bool isLocalNode(UInt n) const¶

bool isMasterNode(UInt n) const¶

bool isSlaveNode(UInt n) const¶

bool isPeriodicSlave(UInt n) const¶

bool isPeriodicMaster(UInt n) const¶

const Vector<Real> &getLowerBounds() const¶

const Vector<Real> &getUpperBounds() const¶

const BBox &getBBox() const¶

const Vector<Real> &getLocalLowerBounds() const¶

const Vector<Real> &getLocalUpperBounds() const¶

const BBox &getLocalBBox() const¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Connectivity, connectivities, UInt)¶: get the connectivity Array for a given type

AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Connectivity, connectivities, UInt)¶

const ElementTypeMapArray<UInt> &getConnectivities() const¶

UInt getNbElement(ElementType type, GhostType ghost_type = _not_ghost) const¶: get the number of element of a type in the mesh

UInt getNbElement(UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind kind = _ek_not_defined) const¶: get the number of element for a given ghost_type and a given dimension

void getBarycenter(const Element &element, Vector<Real> &barycenter) const¶: compute the barycenter of a given element

void getBarycenters(Array<Real> &barycenter, ElementType type, GhostType ghost_type) const¶

const auto &getElementToSubelement() const¶: get the element connected to a subelement (element of lower dimension)

const auto &getElementToSubelement(ElementType el_type, GhostType ghost_type = _not_ghost) const¶: get the element connected to a subelement

const auto &getElementToSubelement(const Element &element) const¶: get the elements connected to a subelement

const auto &getSubelementToElement() const¶: get the subelement (element of lower dimension) connected to a element

const auto &getSubelementToElement(ElementType el_type, GhostType ghost_type = _not_ghost) const¶: get the subelement connected to an element

VectorProxy<Element> getSubelementToElement(const Element &element) const¶: get the subelement (element of lower dimension) connected to a element

VectorProxy<UInt> getConnectivity(const Element &element) const¶: get connectivity of a given element

Vector<UInt> getConnectivityWithPeriodicity(const Element &element) const¶

template<typename T> const Array<T> &getData(const ID &data_name, ElementType el_type, GhostType ghost_type = _not_ghost) const¶: get a name field associated to the mesh

template<typename T> Array<T> &getData(const ID &data_name, ElementType el_type, GhostType ghost_type = _not_ghost)¶: get a name field associated to the mesh

template<typename T> const ElementTypeMapArray<T> &getData(const ID &data_name) const¶: get a name field associated to the mesh

template<typename T> ElementTypeMapArray<T> &getData(const ID &data_name)¶: get a name field associated to the mesh

template<typename T> ElementTypeMap<UInt> getNbDataPerElem(ElementTypeMapArray<T> &array)¶

template<typename T> std::shared_ptr<dumpers::Field> createFieldFromAttachedData(const std::string &field_id, const std::string &group_name, ElementKind element_kind)¶

template<typename T> Array<T> &getDataPointer(const std::string &data_name, ElementType el_type, GhostType ghost_type = _not_ghost, UInt nb_component = 1, bool size_to_nb_element = true, bool resize_with_parent = false)¶: templated getter returning the pointer to data in MeshData (modifiable)

template<typename T> Array<T> &getDataPointer(const ID &data_name, ElementType el_type, GhostType ghost_type, UInt nb_component, bool size_to_nb_element, bool resize_with_parent, const T &defaul_)¶

const Mesh &getMeshFacets() const¶: Facets mesh accessor.

Mesh &getMeshFacets()¶

auto hasMeshFacets() const¶

const Mesh &getMeshParent() const¶: Parent mesh accessor.

bool isMeshFacets() const¶

DumperIOHelper &getGroupDumper(const std::string &dumper_name, const std::string &group_name)¶: return the dumper from a group and and a dumper name

auto getFacetConnectivity(const Element &element, UInt t = 0) const¶: get connectivity of facets for a given element

template<typename ...pack> ElementTypesIteratorHelper elementTypes(pack&&... _pack) const¶

decltype(auto) firstType(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind kind = _ek_regular) const¶

decltype(auto) lastType(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind kind = _ek_regular) const¶

const ElementSynchronizer &getElementSynchronizer() const¶

ElementSynchronizer &getElementSynchronizer()¶

const NodeSynchronizer &getNodeSynchronizer() const¶

NodeSynchronizer &getNodeSynchronizer()¶

const PeriodicNodeSynchronizer &getPeriodicNodeSynchronizer() const¶

PeriodicNodeSynchronizer &getPeriodicNodeSynchronizer()¶

const auto &getCommunicator() const¶

auto &getCommunicator()¶

const auto &getPeriodicMasterSlaves() const¶

template<> void sendEvent(NewElementsEvent &event)¶

template<> void sendEvent(NewNodesEvent &event)¶

template<> void sendEvent(RemovedElementsEvent &event)¶

template<> void sendEvent(RemovedNodesEvent &event)¶

Public Static Functions

UInt getNbNodesPerElement(ElementType type)¶: get the number of nodes per element for a given element type

ElementType getP1ElementType(ElementType type)¶: get the number of nodes per element for a given element type considered as a first order element

ElementKind getKind(ElementType type)¶: get the kind of the element type

UInt getSpatialDimension(ElementType type)¶: get spatial dimension of a type of element

UInt getNaturalSpaceDimension(const ElementType &type)¶: get the natural space dimension of a type of element

UInt getNbFacetsPerElement(ElementType type)¶: get number of facets of a given element type

UInt getNbFacetsPerElement(ElementType type, UInt t)¶: get number of facets of a given element type

auto getFacetLocalConnectivity(ElementType type, UInt t = 0)¶: get local connectivity of a facet for a given facet type

UInt getNbFacetTypes(ElementType type, UInt t = 0)¶: get the number of type of the surface element associated to a given element type

constexpr auto getFacetType(ElementType type, UInt t = 0)¶: get the type of the surface element associated to a given element

constexpr auto getAllFacetTypes(ElementType type)¶: get all the type of the surface element associated to a given element

UInt getNbNodesPerElementList(const Array<Element> &elements)¶: get the number of nodes in the given element list

class PeriodicSlaves¶

Public Functions

PeriodicSlaves(const Mesh &mesh, UInt master)¶

PeriodicSlaves(const PeriodicSlaves &other) = default¶

PeriodicSlaves(PeriodicSlaves &&other) = default¶

PeriodicSlaves &operator=(const PeriodicSlaves &other) = default¶

auto begin() const¶

auto end() const¶

class const_iterator¶

Public Functions

const_iterator(internal_iterator it)¶

const_iterator operator++()¶

bool operator!=(const const_iterator &other)¶

bool operator==(const const_iterator &other)¶

auto operator*()¶

class akantu::FEEngine : public akantu::MeshEventHandler¶

The generic FEEngine class derived in a FEEngineTemplate class containing the shape functions and the integration method

Public Types

using ElementTypesIteratorHelper = ElementTypeMapArray<Real, ElementType>::ElementTypesIteratorHelper¶

Public Functions

FEEngine(Mesh &mesh, UInt element_dimension = _all_dimensions, const ID &id = "fem")¶

~FEEngine() override¶

void initShapeFunctions(GhostType ghost_type = _not_ghost) = 0¶: pre-compute all the shape functions, their derivatives and the jacobians

void integrate(const Array<Real> &f, Array<Real> &intf, UInt nb_degree_of_freedom, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: integrate f for all elements of type “type”

Real integrate(const Array<Real> &f, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: integrate a scalar value f on all elements of type “type”

void integrateOnIntegrationPoints(const Array<Real> &f, Array<Real> &intf, UInt nb_degree_of_freedom, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: integrate f for all integration points of type “type” but don’t sum over all integration points

Real integrate(const Vector<Real> &f, ElementType type, UInt index, GhostType ghost_type = _not_ghost) const = 0¶: integrate one element scalar value on all elements of type “type”

UInt getNbIntegrationPoints(ElementType type, GhostType ghost_type = _not_ghost) const = 0¶: get the number of integration points

const Array<Real> &getShapes(ElementType type, GhostType ghost_type = _not_ghost, UInt id = 0) const = 0¶: get the precomputed shapes

const Array<Real> &getShapesDerivatives(ElementType type, GhostType ghost_type = _not_ghost, UInt id = 0) const = 0¶: get the derivatives of shapes

const Matrix<Real> &getIntegrationPoints(ElementType type, GhostType ghost_type = _not_ghost) const = 0¶: get integration points

void gradientOnIntegrationPoints(const Array<Real> &u, Array<Real> &nablauq, UInt nb_degree_of_freedom, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: Compute the gradient nablauq on the integration points of an element type from nodal values u

void interpolateOnIntegrationPoints(const Array<Real> &u, Array<Real> &uq, UInt nb_degree_of_freedom, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: Interpolate a nodal field u at the integration points of an element type -> uq

void interpolateOnIntegrationPoints(const Array<Real> &u, ElementTypeMapArray<Real> &uq, const ElementTypeMapArray<UInt> *filter_elements = nullptr) const = 0¶: Interpolate a nodal field u at the integration points of many element types -> uq

void computeBtD(const Array<Real> &Ds, Array<Real> &BtDs, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: pre multiplies a tensor by the shapes derivaties

void computeBtDB(const Array<Real> &Ds, Array<Real> &BtDBs, UInt order_d, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: left and right multiplies a tensor by the shapes derivaties

void computeNtb(const Array<Real> &bs, Array<Real> &Ntbs, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: left multiples a vector by the shape functions

void computeNtbN(const Array<Real> &bs, Array<Real> &NtbNs, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: left and right multiplies a tensor by the shapes

void computeIntegrationPointsCoordinates(ElementTypeMapArray<Real> &integration_points_coordinates, const ElementTypeMapArray<UInt> *filter_elements = nullptr) const = 0¶: Compute the interpolation point position in the global coordinates for many element types

void computeIntegrationPointsCoordinates(Array<Real> &integration_points_coordinates, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter) const = 0¶: Compute the interpolation point position in the global coordinates for an element type

void initElementalFieldInterpolationFromIntegrationPoints(const ElementTypeMapArray<Real> &interpolation_points_coordinates, ElementTypeMapArray<Real> &interpolation_points_coordinates_matrices, ElementTypeMapArray<Real> &integration_points_coordinates_inv_matrices, const ElementTypeMapArray<UInt> *element_filter) const = 0¶: Build pre-computed matrices for interpolation of field form integration points at other given positions (interpolation_points)

void interpolateElementalFieldFromIntegrationPoints(const ElementTypeMapArray<Real> &field, const ElementTypeMapArray<Real> &interpolation_points_coordinates, ElementTypeMapArray<Real> &result, GhostType ghost_type, const ElementTypeMapArray<UInt> *element_filter) const = 0¶: interpolate field at given position (interpolation_points) from given values of this field at integration points (field)

void interpolateElementalFieldFromIntegrationPoints(const ElementTypeMapArray<Real> &field, const ElementTypeMapArray<Real> &interpolation_points_coordinates_matrices, const ElementTypeMapArray<Real> &integration_points_coordinates_inv_matrices, ElementTypeMapArray<Real> &result, GhostType ghost_type, const ElementTypeMapArray<UInt> *element_filter) const = 0¶: Interpolate field at given position from given values of this field at integration points (field) using matrices precomputed with initElementalFieldInterplationFromIntegrationPoints

void interpolate(const Vector<Real> &real_coords, const Matrix<Real> &nodal_values, Vector<Real> &interpolated, const Element &element) const = 0¶: interpolate on a phyiscal point inside an element

void computeShapes(const Vector<Real> &real_coords, UInt elem, ElementType type, Vector<Real> &shapes, GhostType ghost_type = _not_ghost) const = 0¶: compute the shape on a provided point

void computeShapeDerivatives(const Vector<Real> &real_coords, UInt element, ElementType type, Matrix<Real> &shape_derivatives, GhostType ghost_type = _not_ghost) const = 0¶: compute the shape derivatives on a provided point

void assembleFieldLumped(const std::function<void(Matrix<Real>&, const Element&)> &field_funct, const ID &matrix_id, const ID &dof_id, DOFManager &dof_manager, ElementType type, GhostType ghost_type = _not_ghost, ) const = 0¶

assembles the lumped version of

\[ \int N^t rho N \]

void assembleFieldMatrix(const std::function<void(Matrix<Real>&, const Element&)> &field_funct, const ID &matrix_id, const ID &dof_id, DOFManager &dof_manager, ElementType type, GhostType ghost_type = _not_ghost, ) const = 0¶

assembles the matrix

\[ \int N^t rho N \]

void computeNormalsOnIntegrationPoints(GhostType ghost_type = _not_ghost) = 0¶: pre-compute normals on integration points

void computeNormalsOnIntegrationPoints(const Array<Real>&, GhostType = _not_ghost)¶: pre-compute normals on integration points

void computeNormalsOnIntegrationPoints(const Array<Real>&, Array<Real>&, ElementType, GhostType = _not_ghost) const¶: pre-compute normals on integration points

void printself(std::ostream &stream, int indent = 0) const¶: function to print the containt of the class

ElementTypesIteratorHelper elementTypes(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind kind = _ek_regular) const¶

UInt getElementDimension() const¶: get the dimension of the element handeled by this fe_engine object

const Mesh &getMesh() const¶: get the mesh contained in the fem object

Mesh &getMesh()¶: get the mesh contained in the fem object

Real getElementInradius(const Element &element) const¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(NormalsOnIntegrationPoints, normals_on_integration_points, Real)¶: get the normals on integration points

const ShapeFunctions &getShapeFunctionsInterface() const = 0¶: get the shape function class (probably useless: see getShapeFunction in fe_engine_template.hh)

const Integrator &getIntegratorInterface() const = 0¶: get the integrator class (probably useless: see getIntegrator in fe_engine_template.hh)

ID getID() const¶

Public Static Functions

template<typename T> void extractNodalToElementField(const Mesh &mesh, const Array<T> &nodal_f, Array<T> &elemental_f, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter)¶: extract the nodal values and store them per element

template<typename T> void filterElementalData(const Mesh &mesh, const Array<T> &elem_f, Array<T> &filtered_f, ElementType type, GhostType ghost_type = _not_ghost, const Array<UInt> &filter_elements = empty_filter)¶: filter a field

Real getElementInradius(const Matrix<Real> &coord, ElementType type)¶: get the in-radius of an element

ElementType getCohesiveElementType(ElementType type_facet)¶: get cohesive element type for a given facet type

Vector<ElementType> getIGFEMElementTypes(ElementType type)¶: get igfem element type for a given regular type

InterpolationType getInterpolationType(ElementType el_type)¶: get the interpolation element associated to an element type

class akantu::Element¶

Subclassed by akantu::IntegrationPoint

Public Functions

ElementKind kind() const¶

bool operator==(const Element &elem) const¶

bool operator!=(const Element &elem) const¶

bool operator<(const Element &rhs) const¶

Public Members

ElementType type¶

UInt element¶

GhostType ghost_type¶

class akantu::GroupManager¶

Subclassed by akantu::FragmentManager, akantu::Mesh

Public Types

using node_group_iterator = NodeGroups::iterator¶

using element_group_iterator = ElementGroups::iterator¶

using const_node_group_iterator = NodeGroups::const_iterator¶

using const_element_group_iterator = ElementGroups::const_iterator¶

Public Functions

GroupManager(Mesh &mesh, const ID &id = "group_manager")¶

~GroupManager()¶

BOOST_PP_CAT (BOOST_PP_CAT(const_, node_group), _iterator) BOOST_PP_CAT(BOOST_PP_CAT(node_group

begin(BOOST_PP_EMPTY()) const¶

BOOST_PP_CAT (node_group, _iterator) BOOST_PP_CAT(BOOST_PP_CAT(node_group

begin(BOOST_PP_EMPTY())¶

BOOST_PP_CAT (BOOST_PP_CAT(const_, node_group), _iterator) BOOST_PP_CAT(BOOST_PP_CAT(node_group

end(BOOST_PP_EMPTY()) const¶

BOOST_PP_CAT (node_group, _iterator) BOOST_PP_CAT(BOOST_PP_CAT(node_group

end(BOOST_PP_EMPTY())¶

BOOST_PP_CAT (BOOST_PP_CAT(const_, element_group), _iterator) BOOST_PP_CAT(BOOST_PP_CAT(element_group

begin(BOOST_PP_EMPTY()) const

BOOST_PP_CAT (element_group, _iterator) BOOST_PP_CAT(BOOST_PP_CAT(element_group

begin(BOOST_PP_EMPTY())

BOOST_PP_CAT (BOOST_PP_CAT(const_, element_group), _iterator) BOOST_PP_CAT(BOOST_PP_CAT(element_group

end(BOOST_PP_EMPTY()) const

BOOST_PP_CAT (element_group, _iterator) BOOST_PP_CAT(BOOST_PP_CAT(element_group

end(BOOST_PP_EMPTY())

BOOST_PP_CAT (BOOST_PP_CAT(const_, element_group), _iterator) BOOST_PP_CAT(BOOST_PP_CAT(element_group

find(const std::string &name) const¶

BOOST_PP_CAT (element_group, _iterator) BOOST_PP_CAT(BOOST_PP_CAT(element_group

find(const std::string &name)¶

BOOST_PP_CAT (BOOST_PP_CAT(const_, node_group), _iterator) BOOST_PP_CAT(BOOST_PP_CAT(node_group

find(const std::string &name) const

BOOST_PP_CAT (node_group, _iterator) BOOST_PP_CAT(BOOST_PP_CAT(node_group

find(const std::string &name)

decltype(auto) iterateNodeGroups()¶

decltype(auto) iterateNodeGroups() const¶

decltype(auto) iterateElementGroups()¶

decltype(auto) iterateElementGroups() const¶

NodeGroup &createNodeGroup(const std::string &group_name, bool replace_group = false)¶: create an empty node group

ElementGroup &createElementGroup(const std::string &group_name, UInt dimension = _all_dimensions, bool replace_group = false)¶: create an element group and the associated node group

void renameElementGroup(const std::string &name, const std::string &new_name)¶: renames an element group

void renameNodeGroup(const std::string &name, const std::string &new_name)¶: renames a node group

void copyElementGroup(const std::string &name, const std::string &new_name)¶: copy an existing element group

void copyNodeGroup(const std::string &name, const std::string &new_name)¶: copy an existing node group

template<typename T> NodeGroup &createFilteredNodeGroup(const std::string &group_name, const NodeGroup &node_group, T &filter)¶: create a node group from another node group but filtered

template<typename T> ElementGroup &createFilteredElementGroup(const std::string &group_name, UInt dimension, const NodeGroup &node_group, T &filter)¶: create an element group from another element group but filtered

void destroyNodeGroup(const std::string &group_name)¶: destroy a node group

void destroyElementGroup(const std::string &group_name, bool destroy_node_group = false)¶: destroy an element group and the associated node group

ElementGroup &createElementGroup(const std::string &group_name, UInt dimension, NodeGroup &node_group)¶: create a element group using an existing node group

template<typename T> void createGroupsFromMeshData(const std::string &dataset_name)¶: create groups based on values stored in a given mesh data

UInt createBoundaryGroupFromGeometry()¶

create boundaries group by a clustering algorithm

Todo:: extend to parallel

Todo:: this function doesn’t work in 1D

UInt createClusters(UInt element_dimension, Mesh &mesh_facets, const std::string &cluster_name_prefix = "cluster", const ClusteringFilter &filter = ClusteringFilter())¶: create element clusters for a given dimension

UInt createClusters(UInt element_dimension, const std::string &cluster_name_prefix = "cluster", const ClusteringFilter &filter = ClusteringFilter())¶: create element clusters for a given dimension

void createElementGroupFromNodeGroup(const std::string &name, const std::string &node_group, UInt dimension = _all_dimensions)¶: Create an ElementGroup based on a NodeGroup.

void printself(std::ostream &stream, int indent = 0) const¶

void synchronizeGroupNames()¶: this function insure that the group names are present on all processors /!\ it is a SMP call

template<typename T, template<bool> class dump_type> std::shared_ptr<dumpers::Field> createElementalField(const ElementTypeMapArray<T> &field, const std::string &group_name, UInt spatial_dimension, ElementKind kind, ElementTypeMap<UInt> nb_data_per_elem = ElementTypeMap<UInt>())¶

< type of InternalMaterialField

template<typename T, template<class> class ret_type, template<class, template<class> class, bool> class dump_type> std::shared_ptr<dumpers::Field> createElementalField(const ElementTypeMapArray<T> &field, const std::string &group_name, UInt spatial_dimension, ElementKind kind, ElementTypeMap<UInt> nb_data_per_elem = ElementTypeMap<UInt>())¶: register an elemental field to the given group name (overloading for ElementalField)

template<typename T, template<typename, bool filtered> class dump_type> std::shared_ptr<dumpers::Field> createElementalField(const ElementTypeMapArray<T> &field, const std::string &group_name, UInt spatial_dimension, ElementKind kind, ElementTypeMap<UInt> nb_data_per_elem)¶: register an elemental field to the given group name (overloading for MaterialInternalField)

template<typename type, bool flag, template<class, bool> class ftype> std::shared_ptr<dumpers::Field> createNodalField(const ftype<type, flag> *field, const std::string &group_name, UInt padding_size = 0)¶

template<typename type, bool flag, template<class, bool> class ftype> std::shared_ptr<dumpers::Field> createStridedNodalField(const ftype<type, flag> *field, const std::string &group_name, UInt size, UInt stride, UInt padding_size)¶

void onNodesAdded(const Array<UInt> &new_nodes, const NewNodesEvent &event)¶

const ElementGroup &getElementGroup(const std::string &name) const¶

const NodeGroup &getNodeGroup(const std::string &name) const¶

ElementGroup &getElementGroup(const std::string &name)¶

NodeGroup &getNodeGroup(const std::string &name)¶

UInt getNbElementGroups(UInt dimension = _all_dimensions) const¶

UInt getNbNodeGroups()¶

bool elementGroupExists(const std::string &name)¶

bool nodeGroupExists(const std::string &name)¶

Public Members

_

class ClusteringFilter¶

Subclassed by akantu::CohesiveElementFilter

Public Functions

bool operator()(const Element&) const¶

class akantu::ElementGroup : public akantu::Dumpable ¶

Public Types

using ElementList = ElementTypeMapArray<UInt>¶

using NodeList = Array<UInt>¶

using type_iterator = ElementList::type_iterator¶

using const_element_iterator = Array<UInt>::const_iterator<UInt>¶

Public Functions

ElementGroup(const std::string &name, const Mesh &mesh, NodeGroup &node_group, UInt dimension = _all_dimensions, const std::string &id = "element_group")¶

ElementGroup(const ElementGroup&)¶

type_iterator firstType(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind kind = _ek_regular) const¶

type_iterator lastType(UInt dim = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind kind = _ek_regular) const¶

template<typename ...pack> decltype(auto) elementTypes(pack&&... _pack) const¶

const_element_iterator begin(ElementType type, GhostType ghost_type = _not_ghost) const¶

const_element_iterator end(ElementType type, GhostType ghost_type = _not_ghost) const¶

void clear()¶: empty the element group

void clear(ElementType type, GhostType ghost_type = _not_ghost)¶

bool empty() const __attribute__((warn_unused_result))¶

void append(const ElementGroup &other_group)¶: append another group to this group BE CAREFUL: it doesn’t conserve the element order

void add(const Element &el, bool add_nodes = false, bool check_for_duplicate = true)¶: add an element to the group. By default the it does not add the nodes to the group

void add(ElementType type, UInt element, GhostType ghost_type = _not_ghost, bool add_nodes = true, bool check_for_duplicate = true)¶

Todo:: fix the default for add_nodes : make it coherent with the other method

void addNode(UInt node_id, bool check_for_duplicate = true)¶

void removeNode(UInt node_id)¶

void printself(std::ostream &stream, int indent = 0) const¶: function to print the contain of the class

void fillFromNodeGroup()¶: fill the elements based on the underlying node group.

void optimize()¶

void addDimension(UInt dimension)¶: change the dimension if needed

void onNodesAdded(const Array<UInt> &new_nodes, const NewNodesEvent &event)¶

const Array<UInt> &getElements(ElementType type, GhostType ghost_type = _not_ghost) const¶

const ElementTypeMapArray<UInt> &getElements() const¶

ElementTypeMapArray<UInt> &getElements()¶

template<class ...Args> auto size(Args&&... pack) const¶

decltype(auto) getElementsIterable(ElementType type, GhostType ghost_type = _not_ghost) const¶

const NodeGroup &getNodeGroup() const¶

NodeGroup &getNodeGroup()¶

UInt getDimension() const¶

std::string getName() const¶

UInt getNbNodes() const¶

class akantu::NodeGroup : public akantu::Dumpable ¶

Public Types

using const_node_iterator = Array<UInt>::const_iterator<UInt>¶

Public Functions

NodeGroup(const std::string &name, const Mesh &mesh, const std::string &id = "node_group")¶

~NodeGroup() override¶

void clear()¶: empty the node group

bool empty() const __attribute__((warn_unused_result))¶

returns treu if the group is empty

Warning: this changed beahavior if you want to empty the group use clear

const_node_iterator begin() const¶: iterator to the beginning of the node group

const_node_iterator end() const¶: iterator to the end of the node group

const_node_iterator add(UInt node, bool check_for_duplicate = true)¶: add a node and give the local position through an iterator

void remove(UInt node)¶: remove a node

decltype(auto) find(UInt node) const¶

void optimize()¶: remove duplicated nodes

void append(const NodeGroup &other_group)¶: append a group to current one

template<typename T> void applyNodeFilter(T &filter)¶: apply a filter on current node group

void printself(std::ostream &stream, int indent = 0) const¶: function to print the contain of the class

Array<UInt> &getNodes()¶

const Array<UInt> &getNodes() const¶

const std::string &getName() const¶

UInt size() const¶: give the number of nodes in the current group

Friends

friend class GroupManager

Models¶

Common¶

class akantu::BC::Dirichlet::FixedValue : public akantu::BC::Dirichlet::DirichletFunctor¶

Public Functions

FixedValue(Real val, Axis ax = _x)¶

void operator()(UInt node, Vector<bool> &flags, Vector<Real> &primal, const Vector<Real> &coord) const override¶

class akantu::BC::Dirichlet::FlagOnly : public akantu::BC::Dirichlet::DirichletFunctor¶

Public Functions

FlagOnly(Axis ax = _x)¶

void operator()(UInt node, Vector<bool> &flags, Vector<Real> &primal, const Vector<Real> &coord) const override¶

class akantu::BC::Dirichlet::IncrementValue : public akantu::BC::Dirichlet::DirichletFunctor¶

Public Functions

IncrementValue(Real val, Axis ax = _x)¶

void operator()(UInt node, Vector<bool> &flags, Vector<Real> &primal, const Vector<Real> &coord) const override¶

void setIncrement(Real val)¶

class akantu::BC::Neumann::FromHigherDim : public akantu::BC::Neumann::NeumannFunctor¶

Public Functions

FromHigherDim(const Matrix<Real> &mat)¶

~FromHigherDim() override = default¶

void operator()(const IntegrationPoint &quad_point, Vector<Real> &dual, const Vector<Real> &coord, const Vector<Real> &normals) const override¶

class akantu::BC::Neumann::FromSameDim : public akantu::BC::Neumann::NeumannFunctor¶

Public Functions

FromSameDim(const Vector<Real> &vec)¶

~FromSameDim() override = default¶

void operator()(const IntegrationPoint &quad_point, Vector<Real> &dual, const Vector<Real> &coord, const Vector<Real> &normals) const override¶

template<class ModelType> class akantu::BoundaryCondition¶

Public Functions

BoundaryCondition()¶

void initBC(ModelType &model, Array<Real> &primal, Array<Real> &dual)¶: Initialize the boundary conditions.

void initBC(ModelType &model, Array<Real> &primal, Array<Real> &primal_increment, Array<Real> &dual)¶

template<typename FunctorType> void applyBC(const FunctorType &func)¶: Apply the boundary conditions.

template<class FunctorType> void applyBC(const FunctorType &func, const std::string &group_name)¶

template<class FunctorType> void applyBC(const FunctorType &func, const ElementGroup &element_group)¶

ModelType &getModel()¶

Array<Real> &getPrimal()¶

Array<Real> &getDual()¶

template<class FunctorType, BC::Functor::Type type = FunctorType::type> struct TemplateFunctionWrapper¶

template<typename FunctorType> _dirichlet >

Public Static Functions

void applyBC(const FunctorType &func, const ElementGroup &group, BoundaryCondition<ModelType> &bc_instance)¶

template<typename FunctorType> _neumann >

Public Static Functions

void applyBC(const FunctorType &func, const ElementGroup &group, BoundaryCondition<ModelType> &bc_instance)

void applyBC(const FunctorType &func, const ElementGroup &group, BoundaryCondition<ModelType> &bc_instance, GhostType ghost_type)¶

Warning

doxygenclass: Cannot find class “akantu::BoundaryConditionFunctor” in doxygen xml output for project “Akantu” from directory: /builds/akantu/akantu/build/doc/dev-doc/xml

template<class EventHandler> class akantu::EventHandlerManager¶

Public Functions

~EventHandlerManager() = default¶

void registerEventHandler(EventHandler &event_handler, EventHandlerPriority priority = _ehp_highest)¶: register a new EventHandler to the Manager. The register object will then be informed about the events the manager observes.

void unregisterEventHandler(EventHandler &event_handler)¶: unregister a EventHandler object. This object will not be notified anymore about the events this manager observes.

template<class Event> void sendEvent(const Event &event)¶: Notify all the registered EventHandlers about the event that just occured.

class akantu::Model : public akantu::ModelSolver, public akantu::MeshEventHandler¶

Subclassed by akantu::ContactMechanicsModel, akantu::CouplerSolidContactTemplate< SolidMechanicsModelType >, akantu::CouplerSolidPhaseField, akantu::HeatTransferModel, akantu::PhaseFieldModel, akantu::SolidMechanicsModel, akantu::StructuralMechanicsModel

Public Types

using FEEngineMap = std::map<std::string, std::unique_ptr<FEEngine>>¶

Public Functions

Model(Mesh &mesh, const ModelType &type, UInt dim = _all_dimensions, const ID &id = "model")¶: Normal constructor where the DOFManager is created internally.

~Model() override¶

template<typename ...pack> std::enable_if_t<are_named_argument<pack...>::value> initFull(pack&&... _pack)¶

template<typename ...pack> std::enable_if_t<not are_named_argument<pack...>::value> initFull(pack&&... _pack)¶

void initNewSolver(const AnalysisMethod &method)¶: initialize a new solver if needed

void dumpGroup(const std::string &group_name)¶: Dump the data for a given group.

void dumpGroup(const std::string &group_name, const std::string &dumper_name)¶

void dumpGroup()¶: Dump the data for all boundaries.

void setGroupDirectory(const std::string &directory, const std::string &group_name)¶: Set the directory for a given group.

void setGroupDirectory(const std::string &directory)¶: Set the directory for all boundaries.

void setGroupBaseName(const std::string &basename, const std::string &group_name)¶: Set the base name for a given group.

DumperIOHelper &getGroupDumper(const std::string &group_name)¶: Get the internal dumper of a given group.

void updateDataForNonLocalCriterion(__attribute__((unused)) ElementTypeMapReal &criterion)¶

const ID &getID() const¶: get id of model

Mesh &getMesh() const¶: get the number of surfaces

void synchronizeBoundaries()¶: synchronize the boundary in case of parallel run

FEEngine &getFEEngine(const ID &name = "") const¶: return the fem object associated with a provided name

FEEngine &getFEEngineBoundary(const ID &name = "")¶: return the fem boundary object associated with a provided name

bool hasFEEngineBoundary(const ID &name = "")¶

template<typename FEEngineClass> void registerFEEngineObject(const std::string &name, Mesh &mesh, UInt spatial_dimension)¶: register a fem object associated with name

void unRegisterFEEngineObject(const std::string &name)¶: unregister a fem object associated with name

SynchronizerRegistry &getSynchronizerRegistry()¶: return the synchronizer registry

template<typename FEEngineClass> FEEngineClass &getFEEngineClass(std::string name = "") const¶: return the fem object associated with a provided name

template<typename FEEngineClass> FEEngineClass &getFEEngineClassBoundary(std::string name = "")¶: return the fem boundary object associated with a provided name

AnalysisMethod getAnalysisMethod() const¶: Get the type of analysis method used.

UInt getSpatialDimension() const¶: return the dimension of the system space

UInt getNbIntegrationPoints(const Array<Element> &elements, const ID &fem_id = ID()) const¶

void setTextModeToDumper()¶

void addDumpGroupFieldToDumper(const std::string &field_id, std::shared_ptr<dumpers::Field> field, DumperIOHelper &dumper)¶

void addDumpField(const std::string &field_id)¶

void addDumpFieldVector(const std::string &field_id)¶

void addDumpFieldToDumper(const std::string &dumper_name, const std::string &field_id)¶

void addDumpFieldVectorToDumper(const std::string &dumper_name, const std::string &field_id)¶

void addDumpFieldTensorToDumper(const std::string &dumper_name, const std::string &field_id)¶

void addDumpFieldTensor(const std::string &field_id)¶

void setBaseName(const std::string &field_id)¶

void setBaseNameToDumper(const std::string &dumper_name, const std::string &basename)¶

void addDumpGroupField(const std::string &field_id, const std::string &group_name)¶

void addDumpGroupFieldToDumper(const std::string &dumper_name, const std::string &field_id, const std::string &group_name, ElementKind element_kind, bool padding_flag)¶

void addDumpGroupFieldToDumper(const std::string &dumper_name, const std::string &field_id, const std::string &group_name, UInt spatial_dimension, ElementKind element_kind, bool padding_flag)¶

void removeDumpGroupField(const std::string &field_id, const std::string &group_name)¶

void removeDumpGroupFieldFromDumper(const std::string &dumper_name, const std::string &field_id, const std::string &group_name)¶

void addDumpGroupFieldVector(const std::string &field_id, const std::string &group_name)¶

void addDumpGroupFieldVectorToDumper(const std::string &dumper_name, const std::string &field_id, const std::string &group_name)¶

std::shared_ptr<dumpers::Field> createNodalFieldReal(const std::string&, const std::string&, bool)¶

std::shared_ptr<dumpers::Field> createNodalFieldUInt(const std::string&, const std::string&, bool)¶

std::shared_ptr<dumpers::Field> createNodalFieldBool(const std::string&, const std::string&, bool)¶

std::shared_ptr<dumpers::Field> createElementalField(const std::string&, const std::string&, bool, UInt, ElementKind)¶

void setDirectory(const std::string &directory)¶

void setDirectoryToDumper(const std::string &dumper_name, const std::string &directory)¶

void dump(const std::string &dumper_name)¶

void dump(const std::string &dumper_name, UInt step)¶

void dump(const std::string &dumper_name, Real time, UInt step)¶

void dump()¶

void dump(UInt step)¶

void dump(Real time, UInt step)¶

class akantu::NonLocalManagerCallback¶

Subclassed by akantu::SolidMechanicsModel

Public Functions

void initializeNonLocal()¶

void insertIntegrationPointsInNeighborhoods(GhostType ghost_type) = 0¶

void computeNonLocalStresses(GhostType ghost_type) = 0¶

void updateLocalInternal(ElementTypeMapReal &internal_flat, GhostType ghost_type, ElementKind kind) = 0¶: update the values of the non local internal

void updateNonLocalInternal(ElementTypeMapReal &internal_flat, GhostType ghost_type, ElementKind kind) = 0¶: copy the results of the averaging in the materials

Solvers¶

class akantu::ModelSolver : public akantu::Parsable, public akantu::SolverCallback, public akantu::SynchronizerRegistry¶

Subclassed by akantu::Model

Public Functions

ModelSolver(Mesh &mesh, const ModelType &type, const ID &id)¶

~ModelSolver() override¶

std::shared_ptr<DOFManager> initDOFManager(std::shared_ptr<DOFManager> dof_manager = nullptr)¶: initialize the dof manager based on solver type passed in the input file

std::shared_ptr<DOFManager> initDOFManager(const ID &solver_type)¶: initialize the dof manager based on the used chosen solver type

void initSolver(TimeStepSolverType, NonLinearSolverType)¶: Callback for the model to instantiate the matricees when needed.

std::tuple<ParserSection, bool> getParserSection()¶: get the section in the input file (if it exsits) corresponding to this model

void solveStep(const ID &solver_id = "")¶: solve a step using a given pre instantiated time step solver and non linear solver

void solveStep(SolverCallback &callback, const ID &solver_id = "")¶: solve a step using a given pre instantiated time step solver and non linear solver with a user defined callback instead of the model itself /!\ This can mess up everything

void getNewSolver(const ID &solver_id, TimeStepSolverType time_step_solver_type, NonLinearSolverType non_linear_solver_type = NonLinearSolverType::_auto)¶: Initialize a time solver that can be used afterwards with its id.

void setIntegrationScheme(const ID &solver_id, const ID &dof_id, const IntegrationSchemeType &integration_scheme_type, IntegrationScheme::SolutionType solution_type = IntegrationScheme::_not_defined)¶: set an integration scheme for a given dof and a given solver

void setIntegrationScheme(const ID &solver_id, const ID &dof_id, std::unique_ptr<IntegrationScheme> &integration_scheme, IntegrationScheme::SolutionType solution_type = IntegrationScheme::_not_defined)¶: set an externally instantiated integration scheme

void predictor() override¶: Predictor interface for the callback.

void corrector() override¶: Corrector interface for the callback.

TimeStepSolverType getDefaultSolverType() const¶: Default time step solver to instantiate for this model.

ModelSolverOptions getDefaultSolverOptions(const TimeStepSolverType &type) const¶: Default configurations for a given time step solver.

DOFManager &getDOFManager()¶: get access to the internal dof manager

Real getTimeStep(const ID &solver_id = "") const¶: get the time step of a given solver

void setTimeStep(Real time_step, const ID &solver_id = "")¶: set the time step of a given solver

bool hasSolver(const ID &solver_id) const¶

set the parameter ‘param’ of the solver ‘solver_id’

get the parameter ‘param’ of the solver ‘solver_id’ answer to the question “does the solver exists ?”

void setDefaultSolver(const ID &solver_id)¶: changes the current default solver

bool hasDefaultSolver() const¶: is a default solver defined

bool hasIntegrationScheme(const ID &solver_id, const ID &dof_id) const¶: is an integration scheme set for a given solver and a given dof

TimeStepSolver &getTimeStepSolver(const ID &solver_id = "")¶

NonLinearSolver &getNonLinearSolver(const ID &solver_id = "")¶

const TimeStepSolver &getTimeStepSolver(const ID &solver_id = "") const¶

const NonLinearSolver &getNonLinearSolver(const ID &solver_id = "") const¶

class akantu::DOFManager : protected akantu::MeshEventHandler¶

Subclassed by akantu::DOFManagerDefault, akantu::DOFManagerPETSc

Public Functions

DOFManager(const ID &id = "dof_manager")¶

DOFManager(Mesh &mesh, const ID &id = "dof_manager")¶

~DOFManager() override¶

void registerDOFs(const ID &dof_id, Array<Real> &dofs_array, const DOFSupportType &support_type)¶: register an array of degree of freedom

void registerDOFs(const ID &dof_id, Array<Real> &dofs_array, const ID &support_group)¶: the dof as an implied type of _dst_nodal and is defined only on a subset of nodes

void registerDOFsPrevious(const ID &dof_id, Array<Real> &dofs_array)¶: register an array of previous values of the degree of freedom

void registerDOFsIncrement(const ID &dof_id, Array<Real> &dofs_array)¶: register an array of increment of degree of freedom

void registerDOFsDerivative(const ID &dof_id, UInt order, Array<Real> &dofs_derivative)¶: register an array of derivatives for a particular dof array

void registerBlockedDOFs(const ID &dof_id, Array<bool> &blocked_dofs)¶: register array representing the blocked degree of freedoms

void assembleToResidual(const ID &dof_id, Array<Real> &array_to_assemble, Real scale_factor = 1.)¶: Assemble an array to the global residual array.

void assembleToLumpedMatrix(const ID &dof_id, Array<Real> &array_to_assemble, const ID &lumped_mtx, Real scale_factor = 1.)¶: Assemble an array to the global lumped matrix array.

void assembleElementalArrayLocalArray(const Array<Real> &elementary_vect, Array<Real> &array_assembeled, ElementType type, GhostType ghost_type, Real scale_factor = 1., const Array<UInt> &filter_elements = empty_filter)¶: Assemble elementary values to a local array of the size nb_nodes * nb_dof_per_node. The dof number is implicitly considered as conn(el, n) * nb_nodes_per_element + d. With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node

void assembleElementalArrayToResidual(const ID &dof_id, const Array<Real> &elementary_vect, ElementType type, GhostType ghost_type, Real scale_factor = 1., const Array<UInt> &filter_elements = empty_filter)¶: Assemble elementary values to the global residual array. The dof number is implicitly considered as conn(el, n) * nb_nodes_per_element + d. With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node

void assembleElementalArrayToLumpedMatrix(const ID &dof_id, const Array<Real> &elementary_vect, const ID &lumped_mtx, ElementType type, GhostType ghost_type, Real scale_factor = 1., const Array<UInt> &filter_elements = empty_filter)¶: Assemble elementary values to a global array corresponding to a lumped matrix

void assembleElementalMatricesToMatrix(const ID &matrix_id, const ID &dof_id, const Array<Real> &elementary_mat, ElementType type, GhostType ghost_type = _not_ghost, const MatrixType &elemental_matrix_type = _symmetric, const Array<UInt> &filter_elements = empty_filter) = 0¶: Assemble elementary values to the global residual array. The dof number is implicitly considered as conn(el, n) * nb_nodes_per_element + d. With 0 < n < nb_nodes_per_element and 0 < d < nb_dof_per_node

void assembleMatMulVectToArray(const ID &dof_id, const ID &A_id, const Array<Real> &x, Array<Real> &array, Real scale_factor = 1) = 0¶: multiply a vector by a matrix and assemble the result to the residual

void assembleLumpedMatMulVectToResidual(const ID &dof_id, const ID &A_id, const Array<Real> &x, Real scale_factor = 1) = 0¶: multiply a vector by a lumped matrix and assemble the result to the residual

void assemblePreassembledMatrix(const ID &matrix_id, const TermsToAssemble &terms) = 0¶: assemble coupling terms between to dofs

void assembleMatMulVectToResidual(const ID &dof_id, const ID &A_id, const Array<Real> &x, Real scale_factor = 1)¶: multiply a vector by a matrix and assemble the result to the residual

void assembleMatMulDOFsToResidual(const ID &A_id, Real scale_factor = 1)¶: multiply the dofs by a matrix and assemble the result to the residual

void updateGlobalBlockedDofs()¶: updates the global blocked_dofs array

void zeroResidual()¶: sets the residual to 0

void zeroMatrix(const ID &mtx)¶: sets the matrix to 0

void zeroLumpedMatrix(const ID &mtx)¶: sets the lumped matrix to 0

void applyBoundary(const ID &matrix_id = "J")¶

void getLumpedMatrixPerDOFs(const ID &dof_id, const ID &lumped_mtx, Array<Real> &lumped)¶: extract a lumped matrix part corresponding to a given dof

void splitSolutionPerDOFs()¶: splits the solution storage from a global view to the per dof storages

bool isLocalOrMasterDOF(UInt local_dof_num)¶: Get the location type of a given dof.

bool isSlaveDOF(UInt local_dof_num)¶: Answer to the question is a dof a slave dof ?

bool isPureGhostDOF(UInt local_dof_num)¶: Answer to the question is a dof a slave dof ?

bool hasGlobalEquationNumber(Int global) const¶: tells if the dof manager knows about a global dof

Int globalToLocalEquationNumber(Int global) const¶: return the local index of the global equation number

Int localToGlobalEquationNumber(Int local) const¶: converts local equation numbers to global equation numbers;

NodeFlag getDOFFlag(Int local_id) const¶: get the array of dof types (use only if you know what you do…)

bool hasBlockedDOFsChanged() const¶: defines if the boundary changed

UInt getSystemSize() const¶: Global number of dofs.

UInt getLocalSystemSize() const¶: Local number of dofs.

UInt getPureLocalSystemSize() const¶: Pure local number of dofs.

std::vector<ID> getDOFIDs() const¶: Retrieve all the registered DOFs.

Array<Real> &getDOFs(const ID &dofs_id)¶: Get a reference to the registered dof array for a given id.

DOFSupportType getSupportType(const ID &dofs_id) const¶: Get the support type of a given dof.

bool hasDOFs(const ID &dof_id) const¶: are the dofs registered

Array<Real> &getDOFsDerivatives(const ID &dofs_id, UInt order)¶: Get a reference to the registered dof derivatives array for a given id.

bool hasDOFsDerivatives(const ID &dofs_id, UInt order) const¶: Does the dof has derivatives.

const Array<bool> &getBlockedDOFs(const ID &dofs_id) const¶: Get a reference to the blocked dofs array registered for the given id.

bool hasBlockedDOFs(const ID &dofs_id) const¶: Does the dof has a blocked array.

Array<Real> &getDOFsIncrement(const ID &dofs_id)¶: Get a reference to the registered dof increment array for a given id.

bool hasDOFsIncrement(const ID &dofs_id) const¶: Does the dof has a increment array.

Array<Real> &getPreviousDOFs(const ID &dofs_id)¶: Does the dof has a previous array.

bool hasPreviousDOFs(const ID &dofs_id) const¶: Get a reference to the registered dof array for previous step values a given id

void savePreviousDOFs(const ID &dofs_id)¶: saves the values from dofs to previous dofs

const Array<Real> &getSolution(const ID &dofs_id) const¶: Get a reference to the solution array registered for the given id.

Array<Real> &getSolution(const ID &dofs_id)¶: Get a reference to the solution array registered for the given id.

const Array<Int> &getGlobalBlockedDOFs() const¶: Get the blocked dofs array.

const Array<Int> &getPreviousGlobalBlockedDOFs() const¶: Get the blocked dofs array.

SparseMatrix &getNewMatrix(const ID &matrix_id, const MatrixType &matrix_type) = 0¶: Get an instance of a new SparseMatrix.

SparseMatrix &getNewMatrix(const ID &matrix_id, const ID &matrix_to_copy_id) = 0¶: Get an instance of a new SparseMatrix as a copy of the SparseMatrix matrix_to_copy_id

const Array<Int> &getLocalEquationsNumbers(const ID &dof_id) const¶: Get the equation numbers corresponding to a dof_id. This might be used to access the matrix.

void getArrayPerDOFs(const ID &dof_id, const SolverVector &global, Array<Real> &local) = 0¶: extract degrees of freedom (identified by ID) from a global solver array

SparseMatrix &getMatrix(const ID &matrix_id)¶: Get the reference of an existing matrix.

bool hasMatrix(const ID &matrix_id) const¶: check if the given matrix exists

SolverVector &getNewLumpedMatrix(const ID &matrix_id) = 0¶: Get an instance of a new lumped matrix.

const SolverVector &getLumpedMatrix(const ID &matrix_id) const¶: Get the lumped version of a given matrix.

SolverVector &getLumpedMatrix(const ID &matrix_id)¶: Get the lumped version of a given matrix.

bool hasLumpedMatrix(const ID &matrix_id) const¶: check if the given matrix exists

NonLinearSolver &getNewNonLinearSolver(const ID &nls_solver_id, const NonLinearSolverType &_non_linear_solver_type) = 0¶: Get instance of a non linear solver.

NonLinearSolver &getNonLinearSolver(const ID &nls_solver_id)¶: get instance of a non linear solver

bool hasNonLinearSolver(const ID &solver_id) const¶: check if the given solver exists

TimeStepSolver &getNewTimeStepSolver(const ID &time_step_solver_id, const TimeStepSolverType &type, NonLinearSolver &non_linear_solver, SolverCallback &solver_callback) = 0¶: Get instance of a time step solver.

TimeStepSolver &getTimeStepSolver(const ID &time_step_solver_id)¶: get instance of a time step solver

bool hasTimeStepSolver(const ID &solver_id) const¶: check if the given solver exists

const Mesh &getMesh()¶

const auto &getCommunicator() const¶

auto &getCommunicator()¶

const auto &getSolution() const¶

auto &getSolution()¶

const auto &getResidual() const¶

auto &getResidual()¶

void onNodesAdded(const Array<UInt> &nodes_list, const NewNodesEvent &event) override¶: function to implement to react on akantu::NewNodesEvent

void onNodesRemoved(const Array<UInt> &nodes_list, const Array<UInt> &new_numbering, const RemovedNodesEvent &event) override¶: function to implement to react on akantu::RemovedNodesEvent

void onElementsAdded(const Array<Element> &elements_list, const NewElementsEvent &event) override¶: function to implement to react on akantu::NewElementsEvent

void onElementsRemoved(const Array<Element> &elements_list, const ElementTypeMapArray<UInt> &new_numbering, const RemovedElementsEvent &event) override¶: function to implement to react on akantu::RemovedElementsEvent

void onElementsChanged(const Array<Element> &old_elements_list, const Array<Element> &new_elements_list, const ElementTypeMapArray<UInt> &new_numbering, const ChangedElementsEvent &event) override¶: function to implement to react on akantu::ChangedElementsEvent

void onMeshIsDistributed(const Mesh &mesh, const MeshIsDistributedEvent &event) override¶: function to implement to react on akantu::MeshIsDistributedEvent

class akantu::NonLinearSolver : public akantu::Parsable¶

Subclassed by akantu::NonLinearSolverLinear, akantu::NonLinearSolverLumped, akantu::NonLinearSolverNewtonRaphson, akantu::NonLinearSolverPETSc

Public Functions

NonLinearSolver(DOFManager &dof_manager, const NonLinearSolverType &non_linear_solver_type, const ID &id = "non_linear_solver")¶

~NonLinearSolver() override¶

void solve(SolverCallback &callback) = 0¶: solve the system described by the jacobian matrix, and rhs contained in the dof manager

template<typename T> void set(const ID &param, T &&t)¶: intercept the call to set for options

class akantu::NonLinearSolverNewtonRaphson : public akantu::NonLinearSolver ¶

Public Functions

NonLinearSolverNewtonRaphson(DOFManagerDefault &dof_manager, const NonLinearSolverType &non_linear_solver_type, const ID &id = "non_linear_solver_newton_raphson")¶

~NonLinearSolverNewtonRaphson() override¶

void solve(SolverCallback &solver_callback) override¶: Function that solve the non linear system described by the dof manager and the solver callback functions

SparseSolverMumps &getSolver()¶

const SparseSolverMumps &getSolver() const¶

Solid Mechanics Model¶

class akantu::SolidMechanicsModel : public akantu::Model, public akantu::DataAccessor<Element>, public akantu::DataAccessor<UInt>, public akantu::BoundaryCondition<SolidMechanicsModel>, public akantu::NonLocalManagerCallback, public akantu::EventHandlerManager<SolidMechanicsModelEventHandler>¶

Subclassed by akantu::EmbeddedInterfaceModel, akantu::SolidMechanicsModelCohesive

Public Types

using MyFEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>¶

Public Functions

SolidMechanicsModel(Mesh &mesh, UInt dim = _all_dimensions, const ID &id = "solid_mechanics_model", std::shared_ptr<DOFManager> dof_manager = nullptr, ModelType model_type = ModelType::_solid_mechanics_model)¶

A solid mechanics model need a mesh and a dimension to be created. the model by it self can not do a lot, the good init functions should be called in order to configure the model depending on what we want to do.

Parameters

mesh: mesh representing the model we want to simulate
dim: spatial dimension of the problem, if dim = 0 (default value) the dimension of the problem is assumed to be the on of the mesh
id: an id to identify the model
model_type: this is an internal parameter for inheritance purposes

~SolidMechanicsModel() override¶

void initMaterials()¶: initialize all internal arrays for materials

void assembleStiffnessMatrix(bool need_to_reassemble = false)¶: assembles the stiffness matrix,

void assembleInternalForces()¶

assembles the internal forces in the array internal_forces

This function computes the internal forces as \(F_{int} = \int_{\Omega} N \sigma d\Omega@\)

bool isDefaultSolverExplicit()¶

Material &registerNewMaterial(const ID &mat_name, const ID &mat_type, const ID &opt_param)¶: register an empty material of a given type

void reassignMaterial()¶: reassigns materials depending on the material selector

void applyEigenGradU(const Matrix<Real> &prescribed_eigen_grad_u, const ID &material_name, GhostType ghost_type = _not_ghost)¶: apply a constant eigen_grad_u on all quadrature points of a given material

void assembleMassLumped()¶: assemble the lumped mass matrix

void assembleMass()¶: assemble the mass matrix for consistent mass resolutions

void assembleMassLumped(GhostType ghost_type)¶: assemble the lumped mass matrix for local and ghost elements

void assembleMass(GhostType ghost_type)¶: assemble the mass matrix for either _ghost or _not_ghost elements

UInt getNbData(const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) override¶

UInt getNbData(const Array<UInt> &dofs, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<UInt> &dofs, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<UInt> &dofs, const SynchronizationTag &tag) override¶

void onDump()¶

bool isInternal(const std::string &field_name, ElementKind element_kind)¶: decide wether a field is a material internal or not

ElementTypeMap<UInt> getInternalDataPerElem(const std::string &field_name, ElementKind kind)¶: give the amount of data per element

ElementTypeMapArray<Real> &flattenInternal(const std::string &field_name, ElementKind kind, GhostType ghost_type = _not_ghost)¶: flatten a given material internal field

void flattenAllRegisteredInternals(ElementKind kind)¶: flatten all the registered material internals

void inflateInternal(const std::string &field_name, const ElementTypeMapArray<Real> &field, ElementKind kind, GhostType ghost_type = _not_ghost)¶: inverse operation of the flatten

std::shared_ptr<dumpers::Field> createNodalFieldReal(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createNodalFieldBool(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createElementalField(const std::string &field_name, const std::string &group_name, bool padding_flag, UInt spatial_dimension, ElementKind kind) override¶

void dump(const std::string &dumper_name) override¶

void dump(const std::string &dumper_name, UInt step) override¶

void dump(const std::string &dumper_name, Real time, UInt step) override¶

void dump() override¶

void dump(UInt step) override¶

void dump(Real time, UInt step) override¶

void setTimeStep(Real time_step, const ID &solver_id = "") override¶: set the value of the time step

Real getF_M2A() const¶: get the value of the conversion from forces/ mass to acceleration

AKANTU_SET_MACRO(F_M2A, f_m2a, Real)¶: set the value of the conversion from forces/ mass to acceleration

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(Displacement, displacement)¶: get the SolidMechanicsModel::displacement array

AKANTU_GET_MACRO_DEREF_PTR(Displacement, displacement)¶: get the SolidMechanicsModel::displacement array

AKANTU_GET_MACRO_DEREF_PTR(PreviousDisplacement, previous_displacement)¶: get the SolidMechanicsModel::previous_displacement array

const Array<Real> &getCurrentPosition()¶: get the SolidMechanicsModel::current_position array

AKANTU_GET_MACRO_DEREF_PTR(Increment, displacement_increment)¶: get the SolidMechanicsModel::displacement_increment array

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(Increment, displacement_increment)¶: get the SolidMechanicsModel::displacement_increment array

AKANTU_GET_MACRO_DEREF_PTR(Mass, mass)¶: get the lumped SolidMechanicsModel::mass array

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(Velocity, velocity)¶: get the SolidMechanicsModel::velocity array

AKANTU_GET_MACRO_DEREF_PTR(Velocity, velocity)¶: get the SolidMechanicsModel::velocity array

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(Acceleration, acceleration)¶: get the SolidMechanicsModel::acceleration array

AKANTU_GET_MACRO_DEREF_PTR(Acceleration, acceleration)¶: get the SolidMechanicsModel::acceleration array

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(ExternalForce, external_force)¶: get the SolidMechanicsModel::external_force array

AKANTU_GET_MACRO_DEREF_PTR(ExternalForce, external_force)¶: get the SolidMechanicsModel::external_force array

Array<Real> &getForce()¶: get the SolidMechanicsModel::force array (external forces)

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(InternalForce, internal_force)¶: get the SolidMechanicsModel::internal_force array (internal forces)

AKANTU_GET_MACRO_DEREF_PTR(InternalForce, internal_force)¶: get the SolidMechanicsModel::internal_force array (internal forces)

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(BlockedDOFs, blocked_dofs)¶: get the SolidMechanicsModel::blocked_dofs array

AKANTU_GET_MACRO_DEREF_PTR(BlockedDOFs, blocked_dofs)¶: get the SolidMechanicsModel::blocked_dofs array

decltype(auto) getMaterials()¶: get an iterable on the materials

decltype(auto) getMaterials() const¶: get an iterable on the materials

Material &getMaterial(UInt mat_index)¶: get a particular material (by numerical material index)

const Material &getMaterial(UInt mat_index) const¶: get a particular material (by numerical material index)

Material &getMaterial(const std::string &name)¶: get a particular material (by material name)

const Material &getMaterial(const std::string &name) const¶: get a particular material (by material name)

const Material &getMaterial(const Element &element) const¶: get a particular material (by material name)

UInt getMaterialIndex(const std::string &name) const¶: get a particular material id from is name

UInt getNbMaterials() const¶: give the number of materials

Int getInternalIndexFromID(const ID &id) const¶: give the material internal index from its id

Real getStableTimeStep()¶: compute the stable time step

Real getEnergy(const std::string &energy_id)¶

Returns the total energy for a given energy type.

Energy types of SolidMechanicsModel expected as argument are:

kinetic
external work

Other energy types are passed on to the materials. All materials should define a potential energy type. For additional energy types, see material documentation.

Real getEnergy(const std::string &energy_id, ElementType type, UInt index)¶: Compute energy for an element type and material index.

Real getEnergy(const std::string &energy_id, const Element &element)¶: Compute energy for an individual element.

Real getEnergy(const ID &energy_id, const ID &group_id)¶: Compute energy for an element group.

const ElementTypeMapArray<UInt> &getMaterialByElement() const¶

const ElementTypeMapArray<UInt> &getMaterialLocalNumbering() const¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(MaterialByElement, material_index, UInt)¶: vectors containing local material element index for each global element index

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(MaterialLocalNumbering, material_local_numbering, UInt)¶

std::shared_ptr<MaterialSelector> getMaterialSelector()¶

void setMaterialSelector(std::shared_ptr<MaterialSelector> material_selector)¶

NonLocalManager &getNonLocalManager() const¶: Access the non_local_manager interface.

FEEngine &getFEEngineBoundary(const ID &name = "") override¶: get the FEEngine object to integrate or interpolate on the boundary

class NewMaterialElementsEvent : public akantu::NewElementsEvent¶

Public Functions

Array<UInt> &getMaterialList()¶

const Array<UInt> &getMaterialList() const¶

Warning

doxygenclass: Cannot find class “akantu::SolidMechanicsModelOptions” in doxygen xml output for project “Akantu” from directory: /builds/akantu/akantu/build/doc/dev-doc/xml

class akantu::MaterialSelector¶

main class to assign same or different materials for different elements

Subclassed by akantu::DefaultMaterialCohesiveSelector, akantu::DefaultMaterialSelector, akantu::ElementDataMaterialSelector< T >, akantu::MaterialCohesiveRulesSelector, akantu::MeshDataMaterialCohesiveSelector

Public Functions

MaterialSelector() = default¶

~MaterialSelector() = default¶

UInt operator()(const Element &element)¶

void setFallback(UInt f)¶

void setFallback(const std::shared_ptr<MaterialSelector> &fallback_selector)¶

std::shared_ptr<MaterialSelector> &getFallbackSelector()¶

UInt getFallbackValue() const¶

template<typename T> class akantu::MeshDataMaterialSelector : public akantu::ElementDataMaterialSelector<T>¶

class to use mesh data information to assign different materials where name is the tag value: tag_0, tag_1

Public Functions

MeshDataMaterialSelector(const std::string &name, const SolidMechanicsModel &model, UInt first_index = 1)¶

class akantu::Material : public akantu::DataAccessor<Element>, public akantu::Parsable, public akantu::MeshEventHandler, protected akantu::SolidMechanicsModelEventHandler¶

Interface of all materials Prerequisites for a new material

inherit from this class

implement the following methods:

 virtual Real getStableTimeStep(Real h, const Element & element =
ElementNull);

 virtual void computeStress(ElementType el_type,
                            GhostType ghost_type = _not_ghost);

 virtual void computeTangentStiffness(ElementType el_type,
                                      Array<Real> & tangent_matrix,
                                      GhostType ghost_type = _not_ghost);

Subclassed by akantu::PlaneStressToolbox< spatial_dimension >, akantu::MaterialCohesive, akantu::MaterialElasticLinearAnisotropic< Dim >, akantu::MaterialThermal< dim >, akantu::PlaneStressToolbox< dim, ParentMaterial >

Public Functions

Material(const Material &mat) = delete¶

Material &operator=(const Material &mat) = delete¶

Material(SolidMechanicsModel &model, const ID &id = "")¶: Initialize material with defaults.

Material(SolidMechanicsModel &model, UInt dim, const Mesh &mesh, FEEngine &fe_engine, const ID &id = "")¶: Initialize material with custom mesh & fe_engine.

~Material() override¶: Destructor.

void extrapolateInternal(const ID &id, const Element &element, const Matrix<Real> &points, Matrix<Real> &extrapolated)¶: extrapolate internal values

Real getPushWaveSpeed(const Element&) const¶: compute the p-wave speed in the material

Real getShearWaveSpeed(const Element&) const¶: compute the s-wave speed in the material

Real getCelerity(const Element &element) const¶: get a material celerity to compute the stable time step (default: is the push wave speed)

template<typename T> void registerInternal(InternalField<T>&)¶

template<typename T> void unregisterInternal(InternalField<T>&)¶

void initMaterial()¶: initialize the material computed parameter

void assembleInternalForces(GhostType ghost_type)¶

compute the residual for this material

assemble the residual for this material

Compute the internal forces by assembling \(\int_{e} \sigma_e \frac{\partial \varphi}{\partial X} dX \)

Parameters

[in] ghost_type: compute the internal forces for _ghost or _not_ghost element

void savePreviousState()¶: save the stress in the previous_stress if needed

void restorePreviousState()¶: restore the stress from previous_stress if needed

void computeAllStresses(GhostType ghost_type = _not_ghost)¶

compute the stresses for this material

Compute the stress from the gradu

Parameters

[in] ghost_type: compute the residual for _ghost or _not_ghost element

void computeAllCauchyStresses(GhostType ghost_type = _not_ghost)¶

void setToSteadyState(GhostType ghost_type = _not_ghost)¶: set material to steady state

void assembleStiffnessMatrix(GhostType ghost_type)¶

compute the stiffness matrix

Compute the stiffness matrix by assembling \(\int_{\omega} B^t \times D \times B d\omega \)

Parameters

[in] ghost_type: compute the residual for _ghost or _not_ghost element

UInt addElement(ElementType type, UInt element, GhostType ghost_type)¶: add an element to the local mesh filter

UInt addElement(const Element &element)¶

void addElements(const Array<Element> &elements_to_add)¶: add many elements at once

void removeElements(const Array<Element> &elements_to_remove)¶: remove many element at once

void printself(std::ostream &stream, int indent = 0) const override¶: function to print the contain of the class

void interpolateStress(ElementTypeMapArray<Real> &result, GhostType ghost_type = _not_ghost)¶: interpolate stress on given positions for each element by means of a geometrical interpolation on quadrature points

void interpolateStressOnFacets(ElementTypeMapArray<Real> &result, ElementTypeMapArray<Real> &by_elem_result, GhostType ghost_type = _not_ghost)¶: interpolate stress on given positions for each element by means of a geometrical interpolation on quadrature points and store the results per facet

void initElementalFieldInterpolation(const ElementTypeMapArray<Real> &interpolation_points_coordinates)¶: function to initialize the elemental field interpolation function by inverting the quadrature points’ coordinates

template<UInt dim> void StoCauchy(ElementType el_type, GhostType ghost_type = _not_ghost)¶: Computation of Cauchy stress tensor in the case of finite deformation from the 2nd Piola-Kirchhoff for a given element type

template<UInt dim> void StoCauchy(const Matrix<Real> &F, const Matrix<Real> &S, Matrix<Real> &sigma, const Real &C33 = 1.0) const¶: Computation the Cauchy stress the 2nd Piola-Kirchhoff and the deformation gradient

UInt getNbData(const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) override¶

template<typename T> void packElementDataHelper(const ElementTypeMapArray<T> &data_to_pack, CommunicationBuffer &buffer, const Array<Element> &elements, const ID &fem_id = ID()) const¶

template<typename T> void unpackElementDataHelper(ElementTypeMapArray<T> &data_to_unpack, CommunicationBuffer &buffer, const Array<Element> &elements, const ID &fem_id = ID())¶

void onNodesAdded(const Array<UInt>&, const NewNodesEvent&) override¶: function to implement to react on akantu::NewNodesEvent

void onNodesRemoved(const Array<UInt>&, const Array<UInt>&, const RemovedNodesEvent&) override¶: function to implement to react on akantu::RemovedNodesEvent

void onElementsAdded(const Array<Element> &element_list, const NewElementsEvent &event) override¶: function to implement to react on akantu::NewElementsEvent

void onElementsRemoved(const Array<Element> &element_list, const ElementTypeMapArray<UInt> &new_numbering, const RemovedElementsEvent &event) override¶: function to implement to react on akantu::RemovedElementsEvent

void onElementsChanged(const Array<Element>&, const Array<Element>&, const ElementTypeMapArray<UInt>&, const ChangedElementsEvent&) override¶: function to implement to react on akantu::ChangedElementsEvent

void beforeSolveStep()¶

void afterSolveStep(bool converged = true)¶

void onDamageIteration() override¶: function to implement to react on akantu::BeginningOfDamageIterationEvent

void onDamageUpdate() override¶: function to implement to react on akantu::AfterDamageEvent

void onDump() override¶: function to implement to react on akantu::BeforeDumpEvent

const std::string &getName() const¶

AKANTU_SET_MACRO(Name, name, const std::string&)¶

const SolidMechanicsModel &getModel() const¶

const ID &getID() const¶

Real getRho() const¶

AKANTU_SET_MACRO(Rho, rho, Real)¶

UInt getSpatialDimension() const¶

Real getPotentialEnergy()¶: return the potential energy for the subset of elements contained by the material

Real getPotentialEnergy(ElementType &type, UInt index)¶: return the potential energy for the provided element

Real getEnergy(const std::string &type)¶: return the energy (identified by id) for the subset of elements contained by the material

Real getEnergy(const std::string &energy_id, ElementType type, UInt index)¶: return the energy (identified by id) for the provided element

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ElementFilter, element_filter, UInt)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(GradU, gradu, Real)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Stress, stress, Real)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(PotentialEnergy, potential_energy, Real)¶

const ElementTypeMapArray<Real> &getGradU() const¶

const ElementTypeMapArray<Real> &getStress() const¶

const ElementTypeMapArray<UInt> &getElementFilter() const¶

FEEngine &getFEEngine() const¶

bool isNonLocal() const¶

template<typename T> const Array<T> &getArray(const ID &id, ElementType type, GhostType ghost_type = _not_ghost) const¶

template<typename T> Array<T> &getArray(const ID &id, ElementType type, GhostType ghost_type = _not_ghost)¶

template<typename T> const InternalField<T> &getInternal(const ID &id) const¶

template<typename T> InternalField<T> &getInternal(const ID &id)¶

template<typename T> bool isInternal(const ID &id, ElementKind element_kind) const¶

template<typename T> ElementTypeMap<UInt> getInternalDataPerElem(const ID &id, ElementKind element_kind) const¶

bool isFiniteDeformation() const¶

bool isInelasticDeformation() const¶

template<typename T> void setParam(const ID &param, T value)¶

const Parameter &getParam(const ID &param) const¶

template<typename T> void flattenInternal(const std::string &field_id, ElementTypeMapArray<T> &internal_flat, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined) const¶

template<typename T> void inflateInternal(const std::string &field_id, const ElementTypeMapArray<T> &field, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶

void applyEigenGradU(const Matrix<Real> &prescribed_eigen_grad_u, GhostType = _not_ghost)¶: apply a constant eigengrad_u everywhere in the material

bool hasMatrixChanged(const ID &id)¶

MatrixType getMatrixType(const ID &id)¶

bool hasStiffnessMatrixChanged()¶: specify if the matrix need to be recomputed for this material

MatrixType getTangentType()¶: specify the type of matrix, if not overloaded the material is not valid for static or implicit computations

Public Static Functions

UInt getCauchyStressMatrixSize(UInt dim)¶: Size of the Stress matrix for the case of finite deformation see: Bathe et al, IJNME, Vol 9, 353-386, 1975

template<UInt dim> void setCauchyStressMatrix(const Matrix<Real> &S_t, Matrix<Real> &sigma)¶: Sets the stress matrix according to Bathe et al, IJNME, Vol 9, 353-386, 1975

template<UInt dim> decltype(auto) stressToVoigt(const Matrix<Real> &stress)¶: write the stress tensor in the Voigt notation.

template<UInt dim> decltype(auto) strainToVoigt(const Matrix<Real> &strain)¶: write the strain tensor in the Voigt notation.

template<UInt dim> void voigtToStress(const Vector<Real> &voigt, Matrix<Real> &stress)¶: write a voigt vector to stress

template<UInt dim> void gradUToF(const Matrix<Real> &grad_u, Matrix<Real> &F)¶

template<UInt dim> decltype(auto) gradUToF(const Matrix<Real> &grad_u)¶

void rightCauchy(const Matrix<Real> &F, Matrix<Real> &C)¶

void leftCauchy(const Matrix<Real> &F, Matrix<Real> &B)¶

template<UInt dim> void gradUToEpsilon(const Matrix<Real> &grad_u, Matrix<Real> &epsilon)¶

template<UInt dim> decltype(auto) gradUToEpsilon(const Matrix<Real> &grad_u)¶

template<UInt dim> void gradUToE(const Matrix<Real> &grad_u, Matrix<Real> &epsilon)¶

template<UInt dim> decltype(auto) gradUToE(const Matrix<Real> &grad_u)¶

Real stressToVonMises(const Matrix<Real> &stress)¶

MaterialFactory &getFactory()¶: static method to reteive the material factory

Warning

doxygenclass: Cannot find class “akantu::InternalField” in doxygen xml output for project “Akantu” from directory: /builds/akantu/akantu/build/doc/dev-doc/xml

Solid Mechanics Model Cohesive¶

class akantu::SolidMechanicsModelCohesive : public akantu::SolidMechanicsModel, public akantu::SolidMechanicsModelEventHandler¶

Public Types

using MyFEEngineCohesiveType = FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_cohesive>¶

using MyFEEngineFacetType = FEEngineTemplate<IntegratorGauss, ShapeLagrange, _ek_regular, FacetsCohesiveIntegrationOrderFunctor>¶

Public Functions

SolidMechanicsModelCohesive(Mesh &mesh, UInt dim = _all_dimensions, const ID &id = "solid_mechanics_model_cohesive", std::shared_ptr<DOFManager> dof_manager = nullptr)¶

~SolidMechanicsModelCohesive() override¶

void setTimeStep(Real time_step, const ID &solver_id = "") override¶: set the value of the time step

void assembleInternalForces() override¶: assemble the residual for the explicit scheme

UInt checkCohesiveStress()¶: function to perform a stress check on each facet and insert cohesive elements if needed (returns the number of new cohesive elements)

void interpolateStress()¶: interpolate stress on facets

void updateAutomaticInsertion()¶: update automatic insertion after a change in the element inserter

void insertIntrinsicElements()¶: insert intrinsic cohesive elements

void afterSolveStep(bool converged = true) override¶: callback for the solver, this is called at end of solve

void onDump() override¶

void addDumpGroupFieldToDumper(const std::string &dumper_name, const std::string &field_id, const std::string &group_name, ElementKind element_kind, bool padding_flag) override¶

UInt getNbData(const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) override¶

const Mesh &getMeshFacets() const¶: get facet mesh

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(StressOnFacets, facet_stress, Real)¶: get stress on facets vector

AKANTU_GET_MACRO_BY_ELEMENT_TYPE(FacetMaterial, facet_material, UInt)¶: get facet material

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(FacetMaterial, facet_material, UInt)¶: get facet material

const ElementTypeMapArray<UInt> &getFacetMaterial() const¶: get facet material

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Tangents, tangents, Real)¶

Todo:: THIS HAS TO BE CHANGED

CohesiveElementInserter &getElementInserter()¶: get element inserter

bool getIsExtrinsic() const¶: get is_extrinsic boolean

ElementSynchronizer &getCohesiveSynchronizer()¶: get cohesive elements synchronizer

class NewCohesiveNodesEvent : public akantu::NewNodesEvent¶

Public Functions

Array<UInt> &getOldNodesList()¶

const Array<UInt> &getOldNodesList() const¶

class akantu::FragmentManager : public akantu::GroupManager ¶

Public Functions

FragmentManager(SolidMechanicsModelCohesive &model, bool dump_data = true, const ID &id = "fragment_manager")¶

void buildFragments(Real damage_limit = 1.)¶: build fragment list (cohesive elements are considered broken if damage >= damage_limit)

void computeCenterOfMass()¶: compute fragments’ center of mass

void computeVelocity()¶: compute fragments’ velocity

void computeInertiaMoments()¶

computes principal moments of inertia with respect to the center of mass of each fragment

Given the distance \( \mathbf{r} \) between a quadrature point and its center of mass, the moment of inertia is computed as

\[ I_\mathrm{CM} = \mathrm{tr}(\mathbf{r}\mathbf{r}^\mathrm{T}) \mathbf{I} - \mathbf{r}\mathbf{r}^\mathrm{T} \]

for more information check Wikipedia (http://en.wikipedia.org/wiki/Moment_of_inertia#Identities_for_a_skew-symmetric_matrix)

void computeAllData(Real damage_limit = 1.)¶: compute all fragments’ data

void computeNbElementsPerFragment()¶: compute number of elements per fragment

UInt getNbFragment() const¶: get number of fragments

const Array<Real> &getMass() const¶: get fragments’ mass

const Array<Real> &getCenterOfMass() const¶: get fragments’ center of mass

const Array<Real> &getVelocity() const¶: get fragments’ velocity

const Array<Real> &getMomentsOfInertia() const¶: get fragments’ principal moments of inertia

const Array<Real> &getPrincipalDirections() const¶: get fragments’ principal directions

const Array<UInt> &getNbElementsPerFragment() const¶: get number of elements per fragment

Heat Transfer Model¶

class akantu::HeatTransferModel : public akantu::Model, public akantu::DataAccessor<Element>, public akantu::DataAccessor<UInt>¶

Public Types

using FEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>¶

Public Functions

HeatTransferModel(Mesh &mesh, UInt dim = _all_dimensions, const ID &id = "heat_transfer_model", std::shared_ptr<DOFManager> dof_manager = nullptr)¶

~HeatTransferModel() override¶

Real getStableTimeStep()¶: compute and get the stable time step

void setTimeStep(Real time_step, const ID &solver_id = "") override¶: set the stable timestep

void assembleCapacityLumped()¶: calculate the lumped capacity vector for heat transfer problem

void assembleConductivityMatrix()¶: assemble the conductivity matrix

void assembleCapacity()¶: assemble the conductivity matrix

void computeRho(Array<Real> &rho, ElementType type, GhostType ghost_type)¶: compute the capacity on quadrature points

UInt getNbData(const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) override¶

UInt getNbData(const Array<UInt> &indexes, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<UInt> &indexes, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<UInt> &indexes, const SynchronizationTag &tag) override¶

std::shared_ptr<dumpers::Field> createNodalFieldReal(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createNodalFieldBool(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createElementalField(const std::string &field_name, const std::string &group_name, bool padding_flag, UInt spatial_dimension, ElementKind kind) override¶

Real getDensity() const¶

Real getCapacity() const¶

Real getTimeStep() const¶: get the current value of the time step

Array<Real> &getInternalHeatRate() const¶: get the assembled heat flux

Array<bool> &getBlockedDOFs() const¶: get the boundary vector

Array<Real> &getExternalHeatRate() const¶: get the external heat rate vector

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(TemperatureGradient, temperature_gradient, Real)¶: get the temperature gradient

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ConductivityOnQpoints, conductivity_on_qpoints, Real)¶: get the conductivity on q points

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(TemperatureOnQpoints, temperature_on_qpoints, Real)¶: get the conductivity on q points

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(KgradT, k_gradt_on_qpoints, Real)¶: internal variables

Array<Real> &getTemperature() const¶: get the temperature

Array<Real> &getTemperatureRate() const¶: get the temperature derivative

Real getEnergy(const std::string &energy_id, ElementType type, UInt index)¶: get the energy denominated by thermal

Real getEnergy(const std::string &energy_id)¶: get the energy denominated by thermal

Real getThermalEnergy(ElementType type, UInt index)¶: get the thermal energy for a given element

Real getThermalEnergy()¶: get the thermal energy for a given element

Phase Field Model¶

class akantu::PhaseFieldModel : public akantu::Model, public akantu::DataAccessor<Element>, public akantu::DataAccessor<UInt>, public akantu::BoundaryCondition<PhaseFieldModel>¶

Public Types

using FEEngineType = FEEngineTemplate<IntegratorGauss, ShapeLagrange>¶

Public Functions

PhaseFieldModel(Mesh &mesh, UInt dim = _all_dimensions, const ID &id = "phase_field_model", ModelType model_type = ModelType::_phase_field_model)¶

~PhaseFieldModel() override¶

PhaseField &registerNewPhaseField(const ID &phase_name, const ID &phase_type, const ID &opt_param)¶: register an empty phasefield of a given type

void reassignPhaseField()¶: reassigns phasefields depending on the phasefield selector

void assembleStiffnessMatrix()¶: assembles the phasefield stiffness matrix

void assembleInternalForces()¶: compute the internal forces

void assembleInternalForces(const GhostType &ghost_type)¶

void setTimeStep(Real time_step, const ID &solver_id = "") override¶: set the stable timestep

UInt getNbData(const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) override¶

UInt getNbData(const Array<UInt> &indexes, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<UInt> &indexes, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<UInt> &indexes, const SynchronizationTag &tag) override¶

AKANTU_GET_MACRO_DEREF_PTR(Damage, damage)¶: return the damage array

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(Damage, damage)¶

AKANTU_GET_MACRO_DEREF_PTR(InternalForce, internal_force)¶: get the PhaseFieldModel::internal_force vector (internal forces)

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(InternalForce, internal_force)¶

AKANTU_GET_MACRO_DEREF_PTR(ExternalForce, external_force)¶: get the PhaseFieldModel::external_force vector (external forces)

AKANTU_GET_MACRO_DEREF_PTR_NOT_CONST(ExternalForce, external_force)¶

Array<Real> &getForce()¶: get the PhaseFieldModel::force vector (external forces)

AKANTU_GET_MACRO_DEREF_PTR(BlockedDOFs, blocked_dofs)¶: get the PhaseFieldModel::blocked_dofs vector

decltype(auto) getPhaseFields()¶: get an iterable on the phasefields

decltype(auto) getPhaseFields() const¶: get an iterable on the phasefields

PhaseField &getPhaseField(UInt mat_index)¶: get a particular phasefield (by phasefield index)

const PhaseField &getPhaseField(UInt mat_index) const¶: get a particular phasefield (by phasefield index)

PhaseField &getPhaseField(const std::string &name)¶: get a particular phasefield (by phasefield name)

const PhaseField &getPhaseField(const std::string &name) const¶: get a particular phasefield (by phasefield name)

UInt getPhaseFieldIndex(const std::string &name) const¶: get a particular phasefield id from is name

UInt getNbPhaseFields() const¶: give the number of phasefields

Int getInternalIndexFromID(const ID &id) const¶: give the phasefield internal index from its id

const ElementTypeMapArray<UInt> &getPhaseFieldByElement() const¶

const ElementTypeMapArray<UInt> &getPhaseFieldLocalNumbering() const¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(PhaseFieldByElement, phasefield_index, UInt)¶: vectors containing local material element index for each global element index

AKANTU_GET_MACRO_BY_ELEMENT_TYPE(PhaseFieldByElement, phasefield_index, UInt)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(PhaseFieldLocalNumbering, phasefield_local_numbering, UInt)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE(PhaseFieldLocalNumbering, phasefield_local_numbering, UInt)¶

PhaseFieldSelector &getPhaseFieldSelector()¶

AKANTU_SET_MACRO(PhaseFieldSelector, phasefield_selector, std::shared_ptr<PhaseFieldSelector>)¶

FEEngine &getFEEngineBoundary(const ID &name = "") override¶: return the fem boundary object associated with a provided name

std::shared_ptr<dumpers::Field> createNodalFieldReal(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createNodalFieldBool(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createElementalField(const std::string &field_name, const std::string &group_name, bool padding_flag, UInt spatial_dimension, ElementKind kind) override¶

class akantu::PhaseField : public akantu::DataAccessor<Element>, public akantu::Parsable¶

Subclassed by akantu::PhaseFieldExponential

Public Functions

PhaseField(const PhaseField &phase) = delete¶

PhaseField &operator=(const PhaseField &phase) = delete¶

PhaseField(PhaseFieldModel &model, const ID &id = "")¶: Initialize phasefield with defaults.

PhaseField(PhaseFieldModel &model, UInt dim, const Mesh &mesh, FEEngine &fe_engine, const ID &id = "")¶: Initialize phasefield with custom mesh & fe_engine.

~PhaseField() override¶: Destructor.

template<typename T> void registerInternal(InternalPhaseField<T>&)¶

template<typename T> void unregisterInternal(InternalPhaseField<T>&)¶

void initPhaseField()¶: initialize the phasefield computed parameter

void beforeSolveStep()¶

void afterSolveStep()¶

void assembleInternalForces(GhostType ghost_type)¶: assemble the residual for this phasefield

void assembleStiffnessMatrix(GhostType ghost_type)¶: assemble the stiffness matrix for this phasefield

void computeAllDrivingForces(GhostType ghost_type = _not_ghost)¶: compute the driving force for this phasefield

void savePreviousState()¶: save the phi in the phi internal field if needed

UInt addElement(const ElementType &type, UInt element, const GhostType &ghost_type)¶: add an element to the local mesh filter

UInt addElement(const Element &element)¶

void printself(std::ostream &stream, int indent = 0) const override¶: function to print the contain of the class

UInt getNbData(const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void packData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) const override¶

void unpackData(CommunicationBuffer &buffer, const Array<Element> &elements, const SynchronizationTag &tag) override¶

template<typename T> void packElementDataHelper(const ElementTypeMapArray<T> &data_to_pack, CommunicationBuffer &buffer, const Array<Element> &elements, const ID &fem_id = ID()) const¶

template<typename T> void unpackElementDataHelper(ElementTypeMapArray<T> &data_to_unpack, CommunicationBuffer &buffer, const Array<Element> &elements, const ID &fem_id = ID())¶

const std::string &getName() const¶

const PhaseFieldModel &getModel() const¶

const ID &getID() const¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Strain, strain, Real)¶

const ElementTypeMapArray<Real> &getStrain() const¶

ElementTypeMapArray<Real> &getStrain()¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Damage, damage, Real)¶

ElementTypeMapArray<Real> &getDamage()¶

const ElementTypeMapArray<Real> &getDamage() const¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(ElementFilter, element_filter, UInt)¶

const ElementTypeMapArray<UInt> &getElementFilter() const¶

template<typename T> const InternalPhaseField<T> &getInternal(const ID &id) const¶

template<typename T> InternalPhaseField<T> &getInternal(const ID &id)¶

template<typename T> bool isInternal(const ID &id, const ElementKind &element_kind) const¶

template<typename T> void setParam(const ID &param, T value)¶

const Parameter &getParam(const ID &param) const¶

template<typename T> void flattenInternal(const std::string &field_id, ElementTypeMapArray<T> &internal_flat, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined) const¶

template<> void registerInternal(InternalPhaseField<Real> &vect)¶

template<> void registerInternal(InternalPhaseField<UInt> &vect)¶

template<> void registerInternal(InternalPhaseField<bool> &vect)¶

template<> void unregisterInternal(InternalPhaseField<Real> &vect)¶

template<> void unregisterInternal(InternalPhaseField<UInt> &vect)¶

template<> void unregisterInternal(InternalPhaseField<bool> &vect)¶

template<typename T> bool isInternal(__attribute__((unused)) const ID &id, __attribute__((unused)) const ElementKind &element_kind) const

template<> bool isInternal(const ID &id, const ElementKind &element_kind) const¶

Structural Mechanics Model¶

Warning

doxygenclass: Cannot find class “akantu::StructuralMaterial” in doxygen xml output for project “Akantu” from directory: /builds/akantu/akantu/build/doc/dev-doc/xml

class akantu::StructuralMechanicsModel : public akantu::Model ¶

Public Types

using MyFEEngineType = FEEngineTemplate<IntegratorGauss, ShapeStructural, _ek_structural>¶

Public Functions

StructuralMechanicsModel(Mesh &mesh, UInt dim = _all_dimensions, const ID &id = "structural_mechanics_model")¶

~StructuralMechanicsModel() override¶

void initFullImpl(const ModelOptions &options) override¶: Init full model.

void initFEEngineBoundary() override¶: Init boundary FEEngine.

MatrixType getMatrixType(const ID &matrix_id) const override¶: get the type of matrix needed

void assembleMatrix(const ID &matrix_id) override¶: callback to assemble a Matrix

void assembleLumpedMatrix(const ID &matrix_id) override¶: callback to assemble a lumped Matrix

void assembleResidual() override¶

callback to assemble the residual (rhs)

callback to assemble the residual StructuralMechanicsModel::(rhs)

void assembleResidual(const ID &residual_part) override¶: callback to assemble the rhs parts, (e.g. internal_forces + external_forces)

bool canSplitResidual() const override¶: tells if the residual can be computed in separated parts

void afterSolveStep(bool converged) override¶

Real getKineticEnergy()¶: compute kinetic energy

Real getPotentialEnergy()¶: compute potential energy

Real getEnergy(const ID &energy)¶: compute the specified energy

void assembleLumpedMassMatrix()¶

This function computes the an approximation of the lumped mass.

The mass is computed by looping over all beams and computing their mass. The mass of a single beam is computed by the (initial) length of the beam, its cross sectional area and its density. The beam mass is then equaly distributed among the two nodes.

For computing the rotational inertia, the function assumes that the mass of a node is uniformaly distributed inside a disc (2D) or a sphere (3D). The size of that disc, depends on the volume of the beam.

Note that the computation of the mass is not unambigius. The reason for this is, that the units of StructralMaterial::rho are not clear. By default the function assumes that its unit are ‘Mass per Volume’. However, this makes the computed mass different than the consistent mass, which seams to assume that its units are ‘mass per unit length’. The main difference between thge two are not the values, but that the first version depends on StructuralMaterial::A while the later does not. By defining the macro AKANTU_STRUCTURAL_MECHANICS_CONSISTENT_LUMPED_MASS the function will compute the mass in a way that is consistent with the consistent mass matrix.

Note

The lumped mass is not stored inside the DOFManager.

Parameters

ghost_type: Should ghost types be computed.

std::shared_ptr<dumpers::Field> createNodalFieldReal(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createNodalFieldBool(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createElementalField(const std::string &field_name, const std::string &group_name, bool padding_flag, UInt spatial_dimension, ElementKind kind) override¶

void setTimeStep(Real time_step, const ID &solver_id = "") override¶: set the value of the time step

Array<Real> &getDisplacement() const¶: get the StructuralMechanicsModel::displacement vector

Array<Real> &getVelocity() const¶: get the StructuralMechanicsModel::velocity vector

Array<Real> &getAcceleration() const¶: get the StructuralMechanicsModel::acceleration vector, updated by StructuralMechanicsModel::updateAcceleration

Array<Real> &getExternalForce() const¶: get the StructuralMechanicsModel::external_force vector

Array<Real> &getInternalForce() const¶: get the StructuralMechanicsModel::internal_force vector (boundary forces)

Array<bool> &getBlockedDOFs() const¶: get the StructuralMechanicsModel::boundary vector

const Array<Real> &getLumpedMass() const¶

Returns a const reference to the array that stores the lumped mass.

The returned array has dimension N x d where N is the number of nodes and d, is the number of degrees of freedom per node.

const Array<Real> &getMass() const¶

bool allocateLumpedMassArray()¶

bool hasLumpedMass() const¶: Tests if *this has a lumped mass pointer.

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(RotationMatrix, rotation_matrix, Real)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE_CONST(Stress, stress, Real)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE(ElementMaterial, element_material, UInt)¶

AKANTU_GET_MACRO_BY_ELEMENT_TYPE(Set_ID, set_ID, UInt)¶

UInt addMaterial(StructuralMaterial &material, const ID &name = "")¶

This function adds the StructuralMaterial material to the list of materials managed by *this.

It is important that this function might invalidate all references to structural materials, that were previously optained by getMaterial().

Return

The ID of the material that was added.

Note

The return type is is new.

Parameters

material: The new material.

const StructuralMaterial &getMaterialByElement(const Element &element) const¶

const StructuralMaterial &getMaterial(UInt material_index) const¶

Returns the ith material of *this.

Parameters

i: The ith material

const StructuralMaterial &getMaterial(const ID &name) const¶

UInt getNbMaterials() const¶: Returns the number of the different materials inside *this.

void computeForcesByGlobalTractionArray(const Array<Real> &traction_global, ElementType type)¶: Compute Linear load function set in global axis.

void computeForcesByLocalTractionArray(const Array<Real> &tractions, ElementType type)¶: Compute Linear load function set in local axis.

Coupler Solid PhaseField¶

class akantu::CouplerSolidPhaseField : public akantu::Model, public akantu::DataAccessor<Element>, public akantu::DataAccessor<UInt>, public akantu::BoundaryCondition<CouplerSolidPhaseField>¶

Public Functions

CouplerSolidPhaseField(Mesh &mesh, UInt dim = _all_dimensions, const ID &id = "coupler_solid_phasefield", ModelType model_type = ModelType::_coupler_solid_phasefield)¶

~CouplerSolidPhaseField() override¶

void assembleStiffnessMatrix()¶: assembles the contact stiffness matrix

void assembleInternalForces()¶: assembles the contant internal forces

void computeDamageOnQuadPoints(const GhostType&)¶: computes damage on quad points for solid mechanics model from damage array from phasefield model

void computeStrainOnQuadPoints(const GhostType &ghost_type)¶: computes strain on quadrature points for phasefield model from displacement gradient from solid mechanics model

void solve(const ID &solid_solver_id = "", const ID &phase_solver_id = "")¶: solve the coupled model

void assembleMassLumped()¶

solve the coupled model

solve a step using a given pre instantiated time step solver and non linear solver with a user defined callback instead of the model itself /!\ This can mess up everything assemble the lumped mass matrix

void assembleMass()¶: assemble the mass matrix for consistent mass resolutions

bool isDefaultSolverExplicit()¶

UInt getNbData(const Array<Element>&, const SynchronizationTag&) const override¶

void packData(CommunicationBuffer&, const Array<Element>&, const SynchronizationTag&) const override¶

void unpackData(CommunicationBuffer&, const Array<Element>&, const SynchronizationTag&) override¶

UInt getNbData(__attribute__((unused)) const Array<UInt> &indexes, __attribute__((unused)) const SynchronizationTag &tag) const override¶

void packData(__attribute__((unused)) CommunicationBuffer &buffer, __attribute__((unused)) const Array<UInt> &dofs, __attribute__((unused)) const SynchronizationTag &tag) const override¶

void unpackData(__attribute__((unused)) CommunicationBuffer &buffer, __attribute__((unused)) const Array<UInt> &dofs, __attribute__((unused)) const SynchronizationTag &tag) override¶

FEEngine &getFEEngineBoundary(const ID &name = "") override¶: return the fem boundary object associated with a provided name

SolidMechanicsModel &getSolidMechanicsModel() const¶: get the solid mechanics model

PhaseFieldModel &getPhaseFieldModel() const¶: get the contact mechanics model

std::shared_ptr<dumpers::Field> createNodalFieldReal(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createNodalFieldBool(const std::string &field_name, const std::string &group_name, bool padding_flag) override¶

std::shared_ptr<dumpers::Field> createElementalField(const std::string &field_name, const std::string &group_name, bool padding_flag, UInt spatial_dimension, ElementKind kind) override¶

void dump(const std::string &dumper_name) override¶

void dump(const std::string &dumper_name, UInt step) override¶

void dump(const std::string &dumper_name, Real time, UInt step) override¶

void dump() override¶

void dump(UInt step) override¶

void dump(Real time, UInt step) override¶

Synchronizers¶

template<class T> class akantu::DataAccessor : public virtual akantu::DataAccessorBase¶

Public Functions

DataAccessor() = default¶

~DataAccessor() override = default¶

UInt getNbData(const Array<T> &elements, const SynchronizationTag &tag) const = 0¶: get the number of data to exchange for a given array of T (elements or dofs) and a given akantu::SynchronizationTag

void packData(CommunicationBuffer &buffer, const Array<T> &element, const SynchronizationTag &tag) const = 0¶: pack the data for a given array of T (elements or dofs) and a given akantu::SynchronizationTag

void unpackData(CommunicationBuffer &buffer, const Array<T> &element, const SynchronizationTag &tag) = 0¶: unpack the data for a given array of T (elements or dofs) and a given akantu::SynchronizationTag

Input/Output¶

class akantu::Dumpable¶

Subclassed by akantu::ElementGroup, akantu::Mesh, akantu::NodeGroup

Public Functions

Dumpable()¶

~Dumpable()¶

template<class T> void registerDumper(const std::string &dumper_name, const std::string &file_name = "", bool is_default = false)¶: create a new dumper (of templated type T) and register it under dumper_name. file_name is used for construction of T. is default states if this dumper is the default dumper.

void registerExternalDumper(std::shared_ptr<DumperIOHelper> dumper, const std::string &dumper_name, bool is_default = false)¶: register an externally created dumper

void addDumpMesh(const Mesh &mesh, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶: register a mesh to the default dumper

void addDumpMeshToDumper(const std::string &dumper_name, const Mesh &mesh, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶: register a mesh to the default identified by its name

void addDumpFilteredMesh(const Mesh &mesh, const ElementTypeMapArray<UInt> &elements_filter, const Array<UInt> &nodes_filter, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶: register a filtered mesh as the default dumper

void addDumpFilteredMeshToDumper(const std::string &dumper_name, const Mesh &mesh, const ElementTypeMapArray<UInt> &elements_filter, const Array<UInt> &nodes_filter, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶: register a filtered mesh and provides a name

void addDumpField(const std::string &field_id)¶: to implement

void addDumpFieldToDumper(const std::string &dumper_name, const std::string &field_id)¶: to implement

void addDumpFieldExternal(const std::string &field_id, std::shared_ptr<dumpers::Field> field)¶: add a field

void addDumpFieldExternalToDumper(const std::string &dumper_name, const std::string &field_id, std::shared_ptr<dumpers::Field> field)¶

template<typename T> void addDumpFieldExternal(const std::string &field_id, const Array<T> &field)¶

template<typename T> void addDumpFieldExternalToDumper(const std::string &dumper_name, const std::string &field_id, const Array<T> &field)¶

template<typename T> void addDumpFieldExternal(const std::string &field_id, const ElementTypeMapArray<T> &field, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶

template<typename T> void addDumpFieldExternalToDumper(const std::string &dumper_name, const std::string &field_id, const ElementTypeMapArray<T> &field, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶

void removeDumpField(const std::string &field_id)¶

void removeDumpFieldFromDumper(const std::string &dumper_name, const std::string &field_id)¶

void addDumpFieldVector(const std::string &field_id)¶

void addDumpFieldVectorToDumper(const std::string &dumper_name, const std::string &field_id)¶

void addDumpFieldTensor(const std::string &field_id)¶

void addDumpFieldTensorToDumper(const std::string &dumper_name, const std::string &field_id)¶

void setDirectory(const std::string &directory)¶

void setDirectoryToDumper(const std::string &dumper_name, const std::string &directory)¶

void setBaseName(const std::string &basename)¶

void setBaseNameToDumper(const std::string &dumper_name, const std::string &basename)¶

void setTimeStepToDumper(Real time_step)¶

void setTimeStepToDumper(const std::string &dumper_name, Real time_step)¶

void setTextModeToDumper(const std::string &dumper_name)¶

void setTextModeToDumper()¶

void dump()¶

void dump(UInt step)¶

void dump(Real time, UInt step)¶

void dump(const std::string &dumper_name)¶

void dump(const std::string &dumper_name, UInt step)¶

void dump(const std::string &dumper_name, Real time, UInt step)¶

void internalAddDumpFieldToDumper(const std::string &dumper_name, const std::string &field_id, std::shared_ptr<dumpers::Field> field)¶

DumperIOHelper &getDumper()¶

DumperIOHelper &getDumper(const std::string &dumper_name)¶

template<class T> T &getDumper(const std::string &dumper_name)¶

std::string getDefaultDumperName() const¶

class akantu::DumperIOHelper : public std::enable_shared_from_this<DumperIOHelper>¶

Subclassed by akantu::DumperParaview, akantu::DumperText

Public Functions

DumperIOHelper()¶

~DumperIOHelper()¶

void registerMesh(const Mesh &mesh, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶: register a given Mesh for the current dumper

void registerFilteredMesh(const Mesh &mesh, const ElementTypeMapArray<UInt> &elements_filter, const Array<UInt> &nodes_filter, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined)¶: register a filtered Mesh (provided filter lists) for the current dumper

void registerField(const std::string &field_id, std::shared_ptr<dumpers::Field> field)¶: register a Field object identified by name and provided by pointer

void unRegisterField(const std::string &field_id)¶: remove the Field identified by name from managed fields

void registerVariable(const std::string &variable_id, std::shared_ptr<dumpers::VariableBase> variable)¶: register a VariableBase object identified by name and provided by pointer

void unRegisterVariable(const std::string &variable_id)¶: remove a VariableBase identified by name from managed fields

void dump()¶: request dump: this calls IOHelper dump routine

void dump(UInt step)¶: request dump: this first set the current step and then calls IOHelper dump routine

void dump(Real current_time, UInt step)¶: request dump: this first set the current step and current time and then calls IOHelper dump routine

void setParallelContext(bool is_parallel)¶: set the parallel context for IOHeper

void setDirectory(const std::string &directory)¶: set the directory where to generate the dumped files

void setBaseName(const std::string &basename)¶: set the base name (needed by most IOHelper dumpers)

iohelper::Dumper &getDumper() const¶: direct access to the iohelper::Dumper object

void setTimeStep(Real time_step)¶: set the timestep of the iohelper::Dumper

template<typename T, bool is_scal = std::is_arithmetic<T>::value> class Variable¶

class akantu::DumperParaview : public akantu::DumperIOHelper ¶

Public Functions

DumperParaview(const std::string &filename, const std::string &directory = "./paraview", bool parallel = true)¶

~DumperParaview() override¶

void setBaseName(const std::string &basename) override¶: set the base name (needed by most IOHelper dumpers)

class akantu::DumperText : public akantu::DumperIOHelper ¶

Public Functions

DumperText(const std::string &basename = "dumper_text", iohelper::TextDumpMode mode = iohelper::_tdm_space, bool parallel = true)¶

~DumperText() override = default¶

void registerMesh(const Mesh &mesh, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined) override¶: register a given Mesh for the current dumper

void registerFilteredMesh(const Mesh &mesh, const ElementTypeMapArray<UInt> &elements_filter, const Array<UInt> &nodes_filter, UInt spatial_dimension = _all_dimensions, GhostType ghost_type = _not_ghost, ElementKind element_kind = _ek_not_defined) override¶: register a filtered Mesh (provided filter lists) for the current dumper

void setBaseName(const std::string &basename) override¶: set the base name (needed by most IOHelper dumpers)

void setPrecision(UInt prec)¶

class akantu::dumpers::Field : public std::enable_shared_from_this<Field>¶

Field interface.

Subclassed by akantu::dumpers::GenericElementalField< SingleType< UInt, Vector, true >, filtered_connectivity_field_iterator >, akantu::dumpers::GenericElementalField< SingleType< T, Vector, false >, elemental_field_iterator >, akantu::dumpers::GenericElementalField< SingleType< T, Vector, false >, quadrature_point_iterator >, akantu::dumpers::GenericElementalField< SingleType< UInt, Vector, false >, element_partition_field_iterator >, akantu::dumpers::FieldCompute< SubFieldCompute, _return_type, support_type_ >, akantu::dumpers::FieldCompute< SubFieldCompute, _return_type, Element >, akantu::dumpers::GenericElementalField< _types, iterator_type >, akantu::dumpers::NodalField< T, filtered, Container, Filter >

Public Functions

Field() = default¶

~Field() = default¶

void registerToDumper(const std::string &id, iohelper::Dumper &dumper) = 0¶: register this to the provided dumper

void setNbData([[gnu::unused]] UInt nb_data)¶: set the number of data per item (used for elements fields at the moment)

void setNbDataPerElem([[gnu::unused]] const ElementTypeMap<UInt> &nb_data)¶: set the number of data per elem (used for elements fields at the moment)

void setNbDataPerElem([[gnu::unused]] UInt nb_data)¶: set the number of data per elem (used for elements fields at the moment)

ElementTypeMap<UInt> getNbComponents([[gnu::unused]] UInt dim = _all_dimensions, [[gnu::unused]] GhostType ghost_type = _not_ghost, [[gnu::unused]] ElementKind kind = _ek_not_defined)¶: get the number of components of the hosted field

std::shared_ptr<Field> connect([[gnu::unused]] FieldComputeProxy &proxy)¶: for connection to a FieldCompute

std::unique_ptr<ComputeFunctorInterface> connect(HomogenizerProxy&)¶: for connection to a FieldCompute

void checkHomogeneity() = 0¶: check if the same quantity of data for all element types

std::string getGroupName()¶: return the dumper name

std::string getID()¶: return the id of the field

bool isHomogeneous()¶: return the flag to know if the field is homogeneous/contiguous

class akantu::Parser : public akantu::ParserSection ¶

Root of parsing tree, represents the global ParserSection.

Public Functions

Parser()¶

void parse(const std::string &filename)¶

std::string getLastParsedFile() const¶

Public Static Functions

bool isPermissive()¶

Real parseReal(const std::string &value, const ParserSection &section)¶: Parse real scalar.

Vector<Real> parseVector(const std::string &value, const ParserSection &section)¶: Parse real vector.

Matrix<Real> parseMatrix(const std::string &value, const ParserSection &section)¶: Parse real matrix.

RandomParameter<Real> parseRandomParameter(const std::string &value, const ParserSection &section)¶: Parse real random parameter.

class akantu::ParserParameter¶

The ParserParameter objects represent the end of tree branches as they are the different informations contained in the input file.

Public Functions

ParserParameter()¶

ParserParameter(const std::string &name, const std::string &value, const ParserSection &parent_section)¶

ParserParameter(const ParserParameter &param) = default¶

~ParserParameter() = default¶

const std::string &getName() const¶: Get parameter name.

const std::string &getValue() const¶: Get parameter value.

void setDebugInfo(const std::string &filename, UInt line, UInt column)¶: Set info for debug output.

template<typename T> operator T() const¶

void printself(std::ostream &stream, __attribute__((unused)) unsigned int indent = 0) const¶: Print parameter info in stream.

class akantu::ParserSection¶

ParserSection represents a branch of the parsing tree.

Subclassed by akantu::Parser

Public Types

using SubSections = std::multimap<ParserType, ParserSection>¶

using Parameters = std::map<std::string, ParserParameter>¶

Public Functions

ParserSection()¶

ParserSection(const std::string &name, ParserType type)¶

ParserSection(const std::string &name, ParserType type, const std::string &option, const ParserSection &parent_section)¶

ParserSection(const ParserSection &section)¶

ParserSection &operator=(const ParserSection &other)¶

~ParserSection()¶

void printself(std::ostream &stream, unsigned int indent = 0) const¶

ParserParameter &addParameter(const ParserParameter &param)¶

ParserSection &addSubSection(const ParserSection &section)¶

auto getSubSections(ParserType type = ParserType::_not_defined) const¶: Get begin and end iterators on subsections of certain type.

UInt getNbSubSections(ParserType type = ParserType::_not_defined) const¶: Get number of subsections of certain type.

auto getParameters() const¶: Get begin and end iterators on parameters.

const ParserParameter &getParameter(const std::string &name, ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const¶: Get parameter within specified context.

template<class T> T getParameter(const std::string &name, const T &default_value, ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const¶: Get parameter within specified context, with a default value in case the parameter does not exists

bool hasParameter(const std::string &name, ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const¶: Check if parameter exists within specified context.

template<class T> T getParameterValue(const std::string &name, ParserParameterSearchCxt search_ctx = _ppsc_current_scope) const¶: Get value of given parameter in context.

std::string getName() const¶: Get section name.

ParserType getType() const¶: Get section type.

std::string getOption(const std::string &def = "") const¶: Get section option.

class const_parameter_iterator¶

Iterator on parameters.

Public Functions

const_parameter_iterator(const const_parameter_iterator &other) = default¶

const_parameter_iterator(const Parameters::const_iterator &it)¶

const_parameter_iterator &operator=(const const_parameter_iterator &other)¶

const ParserParameter &operator*() const¶

const ParserParameter *operator->()¶

bool operator==(const const_parameter_iterator &other) const¶

bool operator!=(const const_parameter_iterator &other) const¶

const_parameter_iterator &operator++()¶

const_parameter_iterator operator++(int)¶

class const_section_iterator¶

Iterator on sections.

Public Types

using iterator_category = std::forward_iterator_tag¶

using value_type = ParserSection ¶

using pointer = ParserSection*¶

using reference = ParserSection&¶

Public Functions

const_section_iterator() = default¶

const_section_iterator(const const_section_iterator_ &it)¶

const_section_iterator(const const_section_iterator &other) = default¶

const_section_iterator &operator=(const const_section_iterator &other) = default¶

const ParserSection &operator*() const¶

const ParserSection *operator->() const¶

bool operator==(const const_section_iterator &other) const¶

bool operator!=(const const_section_iterator &other) const¶

const_section_iterator &operator++()¶

const_section_iterator operator++(int)¶

class SubSectionsRange : public std::pair<const_section_iterator, const_section_iterator>¶

Public Functions

SubSectionsRange(const const_section_iterator &first, const const_section_iterator &second)¶

auto begin()¶

auto end()¶

enum akantu::ParserType¶

Values:

enumerator cohesive_inserter¶

enumerator contact¶

enumerator embedded_interface¶

enumerator friction¶

enumerator global¶

enumerator heat¶

enumerator integration_scheme¶

enumerator material¶

enumerator phasefield¶

enumerator mesh¶

enumerator model¶

enumerator model_solver¶

enumerator neighborhood¶

enumerator neighborhoods¶

enumerator non_linear_solver¶

enumerator non_local¶

enumerator rules¶

enumerator solver¶

enumerator time_step_solver¶

enumerator user¶

enumerator weight_function¶

enumerator not_defined¶