EshelbianPlasticity::TSElasticPreAndPostStep Struct Reference

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

Collaboration diagram for EshelbianPlasticity::TSElasticPreAndPostStep:

Classes
struct	ProjectionScope

Static Public Member Functions
static MoFEMErrorCode	setPreStep (EshelbianCore *ep_ptr, TS ts, bool h1_update=false)
static MoFEMErrorCode	preStepFun (TS ts)
static MoFEMErrorCode	postStepFun (TS ts)

Static Private Member Functions
static MoFEMErrorCode	postStepInitialise (EshelbianCore *ep_ptr)
static MoFEMErrorCode	postStepDestroy ()

Static Private Attributes
static SmartPetscObj< KSP >	prjKsp
static SmartPetscObj< Vec >	prjD
static SmartPetscObj< Vec >	prjF
static SmartPetscObj< DM >	dmPrjSpatial
static EshelbianCore *	epPtr

Detailed Description

Definition at line 10 of file TSElasticPreAndPostStep.hpp.

Member Function Documentation

postStepDestroy()

MoFEMErrorCode EshelbianPlasticity::TSElasticPreAndPostStep::postStepDestroy ( )

staticprivate

Definition at line 340 of file TSElasticPreAndPostStep.cpp.

                                                        {
  MoFEMFunctionBegin;
  prjKsp.reset();
  prjD.reset();
  prjF.reset();
  if (dmPrjSpatial) {
    // Break DM/pipeline reference cycles while the parent problem is alive.
    CHKERR DMMoFEMClearDMCtx(dmPrjSpatial);
    dmPrjSpatial.reset();
  }
  epPtr = nullptr;
  MoFEMFunctionReturn(0);
};

postStepFun()

MoFEMErrorCode EshelbianPlasticity::TSElasticPreAndPostStep::postStepFun ( TS  ts )

static

