ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim > Class Template Reference

Detailed Description

template<int DisplacementDim>
class ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >

Definition at line 15 of file PhaseFieldProcess.h.

#include <PhaseFieldProcess.h>

Inheritance diagram for ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >:

Collaboration diagram for ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >:

Public Member Functions
	PhaseFieldProcess (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, PhaseFieldProcessData< DisplacementDim > &&process_data, SecondaryVariableCollection &&secondary_variables, bool const use_monolithic_scheme)
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.
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
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 = PhaseFieldLocalAssemblerInterface

Private Member Functions
void	constructDofTable () override
void	initializeBoundaryConditions (std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const &media) override
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	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	preTimestepConcreteProcess (std::vector< GlobalVector * > const &x, double const t, double const dt, const int process_id) override
void	postTimestepConcreteProcess (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, const double delta_t, int const process_id) override
void	postNonLinearSolverConcreteProcess (std::vector< GlobalVector * > const &x, std::vector< GlobalVector * > const &x_prev, const double t, double const dt, int const process_id) override
void	updateConstraints (GlobalVector &lower, GlobalVector &upper, int const process_id) override
bool	isPhaseFieldProcess (int const process_id) const

Private Attributes
PhaseFieldProcessData< 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
GlobalSparsityPattern	_sparsity_pattern_with_single_component
std::unique_ptr< GlobalVector >	_x_previous_timestep

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)
void	constructMonolithicProcessDofTable ()
void	constructDofTableOfSpecifiedProcessStaggeredScheme (const int specified_process_id)
virtual std::tuple< NumLib::LocalToGlobalIndexMap *, bool >	getDOFTableForExtrapolatorData () const
std::vector< GlobalIndexType >	getIndicesOfResiduumWithoutInitialCompensation () const override
void	setReleaseNodalForces (GlobalVector const *r_neq, int const process_id) 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::PhaseField::PhaseFieldProcess< DisplacementDim >::LocalAssemblerInterface = PhaseFieldLocalAssemblerInterface

private

Definition at line 44 of file PhaseFieldProcess.h.

Constructor & Destructor Documentation

PhaseFieldProcess()

template<int DisplacementDim>

ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::PhaseFieldProcess	(	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,
		PhaseFieldProcessData< DisplacementDim > &&	process_data,
		SecondaryVariableCollection &&	secondary_variables,
		bool const	use_monolithic_scheme )

Definition at line 21 of file PhaseFieldProcess.cpp.

    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
              integration_order, std::move(process_variables),
              std::move(secondary_variables), use_monolithic_scheme),
      _process_data(std::move(process_data))
{
    // For numerical Jacobian assembler
    if (this->_jacobian_assembler->isPerturbationEnabled())
    {
        OGS_FATAL(
            "The numericial Jacobian assembler is not supported for the "
            "PhaseField process.");
    }
 
    if (use_monolithic_scheme)
    {
        OGS_FATAL(
            "Monolithic scheme is not implemented for the PhaseField process.");
    }
 
    _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));
}

