Detailed Description

template<int DisplacementDim>
class ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >

Definition at line 26 of file SmallDeformationNonlocalProcess.h.

#include <SmallDeformationNonlocalProcess.h>

Inheritance diagram for ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >:

Collaboration diagram for ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >:

Public Member Functions
	SmallDeformationNonlocalProcess (std::string name, MeshLib::Mesh &mesh, std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&process_variables, SmallDeformationNonlocalProcessData< DisplacementDim > &&process_data, SecondaryVariableCollection &&secondary_variables)

ODESystem interface
bool	isLinear () const override

Public Member Functions inherited from ProcessLib::Process
	Process (std::string name_, MeshLib::Mesh &mesh, std::unique_ptr< AbstractJacobianAssembler > &&jacobian_assembler, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters, unsigned const integration_order, std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&process_variables, SecondaryVariableCollection &&secondary_variables, const bool use_monolithic_scheme=true)

void	preTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, const int process_id)
	Preprocessing before starting assembly for new timestep. More...

void	postTimestep (std::vector< GlobalVector * > const &x, const double t, const double delta_t, int const process_id)
	Postprocessing after a complete timestep. More...

void	postNonLinearSolver (GlobalVector const &x, GlobalVector const &xdot, const double t, double const dt, int const process_id)

void	preIteration (const unsigned iter, GlobalVector const &x) final

void	computeSecondaryVariable (double const t, double const dt, std::vector< GlobalVector * > const &x, GlobalVector const &x_dot, int const process_id)
	compute secondary variables for the coupled equations or for output. More...

NumLib::IterationResult	postIteration (GlobalVector const &x) final

void	initialize ()

void	setInitialConditions (std::vector< GlobalVector * > &process_solutions, std::vector< GlobalVector * > const &process_solutions_prev, double const t, int const process_id)

MathLib::MatrixSpecifications	getMatrixSpecifications (const int process_id) const override

void	setCoupledSolutionsForStaggeredScheme (CoupledSolutionsForStaggeredScheme *const coupled_solutions)

void	updateDeactivatedSubdomains (double const time, const int process_id)

bool	isMonolithicSchemeUsed () const

virtual void	setCoupledTermForTheStaggeredSchemeToLocalAssemblers (int const)

virtual void	extrapolateIntegrationPointValuesToNodes (const double, std::vector< GlobalVector * > const &, std::vector< GlobalVector * > &)

void	preAssemble (const double t, double const dt, GlobalVector const &x) final

void	assemble (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) final

void	assembleWithJacobian (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, const double dxdot_dx, const double dx_dx, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) final

std::vector< NumLib::IndexValueVector< GlobalIndexType > > const *	getKnownSolutions (double const t, GlobalVector const &x, int const process_id) const final

virtual NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int) const

MeshLib::Mesh &	getMesh () const

std::vector< std::reference_wrapper< ProcessVariable > > const &	getProcessVariables (const int process_id) const

SecondaryVariableCollection const &	getSecondaryVariables () const

std::vector< std::unique_ptr< IntegrationPointWriter > > const *	getIntegrationPointWriter (MeshLib::Mesh const &mesh) const

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

virtual void	solveReactionEquation (std::vector< GlobalVector * > &, std::vector< GlobalVector * > const &, double const, double const, NumLib::EquationSystem &, int const)

Private Types
using	LocalAssemblerInterface = SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >

Private Member Functions
void	initializeConcreteProcess (NumLib::LocalToGlobalIndexMap const &dof_table, MeshLib::Mesh const &mesh, unsigned const integration_order) override
	Process specific initialization called by initialize(). More...

void	assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b) override

void	preAssembleConcreteProcess (const double t, double const dt, GlobalVector const &x) override

void	assembleWithJacobianConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &xdot, const double dxdot_dx, const double dx_dx, int const process_id, GlobalMatrix &M, GlobalMatrix &K, GlobalVector &b, GlobalMatrix &Jac) override

void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, double const t, double const dt, int const process_id) override

NumLib::IterationResult	postIterationConcreteProcess (GlobalVector const &x) override

Private Attributes
SmallDeformationNonlocalProcessData< DisplacementDim >	_process_data

std::vector< std::unique_ptr< LocalAssemblerInterface > >	_local_assemblers

std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map_single_component

MeshLib::PropertyVector< double > *	_nodal_forces = nullptr

Additional Inherited Members
Public Types inherited from ProcessLib::Process
using	NonlinearSolver = NumLib::NonlinearSolverBase

