MortarContactInterface Struct Reference

#include <users_modules/mortar_contact/src/MortarContactInterface.hpp>

Inheritance diagram for MortarContactInterface:

Collaboration diagram for MortarContactInterface:

Public Types
typedef ContactSearchKdTree::ContactCommonData_multiIndex	contactMIndex
Public Types inherited from GenericElementInterface
enum	TSType {   EX, IM, IM2, IMEX,   DEFAULT, EX, IM, IM2,   IMEX, DEFAULT }
enum	TSType {   EX, IM, IM2, IMEX,   DEFAULT, EX, IM, IM2,   IMEX, DEFAULT }
using	BcMarkerPtr = boost::shared_ptr< std::vector< char unsigned > >
using	BcMarkerPtr = boost::shared_ptr< std::vector< char unsigned > >

Public Member Functions
	MortarContactInterface (MoFEM::Interface &m_field, string postion_field, string mesh_posi_field_name="MESH_NODE_POSITIONS", bool is_displacement_field=false, bool is_quasi_static=true)
	MortarContactInterface ()=delete
MoFEMErrorCode	getCommandLineParameters () override
MoFEMErrorCode	addElementFields () override
MoFEMErrorCode	createElements () override
MoFEMErrorCode	setOperators () override
BitRefLevel	getBitRefLevel () override
MoFEMErrorCode	addElementsToDM (SmartPetscObj< DM > dm) override
MoFEMErrorCode	setupSolverJacobianSNES () override
MoFEMErrorCode	setupSolverFunctionSNES () override
MoFEMErrorCode	setupSolverJacobianTS (const TSType type) override
MoFEMErrorCode	setupSolverFunctionTS (const TSType type) override
MoFEMErrorCode	updateElementVariables () override
MoFEMErrorCode	postProcessElement (int step) override
std::vector< BitRefLevel > &	getBitRefLevelVector ()
MoFEMErrorCode	setupElementEntities ()
MoFEMErrorCode	setPositionFieldOrder (int order)
boost::ptr_deque< MoFEM::ForcesAndSourcesCore::UserDataOperator > &	getPostProcSimpleContactPipeline ()
MoFEMErrorCode	findContactSurfacePairs ()
MoFEMErrorCode	findPostProcSurface ()
template<typename T , bool RHS>
MoFEMErrorCode	setupSolverImpl (const TSType type=IM)
template<typename T >
MoFEMErrorCode	setupSolverFunction (const TSType type=IM)
template<typename T >
MoFEMErrorCode	setupSolverJacobian (const TSType type=IM)
MoFEMErrorCode	postProcessContactState (int step)
template<>
MoFEMErrorCode	setupSolverFunction (const TSType type)
template<>
MoFEMErrorCode	setupSolverFunction (const TSType type)
template<>
MoFEMErrorCode	setupSolverJacobian (const TSType type)
template<>
MoFEMErrorCode	setupSolverJacobian (const TSType type)
template<>
MoFEMErrorCode	setupSolverJacobian (const TSType type)
template<>
MoFEMErrorCode	setupSolverJacobian (const TSType type)
template<>
MoFEMErrorCode	setupSolverFunction (const TSType type)
template<>
MoFEMErrorCode	setupSolverFunction (const TSType type)
Public Member Functions inherited from GenericElementInterface
	GenericElementInterface ()
virtual	~GenericElementInterface ()
virtual MoFEMErrorCode	setGlobalBoundaryMarker (BcMarkerPtr mark)
virtual BcMarkerPtr	getGlobalBoundaryMarker ()
virtual MoFEMErrorCode	setMonitorPtr (boost::shared_ptr< MoFEM::FEMethod > monitor_ptr)
virtual BitRefLevel	getBitRefLevelMask ()
virtual MoFEMErrorCode	opFactoryDomainRhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)
virtual MoFEMErrorCode	opFactoryDomainLhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)
virtual MoFEMErrorCode	setUpdateElementVariablesOperators ()
virtual MoFEMErrorCode	updateElementVariables (SmartPetscObj< DM > dm, string fe_name)
virtual MoFEMErrorCode	postProcessElement (int step, SmartPetscObj< DM > dm, string fe_name)
	GenericElementInterface ()
virtual	~GenericElementInterface ()
virtual MoFEMErrorCode	setGlobalBoundaryMarker (BcMarkerPtr mark)
virtual BcMarkerPtr	getGlobalBoundaryMarker ()
virtual MoFEMErrorCode	setMonitorPtr (boost::shared_ptr< FEMethod > monitor_ptr)
virtual BitRefLevel	getBitRefLevelMask ()
virtual MoFEMErrorCode	opFactoryDomainRhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)
virtual MoFEMErrorCode	opFactoryDomainLhs (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pip)
virtual MoFEMErrorCode	setUpdateElementVariablesOperators ()
virtual MoFEMErrorCode	updateElementVariables (SmartPetscObj< DM > dm, string fe_name)
virtual MoFEMErrorCode	postProcessElement (int step, SmartPetscObj< DM > dm, string fe_name)

