Detailed Description

template<typename ShapeFunction, typename IntegrationMethod, int DisplacementDim>
class ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >

Definition at line 53 of file SmallDeformationNonlocalFEM.h.

#include <SmallDeformationNonlocalFEM.h>

Inheritance diagram for ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >:

[legend]

Collaboration diagram for ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >:

[legend]

Public Types
using	ShapeMatricesType = ShapeMatrixPolicyType< ShapeFunction, DisplacementDim >

using	NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

using	NodalVectorType = typename ShapeMatricesType::NodalVectorType

using	GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

using	ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

using	BMatricesType = BMatrixPolicyType< ShapeFunction, DisplacementDim >

using	BMatrixType = typename BMatricesType::BMatrixType

using	StiffnessMatrixType = typename BMatricesType::StiffnessMatrixType

using	NodalForceVectorType = typename BMatricesType::NodalForceVectorType

using	NodalDisplacementVectorType = typename BMatricesType::NodalForceVectorType

using	IpData = IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >

Public Member Functions
	SmallDeformationNonlocalLocalAssembler (SmallDeformationNonlocalLocalAssembler const &)=delete

	SmallDeformationNonlocalLocalAssembler (SmallDeformationNonlocalLocalAssembler &&)=delete

	SmallDeformationNonlocalLocalAssembler (MeshLib::Element const &e, std::size_t const, bool const is_axially_symmetric, unsigned const integration_order, SmallDeformationNonlocalProcessData< DisplacementDim > &process_data)

std::size_t	setIPDataInitialConditions (std::string const &name, double const *values, int const integration_order) override

void	setIPDataInitialConditionsFromCellData (std::string const &name, std::vector< double > const &value) override

double	alpha_0 (double const distance2) const

void	nonlocal (std::size_t const, std::vector< std::unique_ptr< SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >>> const &local_assemblers) override

Eigen::Vector3d	getSingleIntegrationPointCoordinates (int integration_point) const

void	getIntegrationPointCoordinates (Eigen::Vector3d const &coords, std::vector< double > &distances) const override

void	assemble (double const, double const, std::vector< double > const &, std::vector< double > const &, std::vector< double > &, std::vector< double > &, std::vector< double > &) override

void	preAssemble (double const t, double const dt, std::vector< double > const &local_x) override

void	assembleWithJacobian (double const t, double const, std::vector< double > const &local_x, std::vector< double > const &, const double, const double, std::vector< double > &, std::vector< double > &, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data) override

void	initializeConcrete () override

void	postTimestepConcrete (Eigen::VectorXd const &, double const, double const) override

void	computeCrackIntegral (std::size_t mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double &crack_volume) override

Eigen::Map< const Eigen::RowVectorXd >	getShapeMatrix (const unsigned integration_point) const override
	Provides the shape matrix at the given integration point. More...

std::vector< double > const &	getNodalValues (std::vector< double > &nodal_values) const override

std::vector< double > const &	getIntPtFreeEnergyDensity (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) 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

