#include "users_modules/eshelbian_plasticity/src/IncrementalMechanics.hpp"

Collaboration diagram for EshelbianPlasticity::IncrementalMechanics:

Public Types
using	FieldSnapshot = std::map< EntityHandle, std::vector< double > >

Public Member Functions
	IncrementalMechanics (EshelbianCore &ep, SmartPetscObj< TS > ts)

TS	getTS () const

void	addStateControlField (const std::string &field)

void	addHistoryField (const std::string &field)

MoFEMErrorCode	solveState (Vec state, EquilibriumSolveReport &report)

MoFEMErrorCode	fixedDataAreCurrent (bool &current)

MoFEMErrorCode	restoreState (Vec state)

MoFEMErrorCode	evaluateBaseline (Vec state, double &value)

MoFEMErrorCode	evaluateConservativeValue (double &value)

MoFEMErrorCode	assembleConservativeGradient (DM control_dm, Vec gradient)

bool	supportsHessianAction () const

MoFEMErrorCode	prepareHessian (DM control_dm, Vec control)

MoFEMErrorCode	applyHessian (Vec direction, Vec action)

MoFEMErrorCode	assembleHessianPreconditioner (Mat metric)

PetscInt	getMechanicalSolveCount () const

PetscInt	getDirectionalSolveCount () const

Private Member Functions
MoFEMErrorCode	publishTrialControl ()

MoFEMErrorCode	stateControlBlocksEqual (Vec first, Vec second, PetscBool &equal)

MoFEMErrorCode	zeroStateControlBlocks (Vec control)

MoFEMErrorCode	snapshotHistory (std::vector< FieldSnapshot > &snapshot)

MoFEMErrorCode	refreshConservativeGradient (DM control_dm)

Private Attributes
EshelbianCore &	ep

SmartPetscObj< TS >	timeSolver

std::vector< std::string >	stateControlFields

std::vector< std::string >	historyFields

SmartPetscObj< Vec >	cachedControl

SmartPetscObj< Vec >	cachedState

EquilibriumSolveReport	cachedReport

std::vector< FieldSnapshot >	cachedHistory

double	cachedPhysicalTime = 0

bool	cacheValid = false

PetscInt	mechanicalSolves = 0

SmartPetscObj< Vec >	cachedGradient

bool	gradientValid = false

boost::shared_ptr< PlasticIncrementalOptimizationInternal::ReducedBulkMaterialEnergyHessianWorkspace >	gradientWorkspace

boost::shared_ptr< PlasticIncrementalOptimizationInternal::ReducedBulkMaterialEnergyHessianWorkspace >	hessianWorkspace

Detailed Description

Mechanical state of the incremental optimisation.

One object serves every physics. It owns the fixed-control TS equilibrium solve with its cache, the zero-increment baseline, the bulk Helmholtz value, the base adjoint of the reduced conservative gradient and the frozen tangents of the reduced Hessian action. A physics registers the control fields that enter equilibrium, so only their blocks of the trial control key the state cache, and the mesh history fields whose change invalidates that cache. The mechanical pipelines read the registered control fields from EshelbianCore::incrementalTrialControl.

Definition at line 34 of file IncrementalMechanics.hpp.

Member Typedef Documentation

◆ FieldSnapshot

using EshelbianPlasticity::IncrementalMechanics::FieldSnapshot = std::map<EntityHandle, std::vector<double> >

Definition at line 35 of file IncrementalMechanics.hpp.

Constructor & Destructor Documentation

◆ IncrementalMechanics()

EshelbianPlasticity::IncrementalMechanics::IncrementalMechanics	(	EshelbianCore &	ep,
		SmartPetscObj< TS >	ts
	)

Definition at line 20 of file IncrementalMechanics.cpp.

22 : ep(ep), timeSolver(std::move(ts)) {}

EshelbianPlasticity::IncrementalMechanics::timeSolver

SmartPetscObj< TS > timeSolver