Public Attributes
MoFEM::Interface &	mField
SmartPetscObj< DM >	dM
double	cnValue
PetscInt	oRder
PetscInt	orderContact
PetscInt	orderLambda
PetscInt	nbHoLevels
PetscBool	isNewtonCotes
PetscBool	convectPts
PetscBool	printContactState
PetscBool	almFlag
PetscBool	dEbug
PetscBool	isPartitioned
boost::shared_ptr< MortarContactProblem >	contactProblemPtr
Range	contactPrisms
Range	masterTris
Range	slaveTris
std::vector< std::pair< Range, Range > >	contactSurfacePairs
Range	postProcSurface
double	postProcGapTol
string	positionField
string	meshNodeField
bool	isDisplacementField
bool	isQuasiStatic
std::vector< BitRefLevel >	bitLevels
boost::shared_ptr< contactMIndex >	contactCommondataMultiIndex
boost::shared_ptr< PostProcFaceOnRefinedMesh >	postProcContactPtr
boost::shared_ptr< MortarContactProblem::MortarContactElement >	fePostProcSimpleContact
boost::shared_ptr< MortarContactProblem::CommonDataMortarContact >	commonDataPostProc
moab::Core	mb_post
moab::Interface &	moabPostProcMesh
std::array< double, 2 >	nbGaussPts
std::array< double, 2 >	contactArea
Public Attributes inherited from GenericElementInterface
BcMarkerPtr	mBoundaryMarker
int	atomTest
int	restartRunStep
boost::shared_ptr< MoFEM::FEMethod >	monitorPtr
boost::shared_ptr< FEMethod >	monitorPtr

Detailed Description

Examples

mortar_contact.cpp.

Definition at line 22 of file MortarContactInterface.hpp.

Member Typedef Documentation

contactMIndex

typedef ContactSearchKdTree::ContactCommonData_multiIndex MortarContactInterface::contactMIndex

Definition at line 57 of file MortarContactInterface.hpp.

Constructor & Destructor Documentation

MortarContactInterface() [1/2]

MortarContactInterface::MortarContactInterface ( MoFEM::Interface &  m_field, string  postion_field, string  mesh_posi_field_name = "MESH_NODE_POSITIONS", bool  is_displacement_field = false, bool  is_quasi_static = true  )

inline

Definition at line 71 of file MortarContactInterface.hpp.

      : mField(m_field), positionField(postion_field),
        meshNodeField(mesh_posi_field_name),
        isDisplacementField(is_displacement_field),
        isQuasiStatic(is_quasi_static), moabPostProcMesh(mb_post) {
 
    oRder = -1;
    orderContact = 1;
    nbHoLevels = 0;
    orderLambda = 1;
    cnValue = -1;
    postProcGapTol = 0.;
    almFlag = PETSC_FALSE;
    isNewtonCotes = PETSC_FALSE;
    convectPts = PETSC_FALSE;
    printContactState = PETSC_FALSE;
    dEbug = PETSC_FALSE;
    isPartitioned = PETSC_FALSE;
  }

MortarContactInterface() [2/2]

MortarContactInterface::MortarContactInterface ( )

delete

Member Function Documentation

addElementFields()

MoFEMErrorCode MortarContactInterface::addElementFields ( )

overridevirtual

Implements GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 139 of file MortarContactInterface.cpp.

                                                        {
  MoFEMFunctionBegin;
  auto &moab = mField.get_moab();
 
  if (!contactCommondataMultiIndex)
    CHKERR this->setupElementEntities();
 
  if (!mField.check_field(meshNodeField)) {
 
    CHKERR mField.add_field(meshNodeField, H1, AINSWORTH_LEGENDRE_BASE, 3,
                            MB_TAG_SPARSE, MF_ZERO);
    CHKERR mField.add_ents_to_field_by_type(0, MBTET, meshNodeField);
    CHKERR mField.set_field_order(0, MBTET, meshNodeField, 1);
    CHKERR mField.set_field_order(0, MBTRI, meshNodeField, 1);
    CHKERR mField.set_field_order(0, MBEDGE, meshNodeField, 1);
    CHKERR mField.set_field_order(0, MBVERTEX, meshNodeField, 1);
  }
 
  if (!mField.check_field(positionField)) {
    // FIXME: TODO: we need to discuss how to
    if (oRder < 0)
      SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY,
              "set appropriate position field order, "
              "setPositionFieldOrder(int order)");
 
    // Declare problem add entities (by tets) to the field
    CHKERR mField.add_field(positionField, H1, AINSWORTH_LEGENDRE_BASE, 3,
                            MB_TAG_SPARSE, MF_ZERO);
    CHKERR mField.add_ents_to_field_by_type(0, MBTET, positionField);
    CHKERR mField.set_field_order(0, MBTET, positionField, oRder);
    CHKERR mField.set_field_order(0, MBTRI, positionField, oRder);
    CHKERR mField.set_field_order(0, MBEDGE, positionField, oRder);
    CHKERR mField.set_field_order(0, MBVERTEX, positionField, 1);
  }
 
  CHKERR mField.add_field("LAGMULT", H1, AINSWORTH_LEGENDRE_BASE, 1,
                          MB_TAG_SPARSE, MF_ZERO);
  CHKERR mField.add_ents_to_field_by_type(slaveTris, MBTRI, "LAGMULT");
  CHKERR mField.set_field_order(0, MBTRI, "LAGMULT", orderLambda);
  CHKERR mField.set_field_order(0, MBEDGE, "LAGMULT", orderLambda);
  CHKERR mField.set_field_order(0, MBVERTEX, "LAGMULT", 1);
 
  auto set_contact_order = [&]() {
    MoFEMFunctionBegin;
    Range contact_tris, contact_edges;
    CHKERR moab.get_adjacencies(contactPrisms, 2, false, contact_tris,
                                moab::Interface::UNION);
    contact_tris = contact_tris.subset_by_type(MBTRI);
    CHKERR moab.get_adjacencies(contact_tris, 1, false, contact_edges,
                                moab::Interface::UNION);
    Range ho_ents;
    ho_ents.merge(contact_tris);
    ho_ents.merge(contact_edges);
    for (int ll = 0; ll != nbHoLevels; ll++) {
      Range ents, verts, tets;
      CHKERR moab.get_connectivity(ho_ents, verts, true);
      CHKERR moab.get_adjacencies(verts, 3, false, tets,
                                  moab::Interface::UNION);
      tets = tets.subset_by_type(MBTET);
      for (auto d : {1, 2}) {
        CHKERR moab.get_adjacencies(tets, d, false, ents,
                                    moab::Interface::UNION);
      }
      ho_ents = unite(ho_ents, ents);
      ho_ents = unite(ho_ents, tets);
    }
 
    CHKERR mField.set_field_order(ho_ents, positionField, orderContact);
 
    MoFEMFunctionReturn(0);
  };
 
  if (orderContact > oRder)
    CHKERR set_contact_order();
 
  MoFEMFunctionReturn(0);
}