using	TimeDiscretization = NumLib::TimeDiscretization

Public Attributes inherited from ProcessLib::Process
std::string const	name

Protected Member Functions inherited from ProcessLib::Process
NumLib::Extrapolator &	getExtrapolator () const

NumLib::LocalToGlobalIndexMap const &	getSingleComponentDOFTable () const

void	initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id)

virtual void	constructDofTable ()

void	constructMonolithicProcessDofTable ()

void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_prosess_id)

virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const

Protected Attributes inherited from ProcessLib::Process
MeshLib::Mesh &	_mesh

std::unique_ptr< MeshLib::MeshSubset const >	_mesh_subset_all_nodes

std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map

SecondaryVariableCollection	_secondary_variables

VectorMatrixAssembler	_global_assembler

const bool	_use_monolithic_scheme

CoupledSolutionsForStaggeredScheme *	_coupled_solutions

unsigned const	_integration_order

std::vector< std::unique_ptr< IntegrationPointWriter > >	_integration_point_writer

GlobalSparsityPattern	_sparsity_pattern

std::vector< std::vector< std::reference_wrapper< ProcessVariable > > >	_process_variables

std::vector< BoundaryConditionCollection >	_boundary_conditions

Member Typedef Documentation

◆ LocalAssemblerInterface

template<int DisplacementDim>

using ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::LocalAssemblerInterface = SmallDeformationNonlocalLocalAssemblerInterface<DisplacementDim>

private

Definition at line 79 of file SmallDeformationNonlocalProcess.h.

Constructor & Destructor Documentation

◆ SmallDeformationNonlocalProcess()

template<int DisplacementDim>

ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::SmallDeformationNonlocalProcess	(	std::string	name,
		MeshLib::Mesh &	mesh,
		std::unique_ptr< ProcessLib::AbstractJacobianAssembler > &&	jacobian_assembler,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters,
		unsigned const	integration_order,
		std::vector< std::vector< std::reference_wrapper< ProcessVariable >>> &&	process_variables,
		SmallDeformationNonlocalProcessData< DisplacementDim > &&	process_data,
		SecondaryVariableCollection &&	secondary_variables
	)

Definition at line 26 of file SmallDeformationNonlocalProcess.cpp.

     : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables)),
       _process_data(std::move(process_data))
 {
     _nodal_forces = MeshLib::getOrCreateMeshProperty<double>(
         mesh, "NodalForces", MeshLib::MeshItemType::Node, DisplacementDim);
  
     _integration_point_writer.emplace_back(
         std::make_unique<IntegrationPointWriter>(
             "sigma_ip",
             static_cast<int>(mesh.getDimension() == 2 ? 4 : 6) /*n components*/,
             integration_order, _local_assemblers,
             &LocalAssemblerInterface::getSigma));
  
     _integration_point_writer.emplace_back(
         std::make_unique<IntegrationPointWriter>(
             "kappa_d_ip", 1 /*n_components*/, integration_order,
             _local_assemblers, &LocalAssemblerInterface::getKappaD));
 }

Member Function Documentation

◆ assembleConcreteProcess()

template<int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::assembleConcreteProcess	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	xdot,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b
	)

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 207 of file SmallDeformationNonlocalProcess.cpp.

 {
     DBUG("Assemble SmallDeformationNonlocalProcess.");
  
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_table = {std::ref(*_local_to_global_index_map)};
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     // Call global assembler for each local assembly item.
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
         pv.getActiveElementIDs(), dof_table, t, dt, x, xdot, process_id, M, K,
         b);
 }

References ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::ProcessVariable::getActiveElementIDs().

◆ assembleWithJacobianConcreteProcess()

template<int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::assembleWithJacobianConcreteProcess	(	const double	t,
		double const	dt,
		std::vector< GlobalVector * > const &	x,
		std::vector< GlobalVector * > const &	xdot,
		const double	dxdot_dx,
		const double	dx_dx,
		int const	process_id,
		GlobalMatrix &	M,
		GlobalMatrix &	K,
		GlobalVector &	b,
		GlobalMatrix &	Jac
	)

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 245 of file SmallDeformationNonlocalProcess.cpp.

 {
     DBUG("AssembleWithJacobian SmallDeformationNonlocalProcess.");
  
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_table = {std::ref(*_local_to_global_index_map)};
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     // Call global assembler for each local assembly item.
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
         _local_assemblers, pv.getActiveElementIDs(), dof_table, t, dt, x, xdot,
         dxdot_dx, dx_dx, process_id, M, K, b, Jac);
  
     b.copyValues(*_nodal_forces);
     std::transform(_nodal_forces->begin(), _nodal_forces->end(),
                    _nodal_forces->begin(), [](double val) { return -val; });
 }

References ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), MathLib::EigenVector::copyValues(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::ProcessVariable::getActiveElementIDs().

◆ initializeConcreteProcess()

template<int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::initializeConcreteProcess	(	NumLib::LocalToGlobalIndexMap const &	dof_table,
		MeshLib::Mesh const &	mesh,
		unsigned const	integration_order
	)

overrideprivatevirtual

Process specific initialization called by initialize().

Implements ProcessLib::Process.

Definition at line 67 of file SmallDeformationNonlocalProcess.cpp.

 {
     // Reusing local assembler creation code.
     ProcessLib::SmallDeformation::createLocalAssemblers<
         DisplacementDim, SmallDeformationNonlocalLocalAssembler>(
         mesh.getElements(), dof_table, _local_assemblers,
         mesh.isAxiallySymmetric(), integration_order, _process_data);
  
     // TODO move the two data members somewhere else.
     // for extrapolation of secondary variables
     std::vector<MeshLib::MeshSubset> all_mesh_subsets_single_component{
         *_mesh_subset_all_nodes};
     _local_to_global_index_map_single_component =
         std::make_unique<NumLib::LocalToGlobalIndexMap>(
             std::move(all_mesh_subsets_single_component),
             // by location order is needed for output
             NumLib::ComponentOrder::BY_LOCATION);
  
     Process::_secondary_variables.addSecondaryVariable(
         "sigma",
         makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                              DisplacementDim>::RowsAtCompileTime,
                          getExtrapolator(), _local_assemblers,
                          &LocalAssemblerInterface::getIntPtSigma));
  
     Process::_secondary_variables.addSecondaryVariable(
         "epsilon",
         makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                              DisplacementDim>::RowsAtCompileTime,
                          getExtrapolator(), _local_assemblers,
                          &LocalAssemblerInterface::getIntPtEpsilon));
  
     Process::_secondary_variables.addSecondaryVariable(
         "eps_p_V",
         makeExtrapolator(1, getExtrapolator(), _local_assemblers,
                          &LocalAssemblerInterface::getIntPtEpsPV));
     Process::_secondary_variables.addSecondaryVariable(
         "eps_p_D_xx",
         makeExtrapolator(1, getExtrapolator(), _local_assemblers,
                          &LocalAssemblerInterface::getIntPtEpsPDXX));
  
     Process::_secondary_variables.addSecondaryVariable(
         "damage",
         makeExtrapolator(1, getExtrapolator(), _local_assemblers,
                          &LocalAssemblerInterface::getIntPtDamage));
  
     GlobalExecutor::executeMemberOnDereferenced(
         &LocalAssemblerInterface::nonlocal, _local_assemblers,
         _local_assemblers);
  
     // Set initial conditions for integration point data.
     for (auto const& ip_writer : _integration_point_writer)
     {
         auto const& name = ip_writer->name();
         // First check the field data, which is used for restart.
         if (mesh.getProperties().existsPropertyVector<double>(name))
         {
             auto const& mesh_property =
                 *mesh.getProperties().template getPropertyVector<double>(name);
  
             // The mesh property must be defined on integration points.
             if (mesh_property.getMeshItemType() !=
                 MeshLib::MeshItemType::IntegrationPoint)
             {
                 continue;
             }
  
             auto const ip_meta_data = getIntegrationPointMetaData(mesh, name);
  
             // Check the number of components.
             if (ip_meta_data.n_components !=
                 mesh_property.getNumberOfGlobalComponents())
             {
                 OGS_FATAL(
                     "Different number of components in meta data ({:d}) than "
                     "in the integration point field data for '{:s}': {:d}.",
                     ip_meta_data.n_components, name,
                     mesh_property.getNumberOfGlobalComponents());
             }
  
             // Now we have a properly named vtk's field data array and the
             // corresponding meta data.
             std::size_t position = 0;
             for (auto& local_asm : _local_assemblers)
             {
                 std::size_t const integration_points_read =
                     local_asm->setIPDataInitialConditions(
                         name, &mesh_property[position],
                         ip_meta_data.integration_order);
                 if (integration_points_read == 0)
                 {
                     OGS_FATAL(
                         "No integration points read in the integration point "
                         "initial conditions set function.");
                 }
                 position += integration_points_read * ip_meta_data.n_components;
             }
         }
         else if (mesh.getProperties().existsPropertyVector<double>(name +
                                                                    "_ic"))
         {  // Try to find cell data with '_ic' suffix
             auto const& mesh_property =
                 *mesh.getProperties().template getPropertyVector<double>(name +
                                                                          "_ic");
             if (mesh_property.getMeshItemType() != MeshLib::MeshItemType::Cell)
             {
                 continue;
             }
  
             // Now we have a vtk's cell data array containing the initial
             // conditions for the corresponding integration point writer.
  
             // For each assembler use the single cell value for all
             // integration points.
             for (std::size_t i = 0; i < _local_assemblers.size(); ++i)
             {
                 auto& local_asm = _local_assemblers[i];
  
                 std::vector<double> value(
                     &mesh_property[i],
                     &mesh_property[i] +
                         mesh_property.getNumberOfGlobalComponents());
                 // TODO (naumov) Check sizes / read size / etc.
                 // OR reconstruct dimensions from size / component =
                 // ip_points
                 local_asm->setIPDataInitialConditionsFromCellData(name, value);
             }
         }
     }
  
     // Initialize local assemblers after all variables have been set.
     GlobalExecutor::executeMemberOnDereferenced(
         &LocalAssemblerInterface::initialize, _local_assemblers,
         *_local_to_global_index_map);
 }

