ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim > Class Template Reference

Detailed Description

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

Definition at line 25 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.
void	postTimestep (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double delta_t, int const process_id)
	Postprocessing after a complete timestep.
void	postNonLinearSolver (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, 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_prev, int const process_id)
	compute secondary variables for the coupled equations or for output.
NumLib::IterationResult	postIteration (GlobalVector const &x) final
void	initialize (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
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	updateDeactivatedSubdomains (double const time, const int process_id)
virtual bool	isMonolithicSchemeUsed () 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 &x_prev, 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 &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac) final
void	preOutput (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, int const process_id)
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::vector< std::reference_wrapper< ProcessVariable > > > const &	getProcessVariables () const
std::vector< std::reference_wrapper< ProcessVariable > > const &	getProcessVariables (const int process_id) const
std::vector< std::size_t > const &	getActiveElementIDs () const
SecondaryVariableCollection const &	getSecondaryVariables () const
std::vector< std::unique_ptr< MeshLib::IntegrationPointWriter > > const &	getIntegrationPointWriters () 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)
bool	requiresNormalization () const override
Public Member Functions inherited from ProcessLib::SubmeshAssemblySupport
virtual std::vector< std::vector< std::string > >	initializeAssemblyOnSubmeshes (std::vector< std::reference_wrapper< MeshLib::Mesh > > const &meshes)
virtual	~SubmeshAssemblySupport ()=default

Private Types
using	LocalAssemblerInterface

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().
void	assembleConcreteProcess (const double t, double const dt, std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, 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 &x_prev, int const process_id, GlobalVector &b, GlobalMatrix &Jac) override
void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, 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 Attributes inherited from ProcessLib::Process
std::string const	name
Static Public Attributes inherited from ProcessLib::Process
static PROCESSLIB_EXPORT const std::string	constant_one_parameter_name = "constant_one"
Protected Member Functions inherited from ProcessLib::Process
std::vector< NumLib::LocalToGlobalIndexMap const * >	getDOFTables (int const number_of_processes) const
NumLib::Extrapolator &	getExtrapolator () const
NumLib::LocalToGlobalIndexMap const &	getSingleComponentDOFTable () const
void	initializeProcessBoundaryConditionsAndSourceTerms (const NumLib::LocalToGlobalIndexMap &dof_table, const int process_id, std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media)
virtual void	constructDofTable ()
void	constructMonolithicProcessDofTable ()
void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_process_id)
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const
std::vector< GlobalIndexType >	getIndicesOfResiduumWithoutInitialCompensation () const override
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
CellAverageData	cell_average_data_
std::unique_ptr< ProcessLib::AbstractJacobianAssembler >	_jacobian_assembler
VectorMatrixAssembler	_global_assembler
const bool	_use_monolithic_scheme
unsigned const	_integration_order
std::vector< std::unique_ptr< MeshLib::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

private

Initial value:

 
        SmallDeformationNonlocalLocalAssemblerInterface<DisplacementDim>

Definition at line 78 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 27 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<MeshLib::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<MeshLib::IntegrationPointWriter>(
            "kappa_d_ip", 1 /*n_components*/, integration_order,
            _local_assemblers, &LocalAssemblerInterface::getKappaD));
}

References ProcessLib::Process::_integration_point_writer, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::_local_assemblers, ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::_nodal_forces, MeshLib::Mesh::getDimension(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >::getKappaD(), MeshLib::getOrCreateMeshProperty(), ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalLocalAssemblerInterface< DisplacementDim >::getSigma(), and MeshLib::Node.

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 & x_prev, int const process_id, GlobalMatrix & M, GlobalMatrix & K, GlobalVector & b )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 179 of file SmallDeformationNonlocalProcess.cpp.

{
    DBUG("Assemble SmallDeformationNonlocalProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
        getActiveElementIDs(), dof_table, t, dt, x, x_prev, process_id, &M, &K,
        &b);
}

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

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 & x_prev, int const process_id, GlobalVector & b, GlobalMatrix & Jac )

overrideprivatevirtual

Implements ProcessLib::Process.

Definition at line 212 of file SmallDeformationNonlocalProcess.cpp.