addElementsToDM()

MoFEMErrorCode MortarContactInterface::addElementsToDM ( SmartPetscObj< DM >  dm )

overridevirtual

Implements GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 239 of file MortarContactInterface.cpp.

                                                                           {
  MoFEMFunctionBeginHot;
 
  this->dM = dm;
 
  CHKERR DMMoFEMAddElement(this->dM, "CONTACT_ELEM");
  CHKERR DMMoFEMAddElement(this->dM, "CONTACT_POST_PROC");
 
  auto simple = mField.getInterface<Simple>();
  simple->getOtherFiniteElements().push_back("CONTACT_ELEM");
  simple->getOtherFiniteElements().push_back("CONTACT_POST_PROC");
 
  MoFEMFunctionReturnHot(0);
}

createElements()

MoFEMErrorCode MortarContactInterface::createElements ( )

overridevirtual

Implements GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 219 of file MortarContactInterface.cpp.

                                                      {
  MoFEMFunctionBegin;
 
  contactProblemPtr = boost::make_shared<MortarContactProblem>(
      mField, contactCommondataMultiIndex, boost::make_shared<double>(cnValue),
      isNewtonCotes);
 
  // add fields to the global matrix by adding the element
  contactProblemPtr->addMortarContactElement(
      "CONTACT_ELEM", positionField, "LAGMULT", contactPrisms, meshNodeField);
  contactProblemPtr->addPostProcContactElement(
      "CONTACT_POST_PROC", positionField, "LAGMULT", meshNodeField, slaveTris);
 
  MoFEMFunctionReturn(0);
}

findContactSurfacePairs()

MoFEMErrorCode MortarContactInterface::findContactSurfacePairs

(

)

Definition at line 629 of file MortarContactInterface.cpp.

                                                               {
  MoFEMFunctionBegin;
 
  std::map<std::string, Range> slave_surface_map, master_surface_map;
 
  auto fill_surface_map = [&](auto &surface_map, std::string surface_name) {
    MoFEMFunctionBegin;
 
    for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
      if (it->getName().compare(0, surface_name.size(), surface_name) == 0) {
        Range tris;
        CHKERR mField.get_moab().get_entities_by_type(it->meshset, MBTRI, tris,
                                                      true);
        std::string key = it->getName().substr(surface_name.size());
        auto res = surface_map.insert(std::pair<std::string, Range>(key, tris));
        if (!res.second) {
          SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                   "Contact surface name %s used more than once",
                   it->getName().c_str());
        }
      }
    }
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR fill_surface_map(slave_surface_map, "MORTAR_SLAVE");
  CHKERR fill_surface_map(master_surface_map, "MORTAR_MASTER");
 
  for (const auto &[key, slave_range] : slave_surface_map) {
    auto master_search = master_surface_map.find(key);
    if (master_search != master_surface_map.end()) {
      contactSurfacePairs.push_back(
          std::pair<Range, Range>(slave_range, master_search->second));
      master_surface_map.erase(master_search);
    } else {
      SETERRQ2(
          PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
          "Cannot find pairing contact surface MORTAR_MASTER%s for existing "
          "surface MORTAR_SLAVE%s",
          key.c_str(), key.c_str());
    }
  }
 
  if (!master_surface_map.empty()) {
    std::string key = master_surface_map.begin()->first;
    SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "Cannot find pairing contact surface MORTAR_SLAVE%s for existing "
             "surface MORTAR_MASTER%s",
             key.c_str(), key.c_str());
  }
 
  MoFEMFunctionReturn(0);
}

findPostProcSurface()

MoFEMErrorCode MortarContactInterface::findPostProcSurface

(

)

Definition at line 684 of file MortarContactInterface.cpp.

                                                           {
  MoFEMFunctionBegin;
 
  std::string surface_name = "MORTAR_POST_PROC";
 
  for (_IT_CUBITMESHSETS_BY_SET_TYPE_FOR_LOOP_(mField, BLOCKSET, it)) {
    if (it->getName().compare(0, surface_name.size(), surface_name) == 0) {
      Range tris;
      CHKERR mField.get_moab().get_entities_by_type(it->meshset, MBTRI, tris,
                                                    true);
      postProcSurface.merge(tris);
    }
  }
 
  MoFEMFunctionReturn(0);
}

getBitRefLevel()

BitRefLevel MortarContactInterface::getBitRefLevel ( )

overridevirtual

Reimplemented from GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 235 of file MortarContactInterface.cpp.

                                                   {
  return this->getBitRefLevelVector().back();
};

getBitRefLevelVector()

std::vector< BitRefLevel > & MortarContactInterface::getBitRefLevelVector

(

)

Definition at line 13 of file MortarContactInterface.cpp.

                                                                     {
  return bitLevels;
}

getCommandLineParameters()

MoFEMErrorCode MortarContactInterface::getCommandLineParameters ( )

overridevirtual

