MoFEM::OpGetDataAndGradient< RANK, DIM > Struct Template Reference

Get field values and gradients at Gauss points. More...

#include <src/finite_elements/DataOperators.hpp>

Inheritance diagram for MoFEM::OpGetDataAndGradient< RANK, DIM >:

Collaboration diagram for MoFEM::OpGetDataAndGradient< RANK, DIM >:

Public Member Functions
	OpGetDataAndGradient (MatrixDouble &data_at_gauss_pt, MatrixDouble &data_grad_at_gauss_pt)
template<int R>
FTensor::Tensor1< double *, R >	getValAtGaussPtsTensor (MatrixDouble &data)
template<int R, int D>
FTensor::Tensor2< double *, R, D >	getGradAtGaussPtsTensor (MatrixDouble &data)
MoFEMErrorCode	calculateValAndGrad (int side, EntityType type, EntitiesFieldData::EntData &data)
	Calculate gradient and values at integration points. More...
MoFEMErrorCode	doWork (int side, EntityType type, EntitiesFieldData::EntData &data)
	Operator for linear form, usually to calculate values on right hand side. More...
FTensor::Tensor1< double *, 3 >	getValAtGaussPtsTensor (MatrixDouble &data)
	Specialization for field with 3 coefficients in 3 dimension. More...
FTensor::Tensor2< double *, 3, 3 >	getGradAtGaussPtsTensor (MatrixDouble &data)
	Specialization for field with 3 coefficients in 3 dimension. More...
MoFEMErrorCode	calculateValAndGrad (int side, EntityType type, EntitiesFieldData::EntData &data)
	Specialization for field with 3 coefficients in 3 dimension. More...
MoFEMErrorCode	calculateValAndGrad (int side, EntityType type, EntitiesFieldData::EntData &data)
	Specialization for field with for scalar field in 3 dimension. More...
FTensor::Tensor1< double *, 3 >	getValAtGaussPtsTensor (MatrixDouble &data)
FTensor::Tensor2< double *, 3, 3 >	getGradAtGaussPtsTensor (MatrixDouble &data)
MoFEMErrorCode	calculateValAndGrad (int side, EntityType type, EntitiesFieldData::EntData &data)
MoFEMErrorCode	calculateValAndGrad (int side, EntityType type, EntitiesFieldData::EntData &data)
Public Member Functions inherited from MoFEM::DataOperator
	DataOperator (const bool symm=true)
virtual	~DataOperator ()=default
virtual MoFEMErrorCode	doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)
	Operator for bi-linear form, usually to calculate values on left hand side. More...
virtual MoFEMErrorCode	opLhs (EntitiesFieldData &row_data, EntitiesFieldData &col_data)
virtual MoFEMErrorCode	doWork (int side, EntityType type, EntitiesFieldData::EntData &data)
	Operator for linear form, usually to calculate values on right hand side. More...
virtual MoFEMErrorCode	opRhs (EntitiesFieldData &data, const bool error_if_no_base=false)
bool	getSymm () const
	Get if operator uses symmetry of DOFs or not. More...
void	setSymm ()
	set if operator is executed taking in account symmetry More...
void	unSetSymm ()
	unset if operator is executed for non symmetric problem More...

Public Attributes
MatrixDouble &	dataAtGaussPts
MatrixDouble &	dataGradAtGaussPts
Public Attributes inherited from MoFEM::DataOperator
DoWorkLhsHookFunType	doWorkLhsHook
DoWorkRhsHookFunType	doWorkRhsHook
bool	sYmm
	If true assume that matrix is symmetric structure. More...
std::array< bool, MBMAXTYPE >	doEntities
	If true operator is executed for entity. More...
bool &	doVertices
	\deprectaed If false skip vertices More...
bool &	doEdges
	\deprectaed If false skip edges More...
bool &	doQuads
	\deprectaed More...
bool &	doTris
	\deprectaed More...
bool &	doTets
	\deprectaed More...
bool &	doPrisms
	\deprectaed More...

Additional Inherited Members
Public Types inherited from MoFEM::DataOperator
using	DoWorkLhsHookFunType = boost::function< MoFEMErrorCode(DataOperator *op_ptr, int row_side, int col_side, EntityType row_type, EntityType col_type, EntitiesFieldData::EntData &row_data, EntitiesFieldData::EntData &col_data)>
using	DoWorkRhsHookFunType = boost::function< MoFEMErrorCode(DataOperator *op_ptr, int side, EntityType type, EntitiesFieldData::EntData &data)>