Definition IncrementalMechanics.hpp:85

EshelbianPlasticity::IncrementalMechanics::ep

EshelbianCore & ep

Definition IncrementalMechanics.hpp:84

Member Function Documentation

◆ addHistoryField()

void EshelbianPlasticity::IncrementalMechanics::addHistoryField ( const std::string & field )

inline

Definition at line 43 of file IncrementalMechanics.hpp.

                                               {
    historyFields.push_back(field);
  }

◆ addStateControlField()

void EshelbianPlasticity::IncrementalMechanics::addStateControlField ( const std::string & field )

inline

Definition at line 40 of file IncrementalMechanics.hpp.

                                                    {
    stateControlFields.push_back(field);
  }

◆ applyHessian()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::applyHessian	(	Vec	direction,
		Vec	action
	)

Write the reduced mechanical Hessian action in direction to action through one tangent-state and one incremental-adjoint solve.

Definition at line 260 of file IncrementalMechanics.cpp.

                                                                           {
  MoFEMFunctionBegin;
  if (!hessianWorkspace)
    SETERRQ(ep.mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
            "Mechanical Hessian action requested before prepareHessian()");
  CHKERR assembleReducedBulkMaterialEnergyHessianAction(
      ep, timeSolver, *hessianWorkspace, direction, action);
  MoFEMFunctionReturn(0);
}

◆ assembleConservativeGradient()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::assembleConservativeGradient	(	DM	control_dm,
		Vec	gradient
	)

Reduced conservative gradient on control_dm through the base adjoint; cached until the next equilibrium solve.

Definition at line 230 of file IncrementalMechanics.cpp.

                                                                 {
  MoFEMFunctionBegin;
  if (!gradientValid)
    CHKERR refreshConservativeGradient(control_dm);
  CHKERR VecCopy(cachedGradient, gradient);
  MoFEMFunctionReturn(0);
}

◆ assembleHessianPreconditioner()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::assembleHessianPreconditioner ( Mat metric )

Add the frozen material curvature block to the SPD metric.

Definition at line 270 of file IncrementalMechanics.cpp.

                                                                             {
  MoFEMFunctionBegin;
  if (!hessianWorkspace)
    SETERRQ(ep.mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
            "Mechanical metric block requested before prepareHessian()");
  CHKERR assembleReducedBulkMaterialEnergyFlowPreconditioner(
      ep, *hessianWorkspace, metric, false);
  MoFEMFunctionReturn(0);
}

◆ evaluateBaseline()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::evaluateBaseline	(	Vec	state,
		double &	value
	)

Equilibrium with the registered control blocks zeroed and its Helmholtz value; the trial control is restored afterwards.

