Contact Struct Reference

Collaboration diagram for Contact:

Public Member Functions
	Contact (MoFEM::Interface &m_field)
MoFEMErrorCode	runProblem ()
	[Run problem] More...

Private Member Functions
MoFEMErrorCode	setupProblem ()
	[Run problem] More...
MoFEMErrorCode	createCommonData ()
	[Set up problem] More...
MoFEMErrorCode	bC ()
	[Create common data] More...
MoFEMErrorCode	OPs ()
	[Boundary condition] More...
MoFEMErrorCode	tsSolve ()
	[Push operators to pip] More...
MoFEMErrorCode	postProcess ()
	[Solve] More...
MoFEMErrorCode	checkResults ()
	[Postprocess results] More...

Private Attributes
MoFEM::Interface &	mField
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > >	uXScatter
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > >	uYScatter
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > >	uZScatter
boost::shared_ptr< std::vector< unsigned char > >	boundaryMarker

Detailed Description

Definition at line 138 of file contact.cpp.

Constructor & Destructor Documentation

Contact()

Contact::Contact ( MoFEM::Interface &  m_field )

inline

Definition at line 140 of file contact.cpp.

: mField(m_field) {}

Member Function Documentation

bC()

MoFEMErrorCode Contact::bC ( )

private

[Create common data]

[Boundary condition]

Definition at line 330 of file contact.cpp.

                           {
  MoFEMFunctionBegin;
  auto bc_mng = mField.getInterface<BcManager>();
  auto simple = mField.getInterface<Simple>();
 
  for (auto f : {"U", "SIGMA"}) {
    CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(),
                                             "REMOVE_X", f, 0, 0);
    CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(),
                                             "REMOVE_Y", f, 1, 1);
    CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(),
                                             "REMOVE_Z", f, 2, 2);
    CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(),
                                             "REMOVE_ALL", f, 0, 3);
  }
 
  CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(), "FIX_X",
                                           "SIGMA", 0, 0, false, true);
  CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(), "FIX_Y",
                                           "SIGMA", 1, 1, false, true);
  CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(), "FIX_Z",
                                           "SIGMA", 2, 2, false, true);
  CHKERR bc_mng->removeBlockDOFsOnEntities(simple->getProblemName(), "FIX_ALL",
                                           "SIGMA", 0, 3, false, true);
  CHKERR bc_mng->removeBlockDOFsOnEntities(
      simple->getProblemName(), "NO_CONTACT", "SIGMA", 0, 3, false, true);
 
  // Note remove has to be always before push. Then node marking will be
  // corrupted.
  CHKERR bc_mng->pushMarkDOFsOnEntities<DisplacementCubitBcData>(
      simple->getProblemName(), "U");
  boundaryMarker = bc_mng->getMergedBlocksMarker(vector<string>{"FIX_", "ROTATE_"});
 
  MoFEMFunctionReturn(0);
}

checkResults()

MoFEMErrorCode Contact::checkResults ( )

private

[Postprocess results]

[Check]

Definition at line 699 of file contact.cpp.

{ return 0; }

createCommonData()

MoFEMErrorCode Contact::createCommonData ( )

private

[Set up problem]

[Create common data]

Definition at line 290 of file contact.cpp.

                                         {
  MoFEMFunctionBegin;
 
  auto get_options = [&]() {
    MoFEMFunctionBegin;
    CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-young_modulus",
                                 &young_modulus, PETSC_NULL);
    CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-poisson_ratio",
                                 &poisson_ratio, PETSC_NULL);
    CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-rho", &rho, PETSC_NULL);
    CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-cn", &cn, PETSC_NULL);
    CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-spring_stiffness",
                                 &spring_stiffness, PETSC_NULL);
    CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-alpha_dumping",
                                 &alpha_dumping, PETSC_NULL);
 
    MOFEM_LOG("CONTACT", Sev::inform) << "Young modulus " << young_modulus;
    MOFEM_LOG("CONTACT", Sev::inform) << "Poisson_ratio " << poisson_ratio;
    MOFEM_LOG("CONTACT", Sev::inform) << "Density " << rho;
    MOFEM_LOG("CONTACT", Sev::inform) << "cn " << cn;
    MOFEM_LOG("CONTACT", Sev::inform)
        << "spring_stiffness " << spring_stiffness;
    MOFEM_LOG("CONTACT", Sev::inform) << "alpha_dumping " << alpha_dumping;
 
    MoFEMFunctionReturn(0);
  };
 
  CHKERR get_options();
 
