Inheritance diagram for MixedPoisson::OpError:

Collaboration diagram for MixedPoisson::OpError:

Public Member Functions
	OpError (boost::shared_ptr< CommonData > &common_data_ptr, MoFEM::Interface &m_field)

MoFEMErrorCode	doWork (int side, EntityType type, EntData &data)
	[Output results] More...

Public Attributes
boost::shared_ptr< CommonData >	commonDataPtr

MoFEM::Interface &	mField

Detailed Description

Definition at line 129 of file mixed_poisson.cpp.

Constructor & Destructor Documentation

◆ OpError()

MixedPoisson::OpError::OpError	(	boost::shared_ptr< CommonData > &	common_data_ptr,
		MoFEM::Interface &	m_field
	)

inline

Definition at line 132 of file mixed_poisson.cpp.

         : DomainEleOp("U", OPROW), commonDataPtr(common_data_ptr),
           mField(m_field) {
       std::fill(&doEntities[MBVERTEX], &doEntities[MBMAXTYPE], false);
       doEntities[MBTRI] = doEntities[MBQUAD] = true;
     }

Member Function Documentation

◆ doWork()

MoFEMErrorCode MixedPoisson::OpError::doWork	(	int	side,
		EntityType	type,
		EntData &	data
	)

[Output results]

[OpError]

Examples: mixed_poisson.cpp.

Definition at line 494 of file mixed_poisson.cpp.

                                                             {
   MoFEMFunctionBegin;
   const int nb_integration_pts = getGaussPts().size2();
   const double area = getMeasure();
   auto t_w = getFTensor0IntegrationWeight();
   auto t_val = getFTensor0FromVec(*(commonDataPtr->approxVals));
   auto t_val_grad = getFTensor1FromMat<2>(*(commonDataPtr->approxValsGrad));
   auto t_flux = getFTensor1FromMat<3>(*(commonDataPtr->approxFlux));
   auto t_coords = getFTensor1CoordsAtGaussPts();
   FTensor::Tensor1<double, 2> t_diff;
   FTensor::Index<'i', 2> i;
  
   double error_l2 = 0;
   double error_h1 = 0;
   double error_ind = 0;
   for (int gg = 0; gg != nb_integration_pts; ++gg) {
     const double alpha = t_w * area;
  
     double diff = t_val - MixedPoisson::analyticalFunction(
                               t_coords(0), t_coords(1), t_coords(2));
     error_l2 += alpha * sqr(diff);
  
     VectorDouble vec = MixedPoisson::analyticalFunctionGrad(
         t_coords(0), t_coords(1), t_coords(2));
     auto t_fun_grad = getFTensor1FromArray<2, 2>(vec);
     t_diff(i) = t_val_grad(i) - t_fun_grad(i);
     error_h1 += alpha * t_diff(i) * t_diff(i);
  
     t_diff(i) = t_val_grad(i) - t_flux(i);
     error_ind += alpha * t_diff(i) * t_diff(i);
  
     ++t_w;
     ++t_val;
     ++t_val_grad;
     ++t_flux;
     ++t_coords;
   }
  
   const EntityHandle ent = getFEEntityHandle();
   Tag th_error_l2, th_error_h1, th_error_ind;
   CHKERR MixedPoisson::getTagHandle(mField, "ERROR_L2_NORM", MB_TYPE_DOUBLE,
                                     th_error_l2);
   CHKERR MixedPoisson::getTagHandle(mField, "ERROR_H1_SEMINORM", MB_TYPE_DOUBLE,
                                     th_error_h1);
   CHKERR MixedPoisson::getTagHandle(mField, "ERROR_INDICATOR", MB_TYPE_DOUBLE,
                                     th_error_ind);
  
   double error_l2_norm = sqrt(error_l2);
   double error_h1_seminorm = sqrt(error_h1);
   double error_ind_local = sqrt(error_ind);
   CHKERR mField.get_moab().tag_set_data(th_error_l2, &ent, 1, &error_l2_norm);
   CHKERR mField.get_moab().tag_set_data(th_error_h1, &ent, 1,
                                         &error_h1_seminorm);
   CHKERR mField.get_moab().tag_set_data(th_error_ind, &ent, 1,
                                         &error_ind_local);
  
   if (error_ind_local > commonDataPtr->maxErrorIndicator)
     commonDataPtr->maxErrorIndicator = error_ind_local;
  
   int index = CommonData::ERROR_L2_NORM;
   constexpr std::array<int, CommonData::LAST_ELEMENT> indices = {
       CommonData::ERROR_L2_NORM, CommonData::ERROR_H1_SEMINORM,
       CommonData::ERROR_INDICATOR_TOTAL};
   std::array<double, CommonData::LAST_ELEMENT> values;
   values[0] = error_l2;
   values[1] = error_h1;
   values[2] = error_ind;
   CHKERR VecSetValues(commonDataPtr->petscVec, CommonData::LAST_ELEMENT,
                       indices.data(), values.data(), ADD_VALUES);
   MoFEMFunctionReturn(0);
 }