Reimplemented from GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 22 of file MortarContactInterface.cpp.

                                                                {
  MoFEMFunctionBeginHot;
 
  CHKERR PetscOptionsBegin(PETSC_COMM_WORLD, "", "Mortar Config", "none");
 
  CHKERR PetscOptionsInt(
      "-order_contact",
      "approximation order of spatial positions in contact interface", "", 1,
      &orderContact, PETSC_NULL);
  CHKERR PetscOptionsInt("-ho_levels_num", "number of higher order levels", "",
                         0, &nbHoLevels, PETSC_NULL);
  CHKERR PetscOptionsInt("-order_lambda",
                         "approximation order of Lagrange multipliers", "", 1,
                         &orderLambda, PETSC_NULL);
  isPartitioned = PETSC_FALSE;
  CHKERR PetscOptionsBool("-is_partitioned",
                          "set if mesh is partitioned (this result that each "
                          "process keeps only part of the mes",
                          "", PETSC_FALSE, &isPartitioned, PETSC_NULL);
 
  CHKERR PetscOptionsReal("-cn_value", "default regularisation cn value", "",
                          1., &cnValue, PETSC_NULL);
 
  CHKERR PetscOptionsReal("-post_proc_gap_tol",
                          "gap tolerance for post processing", "", 0.,
                          &postProcGapTol, PETSC_NULL);
 
  CHKERR PetscOptionsBool("-is_newton_cotes",
                          "set if Newton-Cotes quadrature rules are used", "",
                          PETSC_FALSE, &isNewtonCotes, PETSC_NULL);
  CHKERR PetscOptionsBool("-convect", "set to convect integration pts", "",
                          PETSC_FALSE, &convectPts, PETSC_NULL);
  CHKERR PetscOptionsBool("-print_contact_state",
                          "output number of active gp at every iteration", "",
                          PETSC_FALSE, &printContactState, PETSC_NULL);
  CHKERR PetscOptionsBool("-alm_flag", "if set use ALM, if not use C-function",
                          "", PETSC_FALSE, &almFlag, PETSC_NULL);
  CHKERR PetscOptionsBool("-debug", "output debug files", "", PETSC_FALSE,
                          &dEbug, PETSC_NULL);
 
  int order = 1;
  CHKERR PetscOptionsInt("-order", "approximation order of spatial positions",
                         "", 1, &order, PETSC_NULL);
  CHKERR this->setPositionFieldOrder(order);
 
  ierr = PetscOptionsEnd();
  CHKERRQ(ierr);
 
  MoFEMFunctionReturnHot(0);
}

getPostProcSimpleContactPipeline()

boost::ptr_deque< MoFEM::ForcesAndSourcesCore::UserDataOperator > & MortarContactInterface::getPostProcSimpleContactPipeline

(

)

Examples

mortar_contact.cpp.

Definition at line 18 of file MortarContactInterface.cpp.

                                                         {
  return fePostProcSimpleContact->getOpPtrVector();
}

postProcessContactState()

MoFEMErrorCode MortarContactInterface::postProcessContactState

(

int

step

)

Definition at line 540 of file MortarContactInterface.cpp.

                                                                       {
  MoFEMFunctionBegin;
 
  moabPostProcMesh.delete_mesh();
  if (!commonDataPostProc)
    SETERRQ(
        PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY,
        "you need to setup the solver first to use postProcessContactState");
  CHKERR VecZeroEntries(commonDataPostProc->gaussPtsStateVec);
  CHKERR VecZeroEntries(commonDataPostProc->contactAreaVec);
  CHKERR DMoFEMLoopFiniteElements(dM, "CONTACT_ELEM", fePostProcSimpleContact);
 
  auto get_contact_data = [&](auto vec, std::array<double, 2> &data) {
    MoFEMFunctionBegin;
    CHKERR VecAssemblyBegin(vec);
    CHKERR VecAssemblyEnd(vec);
    const double *array;
    CHKERR VecGetArrayRead(vec, &array);
    if (mField.get_comm_rank() == 0) {
      for (int i : {0, 1})
        data[i] = array[i];
    }
    CHKERR VecRestoreArrayRead(vec, &array);
    MoFEMFunctionReturn(0);
  };
 
  CHKERR get_contact_data(commonDataPostProc->gaussPtsStateVec, nbGaussPts);
  CHKERR get_contact_data(commonDataPostProc->contactAreaVec, contactArea);
 
  if (mField.get_comm_rank() == 0) {
    MOFEM_LOG_C("WORLD", Sev::verbose, "Active gauss pts: %d out of %d",
                (int)nbGaussPts[0], (int)nbGaussPts[1]);
         
    if (!postProcSurface.empty())
      MOFEM_LOG("WORLD", Sev::inform)
          << "Computing contact area only on the post process surface";
    if (postProcGapTol > std::numeric_limits<double>::epsilon())
      MOFEM_LOG_C("WORLD", Sev::inform, "Using gap tolerance %3.3f",
                  postProcGapTol);
 
    MOFEM_LOG_C("WORLD", Sev::inform, "Active contact area: %3.3f out of %3.3f",
                contactArea[0], contactArea[1]);
  }
 
  auto out_file_name = "out_contact_integ_pts_" + to_string(step) + ".h5m";
  MOFEM_LOG_C("WORLD", Sev::verbose, "out file %s", out_file_name.c_str());
  CHKERR moabPostProcMesh.write_file(out_file_name.c_str(), "MOAB",
                                     "PARALLEL=WRITE_PART");
 
  MoFEMFunctionReturn(0);
}

postProcessElement()

MoFEMErrorCode MortarContactInterface::postProcessElement ( int  step )

overridevirtual

