Collaboration diagram for MixedPoisson:

[legend]

Classes
struct	CommonData

struct	OpError

Public Member Functions
	MixedPoisson (MoFEM::Interface &m_field)

MoFEMErrorCode	runProblem ()
	[Run programme]

Private Member Functions
MoFEMErrorCode	readMesh ()
	[Run programme]

MoFEMErrorCode	setupProblem ()
	[Read mesh]

MoFEMErrorCode	setIntegrationRules ()
	[Set up problem]

MoFEMErrorCode	createCommonData ()
	[Set integration rule]

MoFEMErrorCode	assembleSystem ()
	[Create common data]

MoFEMErrorCode	solveSystem ()
	[Assemble system]

MoFEMErrorCode	checkError (int iter_num=0)
	[Solve and refine loop]

MoFEMErrorCode	refineOrder (int iter_num=0)
	[Solve]

MoFEMErrorCode	solveRefineLoop ()
	[Refine]

MoFEMErrorCode	outputResults (int iter_num=0)
	[Check error]

Static Private Member Functions
static double	analyticalFunction (const double x, const double y, const double z)
	[Analytical function]

static VectorDouble	analyticalFunctionGrad (const double x, const double y, const double z)
	[Analytical function]

static double	sourceFunction (const double x, const double y, const double z)
	[Analytical function gradient]

static MoFEMErrorCode	getTagHandle (MoFEM::Interface &m_field, const char *name, DataType type, Tag &tag_handle)
	[Source function]

Private Attributes
MoFEM::Interface &	mField

Simple *	simpleInterface

Range	domainEntities

double	totErrorIndicator

double	maxErrorIndicator

double	thetaParam

double	indicTolerance

int	initOrder

boost::shared_ptr< CommonData >	commonDataPtr

Detailed Description

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 31 of file mixed_poisson.cpp.

Constructor & Destructor Documentation

◆ MixedPoisson()

MixedPoisson::MixedPoisson ( MoFEM::Interface & m_field )

inline

Definition at line 33 of file mixed_poisson.cpp.

33: mField(m_field) {}

MixedPoisson::mField

MoFEM::Interface & mField

Definition mixed_poisson.cpp:37

Member Function Documentation

◆ analyticalFunction()

static double MixedPoisson::analyticalFunction	(	const double	x,
		const double	y,
		const double	z
	)

inlinestaticprivate

[Analytical function]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 49 of file mixed_poisson.cpp.

                                                   {
    return exp(-100. * (sqr(x) + sqr(y))) * cos(M_PI * x) * cos(M_PI * y);
  }

◆ analyticalFunctionGrad()

static VectorDouble MixedPoisson::analyticalFunctionGrad	(	const double	x,
		const double	y,
		const double	z
	)

inlinestaticprivate

[Analytical function]

[Analytical function gradient]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 56 of file mixed_poisson.cpp.

                                                             {
    VectorDouble res;
    res.resize(2);
    res[0] = -exp(-100. * (sqr(x) + sqr(y))) *
             (200. * x * cos(M_PI * x) + M_PI * sin(M_PI * x)) * cos(M_PI * y);
    res[1] = -exp(-100. * (sqr(x) + sqr(y))) *
             (200. * y * cos(M_PI * y) + M_PI * sin(M_PI * y)) * cos(M_PI * x);
    return res;
  }

◆ assembleSystem()

MoFEMErrorCode MixedPoisson::assembleSystem ( )

private

[Create common data]

[Assemble system]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 239 of file mixed_poisson.cpp.

                                            {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getOpDomainRhsPipeline().clear();
  pipeline_mng->getOpDomainLhsPipeline().clear();
 
  CHKERR AddHOOps<2, 2, 2>::add(pipeline_mng->getOpDomainLhsPipeline(), {HDIV});
 
  auto beta = [](const double, const double, const double) { return 1; };
  pipeline_mng->getOpDomainLhsPipeline().push_back(
      new OpHdivHdiv("Q", "Q", beta));
  auto unity = []() { return 1; };
  pipeline_mng->getOpDomainLhsPipeline().push_back(
      new OpHdivU("Q", "U", unity, true));
  auto source = [&](const double x, const double y, const double z) {
    return -sourceFunction(x, y, z);
  };
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpDomainSource("U", source));
  MoFEMFunctionReturn(0);
}

◆ checkError()

MoFEMErrorCode MixedPoisson::checkError ( int iter_num = 0 )

private

[Solve and refine loop]