References ProcessLib::Process::Process(), ProcessLib::Process::_integration_point_writer, ProcessLib::Process::_jacobian_assembler, _local_assemblers, _nodal_forces, _process_data, MeshLib::Mesh::getDimension(), MeshLib::getOrCreateMeshProperty(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::getSigma(), ProcessLib::Process::name, MeshLib::Node, and OGS_FATAL.

Member Function Documentation

assembleConcreteProcess()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< 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 198 of file PhaseFieldProcess.cpp.

{
    DBUG("Assemble PhaseFieldProcess.");
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
 
    // For the staggered scheme
    if (process_id == 1)
    {
        DBUG(
            "Assemble the equations of phase field in "
            "PhaseFieldProcess for the staggered scheme.");
    }
    else
    {
        DBUG(
            "Assemble the equations of deformation in "
            "PhaseFieldProcess for the staggered scheme.");
    }
    dof_tables.emplace_back(_local_to_global_index_map_single_component.get());
    dof_tables.emplace_back(_local_to_global_index_map.get());
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assemble, _local_assemblers,
        getActiveElementIDs(), dof_tables, t, dt, x, x_prev, process_id, &M, &K,
        &b);
}

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_single_component, ProcessLib::VectorMatrixAssembler::assemble(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::Process::getActiveElementIDs().

assembleWithJacobianConcreteProcess()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< 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 231 of file PhaseFieldProcess.cpp.

{
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
 
    // For the staggered scheme
    if (process_id == 1)
    {
        DBUG(
            "Assemble the Jacobian equations of phase field in "
            "PhaseFieldProcess for the staggered scheme.");
    }
    else
    {
        DBUG(
            "Assemble the Jacobian equations of deformation in "
            "PhaseFieldProcess for the staggered scheme.");
    }
    dof_tables.emplace_back(_local_to_global_index_map.get());
    dof_tables.emplace_back(_local_to_global_index_map_single_component.get());
 
    // Call global assembler for each local assembly item.
    GlobalExecutor::executeSelectedMemberDereferenced(
        _global_assembler, &VectorMatrixAssembler::assembleWithJacobian,
        _local_assemblers, getActiveElementIDs(), dof_tables, t, dt, x, x_prev,
        process_id, &b, &Jac);
 
    if (process_id == 0)
    {
        b.copyValues(*_nodal_forces);
        std::transform(_nodal_forces->begin(), _nodal_forces->end(),
                       _nodal_forces->begin(), [](double val) { return -val; });
    }
}

References ProcessLib::Process::_global_assembler, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_single_component, _nodal_forces, ProcessLib::VectorMatrixAssembler::assembleWithJacobian(), MathLib::EigenVector::copyValues(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberDereferenced(), and ProcessLib::Process::getActiveElementIDs().

constructDofTable()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< 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 102 of file PhaseFieldProcess.cpp.

{
    // For displacement equation.
    const int mechanics_process_id = 0;
    constructDofTableOfSpecifiedProcessStaggeredScheme(mechanics_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.
    _sparsity_pattern_with_single_component = NumLib::computeSparsityPattern(
        *_local_to_global_index_map_single_component, _mesh);
}

References _local_to_global_index_map_single_component, ProcessLib::Process::_mesh, ProcessLib::Process::_mesh_subset_all_nodes, _sparsity_pattern_with_single_component, NumLib::BY_LOCATION, NumLib::computeSparsityPattern(), and ProcessLib::Process::constructDofTableOfSpecifiedProcessStaggeredScheme().

getDOFTable()

template<int DisplacementDim>

NumLib::LocalToGlobalIndexMap const & ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::getDOFTable ( const int process_id ) const

overridevirtual

Reimplemented from ProcessLib::Process.

Definition at line 89 of file PhaseFieldProcess.cpp.

{
    // For the M process (deformation) in the staggered scheme.
    if (process_id == 0)
    {
        return *_local_to_global_index_map;
    }
 
    // For the equation of phasefield
    return *_local_to_global_index_map_single_component;
}

References ProcessLib::Process::_local_to_global_index_map, and _local_to_global_index_map_single_component.

Referenced by preTimestepConcreteProcess().

getMatrixSpecifications()

template<int DisplacementDim>

MathLib::MatrixSpecifications ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::getMatrixSpecifications ( const int process_id ) const

override

Definition at line 70 of file PhaseFieldProcess.cpp.

{
    // For the M process (deformation) in the staggered scheme.
    if (process_id == 0)
    {
        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.
    auto const& l = *_local_to_global_index_map_single_component;
    return {l.dofSizeWithoutGhosts(), l.dofSizeWithoutGhosts(),
            &l.getGhostIndices(), &_sparsity_pattern_with_single_component};
}

References ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_single_component, ProcessLib::Process::_sparsity_pattern, and _sparsity_pattern_with_single_component.

initializeBoundaryConditions()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::initializeBoundaryConditions ( std::map< int, std::shared_ptr< MaterialPropertyLib::Medium > > const & media )

overrideprivatevirtual

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

Reimplemented from ProcessLib::Process.

Definition at line 182 of file PhaseFieldProcess.cpp.

{
    // Staggered scheme:
    // for the equations of deformation.
    const int mechanical_process_id = 0;
    initializeProcessBoundaryConditionsAndSourceTerms(
        *_local_to_global_index_map, mechanical_process_id, media);
    // for the phase field
    const int phasefield_process_id = 1;
    initializeProcessBoundaryConditionsAndSourceTerms(
        *_local_to_global_index_map_single_component, phasefield_process_id,
        media);
}

References ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_single_component, and ProcessLib::Process::initializeProcessBoundaryConditionsAndSourceTerms().

initializeConcreteProcess()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< 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 126 of file PhaseFieldProcess.cpp.

{
    ProcessLib::SmallDeformation::createLocalAssemblers<
        DisplacementDim, PhaseFieldLocalAssembler>(
        mesh.getElements(), dof_table, _local_assemblers,
        NumLib::IntegrationOrder{integration_order}, mesh.isAxiallySymmetric(),
        _process_data);
 
    _secondary_variables.addSecondaryVariable(
        "sigma",
        makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                             DisplacementDim>::RowsAtCompileTime,
                         getExtrapolator(), _local_assemblers,
                         &LocalAssemblerInterface::getIntPtSigma));
 
    _secondary_variables.addSecondaryVariable(
        "epsilon",
        makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                             DisplacementDim>::RowsAtCompileTime,
                         getExtrapolator(), _local_assemblers,
                         &LocalAssemblerInterface::getIntPtEpsilon));
 
    _secondary_variables.addSecondaryVariable(
        "sigma_tensile",
        makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                             DisplacementDim>::RowsAtCompileTime,
                         getExtrapolator(), _local_assemblers,
                         &LocalAssemblerInterface::getIntPtSigmaTensile));
 
    _secondary_variables.addSecondaryVariable(
        "sigma_compressive",
        makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                             DisplacementDim>::RowsAtCompileTime,
                         getExtrapolator(), _local_assemblers,
                         &LocalAssemblerInterface::getIntPtSigmaCompressive));
 
    _secondary_variables.addSecondaryVariable(
        "eps_tensile",
        makeExtrapolator(MathLib::KelvinVector::KelvinVectorType<
                             DisplacementDim>::RowsAtCompileTime,
                         getExtrapolator(), _local_assemblers,
                         &LocalAssemblerInterface::getIntPtEpsilonTensile));
 
    setIPDataInitialConditions(_integration_point_writer, mesh.getProperties(),
                               _local_assemblers);
 
    // Initialize local assemblers after all variables have been set.
    GlobalExecutor::executeMemberOnDereferenced(
        &LocalAssemblerInterface::initialize, _local_assemblers,
        *_local_to_global_index_map);
}

