v0.14.0
Classes | Public Member Functions | Private Member Functions | Private Attributes | List of all members
Seepage Struct Reference
Collaboration diagram for Seepage:
[legend]

Classes

struct  BlockedParameters
 

Public Member Functions

 Seepage (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 pipeline] More...
 
MoFEMErrorCode addMatBlockOps (boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, std::string block_elastic_name, std::string block_thermal_name, boost::shared_ptr< BlockedParameters > blockedParamsPtr, Sev sev)
 

Private Attributes

MoFEM::InterfacemField
 
PetscBool doEvalField
 
std::array< double, SPACE_DIMfieldEvalCoords
 
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uXScatter
 
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uYScatter
 
std::tuple< SmartPetscObj< Vec >, SmartPetscObj< VecScatter > > uZScatter
 

Detailed Description

Examples
seepage.cpp.

Definition at line 179 of file seepage.cpp.

Constructor & Destructor Documentation

◆ Seepage()

Seepage::Seepage ( MoFEM::Interface m_field)
inline

Definition at line 181 of file seepage.cpp.

181 : mField(m_field) {}

Member Function Documentation

◆ addMatBlockOps()

MoFEMErrorCode Seepage::addMatBlockOps ( boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &  pipeline,
std::string  block_elastic_name,
std::string  block_thermal_name,
boost::shared_ptr< BlockedParameters blockedParamsPtr,
Sev  sev 
)
private

[Calculate elasticity tensor]

[Calculate elasticity tensor]

Examples
seepage.cpp.

Definition at line 221 of file seepage.cpp.

224  {
226 
227  struct OpMatElasticBlocks : public DomainEleOp {
228  OpMatElasticBlocks(boost::shared_ptr<MatrixDouble> m, double bulk_modulus_K,
229  double shear_modulus_G, MoFEM::Interface &m_field,
230  Sev sev,
231  std::vector<const CubitMeshSets *> meshset_vec_ptr)
232  : DomainEleOp(NOSPACE, DomainEleOp::OPSPACE), matDPtr(m),
233  bulkModulusKDefault(bulk_modulus_K),
234  shearModulusGDefault(shear_modulus_G) {
235  CHK_THROW_MESSAGE(extractElasticBlockData(m_field, meshset_vec_ptr, sev),
236  "Can not get data from block");
237  }
238 
239  MoFEMErrorCode doWork(int side, EntityType type,
242 
243  for (auto &b : blockData) {
244 
245  if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
246  CHKERR getMatDPtr(matDPtr, b.bulkModulusK, b.shearModulusG);
248  }
249  }
250 
251  CHKERR getMatDPtr(matDPtr, bulkModulusKDefault, shearModulusGDefault);
253  }
254 
255  private:
256  boost::shared_ptr<MatrixDouble> matDPtr;
257 
258  struct BlockData {
259  double bulkModulusK;
260  double shearModulusG;
261  Range blockEnts;
262  };
263 
264  double bulkModulusKDefault;
265  double shearModulusGDefault;
266  std::vector<BlockData> blockData;
267 
269  extractElasticBlockData(MoFEM::Interface &m_field,
270  std::vector<const CubitMeshSets *> meshset_vec_ptr,
271  Sev sev) {
273 
274  for (auto m : meshset_vec_ptr) {
275  MOFEM_TAG_AND_LOG("WORLD", sev, "Mat Elastic Block") << *m;
276  std::vector<double> block_data;
277  CHKERR m->getAttributes(block_data);
278  if (block_data.size() < 2) {
279  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
280  "Expected that block has two attributes");
281  }
282  auto get_block_ents = [&]() {
283  Range ents;
284  CHKERR
285  m_field.get_moab().get_entities_by_handle(m->meshset, ents, true);
286  return ents;
287  };
288 
289  double young_modulus = block_data[0];
290  double poisson_ratio = block_data[1];
291  double bulk_modulus_K = young_modulus / (3 * (1 - 2 * poisson_ratio));
292  double shear_modulus_G = young_modulus / (2 * (1 + poisson_ratio));
293 
294  MOFEM_TAG_AND_LOG("WORLD", sev, "Mat Elastic Block")
295  << m->getName() << ": E = " << young_modulus
296  << " nu = " << poisson_ratio;
297 
298  blockData.push_back(
299  {bulk_modulus_K, shear_modulus_G, get_block_ents()});
300  }
301  MOFEM_LOG_CHANNEL("WORLD");
303  }
304 
305  MoFEMErrorCode getMatDPtr(boost::shared_ptr<MatrixDouble> mat_D_ptr,
306  double bulk_modulus_K, double shear_modulus_G) {
308  //! [Calculate elasticity tensor]
309  auto set_material_stiffness = [&]() {
315  double A = (SPACE_DIM == 2)
316  ? 2 * shear_modulus_G /
317  (bulk_modulus_K + (4. / 3.) * shear_modulus_G)
318  : 1;
319  auto t_D = getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*mat_D_ptr);
320  t_D(i, j, k, l) =
321  2 * shear_modulus_G * ((t_kd(i, k) ^ t_kd(j, l)) / 4.) +
322  A * (bulk_modulus_K - (2. / 3.) * shear_modulus_G) * t_kd(i, j) *
323  t_kd(k, l);
324  };
325  //! [Calculate elasticity tensor]
326  constexpr auto size_symm = (SPACE_DIM * (SPACE_DIM + 1)) / 2;
327  mat_D_ptr->resize(size_symm * size_symm, 1);
328  set_material_stiffness();
330  }
331  };
332 
333  double default_bulk_modulus_K =
335  double default_shear_modulus_G =
337 
338  pipeline.push_back(new OpMatElasticBlocks(
339  blockedParamsPtr->getDPtr(), default_bulk_modulus_K,
340  default_bulk_modulus_K, mField, sev,
341 
342  // Get blockset using regular expression
343  mField.getInterface<MeshsetsManager>()->getCubitMeshsetPtr(std::regex(
344 
345  (boost::format("%s(.*)") % block_elastic_name).str()
346 
347  ))
348 
349  ));
350 
351  struct OpMatFluidBlocks : public DomainEleOp {
352  OpMatFluidBlocks(boost::shared_ptr<double> conductivity_ptr,
353  MoFEM::Interface &m_field, Sev sev,
354  std::vector<const CubitMeshSets *> meshset_vec_ptr)
355  : DomainEleOp(NOSPACE, DomainEleOp::OPSPACE),
356  conductivityPtr(conductivity_ptr) {
357  CHK_THROW_MESSAGE(extractThermalBlockData(m_field, meshset_vec_ptr, sev),
358  "Can not get data from block");
359  }
360 
361  MoFEMErrorCode doWork(int side, EntityType type,
364 
365  for (auto &b : blockData) {
366 
367  if (b.blockEnts.find(getFEEntityHandle()) != b.blockEnts.end()) {
368  *conductivityPtr = b.conductivity;
370  }
371  }
372 
373  *conductivityPtr = default_conductivity;
374 
376  }
377 
378  private:
379  struct BlockData {
380  double conductivity;
381  Range blockEnts;
382  };
383 
384  std::vector<BlockData> blockData;
385 
387  extractThermalBlockData(MoFEM::Interface &m_field,
388  std::vector<const CubitMeshSets *> meshset_vec_ptr,
389  Sev sev) {
391 
392  for (auto m : meshset_vec_ptr) {
393  MOFEM_TAG_AND_LOG("WORLD", sev, "Mat Thermal Block") << *m;
394  std::vector<double> block_data;
395  CHKERR m->getAttributes(block_data);
396  if (block_data.size() < 1) {
397  SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
398  "Expected that block has two attributes");
399  }
400  auto get_block_ents = [&]() {
401  Range ents;
402  CHKERR
403  m_field.get_moab().get_entities_by_handle(m->meshset, ents, true);
404  return ents;
405  };
406 
407  MOFEM_TAG_AND_LOG("WORLD", sev, "Mat Thermal Block")
408  << m->getName() << ": conductivity = " << block_data[0];
409 
410  blockData.push_back({block_data[0], get_block_ents()});
411  }
412  MOFEM_LOG_CHANNEL("WORLD");
414  }
415 
416  boost::shared_ptr<double> expansionPtr;
417  boost::shared_ptr<double> conductivityPtr;
418  boost::shared_ptr<double> capacityPtr;
419  };
420 
421  pipeline.push_back(new OpMatFluidBlocks(
422  blockedParamsPtr->getConductivityPtr(), mField, sev,
423 
424  // Get blockset using regular expression
426 
427  (boost::format("%s(.*)") % block_thermal_name).str()
428 
429  ))
430 
431  ));
432 
434 }