[Check error]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 371 of file mixed_poisson.cpp.

                                                    {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
  pipeline_mng->getDomainRhsFE().reset();
  pipeline_mng->getOpDomainRhsPipeline().clear();
 
  CHKERR AddHOOps<2, 2, 2>::add(pipeline_mng->getOpDomainRhsPipeline(),
                                {HDIV, L2});
 
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldValues("U", commonDataPtr->approxVals));
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateScalarFieldGradient<2>("U",
                                            commonDataPtr->approxValsGrad));
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpCalculateHVecVectorField<3>("Q", commonDataPtr->approxFlux));
  pipeline_mng->getOpDomainRhsPipeline().push_back(
      new OpError(commonDataPtr, mField));
 
  commonDataPtr->maxErrorIndicator = 0;
  CHKERR VecZeroEntries(commonDataPtr->petscVec);
  CHKERR pipeline_mng->loopFiniteElements();
  CHKERR VecAssemblyBegin(commonDataPtr->petscVec);
  CHKERR VecAssemblyEnd(commonDataPtr->petscVec);
  CHKERR VecGhostUpdateBegin(commonDataPtr->petscVec, INSERT_VALUES,
                             SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(commonDataPtr->petscVec, INSERT_VALUES,
                           SCATTER_FORWARD);
 
  MPI_Allreduce(&commonDataPtr->maxErrorIndicator, &maxErrorIndicator, 1,
                MPI_DOUBLE, MPI_MAX, mField.get_comm());
 
  const double *array;
  CHKERR VecGetArrayRead(commonDataPtr->petscVec, &array);
  MOFEM_LOG("EXAMPLE", Sev::inform)
      << "Global error indicator (max): " << commonDataPtr->maxErrorIndicator;
  MOFEM_LOG("EXAMPLE", Sev::inform)
      << "Global error indicator (total): "
      << std::sqrt(array[CommonData::ERROR_INDICATOR_TOTAL]);
  MOFEM_LOG("EXAMPLE", Sev::inform)
      << "Global error L2 norm: "
      << std::sqrt(array[CommonData::ERROR_L2_NORM]);
  MOFEM_LOG("EXAMPLE", Sev::inform)
      << "Global error H1 seminorm: "
      << std::sqrt(array[CommonData::ERROR_H1_SEMINORM]);
 
  totErrorIndicator = std::sqrt(array[CommonData::ERROR_INDICATOR_TOTAL]);
  CHKERR VecRestoreArrayRead(commonDataPtr->petscVec, &array);
 
  std::vector<Tag> tag_handles;
  tag_handles.resize(4);
  CHKERR getTagHandle(mField, "ERROR_L2_NORM", MB_TYPE_DOUBLE, tag_handles[0]);
  CHKERR getTagHandle(mField, "ERROR_H1_SEMINORM", MB_TYPE_DOUBLE,
                      tag_handles[1]);
  CHKERR getTagHandle(mField, "ERROR_INDICATOR", MB_TYPE_DOUBLE,
                      tag_handles[2]);
  CHKERR getTagHandle(mField, "ORDER", MB_TYPE_INTEGER, tag_handles[3]);
 
  ParallelComm *pcomm =
      ParallelComm::get_pcomm(&mField.get_moab(), MYPCOMM_INDEX);
  if (pcomm == NULL)
    SETERRQ(PETSC_COMM_WORLD, MOFEM_DATA_INCONSISTENCY, "Communicator not set");
 
  tag_handles.push_back(pcomm->part_tag());
  std::ostringstream strm;
  strm << "error_" << iter_num << ".h5m";
  CHKERR mField.get_moab().write_file(strm.str().c_str(), "MOAB",
                                      "PARALLEL=WRITE_PART", 0, 0,
                                      tag_handles.data(), tag_handles.size());
  MoFEMFunctionReturn(0);
}

◆ createCommonData()

MoFEMErrorCode MixedPoisson::createCommonData ( )

private

[Set integration rule]

[Create common data]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 221 of file mixed_poisson.cpp.

                                              {
  MoFEMFunctionBegin;
  commonDataPtr = boost::make_shared<CommonData>();
  PetscInt ghosts[3] = {0, 1, 2};
  if (!mField.get_comm_rank())
    commonDataPtr->petscVec =
        createGhostVector(mField.get_comm(), 3, 3, 0, ghosts);
  else
    commonDataPtr->petscVec =
        createGhostVector(mField.get_comm(), 0, 3, 3, ghosts);
  commonDataPtr->approxVals = boost::make_shared<VectorDouble>();
  commonDataPtr->approxValsGrad = boost::make_shared<MatrixDouble>();
  commonDataPtr->approxFlux = boost::make_shared<MatrixDouble>();
  MoFEMFunctionReturn(0);
}

◆ getTagHandle()