References ProcessLib::Process::_secondary_variables, ProcessLib::SecondaryVariableCollection::addSecondaryVariable(), NumLib::BY_LOCATION, MeshLib::Cell, ProcessLib::SmallDeformation::createLocalAssemblers(), NumLib::SerialExecutor::executeMemberOnDereferenced(), MeshLib::Properties::existsPropertyVector(), MeshLib::Mesh::getElements(), ProcessLib::getIntegrationPointMetaData(), MeshLib::Mesh::getProperties(), ProcessLib::LocalAssemblerInterface::initialize(), MeshLib::IntegrationPoint, MeshLib::Mesh::isAxiallySymmetric(), ProcessLib::makeExtrapolator(), MaterialPropertyLib::name, and OGS_FATAL.

◆ isLinear()

template<int DisplacementDim>

bool ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::isLinear

override

Definition at line 61 of file SmallDeformationNonlocalProcess.cpp.

 {
     return false;
 }

◆ postIterationConcreteProcess()

template<int DisplacementDim>

NumLib::IterationResult ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::postIterationConcreteProcess ( GlobalVector const & x )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 291 of file SmallDeformationNonlocalProcess.cpp.

 {
     _process_data.crack_volume_old = _process_data.crack_volume;
     _process_data.crack_volume = 0.0;
  
     DBUG("PostNonLinearSolver crack volume computation.");
  
     const int process_id = 0;
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &LocalAssemblerInterface::computeCrackIntegral, _local_assemblers,
         pv.getActiveElementIDs(), *_local_to_global_index_map, x,
         _process_data.crack_volume);
  
     INFO("Integral of crack: {:g}", _process_data.crack_volume);
  
     return NumLib::IterationResult::SUCCESS;
 }

References DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), INFO(), and NumLib::SUCCESS.

◆ postTimestepConcreteProcess()

template<int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::postTimestepConcreteProcess	(	std::vector< GlobalVector * > const &	x,
		double const	t,
		double const	dt,
		int const	process_id
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 271 of file SmallDeformationNonlocalProcess.cpp.

 {
     DBUG("PostTimestep SmallDeformationNonlocalProcess.");
     std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
     dof_tables.reserve(x.size());
     std::generate_n(std::back_inserter(dof_tables), x.size(),
                     [&]() { return _local_to_global_index_map.get(); });
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &LocalAssemblerInterface::postTimestep, _local_assemblers,
         pv.getActiveElementIDs(), dof_tables, x, t, dt);
 }

References DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::ProcessVariable::getActiveElementIDs(), and ProcessLib::LocalAssemblerInterface::postTimestep().

◆ preAssembleConcreteProcess()

template<int DisplacementDim>

void ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::preAssembleConcreteProcess	(	const double	t,
		double const	dt,
		GlobalVector const &	x
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 228 of file SmallDeformationNonlocalProcess.cpp.

 {
     DBUG("preAssemble SmallDeformationNonlocalProcess.");
  
     const int process_id = 0;
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     // Call global assembler for each local assembly item.
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::preAssemble,
         _local_assemblers, pv.getActiveElementIDs(),
         *_local_to_global_index_map, t, dt, x);
 }