Implements GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 592 of file MortarContactInterface.cpp.

                                                                  {
  MoFEMFunctionBegin;
 
  if (masterTris.empty())
    MoFEMFunctionReturnHot(0);
 
  this->postProcessContactState(step);
 
  if (!postProcContactPtr) {
    postProcContactPtr = boost::make_shared<PostProcFaceOnRefinedMesh>(mField);
    CHKERR postProcContactPtr->generateReferenceElementMesh();
    CHKERR addHOOpsFace3D(meshNodeField, *postProcContactPtr, false, false);
    CHKERR postProcContactPtr->addFieldValuesPostProc("LAGMULT");
    CHKERR postProcContactPtr->addFieldValuesPostProc(positionField);
    CHKERR postProcContactPtr->addFieldValuesPostProc(meshNodeField);
  }
  CHKERR DMoFEMLoopFiniteElements(this->dM, "CONTACT_POST_PROC",
                                  postProcContactPtr);
 
  auto out_file_name = "out_contact_" + to_string(step) + ".h5m";
  MOFEM_LOG_C("WORLD", Sev::verbose, "out file %s", out_file_name.c_str());
  CHKERR postProcContactPtr->writeFile(out_file_name.c_str());
 
  MoFEMFunctionReturn(0);
}

setOperators()

MoFEMErrorCode MortarContactInterface::setOperators ( )

overridevirtual

Implements GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 217 of file MortarContactInterface.cpp.

{ return 0; }

setPositionFieldOrder()

MoFEMErrorCode MortarContactInterface::setPositionFieldOrder

(

int

order

)

Definition at line 618 of file MortarContactInterface.cpp.

                                                                      {
  MoFEMFunctionBeginHot;
  oRder = order;
  MoFEMFunctionReturnHot(0);
}

setupElementEntities()

MoFEMErrorCode MortarContactInterface::setupElementEntities

(

)

Definition at line 73 of file MortarContactInterface.cpp.

                                                            {
  MoFEMFunctionBegin;
  auto &moab = mField.get_moab();
 
  bitLevels.push_back(BitRefLevel().set(0));
  CHKERR mField.getInterface<BitRefManager>()->setBitRefLevelByDim(
      0, 3, bitLevels.back());
 
  Range meshset_level0;
  CHKERR mField.getInterface<BitRefManager>()->getEntitiesByRefLevel(
      bitLevels.back(), BitRefLevel().set(), meshset_level0);
  MOFEM_LOG("WORLD", Sev::verbose)
      << "Meshset_level0 " << meshset_level0.size();
 
  contactCommondataMultiIndex = boost::make_shared<contactMIndex>();
 
  CHKERR findContactSurfacePairs();
 
  for (auto &contact_surface_pair : contactSurfacePairs) {
    slaveTris.merge(contact_surface_pair.first);
    masterTris.merge(contact_surface_pair.second);
 
    ContactSearchKdTree contact_search_kd_tree(mField);
 
    CHKERR contact_search_kd_tree.buildTree(contact_surface_pair.second);
 
    CHKERR contact_search_kd_tree.contactSearchAlgorithm(
        contact_surface_pair.second, contact_surface_pair.first,
        contactCommondataMultiIndex, contactPrisms);
  }
 
  if (!masterTris.empty() && isPartitioned)
    SETERRQ(PETSC_COMM_WORLD, MOFEM_NOT_IMPLEMENTED,
            "Partitioned mesh is not supported with mortar contact");
 
  EntityHandle meshset_slave_master_prisms;
  CHKERR moab.create_meshset(MESHSET_SET, meshset_slave_master_prisms);
  CHKERR
  moab.add_entities(meshset_slave_master_prisms, contactPrisms);
  CHKERR mField.getInterface<BitRefManager>()->setBitRefLevelByDim(
      meshset_slave_master_prisms, 3, bitLevels.back());
 
  if (dEbug)
    CHKERR moab.write_mesh("slave_master_prisms.vtk",
                           &meshset_slave_master_prisms, 1);
 
  Range tris_from_prism;
  // find actual masters and slave used
  CHKERR mField.get_moab().get_adjacencies(
      contactPrisms, 2, true, tris_from_prism, moab::Interface::UNION);
 
  tris_from_prism = tris_from_prism.subset_by_type(MBTRI);
  slaveTris = intersect(tris_from_prism, slaveTris);
 
  if (dEbug) {
    EntityHandle mshs_surf_slave;
    CHKERR mField.get_moab().create_meshset(MESHSET_SET, mshs_surf_slave);
    CHKERR mField.get_moab().add_entities(mshs_surf_slave, slaveTris);
    CHKERR mField.get_moab().write_mesh("surf_slave.vtk", &mshs_surf_slave, 1);
    // EntityHandle meshset_tri_slave;
    // CHKERR mField.get_moab().create_meshset(MESHSET_SET, meshset_tri_slave);
  }
 
  MoFEMFunctionReturn(0);
}

