12    const int index, boost::shared_ptr<VectorDouble> diff_data_ptr,
 
   13    boost::shared_ptr<Range> ent_ptr)
 
   16      dataPtr(data_ptr), dataVec(data_vec), iNdex(index),
 
   17      diffDataPtr(diff_data_ptr), entsPtr(ent_ptr) {
 
 
   39  const auto nb_integration_points = 
getGaussPts().size2();
 
   47  double norm_on_element = 0.;
 
   49  for (
int gg = 0; gg != nb_integration_points; gg++) {
 
   51    norm_on_element += t_w * t_data * t_data;
 
   58  norm_on_element *= vol;
 
 
   68    const int index, boost::shared_ptr<MatrixDouble> diff_data_ptr,
 
   69    boost::shared_ptr<Range> ent_ptr)
 
   72      dataPtr(data_ptr), dataVec(data_vec), iNdex(index),
 
   73      diffDataPtr(diff_data_ptr), entsPtr(ent_ptr) {
 
 
   88    if (entsPtr->find(this->getFEEntityHandle()) == entsPtr->end())
 
   93  if (dataPtr != diffDataPtr)
 
   94    *diffDataPtr -= *dataPtr;
 
   99  const auto nb_integration_points = getGaussPts().size2();
 
  101  const double vol = getMeasure();
 
  103  auto t_w = getFTensor0IntegrationWeight();
 
  105  auto t_data = getFTensor1FromMat<DIM>(*diffDataPtr);
 
  107  double norm_on_element = 0.;
 
  109  for (
int gg = 0; gg != nb_integration_points; ++gg) {
 
  111    norm_on_element += t_w * (t_data(
i) * t_data(
i));
 
  118  norm_on_element *= vol;
 
  120  CHKERR VecSetValue(dataVec, iNdex, norm_on_element, ADD_VALUES);
 
 
  125template <
int DIM_1, 
int DIM_2>
 
  128    const int index, boost::shared_ptr<MatrixDouble> diff_data_ptr,
 
  129    boost::shared_ptr<Range> ent_ptr)
 
  132      dataPtr(data_ptr), dataVec(data_vec), iNdex(index),
 
  133      diffDataPtr(diff_data_ptr), entsPtr(ent_ptr) {
 
 
  140template <
int DIM_1, 
int DIM_2>
 
  148    if (entsPtr->find(this->getFEEntityHandle()) == entsPtr->end())
 
  153  if (dataPtr != diffDataPtr)
 
  154    *diffDataPtr -= *dataPtr;
 
  160  const auto nb_integration_points = getGaussPts().size2();
 
  162  const double vol = getMeasure();
 
  164  auto t_w = getFTensor0IntegrationWeight();
 
  166  auto t_data = getFTensor2FromMat<DIM_1, DIM_2>(*diffDataPtr);
 
  168  double norm_on_element = 0.;
 
  170  for (
int gg = 0; gg != nb_integration_points; gg++) {
 
  172    norm_on_element += t_w * (t_data(
i, 
j) * t_data(
i, 
j));
 
  179  norm_on_element *= vol;
 
  181  CHKERR VecSetValue(dataVec, iNdex, norm_on_element, ADD_VALUES);
 
 
  187    boost::shared_ptr<VectorDouble> data_ptr, 
ScalarFun scalar_function)
 
  190      dataPtr(data_ptr), sFunc(scalar_function) {}
 
 
  197  const int nb_integration_pts = 
getGaussPts().size2();
 
  199  dataPtr->resize(nb_integration_pts);
 
  206  for (
int gg = 0; gg != nb_integration_pts; ++gg) {
 
  209    t_val = 
sFunc(t_coords(0), t_coords(1), t_coords(2));
 
 
  219template <
int SPACE_DIM, 
int BASE_DIM>
 
  221    boost::shared_ptr<MatrixDouble> data_ptr, 
VectorFunc vector_function)
 
  224      dataPtr(data_ptr), vFunc(vector_function) {}
 
 
  226template <
int SPACE_DIM, 
int BASE_DIM>
 
  234  const int nb_integration_pts = getGaussPts().size2();
 
  236  dataPtr->resize(
BASE_DIM, nb_integration_pts);
 
  238  auto t_val = getFTensor1FromMat<BASE_DIM>(*(dataPtr));
 
  241  auto t_coords = getFTensor1CoordsAtGaussPts();
 
  243  for (
int gg = 0; gg != nb_integration_pts; ++gg) {
 
  245    auto func_val = vFunc(t_coords(0), t_coords(1), t_coords(2));
 
  247    auto t_func_val = getFTensor1FromArray<SPACE_DIM, SPACE_DIM>(func_val);
 
  249    t_val(
i) = t_func_val(
i);
 
 
ForcesAndSourcesCore::UserDataOperator UserDataOperator
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
#define THROW_MESSAGE(msg)
Throw MoFEM exception.
FTensor::Index< 'i', SPACE_DIM > i
FTensor::Index< 'j', 3 > j
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
implementation of Data Operators for Forces and Sources
static auto getFTensor0FromVec(ublas::vector< T, A > &data)
Get tensor rank 0 (scalar) form data vector.
boost::function< VectorDouble(const double, const double, const double)> VectorFunc
Data on single entity (This is passed as argument to DataOperator::doWork)
auto getFTensor1CoordsAtGaussPts()
Get coordinates at integration points assuming linear geometry.
auto getFTensor0IntegrationWeight()
Get integration weights.
double getMeasure() const
get measure of element
MatrixDouble & getGaussPts()
matrix of integration (Gauss) points for Volume Element
structure to get information from mofem into EntitiesFieldData
boost::shared_ptr< VectorDouble > dataPtr
boost::shared_ptr< VectorDouble > diffDataPtr
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
calculate norm of scalar values at integration points
OpCalcNormL2Tensor0(boost::shared_ptr< VectorDouble > data_ptr, SmartPetscObj< Vec > data_vec, const int index, boost::shared_ptr< VectorDouble > diff_data_ptr=nullptr, boost::shared_ptr< Range > ent_ptr=nullptr)
SmartPetscObj< Vec > dataVec
boost::shared_ptr< Range > entsPtr
Get norm of input MatrixDouble for Tensor1.
boost::shared_ptr< MatrixDouble > diffDataPtr
OpCalcNormL2Tensor1(boost::shared_ptr< MatrixDouble > data_ptr, SmartPetscObj< Vec > data_vec, const int index, boost::shared_ptr< MatrixDouble > diff_data_ptr=nullptr, boost::shared_ptr< Range > ent_ptr=nullptr)
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
calculate norm of vector values at integration points
boost::shared_ptr< MatrixDouble > dataPtr
Get norm of input MatrixDouble for Tensor2.
OpCalcNormL2Tensor2(boost::shared_ptr< MatrixDouble > data_ptr, SmartPetscObj< Vec > data_vec, const int index, boost::shared_ptr< MatrixDouble > diff_data_ptr=nullptr, boost::shared_ptr< Range > ent_ptr=nullptr)
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
calculate norm of tensor values at integration points
boost::shared_ptr< MatrixDouble > diffDataPtr
boost::shared_ptr< MatrixDouble > dataPtr
OpGetTensor0fromFunc(boost::shared_ptr< VectorDouble > data_ptr, ScalarFun scalar_function)
boost::shared_ptr< VectorDouble > dataPtr
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
calculate values of scalar function at integration points
OpGetTensor1fromFunc(boost::shared_ptr< MatrixDouble > data_ptr, VectorFunc vector_function)
MoFEMErrorCode doWork(int side, EntityType type, EntitiesFieldData::EntData &data)
calculate values of vector function at integration points
intrusive_ptr for managing petsc objects