Detailed Description

template<int RANK, int DIM>
struct MoFEM::OpGetDataAndGradient< RANK, DIM >

Get field values and gradients at Gauss points.

Definition at line 240 of file DataOperators.hpp.

Constructor & Destructor Documentation

OpGetDataAndGradient()

template<int RANK, int DIM>

MoFEM::OpGetDataAndGradient< RANK, DIM >::OpGetDataAndGradient ( MatrixDouble &  data_at_gauss_pt, MatrixDouble &  data_grad_at_gauss_pt  )

inline

Definition at line 245 of file DataOperators.hpp.

      : dataAtGaussPts(data_at_gauss_pt),
        dataGradAtGaussPts(data_grad_at_gauss_pt) {}

Member Function Documentation

calculateValAndGrad() [1/5]

template<int RANK, int DIM>

MoFEMErrorCode MoFEM::OpGetDataAndGradient< RANK, DIM >::calculateValAndGrad ( int  side, EntityType  type, EntitiesFieldData::EntData &  data  )

inline

Calculate gradient and values at integration points.

Parameters

side	side of entity on element
type	type of entity
data	data stored on entity (dofs values, dofs indices, etc.)

Returns

error code

Definition at line 273 of file DataOperators.hpp.

                                                                     {
    MoFEMFunctionBeginHot;
    const int nb_base_functions = data.getN().size2();
    bool constant_diff = false;
    if (type == MBVERTEX && data.getDiffN().size1() * data.getDiffN().size2() ==
                                DIM * nb_base_functions) {
      constant_diff = true;
    }
    const int nb_dofs = data.getFieldData().size();
    for (unsigned int gg = 0; gg < data.getN().size1(); gg++) {
      double *data_ptr, *n_ptr, *diff_n_ptr;
      n_ptr = &data.getN()(gg, 0);
      if (constant_diff) {
        diff_n_ptr = &data.getDiffN()(0, 0);
      } else {
        diff_n_ptr = &data.getDiffN()(gg, 0);
      }
      data_ptr = &*data.getFieldData().data().begin();
      for (int rr = 0; rr < RANK; rr++, data_ptr++) {
        dataAtGaussPts(gg, rr) +=
            cblas_ddot(nb_dofs / RANK, n_ptr, 1, data_ptr, RANK);
        double *diff_n_ptr2 = diff_n_ptr;
        for (unsigned int dd = 0; dd < DIM; dd++, diff_n_ptr2++) {
          dataGradAtGaussPts(gg, DIM * rr + dd) +=
              cblas_ddot(nb_dofs / RANK, diff_n_ptr2, DIM, data_ptr, RANK);
        }
      }
    }
    MoFEMFunctionReturnHot(0);
  }

calculateValAndGrad() [2/5]

MoFEMErrorCode MoFEM::OpGetDataAndGradient< 3, 3 >::calculateValAndGrad	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Specialization for field with 3 coefficients in 3 dimension.

calculateValAndGrad() [3/5]

MoFEMErrorCode MoFEM::OpGetDataAndGradient< 1, 3 >::calculateValAndGrad	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Specialization for field with for scalar field in 3 dimension.

calculateValAndGrad() [4/5]