◆ bC()

MoFEMErrorCode Seepage::bC ( )
private

[Create common data]

[Boundary condition]

Examples
seepage.cpp.

Definition at line 513 of file seepage.cpp.

513  {
515 
516  MOFEM_LOG("SYNC", Sev::noisy) << "bC";
517  MOFEM_LOG_SEVERITY_SYNC(mField.get_comm(), Sev::noisy);
518 
519  auto simple = mField.getInterface<Simple>();
520  auto bc_mng = mField.getInterface<BcManager>();
521 
522  CHKERR bc_mng->pushMarkDOFsOnEntities<DisplacementCubitBcData>(
523  simple->getProblemName(), "U");
524  CHKERR bc_mng->pushMarkDOFsOnEntities<HeatFluxCubitBcData>(
525  simple->getProblemName(), "FLUX", false);
526 
527  auto get_skin = [&]() {
528  Range body_ents;
529  CHKERR mField.get_moab().get_entities_by_dimension(0, SPACE_DIM, body_ents);
530  Skinner skin(&mField.get_moab());
531  Range skin_ents;
532  CHKERR skin.find_skin(0, body_ents, false, skin_ents);
533  return skin_ents;
534  };
535 
536  auto filter_flux_blocks = [&](auto skin) {
537  auto remove_cubit_blocks = [&](auto c) {
539  for (auto m :
540 
542 
543  ) {
544  Range ents;
545  CHKERR mField.get_moab().get_entities_by_dimension(
546  m->getMeshset(), SPACE_DIM - 1, ents, true);
547  skin = subtract(skin, ents);
548  }
550  };
551 
552  auto remove_named_blocks = [&](auto n) {
555  std::regex(
556 
557  (boost::format("%s(.*)") % n).str()
558 
559  ))
560 
561  ) {
562  Range ents;
563  CHKERR mField.get_moab().get_entities_by_dimension(
564  m->getMeshset(), SPACE_DIM - 1, ents, true);
565  skin = subtract(skin, ents);
566  }
568  };
569 
570  CHK_THROW_MESSAGE(remove_cubit_blocks(NODESET | TEMPERATURESET),
571  "remove_cubit_blocks");
572  CHK_THROW_MESSAGE(remove_cubit_blocks(SIDESET | HEATFLUXSET),
573  "remove_cubit_blocks");
574  CHK_THROW_MESSAGE(remove_named_blocks("PRESSURE"), "remove_named_blocks");
575  CHK_THROW_MESSAGE(remove_named_blocks("FLUIDFLUX"), "remove_named_blocks");
576 
577  return skin;
578  };
579 
580  auto filter_true_skin = [&](auto skin) {
581  Range boundary_ents;
582  ParallelComm *pcomm =
583  ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
584  CHKERR pcomm->filter_pstatus(skin, PSTATUS_SHARED | PSTATUS_MULTISHARED,
585  PSTATUS_NOT, -1, &boundary_ents);
586  return boundary_ents;
587  };
588 
589  auto remove_flux_ents = filter_true_skin(filter_flux_blocks(get_skin()));
590 
591  CHKERR mField.getInterface<CommInterface>()->synchroniseEntities(
592  remove_flux_ents);
593 
594  MOFEM_LOG("SYNC", Sev::noisy) << remove_flux_ents << endl;
595  MOFEM_LOG_SEVERITY_SYNC(mField.get_comm(), Sev::noisy);
596 
597 #ifndef NDEBUG
598 
600  mField.get_moab(),
601  (boost::format("flux_remove_%d.vtk") % mField.get_comm_rank()).str(),
602  remove_flux_ents);
603 
604 #endif
605 
606  CHKERR mField.getInterface<ProblemsManager>()->removeDofsOnEntities(
607  simple->getProblemName(), "FLUX", remove_flux_ents);
608 
610 }

◆ createCommonData()

MoFEMErrorCode Seepage::createCommonData ( )
private

[Set up problem]

[Create common data]

Examples
seepage.cpp.

Definition at line 476 of file seepage.cpp.