setupSolverFunction() [1/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverFunction

(

const TSType

type

)

setupSolverFunction() [2/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverFunction

(

const TSType

type

)

setupSolverFunction() [3/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverFunction

(

const TSType

type

)

Definition at line 490 of file MortarContactInterface.cpp.

                                                                 {
  MoFEMFunctionBeginHot;
  CHKERR setupSolverImpl<TS, true>(type);
  MoFEMFunctionReturnHot(0);
}

setupSolverFunction() [4/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverFunction

(

const TSType

type

)

Definition at line 497 of file MortarContactInterface.cpp.

                                                                   {
  MoFEMFunctionBeginHot;
  CHKERR setupSolverImpl<SNES, true>(type);
  MoFEMFunctionReturnHot(0);
}

setupSolverFunction() [5/5]

template<typename T >

MoFEMErrorCode MortarContactInterface::setupSolverFunction

(

const TSType

type = IM

)

setupSolverFunctionSNES()

MoFEMErrorCode MortarContactInterface::setupSolverFunctionSNES ( )

overridevirtual

Reimplemented from GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 517 of file MortarContactInterface.cpp.

                                                               {
  MoFEMFunctionBegin;
  CHKERR this->setupSolverFunction<SNES>();
  MoFEMFunctionReturn(0);
}

setupSolverFunctionTS()

MoFEMErrorCode MortarContactInterface::setupSolverFunctionTS ( const TSType  type )

overridevirtual

Implements GenericElementInterface.

Definition at line 528 of file MortarContactInterface.cpp.

                                                               {
  MoFEMFunctionBegin;
  CHKERR this->setupSolverFunction<TS>(type);
  MoFEMFunctionReturn(0);
}

setupSolverImpl()

template<typename T , bool RHS>

MoFEMErrorCode MortarContactInterface::setupSolverImpl

(

const TSType

type = IM

)

Definition at line 255 of file MortarContactInterface.cpp.

                                                                        {
  MoFEMFunctionBegin;
 
  if (!dM)
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "DM not defined, addElementsToDM(dm) first");
 
  auto &moab = mField.get_moab();
 
  auto make_contact_element = [&]() {
    return boost::make_shared<MortarContactProblem::MortarContactElement>(
        mField, contactCommondataMultiIndex, positionField, meshNodeField);
  };
 
  auto make_convective_master_element = [&]() {
    return boost::make_shared<
        MortarContactProblem::MortarConvectMasterContactElement>(
        mField, contactCommondataMultiIndex, positionField, meshNodeField);
  };
 
  auto make_convective_slave_element = [&]() {
    return boost::make_shared<
        MortarContactProblem::MortarConvectSlaveContactElement>(
        mField, contactCommondataMultiIndex, positionField, meshNodeField);
  };
 
  auto make_contact_common_data = [&]() {
    return boost::make_shared<MortarContactProblem::CommonDataMortarContact>(
        mField);
  };
 
  auto get_contact_rhs = [&](auto make_element, bool is_alm = false,
                             bool is_displacements = false) {
    auto fe_rhs_simple_contact = make_element();
    auto common_data_mortar_contact = make_contact_common_data();
    if (printContactState) {
      fe_rhs_simple_contact->contactStateVec =
          common_data_mortar_contact->gaussPtsStateVec;
    }
    fe_rhs_simple_contact->getOpPtrVector().push_back(
        new OpSetBc(positionField, true, mBoundaryMarker));
    contactProblemPtr->setContactOperatorsRhs(
        fe_rhs_simple_contact, common_data_mortar_contact, positionField,
        "LAGMULT", is_alm, false, "", is_displacements);
    fe_rhs_simple_contact->getOpPtrVector().push_back(
        new OpUnSetBc(positionField));
    return fe_rhs_simple_contact;
  };
 
  auto get_master_traction_rhs = [&](auto make_element, bool is_alm = false,
                                     bool is_displacements = false) {
    auto fe_rhs_simple_contact = make_element();
    fe_rhs_simple_contact->getOpPtrVector().push_back(
        new OpSetBc(positionField, true, mBoundaryMarker));
    auto common_data_mortar_contact = make_contact_common_data();
    contactProblemPtr->setMasterForceOperatorsRhs(
        fe_rhs_simple_contact, common_data_mortar_contact, positionField,
        "LAGMULT", is_alm, false, "", is_displacements);
    fe_rhs_simple_contact->getOpPtrVector().push_back(
        new OpUnSetBc(positionField));
    return fe_rhs_simple_contact;
  };
 
  auto get_master_traction_lhs = [&](auto make_element, bool is_alm = false,
                                     bool is_displacements = false) {
    auto fe_lhs_simple_contact = make_element();
    auto common_data_mortar_contact = make_contact_common_data();
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpSetBc(positionField, true, mBoundaryMarker));
    contactProblemPtr->setMasterForceOperatorsLhs(
        fe_lhs_simple_contact, common_data_mortar_contact, positionField,
        "LAGMULT", is_alm, false, "", is_displacements);
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpUnSetBc(positionField));
    return fe_lhs_simple_contact;
  };
 
  auto get_master_help_traction_lhs = [&](auto make_element,
                                          bool is_alm = false,
                                          bool is_displacements = false) {
    auto fe_lhs_simple_contact = make_element();
    auto common_data_mortar_contact = make_contact_common_data();
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpSetBc(positionField, true, mBoundaryMarker));
    contactProblemPtr->setMasterForceOperatorsLhs(
        fe_lhs_simple_contact, common_data_mortar_contact, positionField,
        "LAGMULT", is_alm, false, "", is_displacements);
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpUnSetBc(positionField));
    return fe_lhs_simple_contact;
  };
 
  auto get_contact_lhs = [&](auto make_element, bool is_alm = false,
                             bool is_displacements = false) {
    auto fe_lhs_simple_contact = make_element();
    auto common_data_mortar_contact = make_contact_common_data();
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpSetBc(positionField, true, mBoundaryMarker));
    contactProblemPtr->setContactOperatorsLhs(
        fe_lhs_simple_contact, common_data_mortar_contact, positionField,
        "LAGMULT", is_alm, false, "", is_displacements);
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpUnSetBc(positionField));
    return fe_lhs_simple_contact;
  };
 
  auto get_contact_help_lhs = [&](auto make_element, bool is_alm = false,
                                  bool is_displacements = false) {
    auto fe_lhs_simple_contact = make_element();
    auto common_data_mortar_contact = make_contact_common_data();
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpSetBc(positionField, true, mBoundaryMarker));
    contactProblemPtr->setContactOperatorsLhs(
        fe_lhs_simple_contact, common_data_mortar_contact, positionField,
        "LAGMULT", is_alm, false, "", is_displacements);
    fe_lhs_simple_contact->getOpPtrVector().push_back(
        new OpUnSetBc(positionField));
    return fe_lhs_simple_contact;
  };
 
  auto set_solver_pipelines = [&](PetscErrorCode (*function)(
                                      DM, const std::string,
                                      boost::shared_ptr<MoFEM::FEMethod>,
                                      boost::shared_ptr<MoFEM::BasicMethod>,
                                      boost::shared_ptr<MoFEM::BasicMethod>),
                                  PetscErrorCode (*jacobian)(
                                      DM, const std::string,
                                      boost::shared_ptr<MoFEM::FEMethod>,
                                      boost::shared_ptr<MoFEM::BasicMethod>,
                                      boost::shared_ptr<MoFEM::BasicMethod>)) {
    MoFEMFunctionBeginHot;
 
    if (convectPts) {
      if (RHS) {
 
        CHKERR function(this->dM, "CONTACT_ELEM",
                        get_contact_rhs(make_convective_master_element, almFlag,
                                        isDisplacementField),
                        PETSC_NULL, PETSC_NULL);
        CHKERR function(this->dM, "CONTACT_ELEM",
                        get_master_traction_rhs(make_convective_slave_element,
                                                almFlag, isDisplacementField),
                        PETSC_NULL, PETSC_NULL);
      } else {
        if (jacobian) {
 
          CHKERR jacobian(this->dM, "CONTACT_ELEM",
                          get_contact_help_lhs(make_convective_master_element,
                                               almFlag, isDisplacementField),
                          PETSC_NULL, PETSC_NULL);
 
          CHKERR jacobian(
              this->dM, "CONTACT_ELEM",
              get_master_help_traction_lhs(make_convective_slave_element),
              PETSC_NULL, PETSC_NULL);
        }
      }
    } else {
      if (RHS) {
 
        CHKERR function(
            this->dM, "CONTACT_ELEM",
            get_contact_rhs(make_contact_element, almFlag, isDisplacementField),
            PETSC_NULL, PETSC_NULL);
        CHKERR function(this->dM, "CONTACT_ELEM",
                        get_master_traction_rhs(make_contact_element, almFlag,
                                                isDisplacementField),
                        PETSC_NULL, PETSC_NULL);
      } else {
        if (jacobian) {
 
          CHKERR jacobian(this->dM, "CONTACT_ELEM",
                          get_contact_lhs(make_contact_element, almFlag,
                                          isDisplacementField),
                          PETSC_NULL, PETSC_NULL);
          CHKERR jacobian(this->dM, "CONTACT_ELEM",
                          get_master_traction_lhs(make_contact_element, almFlag,
                                                  isDisplacementField),
                          PETSC_NULL, PETSC_NULL);
        }
      }
    }
 
    MoFEMFunctionReturnHot(0);
  };
 
  if constexpr (std::is_same_v<T, SNES>) {
 
    CHKERR set_solver_pipelines(&DMMoFEMSNESSetFunction,
                                &DMMoFEMSNESSetJacobian);
  } else if (std::is_same_v<T, TS>) {
 
    switch (type) {
    case IM:
      CHKERR set_solver_pipelines(&DMMoFEMTSSetIFunction,
                                  &DMMoFEMTSSetIJacobian);
      break;
    case IM2:
      CHKERR set_solver_pipelines(&DMMoFEMTSSetI2Function,
                                  &DMMoFEMTSSetI2Jacobian);
      break;
    case EX:
      CHKERR set_solver_pipelines(&DMMoFEMTSSetRHSFunction,
                                  nullptr);
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_IMPLEMENTED,
              "This TS is not yet implemented for contact");
      break;
    }
 
  } else
    static_assert(!std::is_same_v<T, KSP>,
                  "this solver has not been implemented for contact yet");
 
  if (!commonDataPostProc) {
    commonDataPostProc = make_contact_common_data();
    if (convectPts)
      fePostProcSimpleContact = make_convective_master_element();
    else
      fePostProcSimpleContact = make_contact_element();
 
    CHKERR findPostProcSurface();
 
    contactProblemPtr->setContactOperatorsForPostProc(
        fePostProcSimpleContact, commonDataPostProc, mField, positionField,
        "LAGMULT", moabPostProcMesh, almFlag, false, "", false, postProcSurface,
        postProcGapTol);
  }
 
  MoFEMFunctionReturn(0);
}

