Detailed Description

template<int DisplacementDim>
class ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >

A class to simulate thermo-mechanical fracturing process using phase-field approach in solids described by.

\[ \mathrm{div} \left[ \left(d^2 + k \right) \boldsymbol{\sigma}_0^+ + \boldsymbol{\sigma}_0^- \right] + \varrho \boldsymbol{b} = \boldsymbol{0} \]

\[ 2d \psi^+(\boldsymbol{\epsilon}_\mathrm{el}) - \frac{1 - d}{2 \varepsilon} g_\mathrm{c} - 2 \varepsilon g_\mathrm{c} \mathrm{div}(\mathrm{grad} d) = 0 \]

\[ (\varrho c_\mathrm{p})_\mathrm{eff} \dfrac{\partial \vartheta}{\partial t} - \mathrm{div} \left(\boldsymbol{\kappa}_\mathrm{eff} \mathrm{grad}\,\vartheta \right) = 0 \]

where

\begin{eqnarray*} &d:& \mbox{order parameter,}\\ &\varrho:& \mbox{density,}\\ &g_\mathrm{c}:& \mbox{fracture energy,}\\ &\varepsilon:& \mbox{length scale}\\ &c_\mathrm{p}:& \mbox{specific heat capacity in constant pressure}\\ &\kappa_\mathrm{eff}:& \mbox{effectiev thermal conductivity}\\ \end{eqnarray*}

Detailed model description can refer [16].

Definition at line 54 of file ThermoMechanicalPhaseFieldProcess.h.

#include <ThermoMechanicalPhaseFieldProcess.h>

Inheritance diagram for ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >:

[legend]

Collaboration diagram for ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >:

[legend]

Public Member Functions
	ThermoMechanicalPhaseFieldProcess (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, ThermoMechanicalPhaseFieldProcessData< DisplacementDim > &&process_data, SecondaryVariableCollection &&secondary_variables, int const mechanics_related_process_id, int const phase_field_process_id, int const heat_conduction_process_id)

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

NumLib::LocalToGlobalIndexMap const &	getDOFTable (const int process_id) const override

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

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 Member Functions
void	constructDofTable () override

void	initializeBoundaryConditions () override

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	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	preTimestepConcreteProcess (std::vector< GlobalVector * > const &x, double const t, double const dt, const int process_id) override

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

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

NumLib::LocalToGlobalIndexMap &	getDOFTableByProcessID (const int process_id) const

Private Attributes
ThermoMechanicalPhaseFieldProcessData< DisplacementDim >	_process_data

std::vector< std::unique_ptr< ThermoMechanicalPhaseFieldLocalAssemblerInterface > >	_local_assemblers

std::unique_ptr< NumLib::LocalToGlobalIndexMap >	_local_to_global_index_map_single_component

GlobalSparsityPattern	_sparsity_pattern_with_single_component
	Sparsity pattern for the phase field equation, and it is initialized. More...

int const	_mechanics_related_process_id
	ID of the processes that contains mechanical process. More...

int const	_phase_field_process_id
	ID of phase field process. More...

int const	_heat_conduction_process_id
	ID of heat conduction process. More...

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)

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

Constructor & Destructor Documentation

◆ ThermoMechanicalPhaseFieldProcess()

template<int DisplacementDim>

ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::ThermoMechanicalPhaseFieldProcess	(	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,
		ThermoMechanicalPhaseFieldProcessData< DisplacementDim > &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		int const	mechanics_related_process_id,
		int const	phase_field_process_id,
		int const	heat_conduction_process_id
	)

Definition at line 26 of file ThermoMechanicalPhaseFieldProcess.cpp.

     : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), false),
       _process_data(std::move(process_data)),
       _mechanics_related_process_id(mechanics_related_process_id),
       _phase_field_process_id(phase_field_process_id),
       _heat_conduction_process_id(heat_conduction_process_id)
 {
 }

Member Function Documentation