Definition at line 168 of file IncrementalMechanics.cpp.

                                                                     {
  MoFEMFunctionBegin;
  // The baseline is the equilibrium without any increment. Zero the control
  // blocks that enter equilibrium, solve, and put the trial control back so
  // the current trial is not lost.
  auto trial_before = vectorDuplicate(ep.incrementalTrialControl);
  CHKERR VecCopy(ep.incrementalTrialControl, trial_before);
  CHKERR zeroStateControlBlocks(ep.incrementalTrialControl);
  EquilibriumSolveReport report;
  const MoFEMErrorCode solve_error =
      solveEquilibriumStateTS(ep, timeSolver, state, report);
  MoFEMErrorCode value_error = 0;
  if (!solve_error && report.status == EquilibriumSolveStatus::Converged)
    value_error = evaluateEquilibratedMechanicalValue(ep, timeSolver, value);
  CHKERR VecCopy(trial_before, ep.incrementalTrialControl);
  CHKERR VecGhostUpdateBegin(ep.incrementalTrialControl, INSERT_VALUES,
                             SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(ep.incrementalTrialControl, INSERT_VALUES,
                           SCATTER_FORWARD);
  CHKERR solve_error;
  if (report.status != EquilibriumSolveStatus::Converged)
    SETERRQ(ep.mField.get_comm(), MOFEM_OPERATION_UNSUCCESSFUL,
            "Zero-increment baseline did not equilibrate (residual %g)",
            report.equilibriumNorm);
  CHKERR value_error;
  MoFEMFunctionReturn(0);
}

◆ evaluateConservativeValue()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::evaluateConservativeValue ( double & value )

Bulk Helmholtz free energy of the state on the mesh.

Definition at line 197 of file IncrementalMechanics.cpp.

                                                                            {
  return evaluateEquilibratedMechanicalValue(ep, timeSolver, value);
}

◆ fixedDataAreCurrent()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::fixedDataAreCurrent ( bool & current )

Whether the histories and the physical time still match the cache.

Definition at line 145 of file IncrementalMechanics.cpp.

                                                                      {
  MoFEMFunctionBegin;
  current = true;
  if (!cacheValid)
    MoFEMFunctionReturnHot(0);
  std::vector<FieldSnapshot> history;
  CHKERR snapshotHistory(history);
  int local_changed =
      cachedPhysicalTime != ep.currentPhysicalTime || history != cachedHistory;
  int changed = 0;
  CHKERR MPI_Allreduce(&local_changed, &changed, 1, MPI_INT, MPI_MAX,
                       ep.mField.get_comm());
  current = !changed;
  MoFEMFunctionReturn(0);
}

◆ getDirectionalSolveCount()

PetscInt EshelbianPlasticity::IncrementalMechanics::getDirectionalSolveCount ( ) const

Definition at line 280 of file IncrementalMechanics.cpp.

                                                              {
  return hessianWorkspace ? getReducedBulkMaterialEnergyDirectionalSolveCount(
                                *hessianWorkspace)
                          : 0;
}

◆ getMechanicalSolveCount()

PetscInt EshelbianPlasticity::IncrementalMechanics::getMechanicalSolveCount ( ) const

inline

Definition at line 73 of file IncrementalMechanics.hpp.

73{ return mechanicalSolves; }

EshelbianPlasticity::IncrementalMechanics::mechanicalSolves

PetscInt mechanicalSolves

Definition IncrementalMechanics.hpp:95

◆ getTS()

TS EshelbianPlasticity::IncrementalMechanics::getTS ( ) const

inline

Definition at line 39 of file IncrementalMechanics.hpp.

39{ return timeSolver.get(); }

◆ prepareHessian()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::prepareHessian	(	DM	control_dm,
		Vec	control
	)

Freeze the base adjoint and the tangent matrices at control.

Definition at line 244 of file IncrementalMechanics.cpp.

                                                                 {
  MoFEMFunctionBegin;
  if (!supportsHessianAction())
    SETERRQ(ep.mField.get_comm(), MOFEM_NOT_IMPLEMENTED,
            "The selected material does not provide the curvature of the "
            "reduced mechanical energy");
  if (!gradientValid)
    CHKERR refreshConservativeGradient(control_dm);
  if (!hessianWorkspace)
    hessianWorkspace = createReducedBulkMaterialEnergyHessianWorkspace();
  CHKERR freezeReducedBulkMaterialEnergyHessian(*gradientWorkspace, control,
                                                *hessianWorkspace);
  MoFEMFunctionReturn(0);
}

◆ publishTrialControl()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::publishTrialControl ( )

private

Definition at line 24 of file IncrementalMechanics.cpp.

                                                         {
  MoFEMFunctionBegin;
  if (!ep.dmIncrementalOptimization || !ep.incrementalTrialControl)
    SETERRQ(ep.mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
            "Incremental-optimisation control storage is unavailable");
  CHKERR VecGhostUpdateBegin(ep.incrementalTrialControl, INSERT_VALUES,
                             SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(ep.incrementalTrialControl, INSERT_VALUES,
                           SCATTER_FORWARD);
  CHKERR DMoFEMMeshToLocalVector(ep.dmIncrementalOptimization,
                                 ep.incrementalTrialControl, INSERT_VALUES,
                                 SCATTER_REVERSE, RowColData::ROW);
  MoFEMFunctionReturn(0);
}

◆ refreshConservativeGradient()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::refreshConservativeGradient ( DM control_dm )

private

Definition at line 202 of file IncrementalMechanics.cpp.

                                                               {
  MoFEMFunctionBegin;
  if (!cacheValid || !cachedState)
    SETERRQ(ep.mField.get_comm(), MOFEM_DATA_INCONSISTENCY,
            "The conservative gradient needs an equilibrated state");
  if (!cachedGradient)
    cachedGradient = createDMVector(control_dm);
  CHKERR VecZeroEntries(cachedGradient);
  if (supportsHessianAction()) {
    // Keep the base adjoint; prepareHessian() freezes it for the shell.
    if (!gradientWorkspace)
      gradientWorkspace = createReducedBulkMaterialEnergyHessianWorkspace();
    CHKERR prepareReducedBulkMaterialEnergyHessian(
        ep, timeSolver, control_dm, ep.incrementalTrialControl, cachedState,
        *gradientWorkspace);
    CHKERR assemblePlasticAdjointContribution(
        ep, control_dm,
        getReducedBulkMaterialEnergyBaseAdjoint(*gradientWorkspace),
        cachedGradient);
  } else {
    CHKERR assembleReducedBulkMaterialEnergyGradient(ep, timeSolver, control_dm,
                                                     cachedGradient);
  }
  gradientValid = true;
  MoFEMFunctionReturn(0);
}

◆ restoreState()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::restoreState ( Vec state )

Put the trial control and state back on the mesh.

Definition at line 161 of file IncrementalMechanics.cpp.

                                                           {
  MoFEMFunctionBegin;
  CHKERR publishTrialControl();
  CHKERR setStateOnMesh(ep, state);
  MoFEMFunctionReturn(0);
}

◆ snapshotHistory()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::snapshotHistory ( std::vector< FieldSnapshot > & snapshot )

private

Definition at line 82 of file IncrementalMechanics.cpp.

                                                                        {
  MoFEMFunctionBegin;
  snapshot.clear();
  snapshot.resize(historyFields.size());
  for (std::size_t f = 0; f != historyFields.size(); ++f) {
    auto &field_snapshot = snapshot[f];
    auto save = [&](boost::shared_ptr<FieldEntity> field_entity) {
      MoFEMFunctionBegin;
      auto data = field_entity->getEntFieldData();
      field_snapshot.emplace(field_entity->getEnt(),
                             std::vector<double>(data.begin(), data.end()));
      MoFEMFunctionReturn(0);
    };
    CHKERR ep.mField.getInterface<FieldBlas>()->fieldLambdaOnEntities(
        save, historyFields[f]);
  }
  MoFEMFunctionReturn(0);
}

◆ solveState()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::solveState	(	Vec	state,
		EquilibriumSolveReport &	report
	)

Publish the trial control and equilibrate; a cached state is reused when the registered control blocks, histories and time are unchanged.

Definition at line 102 of file IncrementalMechanics.cpp.

                                                                          {
  MoFEMFunctionBegin;
  CHKERR publishTrialControl();
  std::vector<FieldSnapshot> history;
  CHKERR snapshotHistory(history);
  PetscBool same_control = PETSC_FALSE;
  if (cacheValid)
    CHKERR stateControlBlocksEqual(ep.incrementalTrialControl, cachedControl,
                                   same_control);
  int local_changed = !cacheValid || !same_control ||
                      cachedPhysicalTime != ep.currentPhysicalTime ||
                      history != cachedHistory;
  int changed = 0;
  CHKERR MPI_Allreduce(&local_changed, &changed, 1, MPI_INT, MPI_MAX,
                       ep.mField.get_comm());
  if (!changed) {
    CHKERR VecCopy(cachedState, state);
    CHKERR setStateOnMesh(ep, state);
    report = cachedReport;
    report.mechanicalSolveCount = 0;
    MoFEMFunctionReturnHot(0);
  }
  // Only converged states are cached. A rejected trial keeps the previous
  // cache usable while the optimiser rolls the control back.
  gradientValid = false;
  ++mechanicalSolves;
  CHKERR solveEquilibriumStateTS(ep, timeSolver, state, report);
  report.mechanicalSolveCount = 1;
  if (report.status == EquilibriumSolveStatus::Converged) {
    if (!cachedControl)
      cachedControl = vectorDuplicate(ep.incrementalTrialControl);
    if (!cachedState)
      cachedState = vectorDuplicate(state);
    CHKERR VecCopy(ep.incrementalTrialControl, cachedControl);
    CHKERR VecCopy(state, cachedState);
    cachedHistory = std::move(history);
    cachedPhysicalTime = ep.currentPhysicalTime;
    cachedReport = report;
    cacheValid = true;
  }
  MoFEMFunctionReturn(0);
}

◆ stateControlBlocksEqual()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::stateControlBlocksEqual	(	Vec	first,
		Vec	second,
		PetscBool &	equal
	)

private

Definition at line 39 of file IncrementalMechanics.cpp.

                                                                               {
  MoFEMFunctionBegin;
  equal = PETSC_TRUE;
  for (const auto &field : stateControlFields) {
    IS raw_is = nullptr;
    CHKERR DMMoFEMGetFieldIS(ep.dmIncrementalOptimization, RowColData::ROW,
                             field.c_str(), &raw_is);
    SmartPetscObj<IS> field_is(raw_is);
    Vec first_block = nullptr, second_block = nullptr;
    CHKERR VecGetSubVector(first, field_is, &first_block);
    CHKERR VecGetSubVector(second, field_is, &second_block);
    PetscBool block_equal = PETSC_FALSE;
    CHKERR VecEqual(first_block, second_block, &block_equal);
    CHKERR VecRestoreSubVector(second, field_is, &second_block);
    CHKERR VecRestoreSubVector(first, field_is, &first_block);
    if (!block_equal) {
      equal = PETSC_FALSE;
      break;
    }
  }
  MoFEMFunctionReturn(0);
}

◆ supportsHessianAction()

bool EshelbianPlasticity::IncrementalMechanics::supportsHessianAction ( ) const

Whether the material provides the curvature used by applyHessian().

Definition at line 239 of file IncrementalMechanics.cpp.

                                                       {
  return ep.physicalEquations &&
         ep.physicalEquations->providesHelmholtzCurvature();
}

◆ zeroStateControlBlocks()

MoFEMErrorCode EshelbianPlasticity::IncrementalMechanics::zeroStateControlBlocks ( Vec control )

private

Definition at line 64 of file IncrementalMechanics.cpp.

                                                                       {
  MoFEMFunctionBegin;
  for (const auto &field : stateControlFields) {
    IS raw_is = nullptr;
    CHKERR DMMoFEMGetFieldIS(ep.dmIncrementalOptimization, RowColData::ROW,
                             field.c_str(), &raw_is);
    SmartPetscObj<IS> field_is(raw_is);
    Vec block = nullptr;
    CHKERR VecGetSubVector(control, field_is, &block);
    CHKERR VecZeroEntries(block);
    CHKERR VecRestoreSubVector(control, field_is, &block);
  }
  CHKERR VecGhostUpdateBegin(control, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(control, INSERT_VALUES, SCATTER_FORWARD);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

◆ cachedControl

SmartPetscObj<Vec> EshelbianPlasticity::IncrementalMechanics::cachedControl

private

Definition at line 89 of file IncrementalMechanics.hpp.

◆ cachedGradient

SmartPetscObj<Vec> EshelbianPlasticity::IncrementalMechanics::cachedGradient

private

Definition at line 97 of file IncrementalMechanics.hpp.

◆ cachedHistory

std::vector<FieldSnapshot> EshelbianPlasticity::IncrementalMechanics::cachedHistory

private

Definition at line 92 of file IncrementalMechanics.hpp.

◆ cachedPhysicalTime

double EshelbianPlasticity::IncrementalMechanics::cachedPhysicalTime = 0

private

Definition at line 93 of file IncrementalMechanics.hpp.

◆ cachedReport

EquilibriumSolveReport EshelbianPlasticity::IncrementalMechanics::cachedReport

private

Definition at line 91 of file IncrementalMechanics.hpp.

◆ cachedState

SmartPetscObj<Vec> EshelbianPlasticity::IncrementalMechanics::cachedState

private

Definition at line 90 of file IncrementalMechanics.hpp.

◆ cacheValid

bool EshelbianPlasticity::IncrementalMechanics::cacheValid = false

private

Definition at line 94 of file IncrementalMechanics.hpp.

◆ ep

EshelbianCore& EshelbianPlasticity::IncrementalMechanics::ep

private

Definition at line 84 of file IncrementalMechanics.hpp.

◆ gradientValid

bool EshelbianPlasticity::IncrementalMechanics::gradientValid = false

private

Definition at line 98 of file IncrementalMechanics.hpp.

◆ gradientWorkspace

boost::shared_ptr<PlasticIncrementalOptimizationInternal:: ReducedBulkMaterialEnergyHessianWorkspace> EshelbianPlasticity::IncrementalMechanics::gradientWorkspace

private

Definition at line 101 of file IncrementalMechanics.hpp.

◆ hessianWorkspace

boost::shared_ptr<PlasticIncrementalOptimizationInternal:: ReducedBulkMaterialEnergyHessianWorkspace> EshelbianPlasticity::IncrementalMechanics::hessianWorkspace

private

Definition at line 101 of file IncrementalMechanics.hpp.

◆ historyFields

std::vector<std::string> EshelbianPlasticity::IncrementalMechanics::historyFields

private

Definition at line 87 of file IncrementalMechanics.hpp.

◆ mechanicalSolves

PetscInt EshelbianPlasticity::IncrementalMechanics::mechanicalSolves = 0

private

Definition at line 95 of file IncrementalMechanics.hpp.

◆ stateControlFields

std::vector<std::string> EshelbianPlasticity::IncrementalMechanics::stateControlFields

private

Definition at line 86 of file IncrementalMechanics.hpp.

◆ timeSolver

SmartPetscObj<TS> EshelbianPlasticity::IncrementalMechanics::timeSolver

private

Definition at line 85 of file IncrementalMechanics.hpp.

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

users_modules/eshelbian_plasticity/src/IncrementalMechanics.hpp
users_modules/eshelbian_plasticity/src/impl/IncrementalMechanics.cpp

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ FieldSnapshot

Constructor & Destructor Documentation

◆ IncrementalMechanics()

Member Function Documentation

◆ addHistoryField()

◆ addStateControlField()

◆ applyHessian()

◆ assembleConservativeGradient()

◆ assembleHessianPreconditioner()

◆ evaluateBaseline()

◆ evaluateConservativeValue()

◆ fixedDataAreCurrent()

◆ getDirectionalSolveCount()

◆ getMechanicalSolveCount()

◆ getTS()

◆ prepareHessian()

◆ publishTrialControl()

◆ refreshConservativeGradient()

◆ restoreState()

◆ snapshotHistory()

◆ solveState()

◆ stateControlBlocksEqual()

◆ supportsHessianAction()

◆ zeroStateControlBlocks()

Member Data Documentation

◆ cachedControl

◆ cachedGradient

◆ cachedHistory

◆ cachedPhysicalTime

◆ cachedReport

◆ cachedState

◆ cacheValid

◆ ep

◆ gradientValid

◆ gradientWorkspace

◆ hessianWorkspace

◆ historyFields

◆ mechanicalSolves

◆ stateControlFields

◆ timeSolver