std::vector< double > const &	getIntPtEpsPDXX (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override

std::vector< double > const &	getIntPtSigma (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override

std::vector< double > const &	getIntPtEpsilon (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override

std::size_t	setSigma (double const *values)

std::vector< double >	getSigma () const override

void	setKappaD (double value)

std::vector< double >	getKappaD () const override

std::vector< double > const &	getIntPtDamage (const double, std::vector< GlobalVector * > const &, std::vector< NumLib::LocalToGlobalIndexMap const * > const &, std::vector< double > &cache) const override

unsigned	getNumberOfIntegrationPoints () const override

MaterialLib::Solids::MechanicsBase< DisplacementDim >::MaterialStateVariables const &	getMaterialStateVariablesAt (int const integration_point) const override

Public Member Functions inherited from ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >
virtual void	nonlocal (std::size_t const mesh_item_id, std::vector< std::unique_ptr< SmallDeformationNonlocalLocalAssemblerInterface >> const &local_assemblers)=0

Public Member Functions inherited from ProcessLib::LocalAssemblerInterface
virtual	~LocalAssemblerInterface ()=default

void	setInitialConditions (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double const t, bool const use_monolithic_scheme, int const process_id)

virtual void	initialize (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table)

virtual void	assembleForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_xdot, int const process_id, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data)

virtual void	assembleWithJacobianForStaggeredScheme (double const t, double const dt, Eigen::VectorXd const &local_x, Eigen::VectorXd const &local_xdot, const double dxdot_dx, const double dx_dx, int const process_id, std::vector< double > &local_M_data, std::vector< double > &local_K_data, std::vector< double > &local_b_data, std::vector< double > &local_Jac_data)

virtual void	computeSecondaryVariable (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_dot, int const process_id)

virtual void	preTimestep (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, double const t, double const delta_t)

virtual void	postTimestep (std::size_t const mesh_item_id, std::vector< NumLib::LocalToGlobalIndexMap const * > const &dof_tables, std::vector< GlobalVector * > const &x, double const t, double const dt)

void	postNonLinearSolver (std::size_t const mesh_item_id, NumLib::LocalToGlobalIndexMap const &dof_table, GlobalVector const &x, GlobalVector const &xdot, double const t, double const dt, bool const use_monolithic_scheme, int const process_id)

virtual std::vector< double >	interpolateNodalValuesToIntegrationPoints (std::vector< double > const &)

virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< double > const &) const

virtual Eigen::Vector3d	getFlux (MathLib::Point3d const &, double const, std::vector< std::vector< double >> const &) const
	Fits to staggered scheme. More...

Public Member Functions inherited from NumLib::ExtrapolatableElement
virtual	~ExtrapolatableElement ()=default

Private Member Functions
std::vector< double > const &	getIntPtSigma (std::vector< double > &cache, std::size_t const component) const

std::vector< double > const &	getIntPtEpsilon (std::vector< double > &cache, std::size_t const component) const

IntegrationPointDataNonlocalInterface *	getIPDataPtr (int const ip) override

Private Attributes
SmallDeformationNonlocalProcessData< DisplacementDim > &	_process_data

std::vector< IpData, Eigen::aligned_allocator< IpData > >	_ip_data

IntegrationMethod const	_integration_method

MeshLib::Element const &	_element

SecondaryData< typename ShapeMatrices::ShapeType >	_secondary_data

bool const	_is_axially_symmetric

Static Private Attributes
static const int	displacement_size

Member Typedef Documentation

◆ BMatricesType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::BMatricesType = BMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 63 of file SmallDeformationNonlocalFEM.h.

◆ BMatrixType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::BMatrixType = typename BMatricesType::BMatrixType

Definition at line 65 of file SmallDeformationNonlocalFEM.h.

◆ GlobalDimVectorType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::GlobalDimVectorType = typename ShapeMatricesType::GlobalDimVectorType

Definition at line 61 of file SmallDeformationNonlocalFEM.h.

◆ IpData

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::IpData = IntegrationPointData<BMatricesType, ShapeMatricesType, DisplacementDim>

Definition at line 70 of file SmallDeformationNonlocalFEM.h.

◆ NodalDisplacementVectorType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::NodalDisplacementVectorType = typename BMatricesType::NodalForceVectorType

Definition at line 68 of file SmallDeformationNonlocalFEM.h.

◆ NodalForceVectorType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::NodalForceVectorType = typename BMatricesType::NodalForceVectorType

Definition at line 67 of file SmallDeformationNonlocalFEM.h.

◆ NodalMatrixType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::NodalMatrixType = typename ShapeMatricesType::NodalMatrixType

Definition at line 59 of file SmallDeformationNonlocalFEM.h.

◆ NodalVectorType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::NodalVectorType = typename ShapeMatricesType::NodalVectorType

Definition at line 60 of file SmallDeformationNonlocalFEM.h.

◆ ShapeMatrices

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ShapeMatrices = typename ShapeMatricesType::ShapeMatrices

Definition at line 62 of file SmallDeformationNonlocalFEM.h.

◆ ShapeMatricesType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::ShapeMatricesType = ShapeMatrixPolicyType<ShapeFunction, DisplacementDim>

Definition at line 57 of file SmallDeformationNonlocalFEM.h.

◆ StiffnessMatrixType

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::StiffnessMatrixType = typename BMatricesType::StiffnessMatrixType

Definition at line 66 of file SmallDeformationNonlocalFEM.h.

Constructor & Destructor Documentation

◆ SmallDeformationNonlocalLocalAssembler() [1/3]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::SmallDeformationNonlocalLocalAssembler ( SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim > const & )

delete

◆ SmallDeformationNonlocalLocalAssembler() [2/3]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::SmallDeformationNonlocalLocalAssembler ( SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim > && )

delete

◆ SmallDeformationNonlocalLocalAssembler() [3/3]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::SmallDeformationNonlocalLocalAssembler	(	MeshLib::Element const &	e,
		std::size_t const	,
		bool const	is_axially_symmetric,
		unsigned const	integration_order,
		SmallDeformationNonlocalProcessData< DisplacementDim > &	process_data
	)

inline

Definition at line 78 of file SmallDeformationNonlocalFEM.h.

         : _process_data(process_data),
           _integration_method(integration_order),
           _element(e),
           _is_axially_symmetric(is_axially_symmetric)
     {
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         _ip_data.reserve(n_integration_points);
         _secondary_data.N.resize(n_integration_points);
  
         auto const shape_matrices =
             NumLib::initShapeMatrices<ShapeFunction, ShapeMatricesType,
                                       DisplacementDim>(e, is_axially_symmetric,
                                                        _integration_method);
  
         auto& solid_material =
             MaterialLib::Solids::selectSolidConstitutiveRelation(
                 _process_data.solid_materials,
                 _process_data.material_ids,
                 e.getID());
         auto* ehlers_solid_material = dynamic_cast<
             MaterialLib::Solids::Ehlers::SolidEhlers<DisplacementDim>*>(
             &solid_material);
         if (ehlers_solid_material == nullptr)
         {
             OGS_FATAL(
                 "The SmallDeformationNonlocalLocal process supports only "
                 "Ehlers material at the moment. For other materials the "
                 "interface must be extended first.");
         }
  
         for (unsigned ip = 0; ip < n_integration_points; ip++)
         {
             _ip_data.emplace_back(*ehlers_solid_material);
             auto& ip_data = _ip_data[ip];
             auto const& sm = shape_matrices[ip];
             _ip_data[ip].integration_weight =
                 _integration_method.getWeightedPoint(ip).getWeight() *
                 sm.integralMeasure * sm.detJ;
  
             ip_data.N = sm.N;
             ip_data.dNdx = sm.dNdx;
  
             // Initialize current time step values
             ip_data.sigma.setZero(
                 MathLib::KelvinVector::kelvin_vector_dimensions(
                     DisplacementDim));
             ip_data.eps.setZero(MathLib::KelvinVector::kelvin_vector_dimensions(
                 DisplacementDim));
  
             // Previous time step values are not initialized and are set later.
             ip_data.sigma_prev.resize(
                 MathLib::KelvinVector::kelvin_vector_dimensions(
                     DisplacementDim));
             ip_data.eps_prev.resize(
                 MathLib::KelvinVector::kelvin_vector_dimensions(
                     DisplacementDim));
  
             _secondary_data.N[ip] = shape_matrices[ip].N;
  
             ip_data.coordinates = getSingleIntegrationPointCoordinates(ip);
         }
     }

Member Function Documentation

◆ alpha_0()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

double ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::alpha_0 ( double const distance2 ) const

inline

Definition at line 193 of file SmallDeformationNonlocalFEM.h.

     {
         double const internal_length2 = _process_data.internal_length_squared;
         return (distance2 > internal_length2)
                    ? 0
                    : (1 - distance2 / (internal_length2)) *
                          (1 - distance2 / (internal_length2));
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_process_data.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::nonlocal().

◆ assemble()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assemble	(	double const	,
		double const	,
		std::vector< double > const &	,
		std::vector< double > const &	,
		std::vector< double > &	,
		std::vector< double > &	,
		std::vector< double > &
	)

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 313 of file SmallDeformationNonlocalFEM.h.

     {
         OGS_FATAL(
             "SmallDeformationNonlocalLocalAssembler: assembly without jacobian "
             "is not "
             "implemented.");
     }

References OGS_FATAL.

◆ assembleWithJacobian()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian	(	double const	t,
		double const	,
		std::vector< double > const &	local_x,
		std::vector< double > const &	,
		const double	,
		const double	,
		std::vector< double > &	,
		std::vector< double > &	,
		std::vector< double > &	local_b_data,
		std::vector< double > &	local_Jac_data
	)

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 447 of file SmallDeformationNonlocalFEM.h.

     {
         auto const local_matrix_size = local_x.size();
  
         auto local_Jac = MathLib::createZeroedMatrix<StiffnessMatrixType>(
             local_Jac_data, local_matrix_size, local_matrix_size);
  
         auto local_b = MathLib::createZeroedVector<NodalDisplacementVectorType>(
             local_b_data, local_matrix_size);
  
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         ParameterLib::SpatialPosition x_position;
         x_position.setElementID(_element.getID());
  
         // Non-local integration.
         for (unsigned ip = 0; ip < n_integration_points; ip++)
         {
             x_position.setIntegrationPoint(ip);
             auto const& w = _ip_data[ip].integration_weight;
  
             auto const& N = _ip_data[ip].N;
             auto const& dNdx = _ip_data[ip].dNdx;
  
             auto const x_coord =
                 NumLib::interpolateXCoordinate<ShapeFunction,
                                                ShapeMatricesType>(_element, N);
             auto const B = LinearBMatrix::computeBMatrix<
                 DisplacementDim, ShapeFunction::NPOINTS,
                 typename BMatricesType::BMatrixType>(dNdx, N, x_coord,
                                                      _is_axially_symmetric);
  
             auto& sigma = _ip_data[ip].sigma;
             auto& C = _ip_data[ip].C;
             double& damage = _ip_data[ip].damage;
  
             {
                 double nonlocal_kappa_d = 0;
  
                 if (_ip_data[ip].active_self || _ip_data[ip].activated)
                 {
                     for (auto const& tuple : _ip_data[ip].non_local_assemblers)
                     {
                         // Get local variable for the integration point l.
                         double const kappa_d_l = tuple.ip_l_pointer->kappa_d;
                         double const a_kl_times_w_l = tuple.alpha_kl_times_w_l;
                         nonlocal_kappa_d += a_kl_times_w_l * kappa_d_l;
                     }
                 }
  
                 auto const& ehlers_material =
                     static_cast<MaterialLib::Solids::Ehlers::SolidEhlers<
                         DisplacementDim> const&>(_ip_data[ip].solid_material);
  
                 //
                 // Overnonlocal formulation
                 //
                 // See (Di Luzio & Bazant 2005, IJSS) for details.
                 // The implementation would go here and would be for a given
                 // gamma_nonlocal:
                 //
                 // Update nonlocal damage with local damage (scaled with 1 -
                 // \gamma_{nonlocal}) for the current integration point and the
                 // nonlocal integral part.
                 // nonlocal_kappa_d = (1. - gamma_nonlocal) * kappa_d +
                 //                    gamma_nonlocal * nonlocal_kappa_d;
  
                 nonlocal_kappa_d = std::max(0., nonlocal_kappa_d);
  
                 // Update damage based on nonlocal kappa_d
                 {
                     auto const damage_properties =
                         ehlers_material.evaluatedDamageProperties(t,
                                                                   x_position);
                     damage = calculateDamage(nonlocal_kappa_d,
                                              damage_properties.alpha_d,
                                              damage_properties.beta_d);
                     damage = std::max(0., damage);
                 }
                 sigma = sigma * (1. - damage);
             }
  
             local_b.noalias() -= B.transpose() * sigma * w;
             local_Jac.noalias() += B.transpose() * C * (1. - damage) * B * w;
         }
     }

◆ computeCrackIntegral()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::computeCrackIntegral	(	std::size_t	mesh_item_id,
		NumLib::LocalToGlobalIndexMap const &	dof_table,
		GlobalVector const &	x,
		double &	crack_volume
	)

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 565 of file SmallDeformationNonlocalFEM.h.

     {
         auto const indices = NumLib::getIndices(mesh_item_id, dof_table);
         auto local_x = x.get(indices);
  
         auto u = Eigen::Map<typename BMatricesType::NodalForceVectorType const>(
             local_x.data(), ShapeFunction::NPOINTS * DisplacementDim);
  
         int const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         for (int ip = 0; ip < n_integration_points; ip++)
         {
             auto const& dNdx = _ip_data[ip].dNdx;
             auto const& d = _ip_data[ip].damage;
             auto const& w = _ip_data[ip].integration_weight;
  
             double const div_u =
                 Deformation::divergence<DisplacementDim,
                                         ShapeFunction::NPOINTS>(u, dNdx);
             crack_volume += div_u * d * w;
         }
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, ProcessLib::Deformation::divergence(), MathLib::EigenVector::get(), and NumLib::getIndices().

◆ getIntegrationPointCoordinates()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntegrationPointCoordinates	(	Eigen::Vector3d const &	coords,
		std::vector< double > &	distances
	)		const

inlineoverridevirtual

For each of the current element's integration points the squared distance from the current integration point is computed and stored in the given distances cache.

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 297 of file SmallDeformationNonlocalFEM.h.

     {
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         distances.resize(n_integration_points);
  
         for (unsigned ip = 0; ip < n_integration_points; ip++)
         {
             auto const& xyz = _ip_data[ip].coordinates;
             distances[ip] = (xyz - coords).squaredNorm();
         }
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getIntPtDamage()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtDamage	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache
	)		const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 737 of file SmallDeformationNonlocalFEM.h.

     {
         return ProcessLib::getIntegrationPointScalarData(
             _ip_data, &IpData::damage, cache);
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, ProcessLib::SmallDeformationNonlocal::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::damage, and ProcessLib::getIntegrationPointScalarData().

◆ getIntPtEpsilon() [1/2]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtEpsilon	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache
	)		const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 689 of file SmallDeformationNonlocalFEM.h.

     {
         return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
             _ip_data, &IpData::eps, cache);
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, and ProcessLib::SmallDeformationNonlocal::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::eps.

◆ getIntPtEpsilon() [2/2]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtEpsilon	(	std::vector< double > &	cache,
		std::size_t const	component
	)		const

inlineprivate

Definition at line 781 of file SmallDeformationNonlocalFEM.h.

     {
         cache.clear();
         cache.reserve(_ip_data.size());
  
         for (auto const& ip_data : _ip_data)
         {
             if (component < 3)  // xx, yy, zz components
                 cache.push_back(ip_data.eps[component]);
             else  // mixed xy, yz, xz components
                 cache.push_back(ip_data.eps[component] / std::sqrt(2));
         }
  
         return cache;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getIntPtEpsPDXX()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtEpsPDXX	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache
	)		const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 664 of file SmallDeformationNonlocalFEM.h.

     {
         cache.clear();
         cache.reserve(_ip_data.size());
  
         transform(cbegin(_ip_data), cend(_ip_data), back_inserter(cache),
                   [](auto const& ip_data) { return *ip_data.eps_p_D_xx; });
  
         return cache;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getIntPtEpsPV()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtEpsPV	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache
	)		const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 649 of file SmallDeformationNonlocalFEM.h.

     {
         cache.clear();
         cache.reserve(_ip_data.size());
  
         transform(cbegin(_ip_data), cend(_ip_data), back_inserter(cache),
                   [](auto const& ip_data) { return *ip_data.eps_p_V; });
  
         return cache;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getIntPtFreeEnergyDensity()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtFreeEnergyDensity	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache
	)		const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 633 of file SmallDeformationNonlocalFEM.h.

     {
         cache.clear();
         cache.reserve(_ip_data.size());
  
         transform(
             cbegin(_ip_data), cend(_ip_data), back_inserter(cache),
             [](auto const& ip_data) { return ip_data.free_energy_density; });
  
         return cache;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getIntPtSigma() [1/2]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtSigma	(	const double	,
		std::vector< GlobalVector * > const &	,
		std::vector< NumLib::LocalToGlobalIndexMap const * > const &	,
		std::vector< double > &	cache
	)		const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 679 of file SmallDeformationNonlocalFEM.h.

     {
         return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
             _ip_data, &IpData::sigma, cache);
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, and ProcessLib::SmallDeformationNonlocal::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::sigma.

◆ getIntPtSigma() [2/2]

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIntPtSigma	(	std::vector< double > &	cache,
		std::size_t const	component
	)		const

inlineprivate

Definition at line 760 of file SmallDeformationNonlocalFEM.h.

     {
         cache.clear();
         cache.reserve(_ip_data.size());
  
         for (auto const& ip_data : _ip_data)
         {
             if (component < 3)
             {  // xx, yy, zz components
                 cache.push_back(ip_data.sigma[component]);
             }
             else
             {  // mixed xy, yz, xz components
                 cache.push_back(ip_data.sigma[component] / std::sqrt(2));
             }
         }
  
         return cache;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getIPDataPtr()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

IntegrationPointDataNonlocalInterface* ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getIPDataPtr ( int const ip )

inlineoverrideprivatevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 799 of file SmallDeformationNonlocalFEM.h.

     {
         return &_ip_data[ip];
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getKappaD()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getKappaD ( ) const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 721 of file SmallDeformationNonlocalFEM.h.

     {
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         std::vector<double> result_values;
         result_values.resize(n_integration_points);
  
         for (unsigned ip = 0; ip < n_integration_points; ++ip)
         {
             result_values[ip] = _ip_data[ip].kappa_d;
         }
  
         return result_values;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getMaterialStateVariablesAt()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

MaterialLib::Solids::MechanicsBase< DisplacementDim>::MaterialStateVariables const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getMaterialStateVariablesAt ( int const integration_point ) const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 754 of file SmallDeformationNonlocalFEM.h.

     {
         return *_ip_data[integration_point].material_state_variables;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ getNodalValues()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getNodalValues ( std::vector< double > & nodal_values ) const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 601 of file SmallDeformationNonlocalFEM.h.

     {
         nodal_values.clear();
         auto local_b = MathLib::createZeroedVector<NodalDisplacementVectorType>(
             nodal_values, ShapeFunction::NPOINTS * DisplacementDim);
  
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         for (unsigned ip = 0; ip < n_integration_points; ip++)
         {
             auto const& w = _ip_data[ip].integration_weight;
  
             auto const& N = _ip_data[ip].N;
             auto const& dNdx = _ip_data[ip].dNdx;
  
             auto const x_coord =
                 NumLib::interpolateXCoordinate<ShapeFunction,
                                                ShapeMatricesType>(_element, N);
             auto const B = LinearBMatrix::computeBMatrix<
                 DisplacementDim, ShapeFunction::NPOINTS,
                 typename BMatricesType::BMatrixType>(dNdx, N, x_coord,
                                                      _is_axially_symmetric);
             auto& sigma = _ip_data[ip].sigma;
  
             local_b.noalias() += B.transpose() * sigma * w;
         }
  
         return nodal_values;
     }

◆ getNumberOfIntegrationPoints()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

unsigned ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getNumberOfIntegrationPoints ( ) const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 747 of file SmallDeformationNonlocalFEM.h.

     {
         return _integration_method.getNumberOfPoints();
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method.

◆ getShapeMatrix()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

Eigen::Map<const Eigen::RowVectorXd> ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getShapeMatrix ( const unsigned integration_point ) const

inlineoverridevirtual

Provides the shape matrix at the given integration point.

Implements NumLib::ExtrapolatableElement.

Definition at line 592 of file SmallDeformationNonlocalFEM.h.

     {
         auto const& N = _secondary_data.N[integration_point];
  
         // assumes N is stored contiguously in memory
         return Eigen::Map<const Eigen::RowVectorXd>(N.data(), N.size());
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_secondary_data, and ProcessLib::HeatTransportBHE::SecondaryData< ShapeMatrixType >::N.

◆ getSigma()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<double> ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getSigma ( ) const

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 708 of file SmallDeformationNonlocalFEM.h.

     {
         return ProcessLib::getIntegrationPointKelvinVectorData<DisplacementDim>(
             _ip_data, &IpData::sigma);
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, and ProcessLib::SmallDeformationNonlocal::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::sigma.

◆ getSingleIntegrationPointCoordinates()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

Eigen::Vector3d ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getSingleIntegrationPointCoordinates ( int integration_point ) const

inline

Definition at line 278 of file SmallDeformationNonlocalFEM.h.

     {
         auto const& N = _secondary_data.N[integration_point];
  
         Eigen::Vector3d xyz = Eigen::Vector3d::Zero();  // Resulting coordinates
         auto* nodes = _element.getNodes();
         for (int i = 0; i < N.size(); ++i)
         {
             Eigen::Map<Eigen::Vector3d const> node_coordinates{
                 nodes[i]->getCoords(), 3};
             xyz += node_coordinates * N[i];
         }
         return xyz;
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_element, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_secondary_data, MathLib::TemplatePoint< T, DIM >::getCoords(), MeshLib::Element::getNodes(), and ProcessLib::HeatTransportBHE::SecondaryData< ShapeMatrixType >::N.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::SmallDeformationNonlocalLocalAssembler().

◆ initializeConcrete()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::initializeConcrete ( )

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 542 of file SmallDeformationNonlocalFEM.h.

     {
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         for (unsigned ip = 0; ip < n_integration_points; ip++)
         {
             _ip_data[ip].pushBackState();
         }
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ nonlocal()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::nonlocal	(	std::size_t const	,
		std::vector< std::unique_ptr< SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >>> const &	local_assemblers
	)

inlineoverride

Definition at line 202 of file SmallDeformationNonlocalFEM.h.

     {
         auto const search_element_ids = MeshLib::findElementsWithinRadius(
             _element, _process_data.internal_length_squared);
  
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         std::vector<double> distances;  // Cache for ip-ip distances.
         //
         // For every integration point in this element collect the neighbouring
         // integration points falling in given radius (internal length) and
         // compute the alpha_kl weight.
         //
         for (unsigned k = 0; k < n_integration_points; k++)
         {
             //
             // Collect the integration points.
             //
  
             auto const& xyz = _ip_data[k].coordinates;
  
             // For all neighbors of element
             for (auto const search_element_id : search_element_ids)
             {
                 auto const& la = local_assemblers[search_element_id];
                 la->getIntegrationPointCoordinates(xyz, distances);
                 for (int ip = 0; ip < static_cast<int>(distances.size()); ++ip)
                 {
                     if (distances[ip] >= _process_data.internal_length_squared)
                     {
                         continue;
                     }
                     // save into current ip_k
                     _ip_data[k].non_local_assemblers.push_back(
                         {la->getIPDataPtr(ip),
                          std::numeric_limits<double>::quiet_NaN(),
                          distances[ip]});
                 }
             }
             if (_ip_data[k].non_local_assemblers.size() == 0)
             {
                 OGS_FATAL("no neighbours found!");
             }
  
             double a_k_sum_m = 0;
             for (auto const& tuple : _ip_data[k].non_local_assemblers)
             {
                 double const distance2_m = tuple.distance2;
  
                 auto const& w_m = tuple.ip_l_pointer->integration_weight;
  
                 a_k_sum_m += w_m * alpha_0(distance2_m);
             }
  
             //
             // Calculate alpha_kl =
             //       alpha_0(|x_k - x_l|) / int_{m \in ip} alpha_0(|x_k - x_m|)
             //
             for (auto& tuple : _ip_data[k].non_local_assemblers)
             {
                 double const distance2_l = tuple.distance2;
                 double const a_kl = alpha_0(distance2_l) / a_k_sum_m;
  
                 // Store the a_kl already multiplied with the integration
                 // weight of that l integration point.
                 auto const w_l = tuple.ip_l_pointer->integration_weight;
                 tuple.alpha_kl_times_w_l = a_kl * w_l;
             }
         }
     }

◆ postTimestepConcrete()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::postTimestepConcrete	(	Eigen::VectorXd const &	,
		double const	,
		double const
	)

inlineoverridevirtual

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 553 of file SmallDeformationNonlocalFEM.h.

     {
         unsigned const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         for (unsigned ip = 0; ip < n_integration_points; ip++)
         {
             _ip_data[ip].pushBackState();
         }
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method, and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

◆ preAssemble()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::preAssemble	(	double const	t,
		double const	dt,
		std::vector< double > const &	local_x
	)

inlineoverridevirtual

Compute only the local kappa_d.

Reimplemented from ProcessLib::LocalAssemblerInterface.

Definition at line 326 of file SmallDeformationNonlocalFEM.h.

     {
         auto const n_integration_points =
             _integration_method.getNumberOfPoints();
  
         MPL::VariableArray variables;
         MPL::VariableArray variables_prev;
         ParameterLib::SpatialPosition x_position;
         x_position.setElementID(_element.getID());
  
         for (unsigned ip = 0; ip < n_integration_points; ip++)
         {
             x_position.setIntegrationPoint(ip);
  
             auto const& N = _ip_data[ip].N;
             auto const& dNdx = _ip_data[ip].dNdx;
  
             auto const x_coord =
                 NumLib::interpolateXCoordinate<ShapeFunction,
                                                ShapeMatricesType>(_element, N);
             auto const B = LinearBMatrix::computeBMatrix<
                 DisplacementDim, ShapeFunction::NPOINTS,
                 typename BMatricesType::BMatrixType>(dNdx, N, x_coord,
                                                      _is_axially_symmetric);
             auto const& eps_prev = _ip_data[ip].eps_prev;
             auto const& sigma_prev = _ip_data[ip].sigma_prev;
  
             auto& eps = _ip_data[ip].eps;
             auto& sigma = _ip_data[ip].sigma;
             auto& C = _ip_data[ip].C;
             auto& state = _ip_data[ip].material_state_variables;
             double const& damage_prev = _ip_data[ip].damage_prev;
  
             eps.noalias() =
                 B *
                 Eigen::Map<typename BMatricesType::NodalForceVectorType const>(
                     local_x.data(), ShapeFunction::NPOINTS * DisplacementDim);
  
             // sigma is for plastic part only.
             std::unique_ptr<
                 MathLib::KelvinVector::KelvinMatrixType<DisplacementDim>>
                 new_C;
             std::unique_ptr<typename MaterialLib::Solids::MechanicsBase<
                 DisplacementDim>::MaterialStateVariables>
                 new_state;
  
             // Compute sigma_eff from damage total stress sigma
             using KelvinVectorType = typename BMatricesType::KelvinVectorType;
             KelvinVectorType const sigma_eff_prev =
                 sigma_prev /
                 (1. - damage_prev);  // damage_prev is in [0,1) range. See
                                      // calculateDamage() function.
  
             variables_prev[static_cast<int>(MPL::Variable::stress)]
                 .emplace<
                     MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                     sigma_eff_prev);
             variables_prev[static_cast<int>(MPL::Variable::mechanical_strain)]
                 .emplace<
                     MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                     eps_prev);
             variables_prev[static_cast<int>(MPL::Variable::temperature)]
                 .emplace<double>(_process_data.reference_temperature);
             variables[static_cast<int>(MPL::Variable::mechanical_strain)]
                 .emplace<
                     MathLib::KelvinVector::KelvinVectorType<DisplacementDim>>(
                     eps);
             variables[static_cast<int>(MPL::Variable::temperature)]
                 .emplace<double>(_process_data.reference_temperature);
  
             auto&& solution = _ip_data[ip].solid_material.integrateStress(
                 variables_prev, variables, t, x_position, dt, *state);
  
             if (!solution)
             {
                 OGS_FATAL("Computation of local constitutive relation failed.");
             }
  
             std::tie(sigma, state, C) = std::move(*solution);
  
             {
                 auto const& ehlers_material =
                     static_cast<MaterialLib::Solids::Ehlers::SolidEhlers<
                         DisplacementDim> const&>(_ip_data[ip].solid_material);
                 auto const damage_properties =
                     ehlers_material.evaluatedDamageProperties(t, x_position);
                 auto const material_properties =
                     ehlers_material.evaluatedMaterialProperties(t, x_position);
  
                 // Ehlers material state variables
                 auto& state_vars =
                     static_cast<MaterialLib::Solids::Ehlers::StateVariables<
                         DisplacementDim>&>(
                         *_ip_data[ip].material_state_variables);
  
                 double const eps_p_eff_diff =
                     state_vars.eps_p.eff - state_vars.eps_p_prev.eff;
  
                 _ip_data[ip].kappa_d = calculateDamageKappaD<DisplacementDim>(
                     eps_p_eff_diff, sigma, _ip_data[ip].kappa_d_prev,
                     damage_properties.h_d, material_properties);
  
                 if (!_ip_data[ip].active_self)
                 {
                     _ip_data[ip].active_self |= _ip_data[ip].kappa_d > 0;
                     if (_ip_data[ip].active_self)
                     {
                         for (auto const& tuple :
                              _ip_data[ip].non_local_assemblers)
                         {
                             // Activate the integration point.
                             tuple.ip_l_pointer->activated = true;
                         }
                     }
                 }
             }
         }
     }

◆ setIPDataInitialConditions()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::size_t ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setIPDataInitialConditions	(	std::string const &	name,
		double const *	values,
		int const	integration_order
	)

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 149 of file SmallDeformationNonlocalFEM.h.

     {
         if (integration_order !=
             static_cast<int>(_integration_method.getIntegrationOrder()))
         {
             OGS_FATAL(
                 "Setting integration point initial conditions; The integration "
                 "order of the local assembler for element {:d} is different "
                 "from the integration order in the initial condition.",
                 _element.getID());
         }
  
         if (name == "sigma_ip")
         {
             return setSigma(values);
         }
  
         if (name == "kappa_d_ip")
         {
             return ProcessLib::setIntegrationPointScalarData(values, _ip_data,
                                                              &IpData::kappa_d);
         }
  
         return 0;
     }

◆ setIPDataInitialConditionsFromCellData()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setIPDataInitialConditionsFromCellData	(	std::string const &	name,
		std::vector< double > const &	value
	)

inlineoverridevirtual

Implements ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >.

Definition at line 177 of file SmallDeformationNonlocalFEM.h.

     {
         if (name == "kappa_d_ip")
         {
             if (value.size() != 1)
             {
                 OGS_FATAL(
                     "CellData for kappa_d initial conditions has wrong number "
                     "of components. 1 expected, got {:d}.",
                     value.size());
             }
             setKappaD(value[0]);
         }
     }

References MaterialPropertyLib::name, OGS_FATAL, and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setKappaD().

◆ setKappaD()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setKappaD ( double value )

inline

Definition at line 714 of file SmallDeformationNonlocalFEM.h.

     {
         for (auto& ip_data : _ip_data)
         {
             ip_data.kappa_d = value;
         }
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setIPDataInitialConditionsFromCellData().

◆ setSigma()

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::size_t ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setSigma ( double const * values )

inline

Definition at line 699 of file SmallDeformationNonlocalFEM.h.

     {
         return ProcessLib::setIntegrationPointKelvinVectorData<DisplacementDim>(
             values, _ip_data, &IpData::sigma);
     }

References ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data, and ProcessLib::SmallDeformationNonlocal::IntegrationPointData< BMatricesType, ShapeMatricesType, DisplacementDim >::sigma.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::setIPDataInitialConditions().

Member Data Documentation

◆ _element

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

MeshLib::Element const& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_element

private

Definition at line 810 of file SmallDeformationNonlocalFEM.h.

◆ _integration_method

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

IntegrationMethod const ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_integration_method

private

Definition at line 809 of file SmallDeformationNonlocalFEM.h.

◆ _ip_data

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

std::vector<IpData, Eigen::aligned_allocator<IpData> > ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_ip_data

private

Definition at line 807 of file SmallDeformationNonlocalFEM.h.

◆ _is_axially_symmetric

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

bool const ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_is_axially_symmetric

private

Definition at line 812 of file SmallDeformationNonlocalFEM.h.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::assembleWithJacobian(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getNodalValues(), and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::preAssemble().

◆ _process_data

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

SmallDeformationNonlocalProcessData<DisplacementDim>& ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_process_data

private

Definition at line 805 of file SmallDeformationNonlocalFEM.h.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::SmallDeformationNonlocalLocalAssembler(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::alpha_0(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::nonlocal(), and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::preAssemble().

◆ _secondary_data

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

SecondaryData<typename ShapeMatrices::ShapeType> ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::_secondary_data

private

Definition at line 811 of file SmallDeformationNonlocalFEM.h.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::SmallDeformationNonlocalLocalAssembler(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getShapeMatrix(), and ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::getSingleIntegrationPointCoordinates().

◆ displacement_size

template<typename ShapeFunction , typename IntegrationMethod , int DisplacementDim>

const int ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >::displacement_size

staticprivate

Initial value:

=

ShapeFunction::NPOINTS * DisplacementDim

Definition at line 814 of file SmallDeformationNonlocalFEM.h.

The documentation for this class was generated from the following file:

ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalFEM.h

Detailed Description

template<typename ShapeFunction, typename IntegrationMethod, int DisplacementDim> class ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Static Private Attributes

Member Typedef Documentation

◆ BMatricesType

◆ BMatrixType

◆ GlobalDimVectorType

◆ IpData

◆ NodalDisplacementVectorType

◆ NodalForceVectorType

◆ NodalMatrixType

◆ NodalVectorType

◆ ShapeMatrices

◆ ShapeMatricesType

◆ StiffnessMatrixType

Constructor & Destructor Documentation

◆ SmallDeformationNonlocalLocalAssembler() [1/3]

◆ SmallDeformationNonlocalLocalAssembler() [2/3]

◆ SmallDeformationNonlocalLocalAssembler() [3/3]

Member Function Documentation

◆ alpha_0()

◆ assemble()

◆ assembleWithJacobian()

◆ computeCrackIntegral()

◆ getIntegrationPointCoordinates()

◆ getIntPtDamage()

◆ getIntPtEpsilon() [1/2]

◆ getIntPtEpsilon() [2/2]

◆ getIntPtEpsPDXX()

◆ getIntPtEpsPV()

◆ getIntPtFreeEnergyDensity()

◆ getIntPtSigma() [1/2]

◆ getIntPtSigma() [2/2]

◆ getIPDataPtr()

◆ getKappaD()

◆ getMaterialStateVariablesAt()

◆ getNodalValues()

◆ getNumberOfIntegrationPoints()

◆ getShapeMatrix()

◆ getSigma()

◆ getSingleIntegrationPointCoordinates()

◆ initializeConcrete()

◆ nonlocal()

◆ postTimestepConcrete()

◆ preAssemble()

◆ setIPDataInitialConditions()

◆ setIPDataInitialConditionsFromCellData()

◆ setKappaD()

◆ setSigma()

Member Data Documentation

◆ _element

◆ _integration_method

◆ _ip_data

◆ _is_axially_symmetric

◆ _process_data

◆ _secondary_data

◆ displacement_size

template<typename ShapeFunction, typename IntegrationMethod, int DisplacementDim>
class ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssembler< ShapeFunction, IntegrationMethod, DisplacementDim >