Definition at line 451 of file TSElasticPreAndPostStep.cpp.

                                                         {
  MoFEMFunctionBegin;
 
  double time;
  CHKERR TSGetTime(ts, &time);
 
  MOFEM_LOG("EP", Sev::inform) << "Solve H1 post-step";
  CHKERR VecZeroEntries(prjF);
  CHKERR KSPSolve(prjKsp, prjF, prjD);
  CHKERR VecGhostUpdateBegin(prjD, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(prjD, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR DMoFEMMeshToLocalVector(dmPrjSpatial, prjD, INSERT_VALUES,
                                 SCATTER_REVERSE);
 
  // The projected H1 field now carries the accepted deformation. Reset the
  // incremental stretch and rotation before crack calculations and TS
  // monitors so that the accepted increment is not applied a second time.
  CHKERR resetIncrementalKinematics(epPtr, ts);
 
  if (EshelbianCore::crackingOn) {
    switch (EshelbianCore::energyReleaseSelector) {
    case GRIFFITH_FORCE:
    case GRIFFITH_SKELETON:
      MOFEM_LOG("EP", Sev::inform) << "Calculate Griffith force";
      CHKERR epPtr->calculateFaceMaterialForce(1, ts);
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
              "Energy release selector not handled");
    };
    if (time - EshelbianCore::crackingStartTime >
        std::numeric_limits<double>::epsilon()) {
      MOFEM_LOG("EP", Sev::inform) << "Calculate faces orientation";
 
      EshelbianCore::potentialCrackArrest = false;
      CHKERR epPtr->calculateOrientation(1, true);
    }
    CHKERR epPtr->calculateCrackArea(epPtr->currentCrackAreaPtr);
  }
 
  // Clear history after rebasing incremental kinematics onto the H1 field.
  // With no H1 configuration, retain it until the next pre-step copy.
  if (EshelbianCore::gradApproximator != NO_H1_CONFIGURATION)
    CHKERR VecZeroEntries(epPtr->solTSStep);
 
  PetscBool local_stop = PETSC_FALSE;
  PetscBool global_stop = PETSC_FALSE;
  switch (EshelbianCore::solverType) {
  case EshelbianCore::LoadFactor:
    if (!epPtr->mField.get_comm_rank() && EshelbianCore::crackingOn) {
      const double area_increase =
          *epPtr->currentCrackAreaPtr - epPtr->oldCrackArea;
      const bool crack_arrest_stops =
          EshelbianCore::potentialCrackArrest &&
          !EshelbianCore::propagateUnderCompression;
      if (area_increase > EshelbianCore::maxCrackExtension ||
          epPtr->avgGriffithsEnergy < epPtr->griffithEnergy ||
          crack_arrest_stops) {
        MOFEM_LOG_C("EP", Sev::warning,
                    "Stopping crack growth. Area increase: %3.12e, "
                    "average Griffiths energy: %3.12e, critical Griffiths "
                    "energy: %3.12e",
                    area_increase, epPtr->avgGriffithsEnergy,
                    epPtr->griffithEnergy);
        local_stop = PETSC_TRUE;
      }
    }
    MPI_Bcast(&local_stop, 1, MPIU_BOOL, 0, PETSC_COMM_WORLD);
    global_stop = local_stop;
 
    if (global_stop) {
      TSSetConvergedReason(ts, TS_CONVERGED_USER);
      EshelbianCore::noCrackExtension = true;
      EshelbianCore::nbStepsNoCrackExtension += 1;
    } else {
      EshelbianCore::noCrackExtension = false;
      EshelbianCore::nbStepsNoCrackExtension = 0;
    }
    break;
  default:
    break;
  }
 
  MoFEMFunctionReturn(0);
};

postStepInitialise()

MoFEMErrorCode EshelbianPlasticity::TSElasticPreAndPostStep::postStepInitialise ( EshelbianCore *  ep_ptr )

staticprivate

Definition at line 266 of file TSElasticPreAndPostStep.cpp.

                                                                 {
  MoFEMFunctionBegin;
 
  epPtr = ep_ptr;
 
  // H1 displacement may be excluded from dmElastic; use the full parent DM.
  dmPrjSpatial = createDM(ep_ptr->mField.get_comm(), "DMMOFEM");
  CHKERR DMMoFEMCreateSubDM(dmPrjSpatial, ep_ptr->dM, "PROJECT_SPATIAL");
  CHKERR DMMoFEMSetDestroyProblem(dmPrjSpatial, PETSC_TRUE);
  CHKERR DMMoFEMAddSubFieldRow(dmPrjSpatial, ep_ptr->spatialH1Disp);
  CHKERR DMMoFEMAddElement(dmPrjSpatial, ep_ptr->elementVolumeName);
  CHKERR DMMoFEMSetSquareProblem(dmPrjSpatial, PETSC_TRUE);
  CHKERR DMMoFEMSetIsPartitioned(dmPrjSpatial, PETSC_TRUE);
  CHKERR DMSetUp(dmPrjSpatial);
 
  auto create_post_step_ksp = [&]() {
    auto ksp = createKSP(epPtr->mField.get_comm());
 
    auto set_up = [&]() {
      MoFEMFunctionBegin;
      using DomainEle = VolumeElementForcesAndSourcesCore;
      using DomainEleOp = DomainEle::UserDataOperator;
      using OpDomainMass = FormsIntegrators<DomainEleOp>::Assembly<
          PETSC>::BiLinearForm<GAUSS>::OpMass<1, 3>;
      using OpRhs = FormsIntegrators<DomainEleOp>::Assembly<PETSC>::LinearForm<
          GAUSS>::OpBaseTimesVector<1, 3, 3>;
      auto fe_lhs = boost::make_shared<DomainEle>(ep_ptr->mField);
      auto fe_rhs = boost::make_shared<DomainEle>(ep_ptr->mField);
 
      fe_lhs->getUserPolynomialBase() = boost::shared_ptr<BaseFunction>(
          new CGGUserPolynomialBase(nullptr, true));
      fe_rhs->getUserPolynomialBase() = boost::shared_ptr<BaseFunction>(
          new CGGUserPolynomialBase(nullptr, true));
      CHKERR
      EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
          fe_lhs->getOpPtrVector(), {L2}, ep_ptr->materialH1Positions,
          ep_ptr->frontAdjEdges);
      CHKERR
      EshelbianPlasticity::AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(
          fe_rhs->getOpPtrVector(), {L2}, ep_ptr->materialH1Positions,
          ep_ptr->frontAdjEdges);
 
      fe_lhs->getOpPtrVector().push_back(
          new OpDomainMass(ep_ptr->spatialH1Disp, ep_ptr->spatialH1Disp));
      auto w_ptr = boost::make_shared<MatrixDouble>();
      fe_rhs->getOpPtrVector().push_back(
          new OpCalculateVectorFieldValues<3>(ep_ptr->spatialL2Disp, w_ptr));
      fe_rhs->getOpPtrVector().push_back(
          new OpRhs(ep_ptr->spatialH1Disp, w_ptr));
 
      CHKERR DMMoFEMKSPSetComputeOperators(
          dmPrjSpatial, ep_ptr->elementVolumeName, fe_lhs, nullptr, nullptr);
      CHKERR DMMoFEMKSPSetComputeRHS(dmPrjSpatial, ep_ptr->elementVolumeName,
                                     fe_rhs, nullptr, nullptr);
 
      CHKERR KSPAppendOptionsPrefix(ksp, "prjspatial_");
      CHKERR KSPSetFromOptions(ksp);
      CHKERR KSPSetDM(ksp, dmPrjSpatial);
      CHKERR KSPSetUp(ksp);
      MoFEMFunctionReturn(0);
    };
 
    CHK_THROW_MESSAGE(set_up(), "set up");
 
    return ksp;
  };
 
  prjKsp = create_post_step_ksp();
  prjD = createDMVector(dmPrjSpatial);
  prjF = vectorDuplicate(prjD);
 
  MoFEMFunctionReturn(0);
};