MoFEMErrorCode MoFEM::OpGetDataAndGradient< 3, 3 >::calculateValAndGrad	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Definition at line 835 of file DataOperators.cpp.

                                                               {
  MoFEMFunctionBeginHot;
  if (data.getBase() == NOBASE)
    MoFEMFunctionReturnHot(0);
  const unsigned int nb_gauss_pts = data.getN().size1();
  const unsigned int nb_base_functions = data.getN().size2();
  const unsigned int nb_dofs = data.getFieldData().size();
  if (!nb_dofs)
    MoFEMFunctionReturnHot(0);
  auto t_n = data.getFTensor0N();
  auto t_val = getValAtGaussPtsTensor<3>(dataAtGaussPts);
  auto t_grad = getGradAtGaussPtsTensor<3, 3>(dataGradAtGaussPts);
  FTensor::Index<'i', 3> i;
  FTensor::Index<'j', 3> j;
  if (type == MBVERTEX &&
      data.getDiffN().data().size() == 3 * nb_base_functions) {
    for (unsigned int gg = 0; gg != nb_gauss_pts; ++gg) {
      auto t_data = data.getFTensor1FieldData<3>();
      auto t_diff_n = data.getFTensor1DiffN<3>();
      unsigned int bb = 0;
      for (; bb != nb_dofs / 3; ++bb) {
        t_val(i) += t_data(i) * t_n;
        t_grad(i, j) += t_data(i) * t_diff_n(j);
        ++t_n;
        ++t_diff_n;
        ++t_data;
      }
      ++t_val;
      ++t_grad;
      for (; bb != nb_base_functions; ++bb) {
        ++t_n;
      }
    }
  } else {
    auto t_diff_n = data.getFTensor1DiffN<3>();
    for (unsigned int gg = 0; gg != nb_gauss_pts; ++gg) {
      auto t_data = data.getFTensor1FieldData<3>();
      unsigned int bb = 0;
      for (; bb != nb_dofs / 3; ++bb) {
        t_val(i) += t_data(i) * t_n;
        t_grad(i, j) += t_data(i) * t_diff_n(j);
        ++t_n;
        ++t_diff_n;
        ++t_data;
      }
      ++t_val;
      ++t_grad;
      for (; bb != nb_base_functions; ++bb) {
        ++t_n;
        ++t_diff_n;
      }
    }
  }
  MoFEMFunctionReturnHot(0);
}

calculateValAndGrad() [5/5]

MoFEMErrorCode MoFEM::OpGetDataAndGradient< 1, 3 >::calculateValAndGrad	(	int	side,
		EntityType	type,
		EntitiesFieldData::EntData &	data
	)

Definition at line 893 of file DataOperators.cpp.

                                                               {
  MoFEMFunctionBeginHot;
  const unsigned int nb_gauss_pts = data.getN().size1();
  const unsigned int nb_base_functions = data.getN().size2();
  // bool constant_diff = false;
  const unsigned int nb_dofs = data.getFieldData().size();
  auto t_n = data.getFTensor0N();
  FTensor::Tensor0<double *> t_val =
      FTensor::Tensor0<double *>(&*dataAtGaussPts.data().begin(), 1);
  double *ptr = &*dataGradAtGaussPts.data().begin();
  FTensor::Tensor1<FTensor::PackPtr<double *, 3>, 3> t_grad(ptr, &ptr[1],
                                                            &ptr[2]);
  FTensor::Index<'i', 3> i;
  if (type == MBVERTEX &&
      data.getDiffN().data().size() == 3 * nb_base_functions) {
    for (unsigned int gg = 0; gg != nb_gauss_pts; ++gg) {
      auto t_data = data.getFTensor0FieldData();
      auto t_diff_n = data.getFTensor1DiffN<3>();
      unsigned int bb = 0;
      for (; bb != nb_dofs / 3; ++bb) {
        t_val += t_data * t_n;
        t_grad(i) += t_data * t_diff_n(i);
        ++t_n;
        ++t_diff_n;
        ++t_data;
      }
      ++t_val;
      ++t_grad;
      for (; bb != nb_base_functions; ++bb) {
        ++t_n;
      }
    }
  } else {
    auto t_diff_n = data.getFTensor1DiffN<3>();
    for (unsigned int gg = 0; gg != nb_gauss_pts; ++gg) {
      auto t_data = data.getFTensor0FieldData();
      unsigned int bb = 0;
      for (; bb != nb_dofs / 3; ++bb) {
        t_val = t_data * t_n;
        t_grad(i) += t_data * t_diff_n(i);
        ++t_n;
        ++t_diff_n;
        ++t_data;
      }
      ++t_val;
      ++t_grad;
      for (; bb != nb_base_functions; ++bb) {
        ++t_n;
        ++t_diff_n;
      }
    }
  }
  MoFEMFunctionReturnHot(0);
}

doWork()

template<int RANK, int DIM>

MoFEMErrorCode MoFEM::OpGetDataAndGradient< RANK, DIM >::doWork ( int  side, EntityType  type, EntitiesFieldData::EntData &  data  )

inlinevirtual

Operator for linear form, usually to calculate values on right hand side.

Reimplemented from MoFEM::DataOperator.