static MoFEMErrorCode MixedPoisson::getTagHandle	(	MoFEM::Interface &	m_field,
		const char *	name,
		DataType	type,
		Tag &	tag_handle
	)

inlinestaticprivate

[Source function]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 79 of file mixed_poisson.cpp.

                                                      {
    MoFEMFunctionBegin;
    int int_val = 0;
    double double_val = 0;
    switch (type) {
    case MB_TYPE_INTEGER:
      CHKERR m_field.get_moab().tag_get_handle(
          name, 1, type, tag_handle, MB_TAG_CREAT | MB_TAG_SPARSE, &int_val);
      break;
    case MB_TYPE_DOUBLE:
      CHKERR m_field.get_moab().tag_get_handle(
          name, 1, type, tag_handle, MB_TAG_CREAT | MB_TAG_SPARSE, &double_val);
      break;
    default:
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "Wrong data type %d for tag", type);
    }
    MoFEMFunctionReturn(0);
  }

◆ outputResults()

MoFEMErrorCode MixedPoisson::outputResults ( int iter_num = 0 )

private

[Check error]

[Output results]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 446 of file mixed_poisson.cpp.

                                                       {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  pipeline_mng->getDomainLhsFE().reset();
 
  using PostProcEle = PostProcBrokenMeshInMoab<DomainEle>;
 
  auto post_proc_fe = boost::make_shared<PostProcEle>(mField);
 
  CHKERR AddHOOps<2, 2, 2>::add(post_proc_fe->getOpPtrVector(), {HDIV});
 
  auto u_ptr = boost::make_shared<VectorDouble>();
  auto flux_ptr = boost::make_shared<MatrixDouble>();
  post_proc_fe->getOpPtrVector().push_back(
      new OpCalculateScalarFieldValues("U", u_ptr));
  post_proc_fe->getOpPtrVector().push_back(
      new OpCalculateHVecVectorField<3>("Q", flux_ptr));
 
  using OpPPMap = OpPostProcMapInMoab<3, 3>;
 
  post_proc_fe->getOpPtrVector().push_back(
 
      new OpPPMap(post_proc_fe->getPostProcMesh(),
                  post_proc_fe->getMapGaussPts(),
 
                  OpPPMap::DataMapVec{{"U", u_ptr}},
 
                  OpPPMap::DataMapMat{{"Q", flux_ptr}},
 
                  OpPPMap::DataMapMat{},
 
                  OpPPMap::DataMapMat{}
 
                  )
 
  );
 
  pipeline_mng->getDomainRhsFE() = post_proc_fe;
  CHKERR pipeline_mng->loopFiniteElements();
 
  std::ostringstream strm;
  strm << "out_" << iter_num << ".h5m";
  CHKERR post_proc_fe->writeFile(strm.str().c_str());
  MoFEMFunctionReturn(0);
}

◆ readMesh()

MoFEMErrorCode MixedPoisson::readMesh ( )

private

[Run programme]

[Read mesh]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 155 of file mixed_poisson.cpp.

                                      {
  MoFEMFunctionBegin;
  CHKERR mField.getInterface(simpleInterface);
  CHKERR simpleInterface->getOptions();
  CHKERR simpleInterface->loadFile();
  MoFEMFunctionReturn(0);
}

◆ refineOrder()

MoFEMErrorCode MixedPoisson::refineOrder ( int iter_num = 0 )

private

[Solve]