476  {
478 
479  auto get_command_line_parameters = [&]() {
481  CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-young_modulus",
482  &default_young_modulus, PETSC_NULL);
483  CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-poisson_ratio",
484  &default_poisson_ratio, PETSC_NULL);
485  CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-conductivity",
486  &default_conductivity, PETSC_NULL);
487  CHKERR PetscOptionsGetScalar(PETSC_NULL, "", "-fluid_density",
488  &fluid_density, PETSC_NULL);
489 
490  MOFEM_LOG("Seepage", Sev::inform)
491  << "Default Young modulus " << default_young_modulus;
492  MOFEM_LOG("Seepage", Sev::inform)
493  << "Default Poisson ratio " << default_poisson_ratio;
494  MOFEM_LOG("Seepage", Sev::inform)
495  << "Default conductivity " << default_conductivity;
496  MOFEM_LOG("Seepage", Sev::inform) << "Fluid denisty " << fluid_density;
497 
498  int coords_dim = SPACE_DIM;
499  CHKERR PetscOptionsGetRealArray(NULL, NULL, "-field_eval_coords",
500  fieldEvalCoords.data(), &coords_dim,
501  &doEvalField);
502 
504  };
505 
506  CHKERR get_command_line_parameters();
507 
509 }

◆ OPs()

MoFEMErrorCode Seepage::OPs ( )
private

[Boundary condition]

[Push operators to pipeline]

Examples
seepage.cpp.

Definition at line 614 of file seepage.cpp.

614  {
616  auto pipeline_mng = mField.getInterface<PipelineManager>();
617  auto simple = mField.getInterface<Simple>();
618  auto bc_mng = mField.getInterface<BcManager>();
619 
620  auto boundary_marker =
621  bc_mng->getMergedBlocksMarker(vector<string>{"FLUIDFLUX"});
622 
623  auto u_grad_ptr = boost::make_shared<MatrixDouble>();
624  auto dot_u_grad_ptr = boost::make_shared<MatrixDouble>();
625  auto trace_dot_u_grad_ptr = boost::make_shared<VectorDouble>();
626  auto h_ptr = boost::make_shared<VectorDouble>();
627  auto dot_h_ptr = boost::make_shared<VectorDouble>();
628  auto flux_ptr = boost::make_shared<MatrixDouble>();
629  auto div_flux_ptr = boost::make_shared<VectorDouble>();
630  auto strain_ptr = boost::make_shared<MatrixDouble>();
631  auto stress_ptr = boost::make_shared<MatrixDouble>();
632 
633  auto time_scale = boost::make_shared<TimeScale>();
634 
635  auto block_params = boost::make_shared<BlockedParameters>();
636  auto mDPtr = block_params->getDPtr();
637  auto conductivity_ptr = block_params->getConductivityPtr();
638 
639  auto integration_rule = [](int, int, int approx_order) {
640  return 2 * approx_order;
641  };
642 
643  CHKERR pipeline_mng->setDomainRhsIntegrationRule(integration_rule);
644  CHKERR pipeline_mng->setDomainLhsIntegrationRule(integration_rule);
645  CHKERR pipeline_mng->setBoundaryLhsIntegrationRule(integration_rule);
646  CHKERR pipeline_mng->setBoundaryRhsIntegrationRule(integration_rule);
647 
648  auto add_domain_base_ops = [&](auto &pip) {
650 
651  CHKERR addMatBlockOps(pip, "MAT_ELASTIC", "MAT_FLUID", block_params,
652  Sev::inform);
654 
656  "U", u_grad_ptr));
657  pip.push_back(new OpSymmetrizeTensor<SPACE_DIM>(u_grad_ptr, strain_ptr));
659  "U", dot_u_grad_ptr));
660  pip.push_back(new OpCalculateTraceFromMat<SPACE_DIM>(dot_u_grad_ptr,
661  trace_dot_u_grad_ptr));
662 
663  pip.push_back(new OpCalculateScalarFieldValues("H", h_ptr));
664  pip.push_back(new OpCalculateScalarFieldValuesDot("H", dot_h_ptr));
665  pip.push_back(new OpCalculateHVecVectorField<3>("FLUX", flux_ptr));
667  "FLUX", div_flux_ptr));
668 
670  };
671 
672  auto add_domain_ops_lhs_mechanical = [&](auto &pip) {
674  pip.push_back(new OpKCauchy("U", "U", mDPtr));
675  pip.push_back(new OpBaseDivU(
676  "H", "U",
677  [](const double, const double, const double) { return -9.81; }, true,
678  true));
680  };
681 
682  auto add_domain_ops_rhs_mechanical = [&](auto &pip) {
684 
686  pip, mField, "U", {time_scale}, "BODY_FORCE", Sev::inform);
687 
688  // Calculate internal forece
690  "U", strain_ptr, stress_ptr, mDPtr));
691  pip.push_back(new OpInternalForceCauchy("U", stress_ptr));
692  pip.push_back(
694 
696  };
697 
698  auto add_domain_ops_lhs_seepage = [&](auto &pip, auto &fe) {
700  auto resistance = [conductivity_ptr](const double, const double,
701  const double) {
702  return (1. / *(conductivity_ptr));
703  };
704 
705  auto unity = []() constexpr { return -1; };
706  pip.push_back(new OpHdivHdiv("FLUX", "FLUX", resistance));
707  pip.push_back(new OpHdivQ("FLUX", "H", unity, true));
708  auto op_base_div_u = new OpBaseDivU(
709  "H", "U", [](double, double, double) constexpr { return -1; }, false,
710  false);
711  op_base_div_u->feScalingFun = [](const FEMethod *fe_ptr) {
712  return fe_ptr->ts_a;
713  };
714  pip.push_back(op_base_div_u);
715 
717  };
718 
719  auto add_domain_ops_rhs_seepage = [&](auto &pip) {
721  auto resistance = [conductivity_ptr](double, double, double) {
722  return (1. / (*conductivity_ptr));
723  };
724  auto minus_one = [](double, double, double) constexpr { return -1; };
725 
726  pip.push_back(new OpHdivFlux("FLUX", flux_ptr, resistance));
727  pip.push_back(new OpHDivH("FLUX", h_ptr, minus_one));
728  pip.push_back(new OpBaseDotH("H", trace_dot_u_grad_ptr, minus_one));
729  pip.push_back(new OpBaseDivFlux("H", div_flux_ptr, minus_one));
730 
732  };
733 
734  auto add_boundary_rhs_ops = [&](auto &pip) {
736 
738 
739  pip.push_back(new OpSetBc("FLUX", true, boundary_marker));
740 
742  pipeline_mng->getOpBoundaryRhsPipeline(), mField, "U", {time_scale},
743  "FORCE", Sev::inform);
744 
746  pipeline_mng->getOpBoundaryRhsPipeline(), mField, "FLUX", {time_scale},
747  "PRESSURE", Sev::inform);
748 
749  pip.push_back(new OpUnSetBc("FLUX"));
750 
751  auto mat_flux_ptr = boost::make_shared<MatrixDouble>();
752  pip.push_back(
753  new OpCalculateHVecVectorField<3, SPACE_DIM>("FLUX", mat_flux_ptr));
756  mField, pip, simple->getProblemName(), "FLUX", mat_flux_ptr,
757  {time_scale});
758 
760  };
761 
762  auto add_boundary_lhs_ops = [&](auto &pip) {
764 
766 
769  mField, pip, simple->getProblemName(), "FLUX");
770 
772  };
773 
774  // LHS
775  CHKERR add_domain_base_ops(pipeline_mng->getOpDomainLhsPipeline());
776  CHKERR add_domain_ops_lhs_mechanical(pipeline_mng->getOpDomainLhsPipeline());
777  CHKERR add_domain_ops_lhs_seepage(pipeline_mng->getOpDomainLhsPipeline(),
778  pipeline_mng->getDomainLhsFE());
779 
780  // RHS
781  CHKERR add_domain_base_ops(pipeline_mng->getOpDomainRhsPipeline());
782  CHKERR add_domain_ops_rhs_mechanical(pipeline_mng->getOpDomainRhsPipeline());
783  CHKERR add_domain_ops_rhs_seepage(pipeline_mng->getOpDomainRhsPipeline());
784 
785  CHKERR add_boundary_rhs_ops(pipeline_mng->getOpBoundaryRhsPipeline());
786  CHKERR add_boundary_lhs_ops(pipeline_mng->getOpBoundaryLhsPipeline());
787 
789 }

