OGS
SmallDeformationNonlocalFEM.h
Go to the documentation of this file.
1
11#pragma once
12
13#include <algorithm>
14#include <limits>
15#include <memory>
16#include <vector>
17
18#include "Damage.h"
37
38namespace ProcessLib
39{
40namespace SmallDeformationNonlocal
41{
42namespace MPL = MaterialPropertyLib;
43
46template <typename ShapeMatrixType>
48{
49 std::vector<ShapeMatrixType, Eigen::aligned_allocator<ShapeMatrixType>> N;
50};
51
52template <typename ShapeFunction, int DisplacementDim>
55{
56public:
64
70 using IpData =
72
77
79 MeshLib::Element const& e,
80 std::size_t const /*local_matrix_size*/,
81 NumLib::GenericIntegrationMethod const& integration_method,
82 bool const is_axially_symmetric,
84 : _process_data(process_data),
85 _integration_method(integration_method),
86 _element(e),
87 _is_axially_symmetric(is_axially_symmetric)
88 {
89 unsigned const n_integration_points =
91
92 _ip_data.reserve(n_integration_points);
93 _secondary_data.N.resize(n_integration_points);
94
95 auto const shape_matrices =
97 DisplacementDim>(e, is_axially_symmetric,
99
100 auto& solid_material =
102 _process_data.solid_materials,
103 _process_data.material_ids,
104 e.getID());
105 auto* ehlers_solid_material = dynamic_cast<
107 &solid_material);
108 if (ehlers_solid_material == nullptr)
109 {
110 OGS_FATAL(
111 "The SmallDeformationNonlocalLocal process supports only "
112 "Ehlers material at the moment. For other materials the "
113 "interface must be extended first.");
114 }
115
116 for (unsigned ip = 0; ip < n_integration_points; ip++)
117 {
118 _ip_data.emplace_back(*ehlers_solid_material);
119 auto& ip_data = _ip_data[ip];
120 auto const& sm = shape_matrices[ip];
121 _ip_data[ip].integration_weight =
123 sm.integralMeasure * sm.detJ;
124
125 ip_data.N = sm.N;
126 ip_data.dNdx = sm.dNdx;
127
128 // Initialize current time step values
129 ip_data.sigma.setZero(
131 DisplacementDim));
133 DisplacementDim));
134
135 // Previous time step values are not initialized and are set later.
136 ip_data.sigma_prev.resize(
138 DisplacementDim));
139 ip_data.eps_prev.resize(
141 DisplacementDim));
142
143 _secondary_data.N[ip] = shape_matrices[ip].N;
144
145 ip_data.coordinates = getSingleIntegrationPointCoordinates(ip);
146 }
147 }
148
149 std::size_t setIPDataInitialConditions(std::string const& name,
150 double const* values,
151 int const integration_order) override
152 {
153 if (integration_order !=
154 static_cast<int>(_integration_method.getIntegrationOrder()))
155 {
156 OGS_FATAL(
157 "Setting integration point initial conditions; The integration "
158 "order of the local assembler for element {:d} is different "
159 "from the integration order in the initial condition.",
160 _element.getID());
161 }
162
163 if (name == "sigma_ip")
164 {
165 return setSigma(values);
166 }
167
168 if (name == "kappa_d_ip")
169 {
172 }
173
174 return 0;
175 }
176
178 std::string const& name, std::vector<double> const& value) override
179 {
180 if (name == "kappa_d_ip")
181 {
182 if (value.size() != 1)
183 {
184 OGS_FATAL(
185 "CellData for kappa_d initial conditions has wrong number "
186 "of components. 1 expected, got {:d}.",
187 value.size());
188 }
189 setKappaD(value[0]);
190 }
191 }
192
193 double alpha_0(double const distance2) const
194 {
195 double const internal_length2 = _process_data.internal_length_squared;
196 return (distance2 > internal_length2)
197 ? 0
198 : (1 - distance2 / (internal_length2)) *
199 (1 - distance2 / (internal_length2));
200 }
201
203 std::size_t const /*mesh_item_id*/,
204 std::vector<
206 DisplacementDim>>> const& local_assemblers) override
207 {
208 auto const search_element_ids = MeshLib::findElementsWithinRadius(
209 _element, _process_data.internal_length_squared);
210
211 unsigned const n_integration_points =
213
214 std::vector<double> distances; // Cache for ip-ip distances.
215 //
216 // For every integration point in this element collect the neighbouring
217 // integration points falling in given radius (internal length) and
218 // compute the alpha_kl weight.
219 //
220 for (unsigned k = 0; k < n_integration_points; k++)
221 {
222 //
223 // Collect the integration points.
224 //
225
226 auto const& xyz = _ip_data[k].coordinates;
227
228 // For all neighbors of element
229 for (auto const search_element_id : search_element_ids)
230 {
231 auto const& la = local_assemblers[search_element_id];
232 la->getIntegrationPointCoordinates(xyz, distances);
233 for (int ip = 0; ip < static_cast<int>(distances.size()); ++ip)
234 {
235 if (distances[ip] >= _process_data.internal_length_squared)
236 {
237 continue;
238 }
239 // save into current ip_k
240 _ip_data[k].non_local_assemblers.push_back(
241 {la->getIPDataPtr(ip),
242 std::numeric_limits<double>::quiet_NaN(),
243 distances[ip]});
244 }
245 }
246 if (_ip_data[k].non_local_assemblers.size() == 0)
247 {
248 OGS_FATAL("no neighbours found!");
249 }
250
251 double a_k_sum_m = 0;
252 for (auto const& tuple : _ip_data[k].non_local_assemblers)
253 {
254 double const distance2_m = tuple.distance2;
255
256 auto const& w_m = tuple.ip_l_pointer->integration_weight;
257
258 a_k_sum_m += w_m * alpha_0(distance2_m);
259 }
260
261 //
262 // Calculate alpha_kl =
263 // alpha_0(|x_k - x_l|) / int_{m \in ip} alpha_0(|x_k - x_m|)
264 //
265 for (auto& tuple : _ip_data[k].non_local_assemblers)
266 {
267 double const distance2_l = tuple.distance2;
268 double const a_kl = alpha_0(distance2_l) / a_k_sum_m;
269
270 // Store the a_kl already multiplied with the integration
271 // weight of that l integration point.
272 auto const w_l = tuple.ip_l_pointer->integration_weight;
273 tuple.alpha_kl_times_w_l = a_kl * w_l;
274 }
275 }
276 }
277
279 int integration_point) const
280 {
281 auto const& N = _secondary_data.N[integration_point];
282
283 Eigen::Vector3d xyz = Eigen::Vector3d::Zero(); // Resulting coordinates
284 auto* nodes = _element.getNodes();
285 for (int i = 0; i < N.size(); ++i)
286 {
287 auto const& node_coordinates{nodes[i]->asEigenVector3d()};
288 xyz += node_coordinates * N[i];
289 }
290 return xyz;
291 }
292
297 Eigen::Vector3d const& coords,
298 std::vector<double>& distances) const override
299 {
300 unsigned const n_integration_points =
302
303 distances.resize(n_integration_points);
304
305 for (unsigned ip = 0; ip < n_integration_points; ip++)
306 {
307 auto const& xyz = _ip_data[ip].coordinates;
308 distances[ip] = (xyz - coords).squaredNorm();
309 }
310 }
311
312 void assemble(double const /*t*/, double const /*dt*/,
313 std::vector<double> const& /*local_x*/,
314 std::vector<double> const& /*local_x_prev*/,
315 std::vector<double>& /*local_M_data*/,
316 std::vector<double>& /*local_K_data*/,
317 std::vector<double>& /*local_b_data*/) override
318 {
319 OGS_FATAL(
320 "SmallDeformationNonlocalLocalAssembler: assembly without jacobian "
321 "is not "
322 "implemented.");
323 }
324
325 void preAssemble(double const t, double const dt,
326 std::vector<double> const& local_x) override
327 {
328 auto const n_integration_points =
330
331 MPL::VariableArray variables;
332 MPL::VariableArray variables_prev;
334 x_position.setElementID(_element.getID());
335
336 for (unsigned ip = 0; ip < n_integration_points; ip++)
337 {
338 x_position.setIntegrationPoint(ip);
339
340 auto const& N = _ip_data[ip].N;
341 auto const& dNdx = _ip_data[ip].dNdx;
342
343 auto const x_coord =
344 NumLib::interpolateXCoordinate<ShapeFunction,
346 auto const B = LinearBMatrix::computeBMatrix<
347 DisplacementDim, ShapeFunction::NPOINTS,
348 typename BMatricesType::BMatrixType>(dNdx, N, x_coord,
350 auto const& eps_prev = _ip_data[ip].eps_prev;
351 auto const& sigma_prev = _ip_data[ip].sigma_prev;
352
353 auto& eps = _ip_data[ip].eps;
354 auto& sigma = _ip_data[ip].sigma;
355 auto& C = _ip_data[ip].C;
356 auto& state = _ip_data[ip].material_state_variables;
357 double const& damage_prev = _ip_data[ip].damage_prev;
358
359 eps.noalias() =
360 B *
361 Eigen::Map<typename BMatricesType::NodalForceVectorType const>(
362 local_x.data(), ShapeFunction::NPOINTS * DisplacementDim);
363
364 // sigma is for plastic part only.
365 std::unique_ptr<
367 new_C;
368 std::unique_ptr<typename MaterialLib::Solids::MechanicsBase<
369 DisplacementDim>::MaterialStateVariables>
370 new_state;
371
372 // Compute sigma_eff from damage total stress sigma
373 using KelvinVectorType = typename BMatricesType::KelvinVectorType;
374 KelvinVectorType const sigma_eff_prev =
375 sigma_prev /
376 (1. - damage_prev); // damage_prev is in [0,1) range. See
377 // calculateDamage() function.
378
379 variables_prev.stress.emplace<
381 sigma_eff_prev);
382 variables_prev.mechanical_strain.emplace<
384 eps_prev);
385 variables_prev.temperature = _process_data.reference_temperature;
386 variables.mechanical_strain.emplace<
388 variables.temperature = _process_data.reference_temperature;
389
390 auto&& solution = _ip_data[ip].solid_material.integrateStress(
391 variables_prev, variables, t, x_position, dt, *state);
392
393 if (!solution)
394 {
395 OGS_FATAL("Computation of local constitutive relation failed.");
396 }
397
398 std::tie(sigma, state, C) = std::move(*solution);
399
401 {
402 auto const& ehlers_material =
404 DisplacementDim> const&>(_ip_data[ip].solid_material);
405 auto const damage_properties =
406 ehlers_material.evaluatedDamageProperties(t, x_position);
407 auto const material_properties =
408 ehlers_material.evaluatedMaterialProperties(t, x_position);
409
410 // Ehlers material state variables
411 auto& state_vars =
413 DisplacementDim>&>(
414 *_ip_data[ip].material_state_variables);
415
416 double const eps_p_eff_diff =
417 state_vars.eps_p.eff - state_vars.eps_p_prev.eff;
418
419 _ip_data[ip].kappa_d = calculateDamageKappaD<DisplacementDim>(
420 eps_p_eff_diff, sigma, _ip_data[ip].kappa_d_prev,
421 damage_properties.h_d, material_properties);
422
423 if (!_ip_data[ip].active_self)
424 {
425 _ip_data[ip].active_self |= _ip_data[ip].kappa_d > 0;
426 if (_ip_data[ip].active_self)
427 {
428 for (auto const& tuple :
429 _ip_data[ip].non_local_assemblers)
430 {
431 // Activate the integration point.
432 tuple.ip_l_pointer->activated = true;
433 }
434 }
435 }
436 }
437 }
438 }
439
440 void assembleWithJacobian(double const t, double const /*dt*/,
441 std::vector<double> const& local_x,
442 std::vector<double> const& /*local_x_prev*/,
443 std::vector<double>& /*local_M_data*/,
444 std::vector<double>& /*local_K_data*/,
445 std::vector<double>& local_b_data,
446 std::vector<double>& local_Jac_data) override
447 {
448 auto const local_matrix_size = local_x.size();
449
450 auto local_Jac = MathLib::createZeroedMatrix<StiffnessMatrixType>(
451 local_Jac_data, local_matrix_size, local_matrix_size);
452
453 auto local_b = MathLib::createZeroedVector<NodalDisplacementVectorType>(
454 local_b_data, local_matrix_size);
455
456 unsigned const n_integration_points =
458
460 x_position.setElementID(_element.getID());
461
462 // Non-local integration.
463 for (unsigned ip = 0; ip < n_integration_points; ip++)
464 {
465 x_position.setIntegrationPoint(ip);
466 auto const& w = _ip_data[ip].integration_weight;
467
468 auto const& N = _ip_data[ip].N;
469 auto const& dNdx = _ip_data[ip].dNdx;
470
471 auto const x_coord =
472 NumLib::interpolateXCoordinate<ShapeFunction,
474 auto const B = LinearBMatrix::computeBMatrix<
475 DisplacementDim, ShapeFunction::NPOINTS,
476 typename BMatricesType::BMatrixType>(dNdx, N, x_coord,
478
479 auto& sigma = _ip_data[ip].sigma;
480 auto& C = _ip_data[ip].C;
481 double& damage = _ip_data[ip].damage;
482
483 {
484 double nonlocal_kappa_d = 0;
485
486 if (_ip_data[ip].active_self || _ip_data[ip].activated)
487 {
488 for (auto const& tuple : _ip_data[ip].non_local_assemblers)
489 {
490 // Get local variable for the integration point l.
491 double const kappa_d_l = tuple.ip_l_pointer->kappa_d;
492 double const a_kl_times_w_l = tuple.alpha_kl_times_w_l;
493 nonlocal_kappa_d += a_kl_times_w_l * kappa_d_l;
494 }
495 }
496
497 auto const& ehlers_material =
499 DisplacementDim> const&>(_ip_data[ip].solid_material);
500
501 //
502 // Overnonlocal formulation
503 //
504 // See (Di Luzio & Bazant 2005, IJSS) for details.
505 // The implementation would go here and would be for a given
506 // gamma_nonlocal:
507 //
508 // Update nonlocal damage with local damage (scaled with 1 -
509 // \gamma_{nonlocal}) for the current integration point and the
510 // nonlocal integral part.
511 // nonlocal_kappa_d = (1. - gamma_nonlocal) * kappa_d +
512 // gamma_nonlocal * nonlocal_kappa_d;
513
514 nonlocal_kappa_d = std::max(0., nonlocal_kappa_d);
515
516 // Update damage based on nonlocal kappa_d
517 {
518 auto const damage_properties =
519 ehlers_material.evaluatedDamageProperties(t,
520 x_position);
521 damage = calculateDamage(nonlocal_kappa_d,
522 damage_properties.alpha_d,
523 damage_properties.beta_d);
524 damage = std::max(0., damage);
525 }
526 sigma = sigma * (1. - damage);
527 }
528
529 local_b.noalias() -= B.transpose() * sigma * w;
530 local_Jac.noalias() += B.transpose() * C * (1. - damage) * B * w;
531 }
532 }
533
534 void initializeConcrete() override
535 {
536 unsigned const n_integration_points =
538
539 for (unsigned ip = 0; ip < n_integration_points; ip++)
540 {
541 _ip_data[ip].pushBackState();
542 }
543 }
544
545 void postTimestepConcrete(Eigen::VectorXd const& /*local_x*/,
546 Eigen::VectorXd const& /*local_x_prev*/,
547 double const /*t*/, double const /*dt*/,
548 bool const /*use_monolithic_scheme*/,
549 int const /*process_id*/) override
550 {
551 unsigned const n_integration_points =
553
554 for (unsigned ip = 0; ip < n_integration_points; ip++)
555 {
556 _ip_data[ip].pushBackState();
557 }
558 }
559
560 void computeCrackIntegral(std::size_t mesh_item_id,
561 NumLib::LocalToGlobalIndexMap const& dof_table,
562 GlobalVector const& x,
563 double& crack_volume) override
564 {
565 auto const indices = NumLib::getIndices(mesh_item_id, dof_table);
566 auto local_x = x.get(indices);
567
568 auto u = Eigen::Map<typename BMatricesType::NodalForceVectorType const>(
569 local_x.data(), ShapeFunction::NPOINTS * DisplacementDim);
570
571 int const n_integration_points =
573
574 for (int ip = 0; ip < n_integration_points; ip++)
575 {
576 auto const& dNdx = _ip_data[ip].dNdx;
577 auto const& d = _ip_data[ip].damage;
578 auto const& w = _ip_data[ip].integration_weight;
579
580 double const div_u =
581 Deformation::divergence<DisplacementDim,
582 ShapeFunction::NPOINTS>(u, dNdx);
583 crack_volume += div_u * d * w;
584 }
585 }
586
587 Eigen::Map<const Eigen::RowVectorXd> getShapeMatrix(
588 const unsigned integration_point) const override
589 {
590 auto const& N = _secondary_data.N[integration_point];
591
592 // assumes N is stored contiguously in memory
593 return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
594 }
595
596 std::vector<double> const& getNodalValues(
597 std::vector<double>& nodal_values) const override
598 {
599 nodal_values.clear();
600 auto local_b = MathLib::createZeroedVector<NodalDisplacementVectorType>(
601 nodal_values, ShapeFunction::NPOINTS * DisplacementDim);
602
603 unsigned const n_integration_points =
605
606 for (unsigned ip = 0; ip < n_integration_points; ip++)
607 {
608 auto const& w = _ip_data[ip].integration_weight;
609
610 auto const& N = _ip_data[ip].N;
611 auto const& dNdx = _ip_data[ip].dNdx;
612
613 auto const x_coord =
614 NumLib::interpolateXCoordinate<ShapeFunction,
616 auto const B = LinearBMatrix::computeBMatrix<
617 DisplacementDim, ShapeFunction::NPOINTS,
618 typename BMatricesType::BMatrixType>(dNdx, N, x_coord,
620 auto& sigma = _ip_data[ip].sigma;
621
622 local_b.noalias() += B.transpose() * sigma * w;
623 }
624
625 return nodal_values;
626 }
627
628 std::vector<double> const& getIntPtFreeEnergyDensity(
629 const double /*t*/,
630 std::vector<GlobalVector*> const& /*x*/,
631 std::vector<NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
632 std::vector<double>& cache) const override
633 {
634 cache.clear();
635 cache.reserve(_ip_data.size());
636
637 transform(cbegin(_ip_data), cend(_ip_data), back_inserter(cache),
638 [](auto const& ip_data)
639 { return ip_data.free_energy_density; });
640
641 return cache;
642 }
643
644 std::vector<double> const& getIntPtEpsPV(
645 const double /*t*/,
646 std::vector<GlobalVector*> const& /*x*/,
647 std::vector<NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
648 std::vector<double>& cache) const override
649 {
650 cache.clear();
651 cache.reserve(_ip_data.size());
652
653 transform(cbegin(_ip_data), cend(_ip_data), back_inserter(cache),
654 [](auto const& ip_data) { return *ip_data.eps_p_V; });
655
656 return cache;
657 }
658
659 std::vector<double> const& getIntPtEpsPDXX(
660 const double /*t*/,
661 std::vector<GlobalVector*> const& /*x*/,
662 std::vector<NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
663 std::vector<double>& cache) const override
664 {
665 cache.clear();
666 cache.reserve(_ip_data.size());
667
668 transform(cbegin(_ip_data), cend(_ip_data), back_inserter(cache),
669 [](auto const& ip_data) { return *ip_data.eps_p_D_xx; });
670
671 return cache;
672 }
673
674 std::vector<double> const& getIntPtSigma(
675 const double /*t*/,
676 std::vector<GlobalVector*> const& /*x*/,
677 std::vector<NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
678 std::vector<double>& cache) const override
679 {
680 return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
681 _ip_data, &IpData::sigma, cache);
682 }
683
684 std::vector<double> const& getIntPtEpsilon(
685 const double /*t*/,
686 std::vector<GlobalVector*> const& /*x*/,
687 std::vector<NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
688 std::vector<double>& cache) const override
689 {
690 return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
691 _ip_data, &IpData::eps, cache);
692 }
693
694 std::size_t setSigma(double const* values)
695 {
696 return ProcessLib::setIntegrationPointKelvinVectorData<DisplacementDim>(
697 values, _ip_data, &IpData::sigma);
698 }
699
700 // TODO (naumov) This method is same as getIntPtSigma but for arguments and
701 // the ordering of the cache_mat.
702 // There should be only one.
703 std::vector<double> getSigma() const override
704 {
705 return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
707 }
708
709 void setKappaD(double value)
710 {
711 for (auto& ip_data : _ip_data)
712 {
713 ip_data.kappa_d = value;
714 }
715 }
716 std::vector<double> getKappaD() const override
717 {
718 unsigned const n_integration_points =
720
721 std::vector<double> result_values;
722 result_values.resize(n_integration_points);
723
724 for (unsigned ip = 0; ip < n_integration_points; ++ip)
725 {
726 result_values[ip] = _ip_data[ip].kappa_d;
727 }
728
729 return result_values;
730 }
731
732 std::vector<double> const& getIntPtDamage(
733 const double /*t*/,
734 std::vector<GlobalVector*> const& /*x*/,
735 std::vector<NumLib::LocalToGlobalIndexMap const*> const& /*dof_table*/,
736 std::vector<double>& cache) const override
737 {
739 _ip_data, &IpData::damage, cache);
740 }
741
742 unsigned getNumberOfIntegrationPoints() const override
743 {
745 }
746
748 DisplacementDim>::MaterialStateVariables const&
749 getMaterialStateVariablesAt(int const integration_point) const override
750 {
751 return *_ip_data[integration_point].material_state_variables;
752 }
753
754private:
755 std::vector<double> const& getIntPtSigma(std::vector<double>& cache,
756 std::size_t const component) const
757 {
758 cache.clear();
759 cache.reserve(_ip_data.size());
760
761 for (auto const& ip_data : _ip_data)
762 {
763 if (component < 3)
764 { // xx, yy, zz components
765 cache.push_back(ip_data.sigma[component]);
766 }
767 else
768 { // mixed xy, yz, xz components
769 cache.push_back(ip_data.sigma[component] / std::sqrt(2));
770 }
771 }
772
773 return cache;
774 }
775
776 std::vector<double> const& getIntPtEpsilon(
777 std::vector<double>& cache, std::size_t const component) const
778 {
779 cache.clear();
780 cache.reserve(_ip_data.size());
781
782 for (auto const& ip_data : _ip_data)
783 {
784 if (component < 3) // xx, yy, zz components
785 cache.push_back(ip_data.eps[component]);
786 else // mixed xy, yz, xz components
787 cache.push_back(ip_data.eps[component] / std::sqrt(2));
788 }
789
790 return cache;
791 }
792
794 {
795 return &_ip_data[ip];
796 }
797
798private:
800
801 std::vector<IpData, Eigen::aligned_allocator<IpData>> _ip_data;
802
807
808 static const int displacement_size =
809 ShapeFunction::NPOINTS * DisplacementDim;
810};
811
812} // namespace SmallDeformationNonlocal
813} // namespace ProcessLib
#define OGS_FATAL(...)
Definition: Error.h:26
DamageProperties evaluatedDamageProperties(double const t, ParameterLib::SpatialPosition const &x) const
Definition: Ehlers.h:343
std::variant< std::monostate, Eigen::Matrix< double, 4, 1 >, Eigen::Matrix< double, 6, 1 > > mechanical_strain
Definition: VariableType.h:182
std::variant< std::monostate, Eigen::Matrix< double, 4, 1 >, Eigen::Matrix< double, 6, 1 > > stress
Definition: VariableType.h:192
Global vector based on Eigen vector.
Definition: EigenVector.h:25
double get(IndexType rowId) const
get entry
Definition: EigenVector.h:58
Eigen::Vector3d const & asEigenVector3d() const
Definition: Point3d.h:67
double getWeight() const
Definition: WeightedPoint.h:80
virtual Node *const * getNodes() const =0
Get array of element nodes.
virtual std::size_t getID() const final
Returns the ID of the element.
Definition: Element.h:89
MathLib::WeightedPoint const & getWeightedPoint(unsigned const igp) const
void setElementID(std::size_t element_id)
void setIntegrationPoint(unsigned integration_point)
MatrixType< _kelvin_vector_size, _number_of_dof > BMatrixType
Definition: BMatrixPolicy.h:55
MatrixType< _number_of_dof, _number_of_dof > StiffnessMatrixType
Definition: BMatrixPolicy.h:41
VectorType< _number_of_dof > NodalForceVectorType
Rhs residual.
Definition: BMatrixPolicy.h:44
VectorType< _kelvin_vector_size > KelvinVectorType
Definition: BMatrixPolicy.h:48
void computeCrackIntegral(std::size_t mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double &crack_volume) override
std::vector< double > const & getIntPtEpsilon(std::vector< double > &cache, std::size_t const component) const
void assemble(double const, double const, std::vector< double > const &, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &) override
IntegrationPointDataNonlocalInterface * getIPDataPtr(int const ip) override
SmallDeformationNonlocalLocalAssembler(MeshLib::Element const &e, std::size_t const, NumLib::GenericIntegrationMethod const &integration_method, bool const is_axially_symmetric, SmallDeformationNonlocalProcessData< DisplacementDim > &process_data)
void setIPDataInitialConditionsFromCellData(std::string const &name, std::vector< double > const &value) override
void nonlocal(std::size_t const, std::vector< std::unique_ptr< SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim > > > const &local_assemblers) override
std::vector< double > const & getIntPtSigma(std::vector< double > &cache, std::size_t const component) const
void assembleWithJacobian(double const t, double const, std::vector< double > const &local_x, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data) override
Eigen::Map< const Eigen::RowVectorXd > getShapeMatrix(const unsigned integration_point) const override
Provides the shape matrix at the given integration point.
std::vector< double > const & getIntPtEpsPDXX(const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
MaterialLib::Solids::MechanicsBase< DisplacementDim >::MaterialStateVariables const & getMaterialStateVariablesAt(int const integration_point) const override
std::vector< double > const & getIntPtEpsPV(const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
void preAssemble(double const t, double const dt, std::vector< double > const &local_x) override
std::vector< double > const & getIntPtFreeEnergyDensity(const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
SmallDeformationNonlocalLocalAssembler(SmallDeformationNonlocalLocalAssembler const &)=delete
std::vector< double > const & getIntPtSigma(const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
std::size_t setIPDataInitialConditions(std::string const &name, double const *values, int const integration_order) override
std::vector< double > const & getIntPtEpsilon(const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
ShapeMatrixPolicyType< ShapeFunction, DisplacementDim > ShapeMatricesType
void postTimestepConcrete(Eigen::VectorXd const &, Eigen::VectorXd const &, double const, double const, bool const, int const) override
void getIntegrationPointCoordinates(Eigen::Vector3d const &coords, std::vector< double > &distances) const override
std::vector< double > const & getNodalValues(std::vector< double > &nodal_values) const override
SmallDeformationNonlocalLocalAssembler(SmallDeformationNonlocalLocalAssembler &&)=delete
std::vector< double > const & getIntPtDamage(const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override
auto & selectSolidConstitutiveRelation(SolidMaterialsMap const &constitutive_relations, MeshLib::PropertyVector< int > const *const material_ids, std::size_t const element_id)
Eigen::Matrix< double, kelvin_vector_dimensions(DisplacementDim), 1, Eigen::ColMajor > KelvinVectorType
Definition: KelvinVector.h:49
constexpr int kelvin_vector_dimensions(int const displacement_dim)
Kelvin vector dimensions for given displacement dimension.
Definition: KelvinVector.h:24
Eigen::Matrix< double, kelvin_vector_dimensions(DisplacementDim), kelvin_vector_dimensions(DisplacementDim), Eigen::RowMajor > KelvinMatrixType
Definition: KelvinVector.h:57
std::vector< std::size_t > findElementsWithinRadius(Element const &start_element, double const radius_squared)
double interpolateXCoordinate(MeshLib::Element const &e, typename ShapeMatricesType::ShapeMatrices::ShapeType const &N)
std::vector< GlobalIndexType > getIndices(std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)
std::vector< typename ShapeMatricesType::ShapeMatrices, Eigen::aligned_allocator< typename ShapeMatricesType::ShapeMatrices > > initShapeMatrices(MeshLib::Element const &e, bool const is_axially_symmetric, IntegrationMethod const &integration_method)
double divergence(const Eigen::Ref< Eigen::Matrix< double, NPOINTS *DisplacementDim, 1 > const > &u, DNDX_Type const &dNdx)
Divergence of displacement, the volumetric strain.
Definition: Divergence.h:19
BMatrixType computeBMatrix(DNDX_Type const &dNdx, N_Type const &N, const double radius, const bool is_axially_symmetric)
Fills a B-matrix based on given shape function dN/dx values.
Definition: LinearBMatrix.h:42
double calculateDamage(double const kappa_d, double const alpha_d, double const beta_d)
Definition: Damage.h:25
std::vector< double > const & getIntegrationPointScalarData(IntegrationPointDataVector const &ip_data_vector, MemberType IpData::*const member, std::vector< double > &cache)
std::size_t setIntegrationPointScalarData(double const *values, IntegrationPointDataVector &ip_data_vector, MemberType IpData::*const member)
MatrixType< ShapeFunction::NPOINTS, ShapeFunction::NPOINTS > NodalMatrixType
NumLib::ShapeMatrices< NodalRowVectorType, DimNodalMatrixType, DimMatrixType, GlobalDimNodalMatrixType > ShapeMatrices
VectorType< GlobalDim > GlobalDimVectorType
VectorType< ShapeFunction::NPOINTS > NodalVectorType
PlasticStrain< KelvinVector > eps_p
plastic part of the state.
Definition: Ehlers.h:244
std::vector< ShapeMatrixType, Eigen::aligned_allocator< ShapeMatrixType > > N
Definition: SecondaryData.h:27
std::vector< ShapeMatrixType, Eigen::aligned_allocator< ShapeMatrixType > > N