concepts.hh File Reference

Several concepts. More...

#include <concepts>
#include <type_traits>
#include <utility>
#include <vector>
#include <dune/functions/functionspacebases/basistags.hh>
#include <dune/functions/functionspacebases/lagrangebasis.hh>
#include <Eigen/Dense>
#include <Eigen/Sparse>
#include <autodiff/forward/dual/dual.hpp>
#include "ikarus/assembler/dirichletbcenforcement.hh"
#include "ikarus/finiteelements/mechanics/materials/tags.hh"
#include <ikarus/utils/traits.hh>

Go to the source code of this file.

Namespaces
namespace	Eigen
namespace	Ikarus
namespace	Ikarus::Concepts

Concepts
concept	Ikarus::Concepts::FlatInterLeavedBasis
	Concept to check if a basis uses FlatInterleaved indexing strategy.
concept	Ikarus::Concepts::LagrangeNode
	Concept to check if a node in a basis tree is a Lagrangian node.
concept	Ikarus::Concepts::LagrangeNodeOfOrder
concept	Ikarus::Concepts::FlatLexicographicBasis
	Concept to check if a basis uses FlatLexicographic indexing strategy.
concept	Ikarus::Concepts::FlatIndexBasis
	Concept to check if a basis uses FlatIndex indexing strategy.
concept	Ikarus::Concepts::BlockedInterLeavedBasis
	Concept to check if a basis uses BlockedInterleaved indexing strategy.
concept	Ikarus::Concepts::BlockedLexicographicBasis
	Concept to check if a basis uses BlockedLexicographic indexing strategy.
concept	Ikarus::Concepts::DuneLocalBasis
	Concept to check if a local basis is a duneLocalBasis.
concept	Ikarus::Concepts::BlockedIndexBasis
	Concept to check if a basis uses either BlockedLexicographic or BlockedInterleaved indexing strategy.
concept	Ikarus::Concepts::PathFollowingStrategy
	Concept defining the requirements for a path-following strategy.
concept	Ikarus::Concepts::AdaptiveStepSizingStrategy
	Concept to check if a type implements all the needed functions to be an adaptive step sizing method.
concept	Ikarus::Concepts::LinearSolverCheck
	Concept to check if a linear solver implements all the needed functions for given vector and matrix types.
concept	Ikarus::Concepts::NonLinearSolverCheckForPathFollowing
	Concept to check if a non-linear solver with its non-linear operator satisfies requirements for path following.
concept	Ikarus::Concepts::MultiplyAble
	Concept defining the requirements for types that support multiplication.
concept	Ikarus::Concepts::AddAble
	Concept defining the requirements for types that support addition.
concept	Ikarus::Concepts::SubstractAble
	Concept defining the requirements for types that support subtraction.
concept	Ikarus::Concepts::MultiplyAssignAble
	Concept defining the requirements for types that support in-place multiplication.
concept	Ikarus::Concepts::DivideAssignAble
	Concept defining the requirements for types that support in-place division.
concept	Ikarus::Concepts::AddAssignAble
	Concept defining the requirements for types that support in-place addition.
concept	Ikarus::Concepts::SubstractAssignAble
	Concept defining the requirements for types that support in-place subtraction.
concept	Ikarus::Concepts::DivideAble
	Concept defining the requirements for types that support division.
concept	Ikarus::Concepts::NegateAble
	Concept defining the requirements for types that support negation.
concept	Ikarus::Concepts::TransposeAble
	Concept defining the requirements for types that support transposition.
concept	Ikarus::Concepts::IsFunctorWithArgs
	Concept defining the requirements for functors with arguments.
concept	Ikarus::Concepts::EigenVector
	Concept defining the requirements for Eigen vectors.
concept	Ikarus::Concepts::EigenMatrix
	Concept defining the requirements for Eigen matrices. This also includes Eigen vectors.
concept	Ikarus::Concepts::IsMaterial
	Concept defining the requirements for a material type.
concept	Ikarus::Concepts::GeometricallyLinearMaterial
	Concepts defining the requirements for a material to be geometrically linear This is the case when the corresponding strainTag is linear.
concept	Ikarus::Concepts::ResultType
	A concept to check if a template type satisfies the ResultType requirements.
concept	Ikarus::Concepts::FlatAssembler
	Concept representing the requirements for a FlatAssembler.A type T satisfies FlatAssembler if it provides the necessary member functions and data types for assembling sparse matrices in a flat structure.
concept	Ikarus::Concepts::ScalarFlatAssembler
	Concept representing the requirements for a ScalarFlatAssembler.A type T satisfies ScalarFlatAssembler if it is a FlatAssembler and if it provides the necessary scalar() member functions.
concept	Ikarus::Concepts::VectorFlatAssembler
	Concept representing the requirements for a VectorFlatAssembler.A type T satisfies VectorFlatAssembler if it is a ScalarFlatAssembler and if it provides the necessary vector() member functions.
concept	Ikarus::Concepts::MatrixFlatAssembler
	Concept representing the requirements for a MatrixFlatAssembler.A type T satisfies MatrixFlatAssembler if it is a VectorFlatAssembler and if it provides the necessary matrix() member functions.
concept	Ikarus::Concepts::DataCollector
concept	Ikarus::Concepts::GridView
concept	Ikarus::Concepts::AutodiffScalar
	Concept to check if the underlying scalar type is a dual type.

Macros
#define	MAKE_EIGEN_FIXED_VECTOR_CONCEPT(Size)
#define	MAKE_EIGEN_FIXED_MATRIX_CONCEPT(Size1, Size2)
#define	MAKE_EIGEN_FIXED_MATRIX_OR_VOIGT_CONCEPT(Size1, Size2)

Functions
template<typename Derived >
auto	Ikarus::transpose (const Eigen::EigenBase< Derived > &A)

Macro Definition Documentation

MAKE_EIGEN_FIXED_MATRIX_CONCEPT

#define MAKE_EIGEN_FIXED_MATRIX_CONCEPT	(		Size1,
			Size2
	)

Value:

  template <typename M>                                                                                         \
  concept EigenMatrix##Size1##Size2 = static_cast<bool>(std::remove_cvref_t<M>::RowsAtCompileTime == Size1) and \
                                      static_cast<bool>(std::remove_cvref_t<M>::ColsAtCompileTime == Size2);

MAKE_EIGEN_FIXED_MATRIX_OR_VOIGT_CONCEPT

#define MAKE_EIGEN_FIXED_MATRIX_OR_VOIGT_CONCEPT	(		Size1,
			Size2
	)

Value:

  template <typename M>                                        \
  concept EigenMatrixOrVoigtNotation##Size1 = EigenMatrix##Size1##Size1<M> or EigenVector##Size2<M>;

MAKE_EIGEN_FIXED_VECTOR_CONCEPT

#define MAKE_EIGEN_FIXED_VECTOR_CONCEPT

(

Size

)

Value:

  template <typename V>                       \
  concept EigenVector##Size =                 \
      static_cast<bool>(V::IsVectorAtCompileTime) and static_cast<bool>(V::SizeAtCompileTime == Size);