◆ runProblem()

MoFEMErrorCode Seepage::runProblem ( )

[Run problem]

Examples
seepage.cpp.

Definition at line 437 of file seepage.cpp.

437  {
441  CHKERR bC();
442  CHKERR OPs();
443  CHKERR tsSolve();
445 }

◆ setupProblem()

MoFEMErrorCode Seepage::setupProblem ( )
private

[Run problem]

[Set up problem]

Examples
seepage.cpp.

Definition at line 449 of file seepage.cpp.

449  {
452  // Add field
454  // Mechanical fields
455  CHKERR simple->addDomainField("U", H1, base, SPACE_DIM);
456  CHKERR simple->addBoundaryField("U", H1, base, SPACE_DIM);
457  // Temerature
458  const auto flux_space = (SPACE_DIM == 2) ? HCURL : HDIV;
459  CHKERR simple->addDomainField("H", L2, AINSWORTH_LEGENDRE_BASE, 1);
460  CHKERR simple->addDomainField("FLUX", flux_space, DEMKOWICZ_JACOBI_BASE, 1);
461  CHKERR simple->addBoundaryField("FLUX", flux_space, DEMKOWICZ_JACOBI_BASE, 1);
462 
463  int order = 2.;
464  CHKERR PetscOptionsGetInt(PETSC_NULL, "", "-order", &order, PETSC_NULL);
465  CHKERR simple->setFieldOrder("U", order);
466  CHKERR simple->setFieldOrder("H", order - 1);
467  CHKERR simple->setFieldOrder("FLUX", order);
468 
469  CHKERR simple->setUp();
470 
472 }

◆ tsSolve()

MoFEMErrorCode Seepage::tsSolve ( )
private

[Push operators to pipeline]

[Solve]

Examples
seepage.cpp.

Definition at line 793 of file seepage.cpp.

