version 0.4.4
ferequirements.hh
Go to the documentation of this file.
1// SPDX-FileCopyrightText: 2021-2025 The Ikarus Developers ikarus@ibb.uni-stuttgart.de
2// SPDX-License-Identifier: LGPL-3.0-or-later
3
10#pragma once
11
12#include <iosfwd>
13#include <map>
14#include <set>
15#include <vector>
16
17#include <dune/common/exceptions.hh>
18
19#include <Eigen/Core>
20
22#include <ikarus/utils/basis.hh>
25
26namespace Ikarus {
27// clang-format off
28
34// cppcheck-suppress MAKE_ENUM
36 noAffordance,
37 mechanicalPotentialEnergy,
38 microMagneticPotentialEnergy
39 );
40
47 noAffordance,
48 forces,
49 microMagneticForces
50 );
51
58 noAffordance,
60 materialstiffness,
61 geometricstiffness,
63 microMagneticHessian,
64 mass
65 );
66
73 noParameter,
74 loadfactor,
75 time
76 );
77
84 noSolution,
85 displacement,
86 velocity,
87 director,
88 magnetizationAndVectorPotential
89 );
90
91// clang-format on
92
96template <typename T>
97concept FEAffordance = std::is_same_v<std::remove_cvref_t<T>, ScalarAffordance> or
98 std::is_same_v<std::remove_cvref_t<T>, VectorAffordance> or
99 std::is_same_v<std::remove_cvref_t<T>, MatrixAffordance>;
100
104template <FEAffordance... Affordances>
105requires(sizeof...(Affordances) <= 3)
106struct AffordanceCollection : public std::tuple<Affordances...>
107{
108 using Base = std::tuple<Affordances...>;
109
111 constexpr AffordanceCollection(Affordances... affordances)
112 : Base(affordances...) {}
113
114 static constexpr bool hasScalarAffordance = traits::hasType<ScalarAffordance, std::tuple<Affordances...>>::value;
115 static constexpr bool hasVectorAffordance = traits::hasType<VectorAffordance, std::tuple<Affordances...>>::value;
116 static constexpr bool hasMatrixAffordance = traits::hasType<MatrixAffordance, std::tuple<Affordances...>>::value;
126 template <FEAffordance Affordance>
127 constexpr bool hasAffordance(Affordance&& affordances) const {
128 using AffordanceRaw = std::remove_cvref_t<Affordance>;
129 if constexpr (std::is_same_v<AffordanceRaw, AffordanceCollection>)
130 return affordances == *this;
131 else {
132 if constexpr (std::is_same_v<AffordanceRaw, ScalarAffordance>) {
133 if constexpr (hasScalarAffordance)
134 return affordances == std::get<ScalarAffordance>(*this);
135 else
136 return false;
137 }
138 if constexpr (std::is_same_v<AffordanceRaw, VectorAffordance>) {
139 if constexpr (hasVectorAffordance)
140 return affordances == std::get<VectorAffordance>(*this);
141 else
142 return false;
143 }
144 if constexpr (std::is_same_v<AffordanceRaw, MatrixAffordance>) {
145 if constexpr (hasMatrixAffordance)
146 return affordances == std::get<MatrixAffordance>(*this);
147 else
148 return false;
149 }
150 }
151 return false;
152 }
153
154 auto scalarAffordance() const
155 requires hasScalarAffordance
156 {
157 return std::get<ScalarAffordance>(*this);
158 }
159 auto vectorAffordance() const
160 requires hasVectorAffordance
161 {
162 return std::get<VectorAffordance>(*this);
163 }
164 auto matrixAffordance() const
165 requires hasMatrixAffordance
166 {
167 return std::get<MatrixAffordance>(*this);
168 }
169};
170
172
177
179 if (affordanceM == MatrixAffordance::stiffness)
181 else if (affordanceM == MatrixAffordance::microMagneticHessian)
183 else
185}
186
188 if (affordanceM == MatrixAffordance::stiffness)
190 else if (affordanceM == MatrixAffordance::microMagneticHessian)
192 else
194}
195
197 if (affordanceV == VectorAffordance::forces)
199 else if (affordanceV == VectorAffordance::microMagneticForces)
201 else
203}
204
205namespace AffordanceCollections {
208} // namespace AffordanceCollections
209
222template <FESolutions sol, FEParameter para, typename SV = Eigen::VectorXd, typename PM = double>
224{
225public:
227 using ParameterType = PM;
228
232 FERequirements() = default;
233
240 template <typename SV2 = SV, typename PM2 = PM>
241 FERequirements(SV2&& solVec, PM2&& parameter)
242 : sol_(std::make_unique<SV>(std::forward<SV2>(solVec))),
243 parameter_(std::make_unique<PM>(std::forward<PM2>(parameter))) {}
244
250 template <typename PB>
252 : sol_(std::make_unique<SV>(SV::Zero(basis.flat().size()))),
253 parameter_(std::make_unique<PM>(0.0)) {}
254
263 : sol_(other.sol_ ? std::make_unique<SV>(*other.sol_) : nullptr),
264 parameter_(other.parameter_ ? std::make_unique<PM>(*other.parameter_) : nullptr) {}
265
275 if (this != &other) {
276 sol_ = other.sol_ ? std::make_unique<SV>(*other.sol_) : nullptr;
277 parameter_ = other.parameter_ ? std::make_unique<PM>(*other.parameter_) : nullptr;
278 }
279 return *this;
280 }
281
291 parameter_ = std::make_unique<PM>(val);
292 return *this;
293 }
294
303 template <typename SV2 = SolutionVectorType>
305 sol_ = std::make_unique<SV>(std::forward<SV2>(solVec));
306 return *this;
307 }
308
315 if (!sol_)
316 DUNE_THROW(Dune::InvalidStateException, "Solution vector is not initialized.");
317 return *sol_;
318 }
319
326 if (!sol_)
327 DUNE_THROW(Dune::InvalidStateException, "Solution vector is not initialized.");
328
329 return *sol_;
330 }
331
337 std::size_t size() {
339 return globalSolution().size();
340 else
341 return 0;
342 }
343
349 const PM& parameter() const {
350 if (!parameter_)
351 DUNE_THROW(Dune::InvalidStateException, "Parameter is not initialized.");
352
353 return *parameter_;
354 }
355
361 PM& parameter() {
362 if (!parameter_)
363 DUNE_THROW(Dune::InvalidStateException, "Parameter is not initialized.");
364
365 return *parameter_;
366 }
367
373 bool populated() const { return sol_ and parameter_; }
374
382 template <typename T>
383 SV& operator+=(const T& rhs) {
384 if (!sol_)
385 DUNE_THROW(Dune::InvalidStateException, "Solution vector is not initialized.");
386 if constexpr (not std::is_same_v<T, utils::SyncFERequirements>)
387 *sol_ += rhs;
388 return *sol_;
389 }
390
399 template <typename UF>
400 void syncParameterAndGlobalSolution(UF&& updateFunction) {
401 updateFunction(*this, utils::syncFERequirements);
402 }
403
404private:
405 std::unique_ptr<SV> sol_;
406 std::unique_ptr<PM> parameter_;
407};
408
409} // namespace Ikarus
Implementation of the make enum macro.
Collection of fallback default functions.
Definitions of ResultTypes used for finite element results.
FEParameter
A strongly typed enum class representing the FE parameter.
Definition: ferequirements.hh:76
FESolutions
A strongly typed enum class representing the type of the solutions vectors.
Definition: ferequirements.hh:89
#define MAKE_ENUM(type,...)
Macro to create an enumeration with a string conversion function.The macro creates an enum class with...
Definition: makeenum.hh:40
Definition: assemblermanipulatorbuildingblocks.hh:22
constexpr MatrixAffordance stiffnessdiffBucklingVector
Definition: ferequirements.hh:174
auto vectorAffordance(MatrixAffordance affordanceM)
Definition: ferequirements.hh:178
MatrixAffordance
A strongly typed enum class representing the matrix affordance.
Definition: ferequirements.hh:65
constexpr MatrixAffordance stiffness
Definition: ferequirements.hh:173
constexpr VectorAffordance forces
Definition: ferequirements.hh:171
constexpr ScalarAffordance potentialEnergy
Definition: ferequirements.hh:176
auto scalarAffordance(MatrixAffordance affordanceM)
Definition: ferequirements.hh:187
VectorAffordance
A strongly typed enum class representing the vector affordance.
Definition: ferequirements.hh:50
constexpr MatrixAffordance mass
Definition: ferequirements.hh:175
ScalarAffordance
A strongly typed enum class representing the scalar affordance.
Definition: ferequirements.hh:39
constexpr AffordanceCollection elastoStatics(ScalarAffordance::mechanicalPotentialEnergy, VectorAffordance::forces, MatrixAffordance::stiffness)
struct Ikarus::utils::SyncFERequirements syncFERequirements
def basis(gv, tree)
Definition: basis.py:10
Struct representing a collection of affordances.
Definition: ferequirements.hh:107
std::tuple< Affordances... > Base
Definition: ferequirements.hh:108
auto vectorAffordance() const
Definition: ferequirements.hh:159
constexpr AffordanceCollection(Affordances... affordances)
Definition: ferequirements.hh:111
auto scalarAffordance() const
Definition: ferequirements.hh:154
constexpr bool hasAffordance(Affordance &&affordances) const
Check if a specific affordance is present in the requirements.
Definition: ferequirements.hh:127
auto matrixAffordance() const
Definition: ferequirements.hh:164
Class representing the requirements for finite element calculations.
Definition: ferequirements.hh:224
FERequirements()=default
Default constructor.
bool populated() const
Tells if the class contains all needed values.
Definition: ferequirements.hh:373
std::size_t size()
A helper function to get the size of the solution vector.
Definition: ferequirements.hh:337
void syncParameterAndGlobalSolution(UF &&updateFunction)
This function syncs the parameter and the global solution vector. The can get out of sync,...
Definition: ferequirements.hh:400
FERequirements & operator=(const FERequirements &other)
Copy assignment operator.
Definition: ferequirements.hh:274
FERequirements(const FERequirements &other)
Copy constructor.
Definition: ferequirements.hh:262
SV SolutionVectorType
Type of the solution vector.
Definition: ferequirements.hh:226
FERequirements(SV2 &&solVec, PM2 &&parameter)
Constructor initializing the solution vector and parameter.
Definition: ferequirements.hh:241
PM ParameterType
Type of the parameter.
Definition: ferequirements.hh:227
SV & globalSolution()
Get the global solution vector.
Definition: ferequirements.hh:325
FERequirements & insertGlobalSolution(SV2 &&solVec)
Insert a global solution vector into the requirements.
Definition: ferequirements.hh:304
const SolutionVectorType & globalSolution() const
Get the global solution vector.
Definition: ferequirements.hh:314
FERequirements & insertParameter(const PM &val)
Insert a parameter into the requirements.
Definition: ferequirements.hh:290
const PM & parameter() const
Get the parameter value.
Definition: ferequirements.hh:349
PM & parameter()
Get the parameter value.
Definition: ferequirements.hh:361
FERequirements(const Ikarus::BasisHandler< PB > &basis)
Constructor from a basis.
Definition: ferequirements.hh:251
SV & operator+=(const T &rhs)
Enables the usage of the class as a solution vector.
Definition: ferequirements.hh:383
Wrapper class for a hierarchical basis constructed from a pre-basis.
Definition: utils/basis.hh:30
Type trait to check if a specified type is present in a tuple.
Definition: traits.hh:88
Concept to check if a given type is one of the predefined affordance enums or the AffordanceCollectio...
Definition: ferequirements.hh:97
Concept defining the requirements for Eigen vectors.
Definition: utils/concepts.hh:365
Wrapper around Dune-functions global basis.