[Refine]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 286 of file mixed_poisson.cpp.

                                                     {
  MoFEMFunctionBegin;
  Tag th_error_ind, th_order;
  CHKERR getTagHandle(mField, "ERROR_INDICATOR", MB_TYPE_DOUBLE, th_error_ind);
  CHKERR getTagHandle(mField, "ORDER", MB_TYPE_INTEGER, th_order);
 
  std::vector<Range> refinement_levels;
  refinement_levels.resize(iter_num + 1);
  for (auto ent : domainEntities) {
    double err_indic = 0;
    CHKERR mField.get_moab().tag_get_data(th_error_ind, &ent, 1, &err_indic);
 
    int order, new_order;
    CHKERR mField.get_moab().tag_get_data(th_order, &ent, 1, &order);
    new_order = order + 1;
    Range refined_ents;
    if (err_indic > thetaParam * maxErrorIndicator) {
      refined_ents.insert(ent);
      Range adj;
      CHKERR mField.get_moab().get_adjacencies(&ent, 1, 1, false, adj,
                                               moab::Interface::UNION);
      refined_ents.merge(adj);
      refinement_levels[new_order - initOrder].merge(refined_ents);
      CHKERR mField.get_moab().tag_set_data(th_order, &ent, 1, &new_order);
    }
  }
 
  for (int ll = 1; ll < refinement_levels.size(); ll++) {
    CHKERR mField.getInterface<CommInterface>()->synchroniseEntities(
        refinement_levels[ll]);
 
    if (initOrder + ll > 8) {
      MOFEM_LOG("EXAMPLE", Sev::warning)
          << "setting approximation order higher than 8 is not currently "
             "supported"
          << endl;
    } else {
      CHKERR mField.set_field_order(refinement_levels[ll], "U", initOrder + ll);
      CHKERR mField.set_field_order(refinement_levels[ll], "Q",
                                    initOrder + ll + 1);
    }
  }
 
  CHKERR mField.getInterface<CommInterface>()->synchroniseFieldEntities("Q");
  CHKERR mField.getInterface<CommInterface>()->synchroniseFieldEntities("U");
  CHKERR mField.build_fields();
  CHKERR mField.build_finite_elements();
  CHKERR mField.build_adjacencies(simpleInterface->getBitRefLevel());
  mField.getInterface<ProblemsManager>()->buildProblemFromFields = PETSC_TRUE;
  CHKERR DMSetUp_MoFEM(simpleInterface->getDM());
  MoFEMFunctionReturn(0);
}

◆ runProblem()

MoFEMErrorCode MixedPoisson::runProblem ( )

[Run programme]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 144 of file mixed_poisson.cpp.

                                        {
  MoFEMFunctionBegin;
  CHKERR readMesh();
  CHKERR setupProblem();
  CHKERR createCommonData();
  CHKERR solveRefineLoop();
  MoFEMFunctionReturn(0);
}

◆ setIntegrationRules()

MoFEMErrorCode MixedPoisson::setIntegrationRules ( )

private

[Set up problem]

[Set integration rule]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 207 of file mixed_poisson.cpp.

                                                 {
  MoFEMFunctionBegin;
 
  auto rule = [](int, int, int p) -> int { return 2 * p; };
 
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  CHKERR pipeline_mng->setDomainLhsIntegrationRule(rule);
  CHKERR pipeline_mng->setDomainRhsIntegrationRule(rule);
 
  MoFEMFunctionReturn(0);
}

◆ setupProblem()

MoFEMErrorCode MixedPoisson::setupProblem ( )

private

[Read mesh]

[Set up problem]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 165 of file mixed_poisson.cpp.

                                          {
  MoFEMFunctionBegin;
 
  CHKERR simpleInterface->addDomainField("U", L2, AINSWORTH_LEGENDRE_BASE, 1);
 
  int nb_quads = 0;
  CHKERR mField.get_moab().get_number_entities_by_type(0, MBQUAD, nb_quads);
  auto base = AINSWORTH_LEGENDRE_BASE;
  if (nb_quads) {
    // AINSWORTH_LEGENDRE_BASE is not implemented for HDIV/HCURL space on quads
    base = DEMKOWICZ_JACOBI_BASE;
  }
 
  // Note that in 2D case HDIV and HCURL spaces are isomorphic, and therefore
  // only base for HCURL has been implemented in 2D. Base vectors for HDIV space
  // are be obtained after rotation of HCURL base vectors by a right angle
  CHKERR simpleInterface->addDomainField("Q", HCURL, base, 1);
 
  thetaParam = 0.5;
  CHKERR PetscOptionsGetReal(PETSC_NULLPTR, "", "-theta", &thetaParam, PETSC_NULLPTR);
 
  indicTolerance = 1e-3;
  CHKERR PetscOptionsGetReal(PETSC_NULLPTR, "", "-indic_tol", &indicTolerance,
                             PETSC_NULLPTR);
 
  initOrder = 2;
  CHKERR PetscOptionsGetInt(PETSC_NULLPTR, "", "-order", &initOrder, PETSC_NULLPTR);
  CHKERR simpleInterface->setFieldOrder("U", initOrder);
  CHKERR simpleInterface->setFieldOrder("Q", initOrder + 1);
  CHKERR simpleInterface->setUp();
 
  CHKERR mField.get_moab().get_entities_by_dimension(0, 2, domainEntities);
  Tag th_order;
  CHKERR getTagHandle(mField, "ORDER", MB_TYPE_INTEGER, th_order);
  for (auto ent : domainEntities) {
    CHKERR mField.get_moab().tag_set_data(th_order, &ent, 1, &initOrder);
  }
  MoFEMFunctionReturn(0);
}

◆ solveRefineLoop()

MoFEMErrorCode MixedPoisson::solveRefineLoop ( )

private

[Refine]