793  {
795  auto simple = mField.getInterface<Simple>();
797  ISManager *is_manager = mField.getInterface<ISManager>();
798 
799  auto dm = simple->getDM();
800  auto solver = pipeline_mng->createTSIM();
801  auto snes_ctx_ptr = getDMSnesCtx(dm);
802 
803  auto set_section_monitor = [&](auto solver) {
805  SNES snes;
806  CHKERR TSGetSNES(solver, &snes);
807  CHKERR SNESMonitorSet(snes,
808  (MoFEMErrorCode(*)(SNES, PetscInt, PetscReal,
809  void *))MoFEMSNESMonitorFields,
810  (void *)(snes_ctx_ptr.get()), nullptr);
812  };
813 
814  auto create_post_process_element = [&]() {
815  auto post_proc_fe = boost::make_shared<PostProcEle>(mField);
816 
817  auto block_params = boost::make_shared<BlockedParameters>();
818  auto mDPtr = block_params->getDPtr();
819  CHKERR addMatBlockOps(post_proc_fe->getOpPtrVector(), "MAT_ELASTIC",
820  "MAT_FLUID", block_params, Sev::verbose);
822  post_proc_fe->getOpPtrVector(), {H1, HDIV});
823 
824  auto mat_grad_ptr = boost::make_shared<MatrixDouble>();
825  auto mat_strain_ptr = boost::make_shared<MatrixDouble>();
826  auto mat_stress_ptr = boost::make_shared<MatrixDouble>();
827 
828  auto h_ptr = boost::make_shared<VectorDouble>();
829  auto mat_flux_ptr = boost::make_shared<MatrixDouble>();
830 
831  post_proc_fe->getOpPtrVector().push_back(
832  new OpCalculateScalarFieldValues("H", h_ptr));
833  post_proc_fe->getOpPtrVector().push_back(
834  new OpCalculateHVecVectorField<3, SPACE_DIM>("FLUX", mat_flux_ptr));
835 
836  auto u_ptr = boost::make_shared<MatrixDouble>();
837  post_proc_fe->getOpPtrVector().push_back(
839  post_proc_fe->getOpPtrVector().push_back(
841  mat_grad_ptr));
842  post_proc_fe->getOpPtrVector().push_back(
843  new OpSymmetrizeTensor<SPACE_DIM>(mat_grad_ptr, mat_strain_ptr));
844  post_proc_fe->getOpPtrVector().push_back(
846  "U", mat_strain_ptr, mat_stress_ptr, mDPtr));
847 
849 
850  post_proc_fe->getOpPtrVector().push_back(
851 
852  new OpPPMap(
853 
854  post_proc_fe->getPostProcMesh(), post_proc_fe->getMapGaussPts(),
855 
856  {{"H", h_ptr}},
857 
858  {{"U", u_ptr}, {"FLUX", mat_flux_ptr}},
859 
860  {},
861 
862  {{"STRAIN", mat_strain_ptr}, {"STRESS", mat_stress_ptr}}
863 
864  )
865 
866  );
867 
868  return post_proc_fe;
869  };
870 
871  auto create_creaction_fe = [&]() {
872  auto fe_ptr = boost::make_shared<DomainEle>(mField);
873  fe_ptr->getRuleHook = [](int, int, int o) { return 2 * o; };
874 
875  auto &pip = fe_ptr->getOpPtrVector();
876 
877  auto block_params = boost::make_shared<BlockedParameters>();
878  auto mDPtr = block_params->getDPtr();
879  CHKERR addMatBlockOps(pip, "MAT_ELASTIC", "MAT_FLUID", block_params,
880  Sev::verbose);
882 
883  auto u_grad_ptr = boost::make_shared<MatrixDouble>();
884  auto strain_ptr = boost::make_shared<MatrixDouble>();
885  auto stress_ptr = boost::make_shared<MatrixDouble>();
886 
888  "U", u_grad_ptr));
889  pip.push_back(new OpSymmetrizeTensor<SPACE_DIM>(u_grad_ptr, strain_ptr));
890 
891  // Calculate internal forece
893  "U", strain_ptr, stress_ptr, mDPtr));
894  pip.push_back(new OpInternalForceCauchy("U", stress_ptr));
895 
896  fe_ptr->postProcessHook =
898 
899  return fe_ptr;
900  };
901 
902  auto monitor_ptr = boost::make_shared<FEMethod>();
903  auto post_proc_fe = create_post_process_element();
904  auto res = createDMVector(dm);
905  auto rections_fe = create_creaction_fe();
906 
907  auto set_time_monitor = [&](auto dm, auto solver) {
909  monitor_ptr->preProcessHook = [&]() {
911 
912  CHKERR DMoFEMLoopFiniteElements(dm, simple->getDomainFEName(),
913  post_proc_fe,
914  monitor_ptr->getCacheWeakPtr());
915  CHKERR post_proc_fe->writeFile(
916  "out_" + boost::lexical_cast<std::string>(monitor_ptr->ts_step) +
917  ".h5m");
918 
919  rections_fe->f = res;
920  CHKERR DMoFEMLoopFiniteElements(dm, simple->getDomainFEName(),
921  rections_fe,
922  monitor_ptr->getCacheWeakPtr());
923 
924  double nrm;
925  CHKERR VecNorm(res, NORM_2, &nrm);
926  MOFEM_LOG("Seepage", Sev::verbose)
927  << "Residual norm " << nrm << " at time step "
928  << monitor_ptr->ts_step;
929 
930  if (doEvalField) {
931 
932  auto scalar_field_ptr = boost::make_shared<VectorDouble>();
933  auto vector_field_ptr = boost::make_shared<MatrixDouble>();
934  auto tensor_field_ptr = boost::make_shared<MatrixDouble>();
935 
936  auto field_eval_data = mField.getInterface<FieldEvaluatorInterface>()
937  ->getData<DomainEle>();
938 
939  if constexpr (SPACE_DIM == 3) {
941  field_eval_data, simple->getDomainFEName());
942  } else {
944  field_eval_data, simple->getDomainFEName());
945  }
946 
947  field_eval_data->setEvalPoints(fieldEvalCoords.data(), 1);
948  auto no_rule = [](int, int, int) { return -1; };
949 
950  auto field_eval_ptr = field_eval_data->feMethodPtr.lock();
951  field_eval_ptr->getRuleHook = no_rule;
952 
953  auto u_grad_ptr = boost::make_shared<MatrixDouble>();
954  auto strain_ptr = boost::make_shared<MatrixDouble>();
955  auto stress_ptr = boost::make_shared<MatrixDouble>();
956  auto h_ptr = boost::make_shared<VectorDouble>();
957 
958  auto block_params = boost::make_shared<BlockedParameters>();
959  auto mDPtr = block_params->getDPtr();
960  CHKERR addMatBlockOps(field_eval_ptr->getOpPtrVector(), "MAT_ELASTIC",
961  "MAT_FLUID", block_params, Sev::noisy);
963  field_eval_ptr->getOpPtrVector(), {H1, HDIV});
964  field_eval_ptr->getOpPtrVector().push_back(
966  "U", u_grad_ptr));
967  field_eval_ptr->getOpPtrVector().push_back(
968  new OpSymmetrizeTensor<SPACE_DIM>(u_grad_ptr, strain_ptr));
969  field_eval_ptr->getOpPtrVector().push_back(
970  new OpCalculateScalarFieldValues("H", h_ptr));
971  field_eval_ptr->getOpPtrVector().push_back(
973  "U", strain_ptr, stress_ptr, mDPtr));
974 
975  if constexpr (SPACE_DIM == 3) {
977  ->evalFEAtThePoint3D(
978  fieldEvalCoords.data(), 1e-12, simple->getProblemName(),
979  simple->getDomainFEName(), field_eval_data,
981  MF_EXIST, QUIET);
982  } else {
984  ->evalFEAtThePoint2D(
985  fieldEvalCoords.data(), 1e-12, simple->getProblemName(),
986  simple->getDomainFEName(), field_eval_data,
988  MF_EXIST, QUIET);
989  }
990 
991  MOFEM_LOG("SeepageSync", Sev::inform)
992  << "Eval point hydrostatic hight: " << *h_ptr;
993  MOFEM_LOG("SeepageSync", Sev::inform)
994  << "Eval point skeleton stress pressure: " << *stress_ptr;
995  MOFEM_LOG_SEVERITY_SYNC(mField.get_comm(), Sev::inform);
996  }
997 
999  };
1000  auto null = boost::shared_ptr<FEMethod>();
1001  CHKERR DMMoFEMTSSetMonitor(dm, solver, simple->getDomainFEName(), null,
1002  monitor_ptr, null);
1004  };
1005 
1006  auto set_fieldsplit_preconditioner = [&](auto solver) {
1008 
1009  SNES snes;
1010  CHKERR TSGetSNES(solver, &snes);
1011  KSP ksp;
1012  CHKERR SNESGetKSP(snes, &ksp);
1013  PC pc;
1014  CHKERR KSPGetPC(ksp, &pc);
1015  PetscBool is_pcfs = PETSC_FALSE;
1016  PetscObjectTypeCompare((PetscObject)pc, PCFIELDSPLIT, &is_pcfs);
1017 
1018  // Setup fieldsplit (block) solver - optional: yes/no
1019  if (is_pcfs == PETSC_TRUE) {
1020  auto bc_mng = mField.getInterface<BcManager>();
1021  auto is_mng = mField.getInterface<ISManager>();
1022  auto name_prb = simple->getProblemName();
1023 
1024  SmartPetscObj<IS> is_u;
1025  CHKERR is_mng->isCreateProblemFieldAndRank(name_prb, ROW, "U", 0,
1026  SPACE_DIM, is_u);
1027  SmartPetscObj<IS> is_flux;
1028  CHKERR is_mng->isCreateProblemFieldAndRank(name_prb, ROW, "FLUX", 0, 0,
1029  is_flux);
1030  SmartPetscObj<IS> is_H;
1031  CHKERR is_mng->isCreateProblemFieldAndRank(name_prb, ROW, "H", 0, 0,
1032  is_H);
1033  IS is_tmp;
1034  CHKERR ISExpand(is_H, is_flux, &is_tmp);
1035  auto is_Flux = SmartPetscObj<IS>(is_tmp);
1036 
1037  auto is_all_bc = bc_mng->getBlockIS(name_prb, "FLUIDFLUX", "FLUX", 0, 0);
1038  int is_all_bc_size;
1039  CHKERR ISGetSize(is_all_bc, &is_all_bc_size);
1040  MOFEM_LOG("ThermoElastic", Sev::inform)
1041  << "Field split block size " << is_all_bc_size;
1042  if (is_all_bc_size) {
1043  IS is_tmp2;
1044  CHKERR ISDifference(is_Flux, is_all_bc, &is_tmp2);
1045  is_Flux = SmartPetscObj<IS>(is_tmp2);
1046  CHKERR PCFieldSplitSetIS(pc, PETSC_NULL,
1047  is_all_bc); // boundary block
1048  }
1049 
1050  CHKERR ISSort(is_u);
1051  CHKERR ISSort(is_Flux);
1052  CHKERR PCFieldSplitSetIS(pc, PETSC_NULL, is_Flux);
1053  CHKERR PCFieldSplitSetIS(pc, PETSC_NULL, is_u);
1054  }
1055 
1057  };
1058 
1059  auto pre_proc_ptr = boost::make_shared<FEMethod>();
1060  auto post_proc_rhs_ptr = boost::make_shared<FEMethod>();
1061  auto post_proc_lhs_ptr = boost::make_shared<FEMethod>();
1062  auto time_scale = boost::make_shared<TimeScale>();
1063 
1064  auto get_bc_hook_rhs = [this, pre_proc_ptr, time_scale]() {
1066  {time_scale}, false);
1067  return hook;
1068  };
1069 
1070  auto get_post_proc_hook_rhs = [this, post_proc_rhs_ptr]() {
1073  mField, post_proc_rhs_ptr, nullptr, Sev::verbose)();
1075  mField, post_proc_rhs_ptr, 1.)();
1077  };
1078  auto get_post_proc_hook_lhs = [this, post_proc_lhs_ptr]() {
1080  post_proc_lhs_ptr, 1.);
1081  };
1082 
1083  pre_proc_ptr->preProcessHook = get_bc_hook_rhs();
1084  post_proc_rhs_ptr->postProcessHook = get_post_proc_hook_rhs;
1085  post_proc_lhs_ptr->postProcessHook = get_post_proc_hook_lhs();
1086 
1087  auto ts_ctx_ptr = getDMTsCtx(dm);
1088  ts_ctx_ptr->getPreProcessIFunction().push_front(pre_proc_ptr);
1089  ts_ctx_ptr->getPreProcessIJacobian().push_front(pre_proc_ptr);
1090  ts_ctx_ptr->getPostProcessIFunction().push_back(post_proc_rhs_ptr);
1091  ts_ctx_ptr->getPostProcessIJacobian().push_back(post_proc_lhs_ptr);
1092 
1093  auto D = createDMVector(dm);
1094  CHKERR TSSetSolution(solver, D);
1095  CHKERR TSSetFromOptions(solver);
1096 
1097  CHKERR set_section_monitor(solver);
1098  CHKERR set_fieldsplit_preconditioner(solver);
1099  CHKERR set_time_monitor(dm, solver);
1100 
1101  CHKERR TSSetUp(solver);
1102  CHKERR TSSolve(solver, NULL);
1103 
1105 }