◆ assembleConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< 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 190 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     DBUG("Assemble the equations for ThermoMechanicalPhaseFieldProcess.");
  
     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::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< 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 211 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     std::vector<std::reference_wrapper<NumLib::LocalToGlobalIndexMap>>
         dof_tables;
     // For the staggered scheme
     if (process_id == _mechanics_related_process_id)
     {
         DBUG(
             "Assemble the Jacobian equations of "
             "temperature-deformation in ThermoMechanicalPhaseFieldProcess for "
             "the staggered scheme.");
     }
  
     if (process_id == _phase_field_process_id)
     {
         DBUG(
             "Assemble the Jacobian equations ofphase field in "
             "ThermoMechanicalPhaseFieldProcess for the staggered scheme.");
     }
     else
     {
         DBUG(
             "Assemble the Jacobian equations of heat conduction in "
             "ThermoMechanicalPhaseFieldProcess for the staggered scheme.");
     }
     dof_tables.emplace_back(
         getDOFTableByProcessID(_heat_conduction_process_id));
     dof_tables.emplace_back(
         getDOFTableByProcessID(_mechanics_related_process_id));
     dof_tables.emplace_back(getDOFTableByProcessID(_phase_field_process_id));
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberDereferenced(
         _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
         _local_assemblers, pv.getActiveElementIDs(), dof_tables, t, dt, x, xdot,
         dxdot_dx, dx_dx, process_id, M, K, b, Jac);
 }

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

◆ constructDofTable()

template<int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::constructDofTable

overrideprivatevirtual

This function is for general cases, in which all equations of the coupled processes have the same number of unknowns. For the general cases with the staggered scheme, all equations of the coupled processes share one DOF table hold by _local_to_global_index_map. Other cases can be considered by overloading this member function in the derived class.

Reimplemented from ProcessLib::Process.

Definition at line 105 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     // For displacement equation.
     constructDofTableOfSpecifiedProcessStaggeredScheme(
         _mechanics_related_process_id);
  
     // TODO move the two data members somewhere else.
     // for extrapolation of secondary variables of stress or strain
     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);
  
     assert(_local_to_global_index_map_single_component);
  
     // For phase field equation or the heat conduction.
     _sparsity_pattern_with_single_component = NumLib::computeSparsityPattern(
         *_local_to_global_index_map_single_component, _mesh);
 }

References NumLib::BY_LOCATION, and NumLib::computeSparsityPattern().

◆ getDOFTable()

template<int DisplacementDim>

NumLib::LocalToGlobalIndexMap const & ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::getDOFTable ( const int process_id ) const

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 78 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     if (process_id == _mechanics_related_process_id)
     {
         return *_local_to_global_index_map;
     }
  
     // For the equation of phasefield or heat conduction.
     return *_local_to_global_index_map_single_component;
 }

◆ getDOFTableByProcessID()

template<int DisplacementDim>

NumLib::LocalToGlobalIndexMap & ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::getDOFTableByProcessID ( const int process_id ) const

private

Definition at line 92 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     if (process_id == _mechanics_related_process_id)
     {
         return *_local_to_global_index_map;
     }
  
     // For the equation of phasefield or heat conduction.
     return *_local_to_global_index_map_single_component;
 }

◆ getMatrixSpecifications()

template<int DisplacementDim>

MathLib::MatrixSpecifications ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::getMatrixSpecifications ( const int process_id ) const

override

Definition at line 60 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     if (process_id == _mechanics_related_process_id)
     {
         auto const& l = *_local_to_global_index_map;
         return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
                 &l.getGhostIndices(), &this->_sparsity_pattern};
     }
  
     // For staggered scheme and phase field process or heat conduction.
     auto const& l = *_local_to_global_index_map_single_component;
     return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
             &l.getGhostIndices(), &_sparsity_pattern_with_single_component};
 }

◆ initializeBoundaryConditions()

template<int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::initializeBoundaryConditions

overrideprivatevirtual

Member function to initialize the boundary conditions for all coupled processes. It is called by initialize().

Reimplemented from ProcessLib::Process.

Definition at line 172 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     // Staggered scheme:
     // for the equations of temperature-deformation.
     initializeProcessBoundaryConditionsAndSourceTerms(
         getDOFTableByProcessID(_mechanics_related_process_id),
         _mechanics_related_process_id);
     // for the phase field
     initializeProcessBoundaryConditionsAndSourceTerms(
         getDOFTableByProcessID(_phase_field_process_id),
         _phase_field_process_id);
     // for heat conduction
     initializeProcessBoundaryConditionsAndSourceTerms(
         getDOFTableByProcessID(_heat_conduction_process_id),
         _heat_conduction_process_id);
 }

