diff --git a/python/py_dof_manager.cc b/python/py_dof_manager.cc
index 5c8263521..0d4b0702d 100644
--- a/python/py_dof_manager.cc
+++ b/python/py_dof_manager.cc
@@ -1,166 +1,207 @@
/*
* Copyright (©) 2018-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* Akantu is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Akantu. If not, see .
*/
/* -------------------------------------------------------------------------- */
#include "py_dof_manager.hh"
#include "py_aka_array.hh"
#include "py_akantu_pybind11_compatibility.hh"
/* -------------------------------------------------------------------------- */
#include
#include
#include
/* -------------------------------------------------------------------------- */
#include
#include
#include
/* -------------------------------------------------------------------------- */
namespace py = pybind11;
/* -------------------------------------------------------------------------- */
namespace akantu {
namespace {
- template
- class PySolverCallback : public Parent {
+ class PySolverCallback : public SolverCallback {
public:
- using Parent::Parent;
+ using SolverCallback::SolverCallback;
/// get the type of matrix needed
MatrixType getMatrixType(const ID & matrix_id) const override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE_PURE(MatrixType, SolverCallback, getMatrixType,
matrix_id);
}
/// callback to assemble a Matrix
void assembleMatrix(const ID & matrix_id) override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE_PURE(void, SolverCallback, assembleMatrix, matrix_id);
}
/// callback to assemble a lumped Matrix
void assembleLumpedMatrix(const ID & matrix_id) override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE_PURE(void, SolverCallback, assembleLumpedMatrix,
matrix_id);
}
/// callback to assemble the residual (rhs)
void assembleResidual() override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE_PURE(void, SolverCallback, assembleResidual);
}
- /* ---------------------------------------------------------------------- */
- /* Dynamic simulations part */
- /* ---------------------------------------------------------------------- */
/// callback for the predictor (in case of dynamic simulation)
void predictor() override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE(void, SolverCallback, predictor);
}
/// callback for the corrector (in case of dynamic simulation)
void corrector() override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE(void, SolverCallback, corrector);
}
void beforeSolveStep() override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE(void, SolverCallback, beforeSolveStep);
}
void afterSolveStep(bool converged) override {
// NOLINTNEXTLINE
PYBIND11_OVERRIDE(void, SolverCallback, afterSolveStep, converged);
}
};
+
+ class PyInterceptSolverCallback : public InterceptSolverCallback {
+ public:
+ using InterceptSolverCallback::InterceptSolverCallback;
+
+ MatrixType getMatrixType(const ID & matrix_id) const override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(MatrixType, SolverCallback, getMatrixType, matrix_id);
+ }
+
+ void assembleMatrix(const ID & matrix_id) override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(void, SolverCallback, assembleMatrix, matrix_id);
+ }
+
+ /// callback to assemble a lumped Matrix
+ void assembleLumpedMatrix(const ID & matrix_id) override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(void, SolverCallback, assembleLumpedMatrix, matrix_id);
+ }
+
+ void assembleResidual() override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(void, SolverCallback, assembleResidual);
+ }
+
+ void predictor() override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(void, SolverCallback, predictor);
+ }
+
+ void corrector() override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(void, SolverCallback, corrector);
+ }
+
+ void beforeSolveStep() override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(void, SolverCallback, beforeSolveStep);
+ }
+
+ void afterSolveStep(bool converged) override {
+ // NOLINTNEXTLINE
+ PYBIND11_OVERRIDE(void, SolverCallback, afterSolveStep, converged);
+ }
+ };
+
} // namespace
/* -------------------------------------------------------------------------- */
void register_dof_manager(py::module & mod) {
py::class_(mod, "DOFManager")
.def("getMatrix", &DOFManager::getMatrix,
py::return_value_policy::reference)
.def(
"getNewMatrix",
[](DOFManager & self, const std::string & name,
const std::string & matrix_to_copy_id) -> decltype(auto) {
return self.getNewMatrix(name, matrix_to_copy_id);
},
py::return_value_policy::reference)
.def(
"getResidual",
[](DOFManager & self) -> decltype(auto) {
return self.getResidual();
},
py::return_value_policy::reference)
.def("getArrayPerDOFs", &DOFManager::getArrayPerDOFs)
.def(
"hasMatrix",
[](DOFManager & self, const ID & name) -> bool {
return self.hasMatrix(name);
},
py::arg("name"))
.def("assembleToResidual", &DOFManager::assembleToResidual,
py::arg("dof_id"), py::arg("array_to_assemble"),
py::arg("scale_factor") = 1.)
.def("assembleToLumpedMatrix", &DOFManager::assembleToLumpedMatrix,
py::arg("dof_id"), py::arg("array_to_assemble"),
py::arg("lumped_mtx"), py::arg("scale_factor") = 1.)
.def("assemblePreassembledMatrix",
&DOFManager::assemblePreassembledMatrix, py::arg("matrix_id"),
py::arg("terms"));
py::class_(mod, "NonLinearSolver")
.def(
"set",
[](NonLinearSolver & self, const std::string & id, const Real & val) {
if (id == "max_iterations") {
self.set(id, int(val));
} else {
self.set(id, val);
}
})
.def("set",
[](NonLinearSolver & self, const std::string & id,
const SolveConvergenceCriteria & val) { self.set(id, val); });
- py::class_>(mod,
- "SolverCallback")
+ py::class_(mod, "SolverCallback")
.def(py::init_alias())
.def("getMatrixType", &SolverCallback::getMatrixType)
.def("assembleMatrix", &SolverCallback::assembleMatrix)
.def("assembleLumpedMatrix", &SolverCallback::assembleLumpedMatrix)
.def("assembleResidual",
[](SolverCallback & self) { self.assembleResidual(); })
.def("predictor", &SolverCallback::predictor)
.def("corrector", &SolverCallback::corrector)
.def("beforeSolveStep", &SolverCallback::beforeSolveStep)
.def("afterSolveStep", &SolverCallback::afterSolveStep)
.def_property_readonly("dof_manager", &SolverCallback::getSCDOFManager,
py::return_value_policy::reference);
py::class_>(
- mod, "InterceptSolverCallback")
+ PyInterceptSolverCallback>(mod, "InterceptSolverCallback")
.def(py::init_alias());
}
} // namespace akantu
diff --git a/src/fe_engine/fe_engine_template.hh b/src/fe_engine/fe_engine_template.hh
index 296ca2117..545629934 100644
--- a/src/fe_engine/fe_engine_template.hh
+++ b/src/fe_engine/fe_engine_template.hh
@@ -1,431 +1,431 @@
/**
* @file fe_engine_template.hh
*
* @author Guillaume Anciaux
* @author Sébastien Hartmann
* @author Mohit Pundir
* @author Nicolas Richart
*
* @date creation: Fri Jun 18 2010
* @date last modification: Fri May 14 2021
*
* @brief templated class that calls integration and shape objects
*
*
* @section LICENSE
*
* Copyright (©) 2010-2021 EPFL (Ecole Polytechnique Fédérale de Lausanne)
* Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides)
*
* Akantu is free software: you can redistribute it and/or modify it under the
* terms of the GNU Lesser General Public License as published by the Free
* Software Foundation, either version 3 of the License, or (at your option) any
* later version.
*
* Akantu is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
* A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with Akantu. If not, see .
*
*/
/* -------------------------------------------------------------------------- */
#include "fe_engine.hh"
#include "integrator.hh"
#include "shape_functions.hh"
/* -------------------------------------------------------------------------- */
#include
/* -------------------------------------------------------------------------- */
/* -------------------------------------------------------------------------- */
#ifndef AKANTU_FE_ENGINE_TEMPLATE_HH_
#define AKANTU_FE_ENGINE_TEMPLATE_HH_
namespace akantu {
class DOFManager;
namespace fe_engine {
namespace details {
template struct AssembleLumpedTemplateHelper;
template struct AssembleFieldMatrixHelper;
} // namespace details
} // namespace fe_engine
template struct AssembleFieldMatrixStructHelper;
struct DefaultIntegrationOrderFunctor {
template static inline constexpr int getOrder() {
return ElementClassProperty::polynomial_degree;
}
};
/* -------------------------------------------------------------------------- */
template class I, template class S,
ElementKind kind = _ek_regular,
class IntegrationOrderFunctor = DefaultIntegrationOrderFunctor>
class FEEngineTemplate : public FEEngine {
/* ------------------------------------------------------------------------ */
/* Constructors/Destructors */
/* ------------------------------------------------------------------------ */
public:
using Integ = I;
using Shape = S;
FEEngineTemplate(Mesh & mesh, UInt spatial_dimension = _all_dimensions,
const ID & id = "fem");
~FEEngineTemplate() override;
/* ------------------------------------------------------------------------ */
/* Methods */
/* ------------------------------------------------------------------------ */
public:
/// pre-compute all the shape functions, their derivatives and the jacobians
void initShapeFunctions(GhostType ghost_type = _not_ghost) override;
void initShapeFunctions(const Array & nodes,
GhostType ghost_type = _not_ghost);
/* ------------------------------------------------------------------------ */
/* Integration method bridges */
/* ------------------------------------------------------------------------ */
/// integrate f for all elements of type "type"
void
integrate(const Array & f, Array & intf,
UInt nb_degree_of_freedom, ElementType type,
GhostType ghost_type = _not_ghost,
const Array & filter_elements = empty_filter) const override;
/// integrate a scalar value on all elements of type "type"
Real
integrate(const Array & f, ElementType type,
GhostType ghost_type = _not_ghost,
const Array & filter_elements = empty_filter) const override;
/// integrate one element scalar value on all elements of type "type"
Real integrate(const Vector & f, ElementType type, UInt index,
GhostType ghost_type = _not_ghost) const override;
/// integrate partially around an integration point (@f$ intf_q = f_q * J_q *
/// w_q @f$)
void integrateOnIntegrationPoints(
const Array & f, Array & intf, UInt nb_degree_of_freedom,
ElementType type, GhostType ghost_type = _not_ghost,
const Array & filter_elements = empty_filter) const override;
/// interpolate on a phyiscal point inside an element
void interpolate(const Vector & real_coords,
const Matrix & nodal_values,
Vector & interpolated,
const Element & element) const override;
/// get the number of integration points
UInt getNbIntegrationPoints(ElementType type,
GhostType ghost_type = _not_ghost) const override;
/// get shapes precomputed
const Array & getShapes(ElementType type,
GhostType ghost_type = _not_ghost,
UInt id = 0) const override;
/// get the derivatives of shapes
const Array & getShapesDerivatives(ElementType type,
GhostType ghost_type = _not_ghost,
UInt id = 0) const override;
/// get integration points
const inline Matrix &
getIntegrationPoints(ElementType type,
GhostType ghost_type = _not_ghost) const override;
/* ------------------------------------------------------------------------ */
/* Shape method bridges */
/* ------------------------------------------------------------------------ */
/// compute the gradient of a nodal field on the integration points
void gradientOnIntegrationPoints(
const Array & u, Array & nablauq, UInt nb_degree_of_freedom,
ElementType type, GhostType ghost_type = _not_ghost,
const Array & filter_elements = empty_filter) const override;
/// interpolate a nodal field on the integration points
void interpolateOnIntegrationPoints(
const Array & u, Array & uq, UInt nb_degree_of_freedom,
ElementType type, GhostType ghost_type = _not_ghost,
const Array & filter_elements = empty_filter) const override;
/// interpolate a nodal field on the integration points given a
/// by_element_type
void interpolateOnIntegrationPoints(
const Array & u, ElementTypeMapArray & uq,
const ElementTypeMapArray * filter_elements =
nullptr) const override;
/// pre multiplies a tensor by the shapes derivaties
void
- computeBtD(const Array & Ds, Array & BtDs, ElementType type,
- GhostType ghost_type,
+ computeBtD(const Array & Ds, Array & BtDs,
+ ElementType type, GhostType ghost_type,
const Array & filter_elements = empty_filter) const override;
/// left and right multiplies a tensor by the shapes derivaties
void computeBtDB(
const Array & Ds, Array & BtDBs, UInt order_d,
ElementType type, GhostType ghost_type,
const Array & filter_elements = empty_filter) const override;
/// left multiples a vector by the shape functions
void
computeNtb(const Array & bs, Array & Ntbs, ElementType type,
GhostType ghost_type,
const Array & filter_elements = empty_filter) const override;
/// left and right multiplies a tensor by the shapes
void computeNtbN(
const Array & bs, Array & NtbNs, ElementType type,
GhostType ghost_type,
const Array & filter_elements = empty_filter) const override;
/// compute the position of integration points given by an element_type_map
/// from nodes position
inline void computeIntegrationPointsCoordinates(
ElementTypeMapArray & quadrature_points_coordinates,
const ElementTypeMapArray * filter_elements =
nullptr) const override;
/// compute the position of integration points from nodes position
inline void computeIntegrationPointsCoordinates(
Array & quadrature_points_coordinates, ElementType type,
GhostType ghost_type = _not_ghost,
const Array & filter_elements = empty_filter) const override;
/// interpolate field at given position (interpolation_points) from given
/// values of this field at integration points (field)
inline void interpolateElementalFieldFromIntegrationPoints(
const ElementTypeMapArray & field,
const ElementTypeMapArray & interpolation_points_coordinates,
ElementTypeMapArray & result, GhostType ghost_type,
const ElementTypeMapArray * element_filter) const override;
/// Interpolate field at given position from given values of this field at
/// integration points (field)
/// using matrices precomputed with
/// initElementalFieldInterplationFromIntegrationPoints
inline void interpolateElementalFieldFromIntegrationPoints(
const ElementTypeMapArray & field,
const ElementTypeMapArray &
interpolation_points_coordinates_matrices,
const ElementTypeMapArray & quad_points_coordinates_inv_matrices,
ElementTypeMapArray & result, GhostType ghost_type,
const ElementTypeMapArray * element_filter) const override;
/// Build pre-computed matrices for interpolation of field form integration
/// points at other given positions (interpolation_points)
inline void initElementalFieldInterpolationFromIntegrationPoints(
const ElementTypeMapArray & interpolation_points_coordinates,
ElementTypeMapArray & interpolation_points_coordinates_matrices,
ElementTypeMapArray & quad_points_coordinates_inv_matrices,
const ElementTypeMapArray * element_filter =
nullptr) const override;
/// find natural coords from real coords provided an element
void inverseMap(const Vector & real_coords, UInt element,
ElementType type, Vector & natural_coords,
GhostType ghost_type = _not_ghost) const;
/// return true if the coordinates provided are inside the element, false
/// otherwise
inline bool contains(const Vector & real_coords, UInt element,
ElementType type,
GhostType ghost_type = _not_ghost) const;
/// compute the shape on a provided point
inline void computeShapes(const Vector & real_coords, UInt element,
ElementType type, Vector & shapes,
GhostType ghost_type = _not_ghost) const override;
/// compute the shape derivatives on a provided point
inline void
computeShapeDerivatives(const Vector & real_coords, UInt element,
ElementType type, Matrix & shape_derivatives,
GhostType ghost_type = _not_ghost) const override;
/* ------------------------------------------------------------------------ */
/* Other methods */
/* ------------------------------------------------------------------------ */
/// pre-compute normals on integration points
void
computeNormalsOnIntegrationPoints(GhostType ghost_type = _not_ghost) override;
void
computeNormalsOnIntegrationPoints(const Array & field,
GhostType ghost_type = _not_ghost) override;
void computeNormalsOnIntegrationPoints(
const Array & field, Array & normal, ElementType type,
GhostType ghost_type = _not_ghost) const override;
template
void computeNormalsOnIntegrationPoints(const Array & field,
Array & normal,
GhostType ghost_type) const;
private:
// To avoid a weird full specialization of a method in a non specalized class
void computeNormalsOnIntegrationPointsPoint1(const Array & /*unused*/,
Array & normal,
GhostType ghost_type) const;
public:
/// function to print the contain of the class
void printself(std::ostream & stream, int indent = 0) const override;
void assembleFieldLumped(
const std::function &, const Element &)> & field_funct,
const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
ElementType type, GhostType ghost_type) const override;
/// assemble a field as a matrix (ex. rho to mass matrix)
void assembleFieldMatrix(
const std::function &, const Element &)> & field_funct,
const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
ElementType type, GhostType ghost_type) const override;
/// assemble a field as a lumped matrix (ex. rho in lumped mass)
// template
// void assembleFieldLumped(const Functor & field_funct, const ID & matrix_id,
// const ID & dof_id, DOFManager & dof_manager,
// ElementType type,
// GhostType ghost_type) const;
// /// assemble a field as a matrix (ex. rho to mass matrix)
// template
// void assembleFieldMatrix(const Functor & field_funct, const ID & matrix_id,
// const ID & dof_id, DOFManager & dof_manager,
// ElementType type,
// GhostType ghost_type) const;
// #ifdef AKANTU_STRUCTURAL_MECHANICS
// /// assemble a field as a matrix (ex. rho to mass matrix)
// void assembleFieldMatrix(const Array & field_1,
// UInt nb_degree_of_freedom, SparseMatrix & M,
// Array * n,
// ElementTypeMapArray & rotation_mat,
// ElementType type,
// GhostType ghost_type = _not_ghost)
// const;
// /// compute shapes function in a matrix for structural elements
// void
// computeShapesMatrix(ElementType type, UInt nb_degree_of_freedom,
// UInt nb_nodes_per_element, Array * n, UInt id,
// UInt degree_to_interpolate, UInt degree_interpolated,
// const bool sign,
// GhostType ghost_type = _not_ghost) const
// override;
// #endif
private:
friend struct fe_engine::details::AssembleLumpedTemplateHelper;
friend struct fe_engine::details::AssembleFieldMatrixHelper;
friend struct AssembleFieldMatrixStructHelper;
/// templated function to compute the scaling to assemble a lumped matrix
template
void assembleFieldLumped(
const std::function &, const Element &)> & field_funct,
const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
GhostType ghost_type) const;
/// @f$ \tilde{M}_{i} = \sum_j M_{ij} = \sum_j \int \rho \varphi_i \varphi_j
/// dV = \int \rho \varphi_i dV @f$
template
void assembleLumpedRowSum(const Array & field, const ID & matrix_id,
const ID & dof_id, DOFManager & dof_manager,
GhostType ghost_type) const;
/// @f$ \tilde{M}_{i} = c * M_{ii} = \int_{V_e} \rho dV @f$
template
void assembleLumpedDiagonalScaling(const Array & field,
const ID & matrix_id, const ID & dof_id,
DOFManager & dof_manager,
GhostType ghost_type) const;
/// assemble a field as a matrix (ex. rho to mass matrix)
template
void assembleFieldMatrix(
const std::function &, const Element &)> & field_funct,
const ID & matrix_id, const ID & dof_id, DOFManager & dof_manager,
GhostType ghost_type) const;
#ifdef AKANTU_STRUCTURAL_MECHANICS
/// assemble a field as a matrix for structural elements (ex. rho to mass
/// matrix)
template
void assembleFieldMatrix(const Array & field_1,
UInt nb_degree_of_freedom, SparseMatrix & M,
Array * n,
ElementTypeMapArray & rotation_mat,
__attribute__((unused)) GhostType ghost_type) const;
#endif
/* ------------------------------------------------------------------------ */
/* Mesh Event Handler interface */
/* ------------------------------------------------------------------------ */
public:
void onElementsAdded(const Array & /*new_elements*/,
const NewElementsEvent & /*unused*/) override;
void onElementsRemoved(const Array & /*unused*/,
const ElementTypeMapArray & /*unused*/,
const RemovedElementsEvent & /*unused*/) override;
void onElementsChanged(const Array & /*unused*/,
const Array & /*unused*/,
const ElementTypeMapArray & /*unused*/,
const ChangedElementsEvent & /*unused*/) override;
/* ------------------------------------------------------------------------ */
/* Accessors */
/* ------------------------------------------------------------------------ */
public:
/// get the shape class (probably useless: see getShapeFunction)
const ShapeFunctions & getShapeFunctionsInterface() const override {
return shape_functions;
};
/// get the shape class
const Shape & getShapeFunctions() const { return shape_functions; };
/// get the integrator class (probably useless: see getIntegrator)
const Integrator & getIntegratorInterface() const override {
return integrator;
};
/// get the integrator class
const Integ & getIntegrator() const { return integrator; };
/* ------------------------------------------------------------------------ */
/* Class Members */
/* ------------------------------------------------------------------------ */
private:
Integ integrator;
Shape shape_functions;
};
} // namespace akantu
/* -------------------------------------------------------------------------- */
/* inline functions */
/* -------------------------------------------------------------------------- */
#include "fe_engine_template_tmpl.hh"
#include "fe_engine_template_tmpl_field.hh"
/* -------------------------------------------------------------------------- */
/* Shape Linked specialization */
/* -------------------------------------------------------------------------- */
#if defined(AKANTU_STRUCTURAL_MECHANICS)
#include "fe_engine_template_tmpl_struct.hh"
#endif
/* -------------------------------------------------------------------------- */
/* Shape IGFEM specialization */
/* -------------------------------------------------------------------------- */
#if defined(AKANTU_IGFEM)
#include "fe_engine_template_tmpl_igfem.hh"
#endif
#endif /* AKANTU_FE_ENGINE_TEMPLATE_HH_ */