NormsOperators.hpp

Go to the documentation of this file.

/** \file NormsOperators.hpp
  * \brief User data Operators for calculating norms
 
*/
 
#ifndef __NORM_OPERATORS_HPP__
#define __NORM_OPERATORS_HPP__
 
namespace MoFEM {
 
/** \brief Get norm of input VectorDouble for Tensor0
 *
 */
 
struct OpCalcNormL2Tensor0 : public ForcesAndSourcesCore::UserDataOperator {
 
  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);
 
  /**
   * \brief calculate norm of scalar values at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  boost::shared_ptr<VectorDouble> dataPtr;
  boost::shared_ptr<VectorDouble> diffDataPtr;
  boost::shared_ptr<Range> entsPtr;
  SmartPetscObj<Vec> dataVec;
  const int iNdex;
};
 
/** \brief Get norm of input MatrixDouble for Tensor1
 *
 */
template <int DIM>
struct OpCalcNormL2Tensor1 : public ForcesAndSourcesCore::UserDataOperator {
 
  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);
  /**
   * \brief calculate norm of vector values at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  boost::shared_ptr<MatrixDouble> dataPtr;
  boost::shared_ptr<MatrixDouble> diffDataPtr;
  boost::shared_ptr<Range> entsPtr;
  SmartPetscObj<Vec> dataVec;
  const int iNdex;
};
 
/** \brief Get norm of input MatrixDouble for Tensor2
 *
 */
template <int DIM_1, int DIM_2>
struct OpCalcNormL2Tensor2 : public ForcesAndSourcesCore::UserDataOperator {
 
  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);
 
  /**
   * \brief calculate norm of tensor values at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  boost::shared_ptr<MatrixDouble> dataPtr;
  boost::shared_ptr<MatrixDouble> diffDataPtr;
  SmartPetscObj<Vec> dataVec;
  boost::shared_ptr<Range> entsPtr;
  const int iNdex;
};
 
/** \brief Get norm of input MatrixDouble for symmetric Tensor2
 *
 */
template <int DIM>
struct OpCalcNormL2Tensor2Symmetric
    : public OpCalcNormL2Tensor2<DIM, DIM> {
 
  using OpCalcNormL2Tensor2<DIM, DIM>::OpCalcNormL2Tensor2;
 
  /**
   * \brief calculate norm of symmetric tensor values at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
};
 
/** \brief Get values from scalar function at integration points and save them
 * to VectorDouble for Tensor0
 *
 */
 
struct OpGetTensor0fromFunc : public ForcesAndSourcesCore::UserDataOperator {
 
  OpGetTensor0fromFunc(boost::shared_ptr<VectorDouble> data_ptr,
                       ScalarFun scalar_function);
 
  /**
   * \brief calculate values of scalar function at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  ScalarFun sFunc;
  boost::shared_ptr<VectorDouble> dataPtr;
};
 
typedef boost::function<VectorDouble(const double, const double, const double)>
    VectorFunc;
 
/** \brief Get values from vector function at integration points and save them
 * to MatrixDouble for Tensor1
 *
 * @tparam TENS_DIM Dimension of the stored output tensor in data_ptr.
 * @tparam FUNC_DIM Dimension of the vector returned by vector_function.
 *
 * If FUNC_DIM is larger than TENS_DIM, only the leading TENS_DIM components
 * are copied to the output tensor. If TENS_DIM is larger than FUNC_DIM,
 * doWork returns a data inconsistency error.
 */
 
template <int TENS_DIM, int FUNC_DIM>
struct OpGetTensor1fromFunc : public ForcesAndSourcesCore::UserDataOperator {
 
  OpGetTensor1fromFunc(boost::shared_ptr<MatrixDouble> data_ptr,
                       VectorFunc vector_function);
 
  /**
   * \brief calculate values of vector function at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
private:
  VectorFunc vFunc;
  boost::shared_ptr<MatrixDouble> dataPtr;
};
 
typedef boost::function<MatrixDouble(const double, const double, const double)>
    MatrixFunc;
 
/** \brief Get values from matrix function at integration points and save them
 * to MatrixDouble for Tensor2
 *
 * @tparam TENS_DIM Dimension of the stored output tensor in data_ptr.
 * @tparam FUNC_DIM Dimension of the square matrix returned by matrix_function.
 *
 * If FUNC_DIM is larger than TENS_DIM, only the leading TENS_DIM by TENS_DIM
 * block is copied to the output tensor. If TENS_DIM is larger than FUNC_DIM,
 * doWork returns a data inconsistency error.
 */
 
template <int TENS_DIM, int FUNC_DIM>
struct OpGetTensor2fromFunc : public ForcesAndSourcesCore::UserDataOperator {
 
  OpGetTensor2fromFunc(boost::shared_ptr<MatrixDouble> data_ptr,
                       MatrixFunc matrix_function);
 
  /**
   * \brief calculate values of matrix function at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
 
protected:
  MatrixFunc mFunc;
  boost::shared_ptr<MatrixDouble> dataPtr;
};
 
/** \brief Get values from matrix function in symmetric tensor storage at
 * integration points and save them to MatrixDouble for symmetric Tensor2
 *
 * @tparam TENS_DIM Dimension of the stored output symmetric tensor in data_ptr.
 * @tparam FUNC_DIM Dimension of the symmetric matrix returned by matrix_function.
 *
 * If FUNC_DIM is larger than TENS_DIM, only the leading TENS_DIM by TENS_DIM
 * symmetric block is copied to the output tensor. If TENS_DIM is larger than
 * FUNC_DIM, doWork returns a data inconsistency error.
 */
 
template <int TENS_DIM, int FUNC_DIM>
struct OpGetTensor2SymmetricfromFunc
    : public OpGetTensor2fromFunc<TENS_DIM, FUNC_DIM> {
 
  using OpGetTensor2fromFunc<TENS_DIM, FUNC_DIM>::OpGetTensor2fromFunc;
 
  /**
   * \brief calculate values of matrix function at integration points
   * @param  side side entity number
   * @param  type side entity type
   * @param  data entity data
   * @return      error code
   */
  MoFEMErrorCode doWork(int side, EntityType type,
                        EntitiesFieldData::EntData &data);
};
 
} // namespace MoFEM
 
#endif // __NORM_OPERATORS_HPP__