preStepFun()

MoFEMErrorCode EshelbianPlasticity::TSElasticPreAndPostStep::preStepFun ( TS  ts )

static

Definition at line 354 of file TSElasticPreAndPostStep.cpp.

                                                        {
  MoFEMFunctionBegin;
  MOFEM_LOG("EP", Sev::inform) << "Pre step";
 
  double time;
  CHKERR TSGetTime(ts, &time);
 
  if (EshelbianCore::crackingOn) {
 
    auto debug_crack = [&]() {
      MoFEMFunctionBegin;
 
      PetscBool debug_crack_mesh = PETSC_FALSE;
      CHKERR PetscOptionsGetBool(PETSC_NULLPTR, "", "-debug_crack_mesh",
                                 &debug_crack_mesh, PETSC_NULLPTR);
      if (debug_crack_mesh) {
 
        auto append_meshsets_from_block = [](MoFEM::Interface &m_field,
                                             const std::string &block_name,
                                             const int dim,
                                             std::vector<EntityHandle> &r) {
          MoFEMFunctionBegin;
          auto mesh_mng = m_field.getInterface<MeshsetsManager>();
          auto bcs = mesh_mng->getCubitMeshsetPtr(
 
              std::regex((boost::format("%s(.*)") % block_name).str())
 
          );
 
          for (auto bc : bcs) {
            Range ents;
            CHKERR m_field.get_moab().get_entities_by_dimension(
                bc->getMeshset(), dim, ents, true);
            if (!ents.empty()) {
              r.push_back(bc->getMeshset());
            }
          }
 
          MoFEMFunctionReturn(0);
        };
 
        if (!epPtr->mField.get_comm_rank() &&
            !EshelbianCore::noCrackExtension) {
          if (epPtr->maxMovedFaces) {
            CHKERR epPtr->mField.getInterface<MeshsetsManager>()
                ->addEntitiesToMeshset(BLOCKSET, epPtr->addCrackMeshsetId,
                                       *epPtr->maxMovedFaces);
          }
 
          auto meshset_ptr = get_temp_meshset_ptr(epPtr->mField.get_moab());
          Range tets;
          CHKERR epPtr->mField.get_moab().get_entities_by_dimension(
              *meshset_ptr, 3, tets);
          CHKERR epPtr->mField.get_moab().add_entities(*meshset_ptr, tets);
 
          std::vector<EntityHandle> meshsets;
          meshsets.push_back(*meshset_ptr);
 
          CHKERR append_meshsets_from_block(epPtr->mField, "CRACK", 2,
                                            meshsets);
          CHKERR append_meshsets_from_block(epPtr->mField, "FRONT", 1,
                                            meshsets);
          CHKERR append_meshsets_from_block(epPtr->mField, "EDGE", 1,
                                            meshsets);
 
          int time_step = 0;
          CHKERR TSGetStepNumber(ts, &time_step);
          std::string file_name =
              "crack_meshsets_" + std::to_string(time_step) + ".h5m";
          CHKERR epPtr->mField.get_moab().write_file(file_name.c_str(), "MOAB",
                                                     nullptr, meshsets.data(),
                                                     static_cast<int>(meshsets.size()));
        }
      }
 
      MoFEMFunctionReturn(0);
    };
 
      if (EshelbianCore::crackingStartTime < time) {
        CHKERR epPtr->setNewFrontCoordinates();
        CHKERR debug_crack();
        CHKERR epPtr->addCrackSurfaces();
      }
      CHKERR epPtr->projectGeometry(0, time);
      CHKERR epPtr->projectMaterialTags();
    }
 
  Vec T;
  CHKERR TSGetSolution(ts, &T);
 
  CHKERR VecCopy(T, epPtr->solTSStep);
  CHKERR VecGhostUpdateBegin(epPtr->solTSStep, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(epPtr->solTSStep, INSERT_VALUES, SCATTER_FORWARD);
 
  MoFEMFunctionReturn(0);
}

setPreStep()

MoFEMErrorCode EshelbianPlasticity::TSElasticPreAndPostStep::setPreStep ( EshelbianCore *  ep_ptr, TS  ts, bool  h1_update = false  )

static

Register coefficient reset before solves, with optional H1 bookkeeping.

Definition at line 208 of file TSElasticPreAndPostStep.cpp.

                                                             {
  MoFEMFunctionBegin;
  PetscContainer container = nullptr;
  CHKERR PetscObjectQuery(getPetscObject(ts), elasticPreStepKey,
                          reinterpret_cast<PetscObject *>(&container));
  if (!container) {
    CHKERR PetscContainerCreate(ep_ptr->mField.get_comm(), &container);
    auto *context = new ElasticPreStepContext{ep_ptr, h1_update};
    CHKERR PetscContainerSetPointer(container, context);
    CHKERR PetscContainerSetUserDestroy(container, [](void *pointer) {
      MoFEMFunctionBegin;
      delete static_cast<ElasticPreStepContext *>(pointer);
      MoFEMFunctionReturn(0);
    });
    CHKERR PetscObjectCompose(getPetscObject(ts), elasticPreStepKey,
                              getPetscObject(container));
    CHKERR PetscContainerDestroy(&container);
  } else {
    void *pointer = nullptr;
    CHKERR PetscContainerGetPointer(container, &pointer);
    auto &context = *static_cast<ElasticPreStepContext *>(pointer);
    context.ep = ep_ptr;
    context.h1Update = h1_update;
  }
  CHKERR TSSetPreStep(ts, elasticPreStep);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

dmPrjSpatial

SmartPetscObj<DM> EshelbianPlasticity::TSElasticPreAndPostStep::dmPrjSpatial

inlinestaticprivate

Definition at line 39 of file TSElasticPreAndPostStep.hpp.

epPtr

EshelbianCore* EshelbianPlasticity::TSElasticPreAndPostStep::epPtr

inlinestaticprivate

Definition at line 40 of file TSElasticPreAndPostStep.hpp.

prjD

SmartPetscObj<Vec> EshelbianPlasticity::TSElasticPreAndPostStep::prjD

inlinestaticprivate

Definition at line 37 of file TSElasticPreAndPostStep.hpp.

prjF

SmartPetscObj<Vec> EshelbianPlasticity::TSElasticPreAndPostStep::prjF

inlinestaticprivate

Definition at line 38 of file TSElasticPreAndPostStep.hpp.

prjKsp

SmartPetscObj<KSP> EshelbianPlasticity::TSElasticPreAndPostStep::prjKsp

inlinestaticprivate

Definition at line 36 of file TSElasticPreAndPostStep.hpp.

---

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

• users_modules/eshelbian_plasticity/src/TSElasticPreAndPostStep.hpp
• users_modules/eshelbian_plasticity/src/impl/TSElasticPreAndPostStep.cpp