[Solve and refine loop]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 341 of file mixed_poisson.cpp.

                                             {
  MoFEMFunctionBegin;
  CHKERR assembleSystem();
  CHKERR setIntegrationRules();
  CHKERR solveSystem();
  CHKERR checkError();
  CHKERR outputResults();
 
  int iter_num = 1;
  while (fabs(indicTolerance) > DBL_EPSILON &&
         totErrorIndicator > indicTolerance) {
    MOFEM_LOG("EXAMPLE", Sev::inform) << "Refinement iteration " << iter_num;
 
    CHKERR refineOrder(iter_num);
    CHKERR assembleSystem();
    CHKERR setIntegrationRules();
    CHKERR solveSystem();
    CHKERR checkError(iter_num);
    CHKERR outputResults(iter_num);
 
    iter_num++;
    if (iter_num > 100)
      SETERRQ(PETSC_COMM_SELF, MOFEM_OPERATION_UNSUCCESSFUL,
              "Too many refinement iterations");
  }
  MoFEMFunctionReturn(0);
}

◆ solveSystem()

MoFEMErrorCode MixedPoisson::solveSystem ( )

private

[Assemble system]

[Solve]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 265 of file mixed_poisson.cpp.

                                         {
  MoFEMFunctionBegin;
  PipelineManager *pipeline_mng = mField.getInterface<PipelineManager>();
  auto solver = pipeline_mng->createKSP();
  CHKERR KSPSetFromOptions(solver);
  CHKERR KSPSetUp(solver);
 
  auto dm = simpleInterface->getDM();
  auto D = createDMVector(dm);
  auto F = vectorDuplicate(D);
  CHKERR VecZeroEntries(D);
 
  CHKERR KSPSolve(solver, F, D);
  CHKERR VecGhostUpdateBegin(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR VecGhostUpdateEnd(D, INSERT_VALUES, SCATTER_FORWARD);
  CHKERR DMoFEMMeshToLocalVector(dm, D, INSERT_VALUES, SCATTER_REVERSE);
  MoFEMFunctionReturn(0);
}

◆ sourceFunction()

static double MixedPoisson::sourceFunction	(	const double	x,
		const double	y,
		const double	z
	)

inlinestaticprivate

[Analytical function gradient]

[Source function]

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 69 of file mixed_poisson.cpp.

                                                                               {
    return -exp(-100. * (sqr(x) + sqr(y))) *
           (400. * M_PI *
                (x * cos(M_PI * y) * sin(M_PI * x) +
                 y * cos(M_PI * x) * sin(M_PI * y)) +
            2. * (20000. * (sqr(x) + sqr(y)) - 200. - sqr(M_PI)) *
                cos(M_PI * x) * cos(M_PI * y));
  }

Member Data Documentation

◆ commonDataPtr

boost::shared_ptr<CommonData> MixedPoisson::commonDataPtr

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 128 of file mixed_poisson.cpp.

◆ domainEntities

Range MixedPoisson::domainEntities

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 40 of file mixed_poisson.cpp.

◆ indicTolerance

double MixedPoisson::indicTolerance

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 45 of file mixed_poisson.cpp.

◆ initOrder

int MixedPoisson::initOrder

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 46 of file mixed_poisson.cpp.

◆ maxErrorIndicator

double MixedPoisson::maxErrorIndicator

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 42 of file mixed_poisson.cpp.

◆ mField

MoFEM::Interface& MixedPoisson::mField

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 37 of file mixed_poisson.cpp.

◆ simpleInterface

Simple* MixedPoisson::simpleInterface

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 38 of file mixed_poisson.cpp.

◆ thetaParam

double MixedPoisson::thetaParam

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 44 of file mixed_poisson.cpp.

◆ totErrorIndicator

double MixedPoisson::totErrorIndicator

private

Examples: mofem/tutorials/mix-0/mixed_poisson.cpp.

Definition at line 41 of file mixed_poisson.cpp.

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

tutorials/mix-0/mixed_poisson.cpp

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ MixedPoisson()

Member Function Documentation

◆ analyticalFunction()

◆ analyticalFunctionGrad()

◆ assembleSystem()

◆ checkError()

◆ createCommonData()

◆ getTagHandle()

◆ outputResults()

◆ readMesh()

◆ refineOrder()

◆ runProblem()

◆ setIntegrationRules()

◆ setupProblem()

◆ solveRefineLoop()

◆ solveSystem()

◆ sourceFunction()

Member Data Documentation

◆ commonDataPtr

◆ domainEntities

◆ indicTolerance

◆ initOrder

◆ maxErrorIndicator

◆ mField

◆ simpleInterface

◆ thetaParam

◆ totErrorIndicator