◆ initializeConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< 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 129 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     ProcessLib::SmallDeformation::createLocalAssemblers<
         DisplacementDim, ThermoMechanicalPhaseFieldLocalAssembler>(
         mesh.getElements(), dof_table, _local_assemblers,
         mesh.isAxiallySymmetric(), integration_order, _process_data,
         _mechanics_related_process_id, _phase_field_process_id,
         _heat_conduction_process_id);
  
     _secondary_variables.addSecondaryVariable(
         "sigma",
         makeExtrapolator(
             MathLib::KelvinVector::KelvinVectorType<
                 DisplacementDim>::RowsAtCompileTime,
             getExtrapolator(), _local_assemblers,
             &ThermoMechanicalPhaseFieldLocalAssemblerInterface::getIntPtSigma));
  
     _secondary_variables.addSecondaryVariable(
         "epsilon",
         makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                              DisplacementDim>::RowsAtCompileTime,
                          getExtrapolator(), _local_assemblers,
                          &ThermoMechanicalPhaseFieldLocalAssemblerInterface::
                              getIntPtEpsilon));
  
     _secondary_variables.addSecondaryVariable(
         "heat_flux",
         makeExtrapolator(mesh.getDimension(), getExtrapolator(),
                          _local_assemblers,
                          &ThermoMechanicalPhaseFieldLocalAssemblerInterface::
                              getIntPtHeatFlux));
  
     // Initialize local assemblers after all variables have been set.
     GlobalExecutor::executeMemberOnDereferenced(
         &LocalAssemblerInterface::initialize, _local_assemblers,
         *_local_to_global_index_map);
 }

References ProcessLib::SmallDeformation::createLocalAssemblers(), NumLib::SerialExecutor::executeMemberOnDereferenced(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldLocalAssemblerInterface::getIntPtSigma(), ProcessLib::LocalAssemblerInterface::initialize(), MeshLib::Mesh::isAxiallySymmetric(), and ProcessLib::makeExtrapolator().

◆ isLinear()

template<int DisplacementDim>

bool ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::isLinear

override

Definition at line 53 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     return false;
 }

◆ postNonLinearSolverConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::postNonLinearSolverConcreteProcess	(	GlobalVector const &	x,
		GlobalVector const &	xdot,
		const double	t,
		double const	dt,
		int const	process_id
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 305 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     if (process_id != _mechanics_related_process_id)
     {
         return;
     }
  
     DBUG("PostNonLinearSolver ThermoMechanicalPhaseFieldProcess.");
     // Calculate strain, stress or other internal variables of mechanics.
     const bool use_monolithic_scheme = false;
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &LocalAssemblerInterface::postNonLinearSolver, _local_assemblers,
         pv.getActiveElementIDs(), getDOFTable(process_id), x, xdot, t, dt,
         use_monolithic_scheme, process_id);
 }

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

◆ postTimestepConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< 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 278 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     if (process_id != 0)
     {
         return;
     }
  
     DBUG("PostTimestep ThermoMechanicalPhaseFieldProcess.");
     std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
     auto const n_processes = x.size();
     dof_tables.reserve(n_processes);
     for (std::size_t process_id = 0; process_id < n_processes; ++process_id)
     {
         dof_tables.push_back(&getDOFTable(process_id));
     }
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &ThermoMechanicalPhaseFieldLocalAssemblerInterface::postTimestep,
         _local_assemblers, pv.getActiveElementIDs(), dof_tables, x, t, dt);
 }

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

◆ preTimestepConcreteProcess()

template<int DisplacementDim>

void ProcessLib::ThermoMechanicalPhaseField::ThermoMechanicalPhaseFieldProcess< DisplacementDim >::preTimestepConcreteProcess	(	std::vector< GlobalVector * > const &	x,
		double const	t,
		double const	dt,
		const int	process_id
	)

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 256 of file ThermoMechanicalPhaseFieldProcess.cpp.

 {
     DBUG("PreTimestep ThermoMechanicalPhaseFieldProcess.");
  
     if (process_id != _mechanics_related_process_id)
     {
         return;
     }
  
     ProcessLib::ProcessVariable const& pv = getProcessVariables(process_id)[0];
  
     GlobalExecutor::executeSelectedMemberOnDereferenced(
         &ThermoMechanicalPhaseFieldLocalAssemblerInterface::preTimestep,
         _local_assemblers, pv.getActiveElementIDs(), getDOFTable(process_id),
         *x[process_id], t, dt);
 }