Member Data Documentation

◆ doEvalField

PetscBool Seepage::doEvalField
private

Definition at line 194 of file seepage.cpp.

◆ fieldEvalCoords

std::array<double, SPACE_DIM> Seepage::fieldEvalCoords
private

Definition at line 195 of file seepage.cpp.

◆ mField

MoFEM::Interface& Seepage::mField
private

Definition at line 186 of file seepage.cpp.

◆ uXScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > Seepage::uXScatter
private

Definition at line 197 of file seepage.cpp.

◆ uYScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > Seepage::uYScatter
private

Definition at line 198 of file seepage.cpp.

◆ uZScatter

std::tuple<SmartPetscObj<Vec>, SmartPetscObj<VecScatter> > Seepage::uZScatter
private

Definition at line 199 of file seepage.cpp.


The documentation for this struct was generated from the following file:
NOSPACE
@ NOSPACE
Definition: definitions.h:83
MoFEMFunctionReturnHot
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:460
MoFEM::UnknownInterface::getInterface
MoFEMErrorCode getInterface(IFACE *&iface) const
Get interface reference to pointer of interface.
Definition: UnknownInterface.hpp:93
MoFEM::EntitiesFieldData::EntData
Data on single entity (This is passed as argument to DataOperator::doWork)
Definition: EntitiesFieldData.hpp:128
SIDESET
@ SIDESET
Definition: definitions.h:160
save_range
auto save_range
Definition: seepage.cpp:170
MYPCOMM_INDEX
#define MYPCOMM_INDEX
default communicator number PCOMM
Definition: definitions.h:228
MoFEM::EssentialPreProcReaction< DisplacementCubitBcData >
Specialization for DisplacementCubitBcData.
Definition: EssentialDisplacementCubitBcData.hpp:157
Seepage::createCommonData
MoFEMErrorCode createCommonData()
[Set up problem]
Definition: seepage.cpp:476
H1
@ H1
continuous field
Definition: definitions.h:85
MOFEM_LOG_SEVERITY_SYNC
#define MOFEM_LOG_SEVERITY_SYNC(comm, severity)
Synchronise "SYNC" on curtain severity level.
Definition: LogManager.hpp:352
MOFEM_LOG_CHANNEL
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition: LogManager.hpp:284
young_modulus
double young_modulus
Young modulus.
Definition: plastic.cpp:121
MoFEM::ProblemsManager
Problem manager is used to build and partition problems.
Definition: ProblemsManager.hpp:21
MoFEM::FEMethod
structure for User Loop Methods on finite elements
Definition: LoopMethods.hpp:369
default_conductivity
double default_conductivity
Definition: seepage.cpp:164
SPACE_DIM
constexpr int SPACE_DIM
Definition: seepage.cpp:34
MoFEM::EssentialPostProcLhs< DisplacementCubitBcData >
Specialization for DisplacementCubitBcData.
Definition: EssentialDisplacementCubitBcData.hpp:134
MoFEM::CoreInterface::get_comm
virtual MPI_Comm & get_comm() const =0
Seepage::OPs
MoFEMErrorCode OPs()
[Boundary condition]
Definition: seepage.cpp:614
OpKCauchy
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpGradSymTensorGrad< 1, SPACE_DIM, SPACE_DIM, 0 > OpKCauchy
[Only used with Hooke equation (linear material model)]
Definition: seepage.cpp:50
CHK_THROW_MESSAGE
#define CHK_THROW_MESSAGE(err, msg)
Check and throw MoFEM exception.
Definition: definitions.h:609
Seepage::doEvalField
PetscBool doEvalField
Definition: seepage.cpp:194
L2
@ L2
field with C-1 continuity
Definition: definitions.h:88
OpHdivFlux
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpBaseTimesVector< 3, 3, 1 > OpHdivFlux
Integrating Rhs flux base (1/k) flux (FLUX)
Definition: seepage.cpp:109
MoFEM::EssentialBC
Essential boundary conditions.
Definition: Essential.hpp:111
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition: Exceptions.hpp:56
MoFEM::OpCalculateVectorFieldValues
Get values at integration pts for tensor filed rank 1, i.e. vector field.
Definition: UserDataOperators.hpp:466
MoFEM::CoreInterface::get_comm_rank
virtual int get_comm_rank() const =0
MoFEM::OpCalculateScalarFieldValuesDot
OpCalculateScalarFieldValuesFromPetscVecImpl< PetscData::CTX_SET_X_T > OpCalculateScalarFieldValuesDot
Definition: UserDataOperators.hpp:273
MoFEM::EssentialPostProcRhs< DisplacementCubitBcData >
Specialization for DisplacementCubitBcData.
Definition: EssentialDisplacementCubitBcData.hpp:113
MoFEM::PipelineManager
PipelineManager interface.
Definition: PipelineManager.hpp:24
A
constexpr AssemblyType A
Definition: operators_tests.cpp:30
bulk_modulus_K
double bulk_modulus_K
Definition: dynamic_first_order_con_law.cpp:96
Seepage::mField
MoFEM::Interface & mField
Definition: seepage.cpp:186
MoFEM::DisplacementCubitBcData
Definition of the displacement bc data structure.
Definition: BCData.hpp:76
OpHdivHdiv
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMass< 3, 3 > OpHdivHdiv
Integrate Lhs base of flux (1/k) base of flux (FLUX x FLUX)
Definition: seepage.cpp:87
Seepage::addMatBlockOps
MoFEMErrorCode addMatBlockOps(boost::ptr_deque< ForcesAndSourcesCore::UserDataOperator > &pipeline, std::string block_elastic_name, std::string block_thermal_name, boost::shared_ptr< BlockedParameters > blockedParamsPtr, Sev sev)
Definition: seepage.cpp:221
OpBaseDotH
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpBaseTimesScalarField< 1 > OpBaseDotH
Integrate Rhs base of temperature time heat capacity times heat rate (T)
Definition: seepage.cpp:124
MoFEM::Simple
Simple interface for fast problem set-up.
Definition: Simple.hpp:27
OpInternalForceCauchy
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpGradTimesSymTensor< 1, SPACE_DIM, SPACE_DIM > OpInternalForceCauchy
Definition: seepage.cpp:52
Seepage::setupProblem
MoFEMErrorCode setupProblem()
[Run problem]
Definition: seepage.cpp:449
Seepage::bC
MoFEMErrorCode bC()
[Create common data]
Definition: seepage.cpp:513
order
constexpr int order
Definition: dg_projection.cpp:18
MoFEM::DeprecatedCoreInterface
Deprecated interface functions.
Definition: DeprecatedCoreInterface.hpp:16
ROW
@ ROW
Definition: definitions.h:136
c
const double c
speed of light (cm/ns)
Definition: initial_diffusion.cpp:39
NODESET
@ NODESET
Definition: definitions.h:159
OpHDivH
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::LinearForm< GAUSS >::OpMixDivTimesU< 3, 1, 2 > OpHDivH
Integrate Rhs div flux base times temperature (T)
Definition: seepage.cpp:116
default_young_modulus
double default_young_modulus
Definition: seepage.cpp:162
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:548
MoFEM::createDMVector
auto createDMVector(DM dm)
Get smart vector from DM.
Definition: DMMoFEM.hpp:1099
MoFEM::EssentialPreProc< DisplacementCubitBcData >
Specialization for DisplacementCubitBcData.
Definition: EssentialDisplacementCubitBcData.hpp:91
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
MoFEM::ISManager
Section manager is used to create indexes and sections.
Definition: ISManager.hpp:23
MoFEM::BcManager
Simple interface for fast problem set-up.
Definition: BcManager.hpp:25
MoFEM::OpCalculateHVecVectorField
Get vector field for H-div approximation.
Definition: UserDataOperators.hpp:2115
MoFEM::FieldEvaluatorInterface
Field evaluator interface.
Definition: FieldEvaluator.hpp:21
simple
void simple(double P1[], double P2[], double P3[], double c[], const int N)
Definition: acoustic.cpp:69
double
convert.type
type
Definition: convert.py:64
OpPPMap
OpPostProcMapInMoab< SPACE_DIM, SPACE_DIM > OpPPMap
Definition: photon_diffusion.cpp:29
MoFEM::OpCalculateScalarFieldValues
Get value at integration points for scalar field.
Definition: UserDataOperators.hpp:82
poisson_ratio
double poisson_ratio
Poisson ratio.
Definition: plastic.cpp:122
Seepage::tsSolve
MoFEMErrorCode tsSolve()
[Push operators to pipeline]
Definition: seepage.cpp:793
MoFEM::LogManager::SeverityLevel
SeverityLevel
Severity levels.
Definition: LogManager.hpp:33
MoFEM::AddFluxToRhsPipelineImpl
Definition: Natural.hpp:46
size_symm
constexpr auto size_symm
Definition: plastic.cpp:42
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
MoFEM::OpTensorTimesSymmetricTensor
Calculate .
Definition: UserDataOperators.hpp:1883
t_kd
constexpr auto t_kd
Definition: free_surface.cpp:137
default_poisson_ratio
double default_poisson_ratio
Definition: seepage.cpp:163
FTensor::Index< 'i', SPACE_DIM >
MoFEM::AddHOOps
Add operators pushing bases from local to physical configuration.
Definition: HODataOperators.hpp:413
MoFEM::OpCalculateVectorFieldGradient
Get field gradients at integration pts for scalar filed rank 0, i.e. vector field.
Definition: UserDataOperators.hpp:1535
convert.n
n
Definition: convert.py:82
Seepage::fieldEvalCoords
std::array< double, SPACE_DIM > fieldEvalCoords
Definition: seepage.cpp:195
fluid_density
double fluid_density
Definition: seepage.cpp:165
integration_rule
auto integration_rule
Definition: free_surface.cpp:185
MoFEM::OpUnSetBc
Definition: FormsIntegrators.hpp:49
Range
DomainEleOp
OpBaseDivFlux
OpBaseDotH OpBaseDivFlux
Integrate Rhs base of temperature times divergent of flux (T)
Definition: seepage.cpp:130
MoFEM::PetscOptionsGetRealArray
PetscErrorCode PetscOptionsGetRealArray(PetscOptions *, const char pre[], const char name[], PetscReal dval[], PetscInt *nmax, PetscBool *set)
Definition: DeprecatedPetsc.hpp:192
MOFEM_TAG_AND_LOG
#define MOFEM_TAG_AND_LOG(channel, severity, tag)
Tag and log in channel.
Definition: LogManager.hpp:362
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition: LogManager.hpp:308
OpHdivQ
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMixDivTimesScalar< SPACE_DIM > OpHdivQ
Integrate Lhs div of base of flux time base of temperature (FLUX x T) and transpose of it,...
Definition: seepage.cpp:95
shear_modulus_G
double shear_modulus_G
Definition: dynamic_first_order_con_law.cpp:97
DEMKOWICZ_JACOBI_BASE
@ DEMKOWICZ_JACOBI_BASE
Definition: definitions.h:66
MoFEM::OpSymmetrizeTensor
Definition: UserDataOperators.hpp:1948
MoFEM::CommInterface
Managing BitRefLevels.
Definition: CommInterface.hpp:21
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
approx_order
int approx_order
Definition: test_broken_space.cpp:50
MoFEM::OpCalculateTraceFromMat
Calculates the trace of an input matrix.
Definition: UserDataOperators.hpp:3319
MoFEM::DMMoFEMTSSetMonitor
PetscErrorCode DMMoFEMTSSetMonitor(DM dm, TS ts, const std::string fe_name, boost::shared_ptr< MoFEM::FEMethod > method, boost::shared_ptr< MoFEM::BasicMethod > pre_only, boost::shared_ptr< MoFEM::BasicMethod > post_only)
Set Monitor To TS solver.
Definition: DMMoFEM.cpp:1056
AINSWORTH_LEGENDRE_BASE
@ AINSWORTH_LEGENDRE_BASE
Ainsworth Cole (Legendre) approx. base .
Definition: definitions.h:60
MoFEM::OpSetBc
Set indices on entities on finite element.
Definition: FormsIntegrators.hpp:38
HCURL
@ HCURL
field with continuous tangents
Definition: definitions.h:86
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition: definitions.h:31
TEMPERATURESET
@ TEMPERATURESET
Definition: definitions.h:168
MoFEM::MeshsetsManager
Interface for managing meshsets containing materials and boundary conditions.
Definition: MeshsetsManager.hpp:104
MoFEM::BlockData
Definition: MeshsetsManager.cpp:755
MoFEM::OpCalculateHdivVectorDivergence
Calculate divergence of vector field.
Definition: UserDataOperators.hpp:2212
MoFEM::MoFEMSNESMonitorFields
MoFEMErrorCode MoFEMSNESMonitorFields(SNES snes, PetscInt its, PetscReal fgnorm, SnesCtx *snes_ctx)
Sens monitor printing residual field by field.
Definition: SnesCtx.cpp:232
FieldApproximationBase
FieldApproximationBase
approximation base
Definition: definitions.h:58
ReactionDiffusionEquation::D
const double D
diffusivity
Definition: reaction_diffusion.cpp:20
MoFEM::HeatFluxCubitBcData
Definition of the heat flux bc data structure.
Definition: BCData.hpp:427
m
FTensor::Index< 'm', 3 > m
Definition: shallow_wave.cpp:80
FTensor::Kronecker_Delta_symmetric
Kronecker Delta class symmetric.
Definition: Kronecker_Delta.hpp:49
MoFEM::getDMSnesCtx
auto getDMSnesCtx(DM dm)
Get SNES context data structure used by DM.
Definition: DMMoFEM.hpp:1127
MoFEMFunctionBeginHot
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:453
HEATFLUXSET
@ HEATFLUXSET
Definition: definitions.h:169
QUIET
@ QUIET
Definition: definitions.h:221
MoFEM::PetscOptionsGetScalar
PetscErrorCode PetscOptionsGetScalar(PetscOptions *, const char pre[], const char name[], PetscScalar *dval, PetscBool *set)
Definition: DeprecatedPetsc.hpp:162
MoFEM::MeshsetsManager::getCubitMeshsetPtr
MoFEMErrorCode getCubitMeshsetPtr(const int ms_id, const CubitBCType cubit_bc_type, const CubitMeshSets **cubit_meshset_ptr) const
get cubit meshset
Definition: MeshsetsManager.cpp:578
MoFEM::SmartPetscObj< IS >
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
MoFEM::DMoFEMLoopFiniteElements
PetscErrorCode DMoFEMLoopFiniteElements(DM dm, const char fe_name[], MoFEM::FEMethod *method, CacheTupleWeakPtr cache_ptr=CacheTupleSharedPtr())
Executes FEMethod for finite elements in DM.
Definition: DMMoFEM.cpp:586
MF_EXIST
@ MF_EXIST
Definition: definitions.h:113
convert.int
int
Definition: convert.py:64
MoFEM::OpCalculateVectorFieldGradientDot
Get field gradients time derivative at integration pts for scalar filed rank 0, i....
Definition: UserDataOperators.hpp:1550
MoFEM::PetscOptionsGetInt
PetscErrorCode PetscOptionsGetInt(PetscOptions *, const char pre[], const char name[], PetscInt *ivalue, PetscBool *set)
Definition: DeprecatedPetsc.hpp:142
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:429
HDIV
@ HDIV
field with continuous normal traction
Definition: definitions.h:87
MoFEM::getDMTsCtx
auto getDMTsCtx(DM dm)
Get TS context data structure used by DM.
Definition: DMMoFEM.hpp:1141
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:359
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
OpBaseDivU
FormsIntegrators< DomainEleOp >::Assembly< PETSC >::BiLinearForm< GAUSS >::OpMixScalarTimesDiv< SPACE_DIM > OpBaseDivU
[Essential boundary conditions]
Definition: seepage.cpp:79
SeepageOps::OpDomainRhsHydrostaticStress
Definition: SeepageOps.hpp:22
MoFEM::OpPostProcMapInMoab
Post post-proc data at points from hash maps.
Definition: PostProcBrokenMeshInMoabBase.hpp:698