b2api
B2000++ API Reference Manual, VERSION 4.6
 
Loading...
Searching...
No Matches
b2solid_mechanics.H
1//------------------------------------------------------------------------
2// b2solid_mechanics.H --
3//
4//
5// written by Mathias Doreille
6// Neda Ebrahimi Pour <neda.ebrahimipour@dlr.de>
7//
8// (c) 2004-2016,2017 SMR Engineering & Development SA
9// 2502 Bienne, Switzerland
10//
11// (c) 2023 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
12// Linder Höhe, 51147 Köln
13//
14// All Rights Reserved. Proprietary source code. The contents of
15// this file may not be disclosed to third parties, copied or
16// duplicated in any form, in whole or in part, without the prior
17// written permission of SMR.
18//------------------------------------------------------------------------
19
20#ifndef B2SOLID_MECHANICS_H_
21#define B2SOLID_MECHANICS_H_
22
23#include "model/b2element.H"
24#include "utils/b2linear_algebra.H"
25
26namespace b2000 {
27
29class SolidMechanics : virtual public ElementProperty {
30public:
31 enum LinearType { yes, linear_on_sub_domain, nonlinear };
32};
33
35template <typename T>
36class SolidMechanicsRod : virtual public SolidMechanics {
37public:
47 virtual LinearType linear(const int layer_id = -1) const { return yes; }
48
57 virtual bool isotropic(const int layer_id = -1) const { return true; }
58
68 virtual bool path_dependent(const int layer_id = -1) const { return false; }
69
72 SolidMechanicsRod<T>* copy() override {
73 Exception() << "This object is not mutable." << THROW;
74 return 0;
75 }
76
77 virtual void get_stress(
78 Model* model, const bool linear, const EquilibriumSolution equilibrium_solution,
79 const double time, const double delta_time, GradientContainer* gradient_container,
80 SolverHints* solver_hints, const Element* element,
81 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
82 const T covariant_base[3], const T displacement_gradient[3], const T strain_xx,
83 const T velocity[3], const T acceleration[3], T& force_x, T& C, T inertia_force[3],
84 T& density) {
85 UnimplementedError() << THROW;
86 }
87
88 virtual T get_area() const {
89 UnimplementedError() << THROW;
90 return T(0);
91 }
92
93 virtual T get_density() const {
94 UnimplementedError() << THROW;
95 return T(0);
96 }
97};
98
112template <typename T>
113class SolidMechanics3D : virtual public SolidMechanics {
114public:
124 virtual LinearType linear(const int layer_id = -1) const { return yes; }
125
134 virtual bool isotropic(const int layer_id = -1) const { return true; }
135
145 virtual bool path_dependent(const int layer_id = -1) const { return false; }
146
149 virtual SolidMechanics3D<T>* copy(int layer_) {
150 Exception() << "This object is not mutable." << THROW;
151 return 0;
152 }
153
154 virtual int number_of_layer() const { return 1; }
155
156 virtual void laminate(
157 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
158 T& laminate_begin, T& laminate_end) const {
159 UnimplementedError() << THROW;
160 }
161
162 T laminate_thickness(
163 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation) const {
164 T laminate_begin, laminate_end;
165 laminate(nodes_interpolation, laminate_begin, laminate_end);
166 return laminate_end - laminate_begin;
167 }
168
169 virtual void layer(
170 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
171 const int layer_id, T& layer_begin, T& layer_end) const {
172 UnimplementedError() << THROW;
173 }
174
175 T layer_thickness(
176 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation) const {
177 T layer_begin, layer_end;
178 layer(nodes_interpolation, layer_begin, layer_end);
179 return layer_end - layer_begin;
180 }
181
182 virtual T get_density(const int layer_id) const {
183 UnimplementedError() << THROW;
184 return T(0);
185 }
186
187 virtual void get_stress(
188 Model* model, const bool linear, const EquilibriumSolution equilibrium_solution,
189 const double time, const double delta_time, GradientContainer* gradient_container,
190 SolverHints* solver_hints, const Element* element, const double el_coordinates[3],
191 const int layer_id,
192 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
193 const T bg_coordinates[3], const T covariant_base[3][3], const bool use_covariant_base,
194 const T volume, const T displacement_gradient[3][3], const T strain[6],
195 const T strain_dot[6], const T velocity[3], const T acceleration[3], T stress[6],
196 T d_stress_d_strain[21], T d_stress_d_strain_dot[21], T d_stress_d_time[6],
197 T inertia_force[3], T& density) {
198 UnimplementedError() << THROW;
199 }
200
201 virtual void get_static_linear_stress(
202 Model* model, const double time, const double delta_time,
203 GradientContainer* gradient_container, SolverHints* solver_hints, const Element* element,
204 const double el_coordinates[3], const int layer_id,
205 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
206 const T bg_coordinates[3], const T covariant_base[3][3], const bool use_covariant_base,
207 const T volume, const T displacement_gradient[3][3], const T strain[6], T stress[6],
208 T d_stress_d_strain[21], T d_stress_d_time[6]) {
209 T density;
210 get_stress(
211 model,
212 true, // linear
213 true, // equilibrium_solution
214 time, delta_time, gradient_container, solver_hints, element, el_coordinates, layer_id,
215 nodes_interpolation, bg_coordinates, covariant_base, use_covariant_base, volume,
216 displacement_gradient, strain,
217 0, // strain_dot
218 0, // velocity
219 0, // acceleration
220 stress, d_stress_d_strain,
221 0, // d_stress_d_strain_dot
222 d_stress_d_time,
223 0, // inertia_force
224 density);
225 }
226
227 virtual void get_static_nonlinear_stress(
228 Model* model, const EquilibriumSolution equilibrium_solution, const double time,
229 const double delta_time, GradientContainer* gradient_container, SolverHints* solver_hints,
230 const Element* element, const double el_coordinates[3], const int layer_id,
231 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
232 const T bg_coordinates[3], const T covariant_base[3][3], const bool use_covariant_base,
233 const T volume, const T displacement_gradient[3][3], const T strain[6], T stress[6],
234 T d_stress_d_strain[21], T d_stress_d_time[6]) {
235 T density;
236 get_stress(
237 model,
238 false, // linear
239 equilibrium_solution, time, delta_time, gradient_container, solver_hints, element,
240 el_coordinates, layer_id, nodes_interpolation, bg_coordinates, covariant_base,
241 use_covariant_base, volume, displacement_gradient, strain,
242 0, // strain_dot
243 0, // velocity
244 0, // acceleration
245 stress, d_stress_d_strain,
246 0, // d_stress_d_strain_dot
247 d_stress_d_time,
248 0, // inertia_force
249 density);
250 }
251
252 virtual void get_dynamic_linear_stress(
253 Model* model, const double time, const double delta_time,
254 GradientContainer* gradient_container, SolverHints* solver_hints, const Element* element,
255 const double el_coordinates[3], const int layer_id,
256 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
257 const T bg_coordinates[3], const T covariant_base[3][3], const bool use_covariant_base,
258 const T volume, const T displacement_gradient[3][3], const T strain[6],
259 const T strain_dot[6], const T velocity[3], const T acceleration[3], T stress[6],
260 T d_stress_d_strain[21], T d_stress_d_strain_dot[21], T d_stress_d_time[6],
261 T inertia_force[3], T& density) {
262 get_stress(
263 model,
264 true, // linear
265 true, // equilibrium_solution
266 time, delta_time, gradient_container, solver_hints, element, el_coordinates, layer_id,
267 nodes_interpolation, bg_coordinates, covariant_base, use_covariant_base, volume,
268 displacement_gradient, strain, strain_dot, velocity, acceleration, stress,
269 d_stress_d_strain, d_stress_d_strain_dot, d_stress_d_time, inertia_force, density);
270 }
271
272 virtual void get_dynamic_nonlinear_stress(
273 Model* model, const EquilibriumSolution equilibrium_solution, const double time,
274 const double delta_time, GradientContainer* gradient_container, SolverHints* solver_hints,
275 const Element* element, const double el_coordinates[3], const int layer_id,
276 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
277 const T bg_coordinates[3], const T covariant_base[3][3], const bool use_covariant_base,
278 const T volume, const T displacement_gradient[3][3], const T strain[6],
279 const T strain_dot[6], const T velocity[3], const T acceleration[3], T stress[6],
280 T d_stress_d_strain[21], T d_stress_d_strain_dot[21], T d_stress_d_time[6],
281 T inertia_force[3], T& density) {
282 get_stress(
283 model,
284 false, // linear
285 equilibrium_solution, time, delta_time, gradient_container, solver_hints, element,
286 el_coordinates, layer_id, nodes_interpolation, bg_coordinates, covariant_base,
287 use_covariant_base, volume, displacement_gradient, strain, strain_dot, velocity,
288 acceleration, stress, d_stress_d_strain, d_stress_d_strain_dot, d_stress_d_time,
289 inertia_force, density);
290 }
291
292 virtual void get_static_linear_cross_section_gradient(
293 const T covariant_base[3][3], const T strain[6], const T stress[6],
294 GradientContainer* gradient_container) {
295 UnimplementedError() << THROW;
296 }
297};
298
312template <typename T>
313class SolidMechanics25D : virtual public SolidMechanics {
314public:
324 virtual LinearType linear(const int layer_id = -1) const { return yes; }
325
334 virtual bool isotropic(const int layer_id = -1) const { return true; }
335
345 virtual bool path_dependent(const int layer_id = -1) const { return false; }
346
349 virtual SolidMechanics25D<T>* copy(int layer_) {
350 Exception() << "This object is not mutable." << THROW;
351 return 0;
352 }
353
354 // Return the number of layer of the model.
355 virtual int number_of_layer() const { return 1; }
356
357 virtual void laminate(
358 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
359 T& laminate_begin, T& laminate_end) const {
360 UnimplementedError() << THROW;
361 }
362
363 T laminate_thickness(
364 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation) const {
365 T laminate_begin, laminate_end;
366 laminate(nodes_interpolation, laminate_begin, laminate_end);
367 return laminate_end - laminate_begin;
368 }
369
370 virtual void layer(
371 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
372 const int layer_id, T& layer_begin, T& layer_end) const {
373 UnimplementedError() << THROW;
374 }
375
376 T layer_thickness(
377 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation) const {
378 T layer_begin, layer_end;
379 layer(nodes_interpolation, layer_begin, layer_end);
380 return layer_end - layer_begin;
381 }
382
383 virtual T get_density(const int layer_id) const {
384 UnimplementedError() << THROW;
385 return T(0);
386 }
387
388 virtual void get_stress(
389 Model* model, const bool linear, const EquilibriumSolution equilibrium_solution,
390 const double time, const double delta_time, GradientContainer* gradient_container,
391 SolverHints* solver_hints, const Element* element, const double el_coordinates[3],
392 const int layer_id,
393 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
394 const double thickness_interpolation[2], const T bg_coordinates[3],
395 const T covariant_base[3][3], const bool use_covariant_base, const T volume,
396 const T displacement_gradient[3][3], const T strain[6], const T strain_dot[6],
397 const T velocity[3], const T acceleration[3], T stress[6], T d_stress_d_strain[21],
398 T d_stress_d_strain_dot[21], T d_stress_d_time[6], T inertia_force[3], T& density) {
399 UnimplementedError() << THROW;
400 }
401
402 virtual void get_static_linear_stress(
403 Model* model, const double time, const double delta_time,
404 GradientContainer* gradient_container, SolverHints* solver_hints, const Element* element,
405 const double el_coordinates[3], const int layer_id,
406 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
407 const double thickness_interpolation[2], const T bg_coordinates[3],
408 const T covariant_base[3][3], const bool use_covariant_base, const T volume,
409 const T displacement_gradient[3][3], const T strain[6], T stress[6],
410 T d_stress_d_strain[21], T d_stress_d_time[6]) {
411 T density;
412 get_stress(
413 model,
414 true, // linear
415 true, // equilibrium_solution,
416 time, delta_time, gradient_container, solver_hints, element, el_coordinates, layer_id,
417 nodes_interpolation, thickness_interpolation, bg_coordinates, covariant_base,
418 use_covariant_base, volume, displacement_gradient, strain,
419 0, // strain_dot
420 0, // velocity
421 0, // acceleration
422 stress, d_stress_d_strain,
423 0, // d_stress_d_strain_dot
424 d_stress_d_time,
425 0, // inertia_force
426 density);
427 }
428
429 virtual void get_static_nonlinear_stress(
430 Model* model, const EquilibriumSolution equilibrium_solution, const double time,
431 const double delta_time, GradientContainer* gradient_container, SolverHints* solver_hints,
432 const Element* element, const double el_coordinates[3], const int layer_id,
433 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
434 const double thickness_interpolation[2], const T bg_coordinates[3],
435 const T covariant_base[3][3], const bool use_covariant_base, const T volume,
436 const T displacement_gradient[3][3], const T strain[6], T stress[6],
437 T d_stress_d_strain[21], T d_stress_d_time[6]) {
438 T density;
439 get_stress(
440 model,
441 false, // linear
442 equilibrium_solution, time, delta_time, gradient_container, solver_hints, element,
443 el_coordinates, layer_id, nodes_interpolation, thickness_interpolation,
444 bg_coordinates, covariant_base, use_covariant_base, volume, displacement_gradient,
445 strain,
446 0, // strain_dot
447 0, // velocity
448 0, // acceleration
449 stress, d_stress_d_strain,
450 0, // d_stress_d_strain_dot
451 d_stress_d_time,
452 0, // inertia_force
453 density);
454 }
455
456 virtual void get_dynamic_linear_stress(
457 Model* model, const double time, const double delta_time,
458 GradientContainer* gradient_container, SolverHints* solver_hints, const Element* element,
459 const double el_coordinates[3], const int layer_id,
460 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
461 const double thickness_interpolation[2], const T bg_coordinates[3],
462 const T covariant_base[3][3], const bool use_covariant_base, const T volume,
463 const T displacement_gradient[3][3], const T strain[6], const T strain_dot[6],
464 const T velocity[3], const T acceleration[3], T stress[6], T d_stress_d_strain[21],
465 T d_stress_d_strain_dot[21], T d_stress_d_time[6], T inertia_force[3], T& density) {
466 get_stress(
467 model,
468 true, // linear
469 true, // equilibrium_solution,
470 time, delta_time, gradient_container, solver_hints, element, el_coordinates, layer_id,
471 nodes_interpolation, thickness_interpolation, bg_coordinates, covariant_base,
472 use_covariant_base, volume, displacement_gradient, strain, strain_dot, velocity,
473 acceleration, stress, d_stress_d_strain, d_stress_d_strain_dot, d_stress_d_time,
474 inertia_force, density);
475 }
476
477 virtual void get_dynamic_nonlinear_stress(
478 Model* model, const EquilibriumSolution equilibrium_solution, const double time,
479 const double delta_time, GradientContainer* gradient_container, SolverHints* solver_hints,
480 const Element* element, const double el_coordinates[3], const int layer_id,
481 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
482 const double thickness_interpolation[2], const T bg_coordinates[3],
483 const T covariant_base[3][3], const bool use_covariant_base, const T volume,
484 const T displacement_gradient[3][3], const T strain[6], const T strain_dot[6],
485 const T velocity[3], const T acceleration[3], T stress[6], T d_stress_d_strain[21],
486 T d_stress_d_strain_dot[21], T d_stress_d_time[6], T inertia_force[3], T& density) {
487 get_stress(
488 model,
489 false, // linear
490 equilibrium_solution, time, delta_time, gradient_container, solver_hints, element,
491 el_coordinates, layer_id, nodes_interpolation, thickness_interpolation,
492 bg_coordinates, covariant_base, use_covariant_base, volume, displacement_gradient,
493 strain, strain_dot, velocity, acceleration, stress, d_stress_d_strain,
494 d_stress_d_strain_dot, d_stress_d_time, inertia_force, density);
495 }
496
497 virtual bool has_shell_stress_interface() const { return false; }
498
500 virtual void get_static_nonlinear_shell_stress(
501 Model* model, const EquilibriumSolution equilibrium_solution, const double time,
502 const double delta_time, GradientContainer* gradient_container, SolverHints* solver_hints,
503 const Element* element, const double el_coordinates[2],
504 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
505 const T bg_coordinates[3], const T covariant_base[6][3], const bool use_covariant_base,
506 const T displacement_gradient[6][3], const T shell_strain[8], T shell_stress[8],
507 T d_shell_stress_d_strain[36], T d_shell_stress_d_time[8]) {
508 UnimplementedError() << THROW;
509 }
510
512 virtual void set_static_nonlinear_shell_stress(
513 Model* model, const double time, const double delta_time,
514 GradientContainer* gradient_container, const Element* element,
515 const double el_coordinates[2],
516 const b2linalg::Vector<T, b2linalg::Vdense_constref> nodes_interpolation,
517 const T bg_coordinates[3], const T covariant_base[6][3], const bool use_covariant_base,
518 const T displacement_gradient[6][3], const T shell_strain[8], const T shell_stress[8],
519 const T d_shell_stress_d_ec[2][8]) {
520 UnimplementedError() << THROW;
521 }
522
524 virtual void get_shell_stress(
525 Model* model, const EquilibriumSolution equilibrium_solution, const double time,
526 const double delta_time, GradientContainer* gradient_container, SolverHints* solver_hints,
527 const Element* element, const double el_coordinates[2],
528 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
529 const T bg_coordinates[3], const T covariant_base[6][3], const bool use_covariant_base,
530 const T volume, const T displacement_gradient[6][3], const T shell_strain[8],
531 const T strain_dot[8], const T velocity[6], const T acceleration[6], T shell_stress[8],
532 T d_shell_stress_d_strain[36], T d_stress_d_strain_dot[36], T d_shell_stress_d_time[8],
533 T d_stress_d_time[6], T inertia_force[6], T density[3]) {
534 UnimplementedError() << THROW;
535 }
536
537 virtual T get_drill_stiffness() const {
538 UnimplementedError() << THROW;
539 return T(0);
540 }
541
542 virtual T get_inplane_shear_modulus(const int layer_id) const {
543 UnimplementedError() << THROW;
544 return T(0);
545 }
546};
547
561template <typename T>
562class SolidMechanics2D : virtual public SolidMechanics {
563public:
573 virtual LinearType linear(const int layer_id = -1) const { return yes; }
574
583 virtual bool isotropic(const int layer_id = -1) const { return true; }
584
594 virtual bool path_dependent(const int layer_id = -1) const { return false; }
595
597 // 1 path dependent material.
598 virtual SolidMechanics2D<T>* copy(int layer_) {
599 Exception() << "This object is not mutable." << THROW;
600 return 0;
601 }
602
603 // Return the number of layer of the model.
604 virtual int number_of_layer() const { return 1; }
605
606 virtual void laminate(
607 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
608 T& laminate_begin, T& laminate_end) const {
609 UnimplementedError() << THROW;
610 }
611
612 T laminate_thickness(
613 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation) const {
614 T laminate_begin, laminate_end;
615 laminate(nodes_interpolation, laminate_begin, laminate_end);
616 return laminate_end - laminate_begin;
617 }
618
619 virtual void layer(
620 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
621 const int layer_id, T& layer_begin, T& layer_end) const {
622 UnimplementedError() << THROW;
623 }
624
625 T layer_thickness(
626 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation) const {
627 T layer_begin, layer_end;
628 layer(nodes_interpolation, layer_begin, layer_end);
629 return layer_end - layer_begin;
630 }
631
632 virtual void get_stress(
633 Model* model, const bool linear, const EquilibriumSolution equilibrium_solution,
634 const double time, const double delta_time, GradientContainer* gradient_container,
635 SolverHints* solver_hints, const Element* element, const double el_coordinates[2],
636 const int layer_id,
637 const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
638 const T bg_coordinates[3], const T covariant_base[2][2], const bool use_covariant_base,
639 const T volume, const T displacement_gradient[2][2], const T strain[3],
640 const T strain_dot[3], const T velocity[2], const T acceleration[2], T stress[3],
641 T d_stress_d_strain[6], T d_stress_d_strain_dot[6], T d_stress_d_time[3],
642 T inertia_force[2], T& density) {
643 UnimplementedError() << THROW;
644 }
645
646 virtual T get_density(const int layer_id) const {
647 UnimplementedError() << THROW;
648 return T(0);
649 }
650};
651} // namespace b2000
652#endif // B2SOLID_MECHANICS_H_
THROW
#define THROW
Definition b2exception.H:198
b2000::ElementProperty
Definition b2element.H:71
b2000::Element
Defines the complete interface for Element instances (C++ representations of Finite Elements).
Definition b2element.H:156
b2000::Exception
Definition b2exception.H:131
b2000::GradientContainer
Definition b2solution.H:54
b2000::Model
Definition b2model.H:69
b2000::SolidMechanics25D
Definition b2solid_mechanics.H:313
b2000::SolidMechanics25D::get_shell_stress
virtual void get_shell_stress(Model *model, const EquilibriumSolution equilibrium_solution, const double time, const double delta_time, GradientContainer *gradient_container, SolverHints *solver_hints, const Element *element, const double el_coordinates[2], const b2linalg::Vector< double, b2linalg::Vdense_constref > nodes_interpolation, const T bg_coordinates[3], const T covariant_base[6][3], const bool use_covariant_base, const T volume, const T displacement_gradient[6][3], const T shell_strain[8], const T strain_dot[8], const T velocity[6], const T acceleration[6], T shell_stress[8], T d_shell_stress_d_strain[36], T d_stress_d_strain_dot[36], T d_shell_stress_d_time[8], T d_stress_d_time[6], T inertia_force[6], T density[3])
Definition b2solid_mechanics.H:524
b2000::SolidMechanics25D::linear
virtual LinearType linear(const int layer_id=-1) const
Definition b2solid_mechanics.H:324
b2000::SolidMechanics25D::isotropic
virtual bool isotropic(const int layer_id=-1) const
Definition b2solid_mechanics.H:334
b2000::SolidMechanics25D::copy
virtual SolidMechanics25D< T > * copy(int layer_)
Definition b2solid_mechanics.H:349
b2000::SolidMechanics25D::get_static_nonlinear_shell_stress
virtual void get_static_nonlinear_shell_stress(Model *model, const EquilibriumSolution equilibrium_solution, const double time, const double delta_time, GradientContainer *gradient_container, SolverHints *solver_hints, const Element *element, const double el_coordinates[2], const b2linalg::Vector< double, b2linalg::Vdense_constref > nodes_interpolation, const T bg_coordinates[3], const T covariant_base[6][3], const bool use_covariant_base, const T displacement_gradient[6][3], const T shell_strain[8], T shell_stress[8], T d_shell_stress_d_strain[36], T d_shell_stress_d_time[8])
Definition b2solid_mechanics.H:500
b2000::SolidMechanics25D::path_dependent
virtual bool path_dependent(const int layer_id=-1) const
Definition b2solid_mechanics.H:345
b2000::SolidMechanics25D::set_static_nonlinear_shell_stress
virtual void set_static_nonlinear_shell_stress(Model *model, const double time, const double delta_time, GradientContainer *gradient_container, const Element *element, const double el_coordinates[2], const b2linalg::Vector< T, b2linalg::Vdense_constref > nodes_interpolation, const T bg_coordinates[3], const T covariant_base[6][3], const bool use_covariant_base, const T displacement_gradient[6][3], const T shell_strain[8], const T shell_stress[8], const T d_shell_stress_d_ec[2][8])
Definition b2solid_mechanics.H:512
b2000::SolidMechanics2D
Definition b2solid_mechanics.H:562
b2000::SolidMechanics2D::copy
virtual SolidMechanics2D< T > * copy(int layer_)
Create a copy of the object to be used in nonlinear analysis of.
Definition b2solid_mechanics.H:598
b2000::SolidMechanics2D::linear
virtual LinearType linear(const int layer_id=-1) const
Definition b2solid_mechanics.H:573
b2000::SolidMechanics2D::isotropic
virtual bool isotropic(const int layer_id=-1) const
Definition b2solid_mechanics.H:583
b2000::SolidMechanics2D::path_dependent
virtual bool path_dependent(const int layer_id=-1) const
Definition b2solid_mechanics.H:594
b2000::SolidMechanics3D
Definition b2solid_mechanics.H:113
b2000::SolidMechanics3D::linear
virtual LinearType linear(const int layer_id=-1) const
Definition b2solid_mechanics.H:124
b2000::SolidMechanics3D::isotropic
virtual bool isotropic(const int layer_id=-1) const
Definition b2solid_mechanics.H:134
b2000::SolidMechanics3D::path_dependent
virtual bool path_dependent(const int layer_id=-1) const
Definition b2solid_mechanics.H:145
b2000::SolidMechanics3D::copy
virtual SolidMechanics3D< T > * copy(int layer_)
Definition b2solid_mechanics.H:149
b2000::SolidMechanicsRod
The base class of the material API for rod elements.
Definition b2solid_mechanics.H:36
b2000::SolidMechanicsRod::copy
SolidMechanicsRod< T > * copy() override
Definition b2solid_mechanics.H:72
b2000::SolidMechanicsRod::isotropic
virtual bool isotropic(const int layer_id=-1) const
Definition b2solid_mechanics.H:57
b2000::SolidMechanicsRod::linear
virtual LinearType linear(const int layer_id=-1) const
Definition b2solid_mechanics.H:47
b2000::SolidMechanicsRod::path_dependent
virtual bool path_dependent(const int layer_id=-1) const
Definition b2solid_mechanics.H:68
b2000::SolidMechanics
The base class of the material API for use by stress elements.
Definition b2solid_mechanics.H:29
b2000::SolverHints
Definition b2solver.H:168
b2000
Contains the base classes for implementing Finite Elements.
Definition b2boundary_condition.H:32
b2000::UnimplementedError
GenericException< UnimplementedError_name > UnimplementedError
Definition b2exception.H:314
b2000::EquilibriumSolution
Definition b2type.H:72