#ifdef PYTHON_SFD
  sdfPythonPtr = boost::make_shared<SDFPython>();
  CHKERR sdfPythonPtr->sdfInit("sdf.py");
  sdfPythonWeakPtr = sdfPythonPtr;
#endif
 
  MoFEMFunctionReturn(0);
}

OPs()

MoFEMErrorCode Contact::OPs ( )

private

[Boundary condition]

[Push operators to pip]

Definition at line 368 of file contact.cpp.

                            {
  MoFEMFunctionBegin;
  auto simple = mField.getInterface<Simple>();
  auto *pip_mng = mField.getInterface<PipelineManager>();
  auto bc_mng = mField.getInterface<BcManager>();
  auto time_scale = boost::make_shared<TimeScale>();
 
  auto add_domain_base_ops = [&](auto &pip) {
    CHKERR AddHOOps<SPACE_DIM, SPACE_DIM, SPACE_DIM>::add(pip, {H1, HDIV}/*,
                                                          "GEOMETRY"*/);
  };
 
  auto common_data_ptr = boost::make_shared<ContactOps::CommonData>();
  auto henky_common_data_ptr = boost::make_shared<HenckyOps::CommonData>();
  henky_common_data_ptr->matGradPtr = common_data_ptr->mGradPtr();
  henky_common_data_ptr->matDPtr = common_data_ptr->mDPtr();
 
  auto add_domain_ops_lhs = [&](auto &pip) {
    pip.push_back(new OpSetBc("U", true, boundaryMarker));
 
    CHKERR addMatBlockOps(mField, pip, "U", "MAT_ELASTIC",
                          common_data_ptr->mDPtr(), Sev::verbose);
 
    pip.push_back(new OpCalculateVectorFieldGradient<SPACE_DIM, SPACE_DIM>(
        "U", common_data_ptr->mGradPtr()));
    pip.push_back(
        new OpCalculateEigenVals<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(new OpCalculateLogC<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(
        new OpCalculateLogC_dC<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(
        new OpCalculateHenckyStress<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(
        new OpCalculatePiolaStress<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(new OpHenckyTangent<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(
        new OpKPiola("U", "U", henky_common_data_ptr->getMatTangent()));
 
    if (!is_quasi_static) {
      auto get_inertia_and_mass_dumping = [this](const double, const double,
                                                 const double) {
        auto *pip_mng = mField.getInterface<PipelineManager>();
        auto &fe_domain_lhs = pip_mng->getDomainLhsFE();
        return rho * fe_domain_lhs->ts_aa + alpha_dumping * fe_domain_lhs->ts_a;
      };
      pip.push_back(new OpMass("U", "U", get_inertia_and_mass_dumping));
    } else if (alpha_dumping > 0) {
      auto get_mass_dumping = [this](const double, const double,
                                      const double) {
        auto *pip_mng = mField.getInterface<PipelineManager>();
        auto &fe_domain_lhs = pip_mng->getDomainLhsFE();
        return alpha_dumping * fe_domain_lhs->ts_a;
      };
      pip.push_back(new OpMass("U", "U", get_mass_dumping));
    }
 
    auto unity = []() { return 1; };
    pip.push_back(new OpMixDivULhs("SIGMA", "U", unity, true));
    pip.push_back(new OpLambdaGraULhs("SIGMA", "U", unity, true));
 
    pip.push_back(new OpUnSetBc("U"));
  };
 
  auto add_domain_ops_rhs = [&](auto &pip) {
    pip.push_back(new OpSetBc("U", true, boundaryMarker));
 
    CHKERR DomainRhsBCs::AddFluxToPipeline<OpDomainRhsBCs>::add(
        pip, mField, "U", {time_scale}, Sev::inform);
 
    CHKERR addMatBlockOps(mField, pip, "U", "MAT_ELASTIC",
                          common_data_ptr->mDPtr(), Sev::inform);
    pip.push_back(new OpCalculateVectorFieldGradient<SPACE_DIM, SPACE_DIM>(
        "U", common_data_ptr->mGradPtr()));
 
    pip.push_back(
        new OpCalculateEigenVals<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(new OpCalculateLogC<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(
        new OpCalculateLogC_dC<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(
        new OpCalculateHenckyStress<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(
        new OpCalculatePiolaStress<SPACE_DIM>("U", henky_common_data_ptr));
    pip.push_back(new OpInternalForcePiola(
        "U", henky_common_data_ptr->getMatFirstPiolaStress()));
 
    pip.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
        "U", common_data_ptr->contactDispPtr()));
 
    pip.push_back(new OpCalculateHVecTensorField<SPACE_DIM, SPACE_DIM>(
        "SIGMA", common_data_ptr->contactStressPtr()));
    pip.push_back(new OpCalculateHVecTensorDivergence<SPACE_DIM, SPACE_DIM>(
        "SIGMA", common_data_ptr->contactStressDivergencePtr()));
 
    pip.push_back(new OpMixDivURhs("SIGMA", common_data_ptr->contactDispPtr(),
                                   [](double, double, double) { return 1; }));
    pip.push_back(
        new OpMixLambdaGradURhs("SIGMA", common_data_ptr->mGradPtr()));
 
    pip.push_back(new OpMixUTimesDivLambdaRhs(
        "U", common_data_ptr->contactStressDivergencePtr()));
    pip.push_back(
        new OpMixUTimesLambdaRhs("U", common_data_ptr->contactStressPtr()));
 
    // only in case of dynamics
    if (!is_quasi_static) {
      auto mat_acceleration = boost::make_shared<MatrixDouble>();
      pip.push_back(new OpCalculateVectorFieldValuesDotDot<SPACE_DIM>(
          "U", mat_acceleration));
      pip.push_back(new OpInertiaForce(
          "U", mat_acceleration, [](double, double, double) { return rho; }));
    }
    if (alpha_dumping > 0) {
      auto mat_velocity = boost::make_shared<MatrixDouble>();
      pip.push_back(
          new OpCalculateVectorFieldValuesDot<SPACE_DIM>("U", mat_velocity));
      pip.push_back(
          new OpInertiaForce("U", mat_velocity, [](double, double, double) {
            return alpha_dumping;
          }));
    }
    pip.push_back(new OpUnSetBc("U"));
  };
 
  auto add_boundary_base_ops = [&](auto &pip) {
    CHKERR AddHOOps<SPACE_DIM - 1, SPACE_DIM, SPACE_DIM>::add(pip, {HDIV}/*,
                                                              "GEOMETRY"*/);
    pip.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>(
        "U", common_data_ptr->contactDispPtr()));
    pip.push_back(new OpCalculateHVecTensorTrace<SPACE_DIM, BoundaryEleOp>(
        "SIGMA", common_data_ptr->contactTractionPtr()));
  };
 
  auto add_boundary_ops_lhs = [&](auto &pip) {
    MoFEMFunctionBegin;
    CHKERR EssentialBC<BoundaryEleOp>::Assembly<A>::BiLinearForm<GAUSS>::
        AddEssentialToPipeline<OpEssentialLhs>::add(
            mField, pip, simple->getProblemName(), "U");
    pip.push_back(new OpSetBc("U", true, boundaryMarker));
    CHKERR BoundaryLhsBCs::AddFluxToPipeline<OpBoundaryLhsBCs>::add(
        pip, mField, "U", Sev::inform);
    pip.push_back(new OpConstrainBoundaryLhs_dU("SIGMA", "U", common_data_ptr));
    pip.push_back(new OpConstrainBoundaryLhs_dTraction("SIGMA", "SIGMA",
                                                       common_data_ptr));
 
    if (spring_stiffness > 0)
      pip.push_back(new OpSpringLhs(
          "U", "U",
 
          [this](double, double, double) { return spring_stiffness; }
 
          ));
 
    pip.push_back(new OpUnSetBc("U"));
    MoFEMFunctionReturn(0);
  };
 
  auto add_boundary_ops_rhs = [&](auto &pip) {
    MoFEMFunctionBegin;
 
    auto u_mat_ptr = boost::make_shared<MatrixDouble>();
    pip.push_back(new OpCalculateVectorFieldValues<SPACE_DIM>("U", u_mat_ptr));
    CHKERR EssentialBC<BoundaryEleOp>::Assembly<A>::LinearForm<GAUSS>::
        AddEssentialToPipeline<OpEssentialRhs>::add(
            mField, pip, simple->getProblemName(), "U", u_mat_ptr,
            {boost::make_shared<TimeScale>()}); // note displacements have no
                                                // scaling
 
    pip.push_back(new OpSetBc("U", true, boundaryMarker));
    CHKERR BoundaryRhsBCs::AddFluxToPipeline<OpBoundaryRhsBCs>::add(
        pip, mField, "U", {time_scale}, Sev::inform);
    pip.push_back(new OpConstrainBoundaryRhs("SIGMA", common_data_ptr));
    if (spring_stiffness > 0)
      pip.push_back(new OpSpringRhs(
          "U", common_data_ptr->contactDispPtr(),
          [this](double, double, double) { return spring_stiffness; }));
    pip.push_back(new OpUnSetBc("U"));
    MoFEMFunctionReturn(0);
  };
 
  add_domain_base_ops(pip_mng->getOpDomainLhsPipeline());
  add_domain_base_ops(pip_mng->getOpDomainRhsPipeline());
  add_domain_ops_lhs(pip_mng->getOpDomainLhsPipeline());
  add_domain_ops_rhs(pip_mng->getOpDomainRhsPipeline());
 
  add_boundary_base_ops(pip_mng->getOpBoundaryLhsPipeline());
  add_boundary_base_ops(pip_mng->getOpBoundaryRhsPipeline());
  CHKERR add_boundary_ops_lhs(pip_mng->getOpBoundaryLhsPipeline());
  CHKERR add_boundary_ops_rhs(pip_mng->getOpBoundaryRhsPipeline());
 
  auto integration_rule_vol = [](int, int, int approx_order) {
    return 2 * approx_order + geom_order - 1;
  };
  CHKERR pip_mng->setDomainRhsIntegrationRule(integration_rule_vol);
  CHKERR pip_mng->setDomainLhsIntegrationRule(integration_rule_vol);
  auto integration_rule_boundary = [](int, int, int approx_order) {
    return 2 * approx_order + geom_order - 1;
  };
  CHKERR pip_mng->setBoundaryRhsIntegrationRule(integration_rule_boundary);
  CHKERR pip_mng->setBoundaryLhsIntegrationRule(integration_rule_boundary);
 
  MoFEMFunctionReturn(0);
}

postProcess()

MoFEMErrorCode Contact::postProcess ( )

private

[Solve]

[Postprocess results]

Definition at line 695 of file contact.cpp.

{ return 0; }

runProblem()

MoFEMErrorCode Contact::runProblem

(

)

[Run problem]

Definition at line 166 of file contact.cpp.

                                   {
  MoFEMFunctionBegin;
  CHKERR setupProblem();
  CHKERR createCommonData();
  CHKERR bC();
  CHKERR OPs();
  CHKERR tsSolve();
  CHKERR postProcess();
  CHKERR checkResults();
  MoFEMFunctionReturn(0);
}

setupProblem()

MoFEMErrorCode Contact::setupProblem ( )

private

[Run problem]

[Set up problem]

Definition at line 180 of file contact.cpp.

                                     {
  MoFEMFunctionBegin;
  Simple *simple = mField.getInterface<Simple>();
 
  CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-order", &order, PETSC_NULL);
  // CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-geom_order", &geom_order,
  //                           PETSC_NULL);
  MOFEM_LOG("CONTACT", Sev::inform) << "Order " << order;
  MOFEM_LOG("CONTACT", Sev::inform) << "Geom order " << geom_order;
 
  // Select base
  enum bases { AINSWORTH, DEMKOWICZ, LASBASETOPT };
  const char *list_bases[LASBASETOPT] = {"ainsworth", "demkowicz"};
  PetscInt choice_base_value = AINSWORTH;
  CHKERR PetscOptionsGetEList(PETSC_NULL, NULL, "-base", list_bases,
                              LASBASETOPT, &choice_base_value, PETSC_NULL);
 
  FieldApproximationBase base;
  switch (choice_base_value) {
  case AINSWORTH:
    base = AINSWORTH_LEGENDRE_BASE;
    MOFEM_LOG("CONTACT", Sev::inform)
        << "Set AINSWORTH_LEGENDRE_BASE for displacements";
    break;
  case DEMKOWICZ:
    base = DEMKOWICZ_JACOBI_BASE;
    MOFEM_LOG("CONTACT", Sev::inform)
        << "Set DEMKOWICZ_JACOBI_BASE for displacements";
    break;
  default:
    base = LASTBASE;
    break;
  }
 
  // Note: For tets we have only H1 Ainsworth base, for Hex we have only H1
  // Demkowicz base. We need to implement Demkowicz H1 base on tet.
  CHKERR simple->addDomainField("U", H1, base, SPACE_DIM);
  CHKERR simple->addBoundaryField("U", H1, base, SPACE_DIM);
  CHKERR simple->addDomainField("SIGMA", CONTACT_SPACE, DEMKOWICZ_JACOBI_BASE,
                                SPACE_DIM);
  CHKERR simple->addBoundaryField("SIGMA", CONTACT_SPACE, DEMKOWICZ_JACOBI_BASE,
                                  SPACE_DIM);
  // CHKERR simple->addDataField("GEOMETRY", H1, base, SPACE_DIM);
 
 
  CHKERR simple->setFieldOrder("U", order);
  // CHKERR simple->setFieldOrder("SIGMA", 0);
  // CHKERR simple->setFieldOrder("GEOMETRY", geom_order);
 
  auto get_skin = [&]() {
    Range body_ents;
    CHKERR mField.get_moab().get_entities_by_dimension(0, SPACE_DIM, body_ents);
    Skinner skin(&mField.get_moab());
    Range skin_ents;
    CHKERR skin.find_skin(0, body_ents, false, skin_ents);
    return skin_ents;
  };
 
  auto filter_blocks = [&](auto skin) {
    Range contact_range;
    for (auto m :
         mField.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
 
             (boost::format("%s(.*)") % "CONTACT").str()
 
                 ))
 
    ) {
      MOFEM_LOG("CONTACT", Sev::inform)
          << "Find contact block set:  " << m->getName();
      auto meshset = m->getMeshset();
      CHKERR mField.get_moab().get_entities_by_dimension(meshset, SPACE_DIM - 1,
                                                         contact_range, true);
 
      MOFEM_LOG("SYNC", Sev::inform)
          << "Nb entities in contact surface: " << contact_range.size();
      MOFEM_LOG_SYNCHRONISE(mField.get_comm());
      CHKERR mField.getInterface<CommInterface>()->synchroniseEntities(
          contact_range);
      skin = intersect(skin, contact_range);
    }
    return skin;
  };
 
  auto filter_true_skin = [&](auto skin) {
    Range boundary_ents;
    ParallelComm *pcomm =
        ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
    CHKERR pcomm->filter_pstatus(skin, PSTATUS_SHARED | PSTATUS_MULTISHARED,
                                 PSTATUS_NOT, -1, &boundary_ents);
    return boundary_ents;
  };
 
  auto boundary_ents = filter_true_skin(filter_blocks(get_skin()));
  CHKERR simple->setFieldOrder("SIGMA", 0);
  CHKERR simple->setFieldOrder("SIGMA", order - 1, &boundary_ents);
 
  CHKERR simple->setUp();
 
  // auto project_ho_geometry = [&]() {
  //   Projection10NodeCoordsOnField ent_method(mField, "GEOMETRY");
  //   return mField.loop_dofs("GEOMETRY", ent_method);
  // };
  // CHKERR project_ho_geometry();
 
  MoFEMFunctionReturn(0);
}

tsSolve()

MoFEMErrorCode Contact::tsSolve ( )

private

[Push operators to pip]

[Solve]

Definition at line 574 of file contact.cpp.

                                {
  MoFEMFunctionBegin;
 
  Simple *simple = mField.getInterface<Simple>();
  PipelineManager *pip_mng = mField.getInterface<PipelineManager>();
  ISManager *is_manager = mField.getInterface<ISManager>();
 
  auto set_section_monitor = [&](auto solver) {
    MoFEMFunctionBegin;
    SNES snes;
    CHKERR TSGetSNES(solver, &snes);
    PetscViewerAndFormat *vf;
    CHKERR PetscViewerAndFormatCreate(PETSC_VIEWER_STDOUT_WORLD,
                                      PETSC_VIEWER_DEFAULT, &vf);
    CHKERR SNESMonitorSet(
        snes,
        (MoFEMErrorCode(*)(SNES, PetscInt, PetscReal, void *))SNESMonitorFields,
        vf, (MoFEMErrorCode(*)(void **))PetscViewerAndFormatDestroy);
    MoFEMFunctionReturn(0);
  };
 
  auto scatter_create = [&](auto D, auto coeff) {
    SmartPetscObj<IS> is;
    CHKERR is_manager->isCreateProblemFieldAndRank(simple->getProblemName(),
                                                   ROW, "U", coeff, coeff, is);
    int loc_size;
    CHKERR ISGetLocalSize(is, &loc_size);
    Vec v;
    CHKERR VecCreateMPI(mField.get_comm(), loc_size, PETSC_DETERMINE, &v);
    VecScatter scatter;
    CHKERR VecScatterCreate(D, is, v, PETSC_NULL, &scatter);
    return std::make_tuple(SmartPetscObj<Vec>(v),
                           SmartPetscObj<VecScatter>(scatter));
  };
 
  auto set_time_monitor = [&](auto dm, auto solver) {
    MoFEMFunctionBegin;
    boost::shared_ptr<Monitor> monitor_ptr(
        new Monitor(dm, uXScatter, uYScatter, uZScatter));
    boost::shared_ptr<ForcesAndSourcesCore> null;
    CHKERR DMMoFEMTSSetMonitor(dm, solver, simple->getDomainFEName(),
                               monitor_ptr, null, null);
    MoFEMFunctionReturn(0);
  };
 
  auto set_fieldsplit_preconditioner = [&](auto solver) {
    MoFEMFunctionBegin;
 
    SNES snes;
    CHKERR TSGetSNES(solver, &snes);
    KSP ksp;
    CHKERR SNESGetKSP(snes, &ksp);
    PC pc;
    CHKERR KSPGetPC(ksp, &pc);
    PetscBool is_pcfs = PETSC_FALSE;
    PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
 
    // Setup fieldsplit (block) solver - optional: yes/no
    if (is_pcfs == PETSC_TRUE) {
      auto bc_mng = mField.getInterface<BcManager>();
      auto name_prb = simple->getProblemName();
      auto is_all_bc = bc_mng->getBlockIS(name_prb, "FIX_X", "U", 0, 0);
      is_all_bc = bc_mng->getBlockIS(name_prb, "FIX_Y", "U", 1, 1, is_all_bc);
      is_all_bc = bc_mng->getBlockIS(name_prb, "FIX_Z", "U", 2, 2, is_all_bc);
      is_all_bc = bc_mng->getBlockIS(name_prb, "FIX_ALL", "U", 0, 2, is_all_bc);
      int is_all_bc_size;
      CHKERR ISGetSize(is_all_bc, &is_all_bc_size);
      MOFEM_LOG("CONTACT", Sev::inform)
          << "Field split block size " << is_all_bc_size;
      CHKERR PCFieldSplitSetIS(pc, PETSC_NULL,
                               is_all_bc); // boundary block
    }
 
    MoFEMFunctionReturn(0);
  };
 
  auto dm = simple->getDM();
  auto D = createDMVector(dm);
 
  ContactOps::CommonData::createTotalTraction(mField);
 
  uXScatter = scatter_create(D, 0);
  uYScatter = scatter_create(D, 1);
  if (SPACE_DIM == 3)
    uZScatter = scatter_create(D, 2);
 
  if (is_quasi_static) {
    auto solver = pip_mng->createTSIM();
    auto D = createDMVector(dm);
    CHKERR set_section_monitor(solver);
    CHKERR set_time_monitor(dm, solver);
    CHKERR TSSetSolution(solver, D);
    CHKERR TSSetFromOptions(solver);
    CHKERR set_fieldsplit_preconditioner(solver);
    CHKERR TSSetUp(solver);
    CHKERR TSSolve(solver, NULL);
  } else {
    auto solver = pip_mng->createTSIM2();
    auto dm = simple->getDM();
    auto D = createDMVector(dm);
    auto DD = vectorDuplicate(D);
    CHKERR set_section_monitor(solver);
    CHKERR set_time_monitor(dm, solver);
    CHKERR TS2SetSolution(solver, D, DD);
    CHKERR TSSetFromOptions(solver);
    CHKERR set_fieldsplit_preconditioner(solver);
    CHKERR TSSetUp(solver);
    CHKERR TSSolve(solver, NULL);
  }
 
  ContactOps::CommonData::totalTraction.reset();
 
  CHKERR VecGhostUpdateBegin(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR DMoFEMMeshToLocalVector(dm, D, INSERT_VALUES, SCATTER_REVERSE);
 
  MoFEMFunctionReturn(0);
}

Member Data Documentation

boundaryMarker

boost::shared_ptr<std::vector<unsigned char> > Contact::boundaryMarker

private

Definition at line 158 of file contact.cpp.

mField

MoFEM::Interface& Contact::mField

private

Definition at line 145 of file contact.cpp.

uXScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > Contact::uXScatter

private

Definition at line 155 of file contact.cpp.

uYScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > Contact::uYScatter

private

Definition at line 156 of file contact.cpp.

uZScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > Contact::uZScatter

private

Definition at line 157 of file contact.cpp.

---

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

• users_modules/tutorials/adv-1/contact.cpp