References ProcessLib::Process::_integration_point_writer, _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _process_data, ProcessLib::Process::_secondary_variables, ProcessLib::SmallDeformation::createLocalAssemblers(), NumLib::SerialExecutor::executeMemberOnDereferenced(), MeshLib::Mesh::getElements(), ProcessLib::Process::getExtrapolator(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::getIntPtEpsilon(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::getIntPtEpsilonTensile(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::getIntPtSigma(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::getIntPtSigmaCompressive(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::getIntPtSigmaTensile(), MeshLib::Mesh::getProperties(), ProcessLib::LocalAssemblerInterface::initialize(), MeshLib::Mesh::isAxiallySymmetric(), ProcessLib::makeExtrapolator(), and ProcessLib::setIPDataInitialConditions().

isLinear()

template<int DisplacementDim>

bool ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::isLinear ( ) const

override

Definition at line 63 of file PhaseFieldProcess.cpp.

{
    return false;
}

isPhaseFieldProcess()

template<int DisplacementDim>

bool ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::isPhaseFieldProcess ( int const process_id ) const

private

Check whether the process represented by process_id is/has mechanical process. In the present implementation, the mechanical process has process_id == 0 in the staggered scheme.

Definition at line 408 of file PhaseFieldProcess.cpp.

{
    return process_id == 1;
}

Referenced by postNonLinearSolverConcreteProcess(), and postTimestepConcreteProcess().

postNonLinearSolverConcreteProcess()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::postNonLinearSolverConcreteProcess ( std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, const double t, double const dt, int const process_id )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 334 of file PhaseFieldProcess.cpp.

{
    _process_data.crack_volume = 0.0;
 
    if (isPhaseFieldProcess(process_id))
    {
        if (_process_data.propagating_pressurized_crack)
        {
            auto& u = *x[0];
            MathLib::LinAlg::scale(const_cast<GlobalVector&>(u),
                                   1 / _process_data.pressure);
        }
        return;
    }
 
    std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
 
    dof_tables.emplace_back(_local_to_global_index_map.get());
    dof_tables.emplace_back(_local_to_global_index_map_single_component.get());
 
    DBUG("PostNonLinearSolver crack volume computation.");
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &LocalAssemblerInterface::computeCrackIntegral, _local_assemblers,
        getActiveElementIDs(), dof_tables, x, t, _process_data.crack_volume);
 
#ifdef USE_PETSC
    _process_data.crack_volume = BaseLib::MPI::allreduce(
        _process_data.crack_volume, MPI_SUM, BaseLib::MPI::Mpi{});
#endif
 
    INFO("Integral of crack: {:g}", _process_data.crack_volume);
 
    if (_process_data.propagating_pressurized_crack)
    {
        _process_data.pressure_old = _process_data.pressure;
        _process_data.pressure =
            _process_data.injected_volume / _process_data.crack_volume;
        _process_data.pressure_error =
            std::abs(_process_data.pressure_old - _process_data.pressure) /
            _process_data.pressure;
        INFO("Internal pressure: {:g} and Pressure error: {:.4e}",
             _process_data.pressure, _process_data.pressure_error);
 
        auto& u = *x[0];
        MathLib::LinAlg::scale(const_cast<GlobalVector&>(u),
                               _process_data.pressure);
    }
}

References _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_single_component, _process_data, BaseLib::MPI::allreduce(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::computeCrackIntegral(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), INFO(), isPhaseFieldProcess(), and MathLib::LinAlg::scale().

postTimestepConcreteProcess()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::postTimestepConcreteProcess ( std::vector< GlobalVector * > const & x, std::vector< GlobalVector * > const & x_prev, const double t, const double delta_t, int const process_id )

overrideprivatevirtual

Reimplemented from ProcessLib::Process.

Definition at line 286 of file PhaseFieldProcess.cpp.

{
    if (isPhaseFieldProcess(process_id))
    {
        DBUG("PostTimestep PhaseFieldProcess.");
 
        _process_data.elastic_energy = 0.0;
        _process_data.surface_energy = 0.0;
        _process_data.pressure_work = 0.0;
 
        std::vector<NumLib::LocalToGlobalIndexMap const*> dof_tables;
 
        dof_tables.emplace_back(_local_to_global_index_map.get());
        dof_tables.emplace_back(
            _local_to_global_index_map_single_component.get());
 
        GlobalExecutor::executeSelectedMemberOnDereferenced(
            &LocalAssemblerInterface::computeEnergy, _local_assemblers,
            getActiveElementIDs(), dof_tables, x, t,
            _process_data.elastic_energy, _process_data.surface_energy,
            _process_data.pressure_work);
 
#ifdef USE_PETSC
        BaseLib::MPI::Mpi mpi{};
        _process_data.elastic_energy =
            BaseLib::MPI::allreduce(_process_data.elastic_energy, MPI_SUM, mpi);
        _process_data.surface_energy =
            BaseLib::MPI::allreduce(_process_data.surface_energy, MPI_SUM, mpi);
        _process_data.pressure_work =
            BaseLib::MPI::allreduce(_process_data.pressure_work, MPI_SUM, mpi);
#endif
 
        INFO(
            "Elastic energy: {:g} Surface energy: {:g} Pressure work: {:g}  at "
            "time: {:g} ",
            _process_data.elastic_energy, _process_data.surface_energy,
            _process_data.pressure_work, t);
        if (_process_data.propagating_pressurized_crack)
        {
            INFO("Pressure: {:g} at time: {:g} ", _process_data.pressure, t);
        }
    }
}

References _local_assemblers, ProcessLib::Process::_local_to_global_index_map, _local_to_global_index_map_single_component, _process_data, BaseLib::MPI::allreduce(), ProcessLib::PhaseField::PhaseFieldLocalAssemblerInterface::computeEnergy(), DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), INFO(), and isPhaseFieldProcess().

preTimestepConcreteProcess()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< 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 269 of file PhaseFieldProcess.cpp.

{
    DBUG("PreTimestep PhaseFieldProcess {:d}.", process_id);
 
    _process_data.injected_volume = t;
 
    _x_previous_timestep =
        MathLib::MatrixVectorTraits<GlobalVector>::newInstance(*x[process_id]);
 
    GlobalExecutor::executeSelectedMemberOnDereferenced(
        &LocalAssemblerInterface::preTimestep, _local_assemblers,
        getActiveElementIDs(), getDOFTable(process_id), *x[process_id], t, dt);
}

References _local_assemblers, _process_data, _x_previous_timestep, DBUG(), NumLib::SerialExecutor::executeSelectedMemberOnDereferenced(), ProcessLib::Process::getActiveElementIDs(), getDOFTable(), and ProcessLib::LocalAssemblerInterface::preTimestep().

updateConstraints()

template<int DisplacementDim>

void ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::updateConstraints ( GlobalVector & lower, GlobalVector & upper, int const process_id )

overrideprivate

Definition at line 388 of file PhaseFieldProcess.cpp.

{
    lower.setZero();
    MathLib::LinAlg::setLocalAccessibleVector(*_x_previous_timestep);
    MathLib::LinAlg::copy(*_x_previous_timestep, upper);
 
    GlobalIndexType const x_begin = _x_previous_timestep->getRangeBegin();
    GlobalIndexType const x_end = _x_previous_timestep->getRangeEnd();
 
    for (GlobalIndexType i = x_begin; i < x_end; i++)
    {
        if ((*_x_previous_timestep)[i] > _process_data.irreversible_threshold)
        {
            upper.set(i, 1.0);
        }
    }
}

References _process_data, _x_previous_timestep, MathLib::LinAlg::copy(), MathLib::EigenVector::set(), MathLib::LinAlg::setLocalAccessibleVector(), and MathLib::EigenVector::setZero().

Member Data Documentation

_local_assemblers

template<int DisplacementDim>

std::vector<std::unique_ptr<LocalAssemblerInterface> > ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::_local_assemblers

private

Definition at line 88 of file PhaseFieldProcess.h.

Referenced by PhaseFieldProcess(), assembleConcreteProcess(), assembleWithJacobianConcreteProcess(), initializeConcreteProcess(), postNonLinearSolverConcreteProcess(), postTimestepConcreteProcess(), and preTimestepConcreteProcess().

_local_to_global_index_map_single_component

template<int DisplacementDim>

std::unique_ptr<NumLib::LocalToGlobalIndexMap> ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::_local_to_global_index_map_single_component

private

Definition at line 91 of file PhaseFieldProcess.h.

Referenced by assembleConcreteProcess(), assembleWithJacobianConcreteProcess(), constructDofTable(), getDOFTable(), getMatrixSpecifications(), initializeBoundaryConditions(), postNonLinearSolverConcreteProcess(), and postTimestepConcreteProcess().

_nodal_forces

template<int DisplacementDim>

MeshLib::PropertyVector<double>* ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::_nodal_forces = nullptr

private

Definition at line 93 of file PhaseFieldProcess.h.

Referenced by PhaseFieldProcess(), and assembleWithJacobianConcreteProcess().

_process_data

template<int DisplacementDim>

PhaseFieldProcessData<DisplacementDim> ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::_process_data

private

Definition at line 86 of file PhaseFieldProcess.h.

Referenced by PhaseFieldProcess(), initializeConcreteProcess(), postNonLinearSolverConcreteProcess(), postTimestepConcreteProcess(), preTimestepConcreteProcess(), and updateConstraints().

_sparsity_pattern_with_single_component

template<int DisplacementDim>

GlobalSparsityPattern ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::_sparsity_pattern_with_single_component

private

Sparsity pattern for the phase field equation, and it is initialized only if the staggered scheme is used.

Definition at line 97 of file PhaseFieldProcess.h.

Referenced by constructDofTable(), and getMatrixSpecifications().

_x_previous_timestep

template<int DisplacementDim>

std::unique_ptr<GlobalVector> ProcessLib::PhaseField::PhaseFieldProcess< DisplacementDim >::_x_previous_timestep

private

Definition at line 99 of file PhaseFieldProcess.h.

Referenced by preTimestepConcreteProcess(), and updateConstraints().

---

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

• PhaseFieldProcess.h
• PhaseFieldProcess.cpp