{
    DBUG("AssembleWithJacobian SmallDeformationNonlocalProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_table = {
        _local_to_global_index_map.get()};
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, getActiveElementIDs(), dof_table, t, dt, x, x_prev,
        process_id, &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(), and NumLib::SerialExecutor::executeSelectedMemberDereferenced().

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 68 of file SmallDeformationNonlocalProcess.cpp.

{
    // Reusing local assembler creation code.
    ProcessLib::SmallDeformation::createLocalAssemblers<
        DisplacementDim, SmallDeformationNonlocalLocalAssembler>(
        mesh.getElements(), dof_table, _local_assemblers,
        NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
        _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);
 
    setIPDataInitialConditions(_integration_point_writer, mesh.getProperties(),
                               _local_assemblers);
 
    // Set initial conditions for integration point from cell mesh properties.
    for (auto const& ip_writer : _integration_point_writer)
    {
        auto const& name = ip_writer->name();
        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;
            }
 
            // Disallow setting ip-data from both, the e.g. sigma_ip and
            // sigma_ip_ic fields simultaneously.
            if (mesh.getProperties().existsPropertyVector<double>(
                    name, MeshLib::MeshItemType::IntegrationPoint,
                    mesh_property.getNumberOfGlobalComponents()))
            {
                OGS_FATAL(
                    "Both, the field-data ({:s}) and cell-data ({:s}) "
                    "properties are available in the mesh for integration "
                    "point initialization, but only one can be used.",
                    name, name + "_ic");
            }
            // 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(), MeshLib::Mesh::getProperties(), ProcessLib::LocalAssemblerInterface::initialize(), MeshLib::IntegrationPoint, MeshLib::Mesh::isAxiallySymmetric(), ProcessLib::makeExtrapolator(), OGS_FATAL, and ProcessLib::setIPDataInitialConditions().

isLinear()

template<int DisplacementDim>

bool ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::isLinear ( ) const

override

Definition at line 62 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 255 of file SmallDeformationNonlocalProcess.cpp.

{
    _process_data.crack_volume_old = _process_data.crack_volume;
    _process_data.crack_volume = 0.0;
 
    DBUG("PostNonLinearSolver crack volume computation.");
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &LocalAssemblerInterface::computeCrackIntegral, _local_assemblers,
        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(), INFO(), and NumLib::SUCCESS.

postTimestepConcreteProcess()

template<int DisplacementDim>

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

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 235 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(); });
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &LocalAssemblerInterface::postTimestep, _local_assemblers,
        getActiveElementIDs(), dof_tables, x, x_prev, t, dt, process_id);
}

References DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), 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 198 of file SmallDeformationNonlocalProcess.cpp.

{
    DBUG("preAssemble SmallDeformationNonlocalProcess.");
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::preAssemble,
        _local_assemblers, getActiveElementIDs(), *_local_to_global_index_map,
        t, dt, x);
}

References DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::VectorMatrixAssembler::preAssemble().

Member Data Documentation

_local_assemblers

template<int DisplacementDim>

std::vector<std::unique_ptr<LocalAssemblerInterface> > ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::_local_assemblers

private

Definition at line 80 of file SmallDeformationNonlocalProcess.h.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::SmallDeformationNonlocalProcess().

_local_to_global_index_map_single_component

template<int DisplacementDim>

std::unique_ptr<NumLib::LocalToGlobalIndexMap> ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::_local_to_global_index_map_single_component

private

Definition at line 83 of file SmallDeformationNonlocalProcess.h.

_nodal_forces

template<int DisplacementDim>

MeshLib::PropertyVector<double>* ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::_nodal_forces = nullptr

private

Definition at line 85 of file SmallDeformationNonlocalProcess.h.

Referenced by ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::SmallDeformationNonlocalProcess().

_process_data

template<int DisplacementDim>

SmallDeformationNonlocalProcessData<DisplacementDim> ProcessLib::SmallDeformationNonlocal::SmallDeformationNonlocalProcess< DisplacementDim >::_process_data

private

Definition at line 76 of file SmallDeformationNonlocalProcess.h.

---

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

• ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.h
• ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.cpp