setupSolverJacobian() [1/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverJacobian

(

const TSType

type

)

setupSolverJacobian() [2/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverJacobian

(

const TSType

type

)

setupSolverJacobian() [3/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverJacobian

(

const TSType

type

)

Definition at line 504 of file MortarContactInterface.cpp.

                                                                   {
  MoFEMFunctionBeginHot;
  CHKERR setupSolverImpl<SNES, false>(type);
  MoFEMFunctionReturnHot(0);
}

setupSolverJacobian() [4/5]

template<>

MoFEMErrorCode MortarContactInterface::setupSolverJacobian

(

const TSType

type

)

Definition at line 511 of file MortarContactInterface.cpp.

                                                                 {
  MoFEMFunctionBeginHot;
  CHKERR setupSolverImpl<TS, false>(type);
  MoFEMFunctionReturnHot(0);
}

setupSolverJacobian() [5/5]

template<typename T >

MoFEMErrorCode MortarContactInterface::setupSolverJacobian

(

const TSType

type = IM

)

setupSolverJacobianSNES()

MoFEMErrorCode MortarContactInterface::setupSolverJacobianSNES ( )

overridevirtual

Reimplemented from GenericElementInterface.

Examples

mortar_contact.cpp.

Definition at line 522 of file MortarContactInterface.cpp.

                                                               {
  MoFEMFunctionBegin;
  CHKERR this->setupSolverJacobian<SNES>();
  MoFEMFunctionReturn(0);
}

setupSolverJacobianTS()

MoFEMErrorCode MortarContactInterface::setupSolverJacobianTS ( const TSType  type )

overridevirtual

Implements GenericElementInterface.

Definition at line 534 of file MortarContactInterface.cpp.

                                                               {
  MoFEMFunctionBegin;
  CHKERR this->setupSolverJacobian<TS>(type);
  MoFEMFunctionReturn(0);
}

updateElementVariables()

MoFEMErrorCode MortarContactInterface::updateElementVariables ( )

overridevirtual

Reimplemented from GenericElementInterface.

Definition at line 624 of file MortarContactInterface.cpp.

                                                              {
  MoFEMFunctionBeginHot;
  MoFEMFunctionReturnHot(0);
}

Member Data Documentation

almFlag

PetscBool MortarContactInterface::almFlag

Definition at line 36 of file MortarContactInterface.hpp.

bitLevels

std::vector<BitRefLevel> MortarContactInterface::bitLevels

Definition at line 55 of file MortarContactInterface.hpp.

cnValue

double MortarContactInterface::cnValue

Definition at line 28 of file MortarContactInterface.hpp.

commonDataPostProc

boost::shared_ptr<MortarContactProblem::CommonDataMortarContact> MortarContactInterface::commonDataPostProc

Examples

mortar_contact.cpp.

Definition at line 64 of file MortarContactInterface.hpp.

contactArea

std::array<double, 2> MortarContactInterface::contactArea

Examples

mortar_contact.cpp.

Definition at line 69 of file MortarContactInterface.hpp.

contactCommondataMultiIndex

boost::shared_ptr<contactMIndex> MortarContactInterface::contactCommondataMultiIndex

Definition at line 58 of file MortarContactInterface.hpp.

contactPrisms

Range MortarContactInterface::contactPrisms

Definition at line 42 of file MortarContactInterface.hpp.

contactProblemPtr

boost::shared_ptr<MortarContactProblem> MortarContactInterface::contactProblemPtr

Definition at line 41 of file MortarContactInterface.hpp.

contactSurfacePairs

std::vector<std::pair<Range, Range> > MortarContactInterface::contactSurfacePairs

Definition at line 44 of file MortarContactInterface.hpp.

convectPts

PetscBool MortarContactInterface::convectPts

Definition at line 34 of file MortarContactInterface.hpp.

dEbug

PetscBool MortarContactInterface::dEbug

Definition at line 37 of file MortarContactInterface.hpp.

dM

SmartPetscObj<DM> MortarContactInterface::dM

Definition at line 25 of file MortarContactInterface.hpp.

fePostProcSimpleContact

boost::shared_ptr<MortarContactProblem::MortarContactElement> MortarContactInterface::fePostProcSimpleContact

Definition at line 62 of file MortarContactInterface.hpp.

isDisplacementField

bool MortarContactInterface::isDisplacementField

Definition at line 52 of file MortarContactInterface.hpp.

isNewtonCotes

PetscBool MortarContactInterface::isNewtonCotes

Definition at line 33 of file MortarContactInterface.hpp.

isPartitioned

PetscBool MortarContactInterface::isPartitioned

Definition at line 38 of file MortarContactInterface.hpp.

isQuasiStatic

bool MortarContactInterface::isQuasiStatic

Definition at line 53 of file MortarContactInterface.hpp.

masterTris

Range MortarContactInterface::masterTris

Definition at line 43 of file MortarContactInterface.hpp.

mb_post

moab::Core MortarContactInterface::mb_post

Definition at line 66 of file MortarContactInterface.hpp.

meshNodeField

string MortarContactInterface::meshNodeField

Definition at line 50 of file MortarContactInterface.hpp.

mField

MoFEM::Interface& MortarContactInterface::mField

Definition at line 24 of file MortarContactInterface.hpp.

moabPostProcMesh

moab::Interface& MortarContactInterface::moabPostProcMesh

Definition at line 67 of file MortarContactInterface.hpp.

nbGaussPts

std::array<double, 2> MortarContactInterface::nbGaussPts

Examples

mortar_contact.cpp.

Definition at line 68 of file MortarContactInterface.hpp.

nbHoLevels

PetscInt MortarContactInterface::nbHoLevels

Definition at line 32 of file MortarContactInterface.hpp.

oRder

PetscInt MortarContactInterface::oRder

Definition at line 29 of file MortarContactInterface.hpp.

orderContact

PetscInt MortarContactInterface::orderContact

Definition at line 30 of file MortarContactInterface.hpp.

orderLambda

PetscInt MortarContactInterface::orderLambda

Definition at line 31 of file MortarContactInterface.hpp.

positionField

string MortarContactInterface::positionField

Definition at line 49 of file MortarContactInterface.hpp.

postProcContactPtr

boost::shared_ptr<PostProcFaceOnRefinedMesh> MortarContactInterface::postProcContactPtr

Definition at line 59 of file MortarContactInterface.hpp.

postProcGapTol

double MortarContactInterface::postProcGapTol

Definition at line 47 of file MortarContactInterface.hpp.

postProcSurface

Range MortarContactInterface::postProcSurface

Definition at line 46 of file MortarContactInterface.hpp.

printContactState

PetscBool MortarContactInterface::printContactState

Definition at line 35 of file MortarContactInterface.hpp.

slaveTris

Range MortarContactInterface::slaveTris

Definition at line 43 of file MortarContactInterface.hpp.

---

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

• users_modules/mortar_contact/src/MortarContactInterface.hpp
• users_modules/mortar_contact/src/impl/MortarContactInterface.cpp