Definition at line 305 of file DataOperators.hpp.

                                                        {
 
    MoFEMFunctionBegin;
 
    if (data.getFieldData().size() == 0) {
      MoFEMFunctionReturnHot(0);
    }
 
    unsigned int nb_dofs = data.getFieldData().size();
    if (nb_dofs == 0)
      MoFEMFunctionReturnHot(0);
 
    if (nb_dofs % RANK != 0) {
      SETERRQ4(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "data inconsistency, type %d, side %d, nb_dofs %d, rank %d",
               type, side, nb_dofs, RANK);
    }
    if (nb_dofs / RANK > data.getN().size2()) {
      std::cerr << side << " " << type << " "
                << ApproximationBaseNames[data.getBase()] << std::endl;
      std::cerr << data.getN() << std::endl;
      SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
               "data inconsistency nb_dofs >= data.N.size2(), i.e. %u >= %u",
               nb_dofs, data.getN().size2());
    }
 
    if (type == MBVERTEX) {
      dataAtGaussPts.resize(data.getN().size1(), RANK, false);
      dataGradAtGaussPts.resize(data.getN().size1(), RANK * DIM, false);
      dataAtGaussPts.clear();
      dataGradAtGaussPts.clear();
    }
 
    CHKERR calculateValAndGrad(side, type, data);
 
    MoFEMFunctionReturn(0);
  }

getGradAtGaussPtsTensor() [1/3]

FTensor::Tensor2< double *, 3, 3 > MoFEM::OpGetDataAndGradient< 3, 3 >::getGradAtGaussPtsTensor< 3, 3 >

(

MatrixDouble &

data

)

Specialization for field with 3 coefficients in 3 dimension.

getGradAtGaussPtsTensor() [2/3]

template<int RANK, int DIM>

template<int R, int D>

FTensor::Tensor2< double *, R, D > MoFEM::OpGetDataAndGradient< RANK, DIM >::getGradAtGaussPtsTensor ( MatrixDouble &  data )

inline

Return tensor associated with matrix storing gradient values

Definition at line 262 of file DataOperators.hpp.

                                                                             {
    THROW_MESSAGE("Not implemented");
  }

getGradAtGaussPtsTensor() [3/3]

FTensor::Tensor2< double *, 3, 3 > MoFEM::OpGetDataAndGradient< 3, 3 >::getGradAtGaussPtsTensor< 3, 3 >

(

MatrixDouble &

data

)

Definition at line 733 of file DataOperators.cpp.

                                                                            {
  double *ptr = &*data.data().begin();
  return FTensor::Tensor2<double *, 3, 3>(ptr, &ptr[1], &ptr[2], &ptr[3],
                                          &ptr[4], &ptr[5], &ptr[6], &ptr[7],
                                          &ptr[8], 9);
}

getValAtGaussPtsTensor() [1/3]

FTensor::Tensor1< double *, 3 > MoFEM::OpGetDataAndGradient< 3, 3 >::getValAtGaussPtsTensor< 3 >

(

MatrixDouble &

data

)

Specialization for field with 3 coefficients in 3 dimension.

getValAtGaussPtsTensor() [2/3]

template<int RANK, int DIM>

template<int R>

FTensor::Tensor1< double *, R > MoFEM::OpGetDataAndGradient< RANK, DIM >::getValAtGaussPtsTensor ( MatrixDouble &  data )

inline

Return tensor associated with matrix storing values

Definition at line 254 of file DataOperators.hpp.

                                                                         {
    THROW_MESSAGE("Not implemented");
  }

getValAtGaussPtsTensor() [3/3]

FTensor::Tensor1< double *, 3 > MoFEM::OpGetDataAndGradient< 3, 3 >::getValAtGaussPtsTensor< 3 >

(

MatrixDouble &

data

)

Definition at line 733 of file DataOperators.cpp.

                                                                        {
  double *ptr = &*data.data().begin();
  return FTensor::Tensor1<double *, 3>(ptr, &ptr[1], &ptr[2], 3);
}

Member Data Documentation

dataAtGaussPts

template<int RANK, int DIM>

MatrixDouble& MoFEM::OpGetDataAndGradient< RANK, DIM >::dataAtGaussPts

Definition at line 242 of file DataOperators.hpp.

dataGradAtGaussPts

template<int RANK, int DIM>

MatrixDouble& MoFEM::OpGetDataAndGradient< RANK, DIM >::dataGradAtGaussPts

Definition at line 243 of file DataOperators.hpp.

---

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

• src/finite_elements/DataOperators.hpp