ts_elastic_projection_atom.cpp

Go to the documentation of this file.

/** @file ts_elastic_projection_atom.cpp
 * @brief Verify elastic projection ownership and cleanup on failed solves.
 */
 
#include <MoFEM.hpp>
using namespace MoFEM;
#include "AuxiliaryLogarithmicStressTestSetup.hpp"
#include <TSElasticPreAndPostStep.hpp>
using namespace EshelbianPlasticity;
 
namespace {
 
MoFEMErrorCode checkProjection(EshelbianCore &ep, const bool present) {
  MoFEMFunctionBegin;
  if (ep.mField.check_problem("PROJECT_SPATIAL") != present)
    SETERRQ(ep.mField.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Unexpected spatial projection lifetime");
  if (present) {
    const Problem *problem;
    CHKERR ep.mField.get_problem("PROJECT_SPATIAL", &problem);
    if (!problem->getNbDofsRow() ||
        problem->getNbDofsRow() != problem->getNbDofsCol())
      SETERRQ(ep.mField.get_comm(), MOFEM_ATOM_TEST_INVALID,
              "Spatial projection must be a nonempty square problem");
    for (const auto &dof : *problem->getNumeredRowDofsPtr())
      if (dof->getName() != ep.spatialH1Disp)
        SETERRQ(ep.mField.get_comm(), MOFEM_ATOM_TEST_INVALID,
                "Spatial projection contains a non-H1-displacement field");
  }
  MoFEMFunctionReturn(0);
}
 
MoFEMErrorCode runProjectionAtom(EshelbianCore &ep) {
  MoFEMFunctionBegin;
  CHKERR checkProjection(ep, false);
  {
    TSElasticPreAndPostStep::ProjectionScope projection(&ep);
    CHKERR checkProjection(ep, true);
    CHKERR projection.close();
    CHKERR projection.close();
    CHKERR checkProjection(ep, false);
  }
 
  // A solver error must release the subproblem before its Core is destroyed.
  const auto failed_solve = [&]() -> MoFEMErrorCode {
    TSElasticPreAndPostStep::ProjectionScope projection(&ep);
    CHKERR checkProjection(ep, true);
    return PETSC_ERR_USER;
  };
  if (failed_solve() != PETSC_ERR_USER)
    SETERRQ(ep.mField.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Expected simulated solver failure");
  CHKERR checkProjection(ep, false);
  try {
    TSElasticPreAndPostStep::ProjectionScope projection(&ep);
    THROW_MESSAGE("Simulated solve exception");
  } catch (const MoFEMException &) {
  }
  CHKERR checkProjection(ep, false);
 
  // Fail KSP setup after the DM/pipelines exist, then initialise again.
  char previous_type[256] = "";
  PetscBool found;
  CHKERR PetscOptionsGetString(nullptr, nullptr, "-prjspatial_ksp_type",
                               previous_type, sizeof(previous_type), &found);
  CHKERR PetscOptionsSetValue(nullptr, "-prjspatial_ksp_type",
                              "invalid_projection_ksp");
  CHKERR PetscPushErrorHandler(PetscReturnErrorHandler, nullptr);
  bool failed_initialisation = false;
  try {
    TSElasticPreAndPostStep::ProjectionScope projection(&ep);
  } catch (const MoFEMException &) {
    failed_initialisation = true;
  }
  CHKERR PetscPopErrorHandler();
  if (found)
    CHKERR PetscOptionsSetValue(nullptr, "-prjspatial_ksp_type", previous_type);
  else
    CHKERR PetscOptionsClearValue(nullptr, "-prjspatial_ksp_type");
  if (!failed_initialisation)
    SETERRQ(ep.mField.get_comm(), MOFEM_ATOM_TEST_INVALID,
            "Invalid projection KSP type must fail initialisation");
  CHKERR checkProjection(ep, false);
  {
    TSElasticPreAndPostStep::ProjectionScope projection(&ep);
    CHKERR checkProjection(ep, true);
  }
  CHKERR checkProjection(ep, false);
  CHKERR PetscPrintf(ep.mField.get_comm(),
                     "Elastic spatial projection lifecycle atom passed\n");
  MoFEMFunctionReturn(0);
}
 
} // namespace
 
static char help[] = "Verify elastic projection resource ownership.\n";
 
int main(int argc, char *argv[]) {
  MoFEM::Core::Initialize(&argc, &argv, nullptr, help);
  auto core_log = logging::core::get();
  core_log->add_sink(LogManager::createSink(LogManager::getStrmWorld(), "EP"));
  LogManager::setLog("EP");
  core_log->add_sink(
      LogManager::createSink(LogManager::getStrmSelf(), "EPSELF"));
  LogManager::setLog("EPSELF");
  core_log->add_sink(
      LogManager::createSink(LogManager::getStrmSync(), "EPSYNC"));
  LogManager::setLog("EPSYNC");
  try {
    CHKERR runAuxiliaryLogarithmicStressTest(runProjectionAtom);
  }
  CATCH_ERRORS;
  MoFEM::Core::Finalize();
  return 0;
}