MoFEM::FieldBlas Struct Reference

Basic algebra on fields. More...

#include <src/interfaces/FieldBlas.hpp>

Inheritance diagram for MoFEM::FieldBlas:

Collaboration diagram for MoFEM::FieldBlas:

Public Types
using	OneFieldFunctionOnValues = boost::function< double(const double field_val)>
	function to set a field value More...
using	OneFieldFunctionOnEntities = boost::function< MoFEMErrorCode(boost::shared_ptr< FieldEntity > field_entity_ptr)>
using	TwoFieldFunctionOnValues = boost::function< double(const double y_field_value_reference, const double x_field_value)>
using	TwoFieldFunctionOnEntities = boost::function< MoFEMErrorCode(boost::shared_ptr< FieldEntity > y_field_entity_ptr, const boost::shared_ptr< FieldEntity > x_field_entity_ptr)>
using	VertexCoordsFunction = boost::function< MoFEMErrorCode(VectorAdaptor &&field_data, double *xcoord, double *ycoord, double *zcoord)>

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	FieldBlas (const MoFEM::Core &core)
	~FieldBlas ()=default
MoFEMErrorCode	fieldLambdaOnEntities (OneFieldFunctionOnEntities lambda, const std::string field_name, Range *ents_ptr=nullptr)
	filed lambda More...
MoFEMErrorCode	fieldLambdaOnValues (OneFieldFunctionOnValues lambda, const std::string field_name, Range *ents_ptr=nullptr)
	filed lambda More...
MoFEMErrorCode	fieldLambdaOnValues (TwoFieldFunctionOnValues lambda, const std::string field_name_x, const std::string field_name_y, bool error_if_missing=false, Range *ents_ptr=nullptr)
	filed lambda More...
MoFEMErrorCode	fieldLambdaOnEntities (TwoFieldFunctionOnEntities lambda, const std::string field_name_x, const std::string field_name_y, bool error_if_missing=false, Range *ents_ptr=nullptr)
	filed lambda More...
DEPRECATED MoFEMErrorCode	fieldLambda (TwoFieldFunctionOnValues lambda, const std::string field_name_x, const std::string field_name_y, bool error_if_missing, bool create_if_missing)
MoFEMErrorCode	fieldAxpy (const double alpha, const std::string field_name_x, const std::string field_name_y, bool error_if_missing=false, Range *ents_ptr=nullptr)
	axpy fields More...
DEPRECATED MoFEMErrorCode	fieldAxpy (const double alpha, const std::string field_name_x, const std::string field_name_y, bool error_if_missing, bool create_if_missing)
MoFEMErrorCode	fieldCopy (const double alpha, const std::string field_name_x, const std::string field_name_y, bool error_if_missing=false, Range *ents_ptr=nullptr)
	copy and scale fields More...
DEPRECATED MoFEMErrorCode	fieldCopy (const double alpha, const std::string field_name_x, const std::string field_name_y, bool error_if_missing, bool create_if_missing)
MoFEMErrorCode	fieldScale (const double alpha, const std::string field_name, Range *ents_ptr=nullptr)
	field scale More...
MoFEMErrorCode	setVertexDofs (VertexCoordsFunction lambda, const std::string field_name, Range *verts=nullptr)
	Set DOFs on vertices using user function. More...
MoFEMErrorCode	setField (const double val, const EntityType type, const std::string field_name)
MoFEMErrorCode	setField (const double val, const EntityType type, const Range &ents, const std::string field_name)
	set field More...
MoFEMErrorCode	setField (const double val, const std::string field_name)
	set field More...
Public Member Functions inherited from MoFEM::UnknownInterface
template<class IFACE >
MoFEMErrorCode	registerInterface (bool error_if_registration_failed=true)
	Register interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE *&iface) const
	Get interface reference to pointer of interface. More...
template<class IFACE >
MoFEMErrorCode	getInterface (IFACE **const iface) const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_pointer< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get interface pointer to pointer of interface. More...
template<class IFACE , typename boost::enable_if< boost::is_reference< IFACE >, int >::type = 0>
IFACE	getInterface () const
	Get reference to interface. More...
template<class IFACE >
IFACE *	getInterface () const
	Function returning pointer to interface. More...
virtual	~UnknownInterface ()=default

Public Attributes
const MoFEM::Interface &	cOre
bool	dEbug

Additional Inherited Members
Static Public Member Functions inherited from MoFEM::UnknownInterface
static MoFEMErrorCode	getLibVersion (Version &version)
	Get library version. More...
static MoFEMErrorCode	getFileVersion (moab::Interface &moab, Version &version)
	Get database major version. More...
static MoFEMErrorCode	setFileVersion (moab::Interface &moab, Version version=Version(MoFEM_VERSION_MAJOR, MoFEM_VERSION_MINOR, MoFEM_VERSION_BUILD))
	Get database major version. More...
static MoFEMErrorCode	getInterfaceVersion (Version &version)
	Get database major version. More...

Detailed Description

Basic algebra on fields.

Examples

adolc_plasticity.cpp, approx_sphere.cpp, dm_partitioned_no_field.cpp, dynamic_first_order_con_law.cpp, elasticity.cpp, field_blas.cpp, free_surface.cpp, heat_equation.cpp, level_set.cpp, mesh_smoothing.cpp, navier_stokes.cpp, nonlinear_dynamics.cpp, reaction_diffusion.cpp, Remodeling.cpp, simple_contact_thermal.cpp, test_jacobian_of_simple_contact_element.cpp, and thermo_elastic.cpp.

Definition at line 21 of file FieldBlas.hpp.

Member Typedef Documentation

OneFieldFunctionOnEntities

using MoFEM::FieldBlas::OneFieldFunctionOnEntities = boost::function<MoFEMErrorCode( boost::shared_ptr<FieldEntity> field_entity_ptr)>

Definition at line 45 of file FieldBlas.hpp.

OneFieldFunctionOnValues

using MoFEM::FieldBlas::OneFieldFunctionOnValues = boost::function<double(const double field_val)>

function to set a field value

Definition at line 38 of file FieldBlas.hpp.

TwoFieldFunctionOnEntities

using MoFEM::FieldBlas::TwoFieldFunctionOnEntities = boost::function<MoFEMErrorCode( boost::shared_ptr<FieldEntity> y_field_entity_ptr, const boost::shared_ptr<FieldEntity> x_field_entity_ptr)>

Parameters

y_field_entity_ptr	pointer to second "y_field" field entities
x_field_entity_ptr	pointer to first "x_field" field entities

Definition at line 62 of file FieldBlas.hpp.

TwoFieldFunctionOnValues

using MoFEM::FieldBlas::TwoFieldFunctionOnValues = boost::function<double( const double y_field_value_reference, const double x_field_value)>

Parameters

y_field_value_reference	field "y_field" values
x_field_value

Definition at line 53 of file FieldBlas.hpp.

VertexCoordsFunction

using MoFEM::FieldBlas::VertexCoordsFunction = boost::function<MoFEMErrorCode(VectorAdaptor &&field_data, double *xcoord, double *ycoord, double *zcoord)>

Definition at line 282 of file FieldBlas.hpp.

Constructor & Destructor Documentation

FieldBlas()

MoFEM::FieldBlas::FieldBlas

(

const MoFEM::Core &

core

)

Definition at line 17 of file FieldBlas.cpp.

    : cOre(const_cast<MoFEM::Core &>(core)), dEbug(false) {}

~FieldBlas()

MoFEM::FieldBlas::~FieldBlas ( )

default

Member Function Documentation

fieldAxpy() [1/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldAxpy	(	const double	alpha,
		const std::string	field_name_x,
		const std::string	field_name_y,
		bool	error_if_missing,
		bool	create_if_missing
	)

Deprecated:

axpy fields

field_y = field_y + alpha*field_x

Parameters

alpha
field_name_x	name of field_x
field_name_y	name of field_y
error_if_missing	throw error if entity/dof exist in field_x but not on field_y
create_if_missing	creat dof in field_y from field_x if it is not database

Definition at line 280 of file FieldBlas.cpp.

                                                            {
  return fieldAxpy(alpha, field_name_x, field_name_y, error_if_missing);
}

fieldAxpy() [2/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldAxpy	(	const double	alpha,
		const std::string	field_name_x,
		const std::string	field_name_y,
		bool	error_if_missing = false,
		Range *	ents_ptr = nullptr
	)

axpy fields

field_y = field_y + alpha*field_x

Parameters

alpha
field_name_x	name of field_x
field_name_y	name of field_y
error_if_missing	throw error if entity/dof exist in field_x but not
ents_ptr	execute lambda function only on entities given by pointer on field_y

Definition at line 267 of file FieldBlas.cpp.

                                                                            {
  MoFEMFunctionBegin;
  auto axpy = [alpha](const double fy, const double fx) {
    return fy + alpha * fx;
  };
  CHKERR fieldLambdaOnValues(axpy, field_name_x, field_name_y, error_if_missing,
                             ents_ptr);
  MoFEMFunctionReturn(0);
}

fieldCopy() [1/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldCopy	(	const double	alpha,
		const std::string	field_name_x,
		const std::string	field_name_y,
		bool	error_if_missing,
		bool	create_if_missing
	)

Definition at line 299 of file FieldBlas.cpp.

                                                            {
  return fieldCopy(alpha, field_name_x, field_name_y, error_if_missing);
}

fieldCopy() [2/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldCopy	(	const double	alpha,
		const std::string	field_name_x,
		const std::string	field_name_y,
		bool	error_if_missing = false,
		Range *	ents_ptr = nullptr
	)

copy and scale fields

field_y = alpha*field_x

Parameters

alpha
field_name_x	name of field_x
field_name_y	name of field_y
error_if_missing	throw error if entity/dof exist in field_x but not
ents_ptr	execute lambda function only on entities given by pointer on field_y
create_if_missing	creat dof in field_y from field_x if it is not database

Definition at line 288 of file FieldBlas.cpp.

                                                                            {
  MoFEMFunctionBegin;
  auto copy = [alpha](const double fy, const double fx) { return alpha * fx; };
  CHKERR fieldLambdaOnValues(copy, field_name_x, field_name_y, error_if_missing,
                             ents_ptr);
  MoFEMFunctionReturn(0);
}

fieldLambda()

MoFEMErrorCode MoFEM::FieldBlas::fieldLambda	(	TwoFieldFunctionOnValues	lambda,
		const std::string	field_name_x,
		const std::string	field_name_y,
		bool	error_if_missing,
		bool	create_if_missing
	)

Deprecated:

This is with obsolete last option

Parameters

lambda
field_name_x
field_name_y
error_if_missing
create_if_missing

Returns

DEPRECATED

Definition at line 255 of file FieldBlas.cpp.

                                                              {
  if (create_if_missing)
    MOFEM_LOG("SELF", Sev::noisy)
        << "Option create_if_missing is set to true but have no effect";
  return fieldLambdaOnValues(lambda, field_name_x, field_name_y,
                             error_if_missing);
}

fieldLambdaOnEntities() [1/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldLambdaOnEntities	(	FieldBlas::OneFieldFunctionOnEntities	lambda,
		const std::string	field_name,
		Range *	ents_ptr = nullptr
	)

filed lambda

Do calculation on one field using lambda function with entity field input

auto field_abs = [&](
 boost::shared_ptr<FieldEntity> ent_ptr) {
   MoFEMFunctionBeginHot;
   auto field_data = ent_ptr->getEntFieldData();
   for (auto &v : field_data)
     v = std::abs(v);
   MoFEMFunctionReturnHot(0);
 };
 
CHKERR
m_field.getInterface<FieldBlas>()->fieldLambdaOnEntities(field_abs,
"U", block_ents_ptr);

Parameters

function	f(double &x, double)
field_name	name of field
ents_ptr	execute lambda function only on entities given by pointer to range

Definition at line 50 of file FieldBlas.cpp.

                                                  {
  const MoFEM::Interface &m_field = cOre;
  auto fields_ptr = m_field.get_fields();
  auto field_ents = m_field.get_field_ents();
  MoFEMFunctionBegin;
 
  auto fit = fields_ptr->get<FieldName_mi_tag>().find(field_name);
  if (fit == fields_ptr->get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "field < %s > not found, (top tip: check spelling)",
             field_name.c_str());
  }
 
  // End of iterator for y_field
  const auto bit_number = (*fit)->getBitNumber();
 
  auto loop_ents = [&](const EntityHandle f, const EntityHandle s) {
    MoFEMFunctionBeginHot;
 
    const auto lo_uid = FieldEntity::getLoLocalEntityBitNumber(bit_number, f);
    const auto hi_uid = FieldEntity::getHiLocalEntityBitNumber(bit_number, s);
 
    // Start of iterator for x_field
    auto eit = field_ents->get<Unique_mi_tag>().lower_bound(lo_uid);
    // End of iterator for x_field
    auto eit_hi = field_ents->get<Unique_mi_tag>().upper_bound(hi_uid);
 
    for (; eit != eit_hi; ++eit) {
      CHKERR lambda(*eit);
    }
 
    MoFEMFunctionReturnHot(0);
  };
 
  if (ents_ptr) {
    for (auto p = ents_ptr->const_pair_begin(); p != ents_ptr->const_pair_end();
         ++p) {
      CHKERR loop_ents(p->first, p->second);
    }
  } else {
    // we are looping from the very first possible entity handle (MBVERTEX) to
    // the very last (MBENTITYSET)
    CHKERR loop_ents(get_id_for_min_type<MBVERTEX>(),
                     get_id_for_max_type<MBENTITYSET>());
  }
 
  MoFEMFunctionReturn(0);
}

fieldLambdaOnEntities() [2/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldLambdaOnEntities	(	FieldBlas::TwoFieldFunctionOnEntities	lambda,
		const std::string	field_name_x,
		const std::string	field_name_y,
		bool	error_if_missing = false,
		Range *	ents_ptr = nullptr
	)

filed lambda

Do calculation on two fields and save result to field fy input function usees field entities

auto vector_times_scalar_field = [&](boost::shared_ptr<FieldEntity> ent_ptr_y,
   boost::shared_ptr<FieldEntity> ent_ptr_x) {
   MoFEMFunctionBeginHot;
   auto x_data = ent_ptr_x->getEntFieldData();
   auto y_data = ent_ptr_y->getEntFieldData();
   const auto size_x = x_data.size(); // scalar
   const auto size_y = y_data.size(); // vector
 
   for (size_t dd = 0; dd != size_y; ++dd)
     y_data[dd] *= x_data[0];
 
   MoFEMFunctionReturnHot(0);
 };
 
CHKERR
m_field.getInterface<FieldBlas>()->fieldLambdaOnValues(vector_times_scalar_field,
     "U", "P" false, block_ents_ptr);

Parameters

function	f(double &x, double)
field_name_x	name of field_x
field_name_y	name of field_y
error_if_missing	throw error if missing entities of field y
ents_ptr	execute lambda function only on entities given by pointer to range

Definition at line 158 of file FieldBlas.cpp.

                                                                         {
  const MoFEM::Interface &m_field = cOre;
  auto fields_ptr = m_field.get_fields();
  auto field_ents = m_field.get_field_ents();
  MoFEMFunctionBegin;
 
  auto x_fit = fields_ptr->get<FieldName_mi_tag>().find(field_name_x);
  if (x_fit == fields_ptr->get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "x field < %s > not found, (top tip: check spelling)",
             field_name_x.c_str());
  }
  auto y_fit = fields_ptr->get<FieldName_mi_tag>().find(field_name_y);
  if (y_fit == fields_ptr->get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "y field < %s > not found, (top tip: check spelling)",
             field_name_y.c_str());
  }
 
  // End of iterator for y_field
  const auto x_bit_number = (*x_fit)->getBitNumber();
  const auto y_bit_number = (*y_fit)->getBitNumber();
  const auto y_eit_hi = field_ents->get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId(y_bit_number));
 
  auto loop_ents = [&](const EntityHandle f, const EntityHandle s) {
    MoFEMFunctionBeginHot;
 
    const auto x_lo_uid =
        FieldEntity::getLoLocalEntityBitNumber(x_bit_number, f);
    const auto x_hi_uid =
        FieldEntity::getHiLocalEntityBitNumber(x_bit_number, s);
 
    // Start of iterator for x_field
    auto x_eit = field_ents->get<Unique_mi_tag>().lower_bound(x_lo_uid);
    // End of iterator for x_field
    auto x_eit_hi = field_ents->get<Unique_mi_tag>().upper_bound(x_hi_uid);
 
    for (; x_eit != x_eit_hi;) {
 
      const auto y_lo_uid = FieldEntity::getLocalUniqueIdCalculate(
          (*y_fit)->getBitNumber(), (*x_eit)->getEnt());
      auto y_eit = field_ents->get<Unique_mi_tag>().find(y_lo_uid);
 
      if (y_eit == field_ents->end()) {
 
        if (error_if_missing) {
          SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                  "Missing entity in y_field.");
        }
 
        ++x_eit;
 
      } else {
 
        auto check = [&]() {
          if (x_eit == x_eit_hi)
            return false;
          if (y_eit == y_eit_hi)
            return false;
          if ((*y_eit)->getEnt() != (*x_eit)->getEnt())
            return false;
          return true;
        };
 
        do {
 
          CHKERR lambda(*y_eit, *x_eit);
 
          ++x_eit;
          ++y_eit;
 
        } while (check());
      }
    }
 
    MoFEMFunctionReturnHot(0);
  };
 
  if (ents_ptr) {
    for (auto p = ents_ptr->const_pair_begin(); p != ents_ptr->const_pair_end();
         ++p) {
      CHKERR loop_ents(p->first, p->second);
    }
  } else {
    // we are looping from the very first possible entity handle (MBVERTEX) to
    // the very last (MBENTITYSET)
    CHKERR loop_ents(get_id_for_min_type<MBVERTEX>(),
                     get_id_for_max_type<MBENTITYSET>());
  }
 
  MoFEMFunctionReturn(0);
}

fieldLambdaOnValues() [1/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldLambdaOnValues	(	FieldBlas::OneFieldFunctionOnValues	lambda,
		const std::string	field_name,
		Range *	ents_ptr = nullptr
	)

filed lambda

Do calculation on one field using lambda function with field value input

auto scale_field = [&](const double val) {
  double time = ts_t; // global variable
  return val * time;
 };
CHKERR
m_field.getInterface<FieldBlas>()->fieldLambdaOnValues(scale_field,
"U", false, block_ents_ptr);

Parameters

function	f(const double)
field_name	name of field
ents_ptr	execute lambda function only on entities given by pointer to range

Definition at line 21 of file FieldBlas.cpp.

                                                                            {
  const MoFEM::Interface &m_field = cOre;
  auto fields_ptr = m_field.get_fields();
  MoFEMFunctionBegin;
 
  auto x_fit = fields_ptr->get<FieldName_mi_tag>().find(field_name);
  if (x_fit == fields_ptr->get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "field < %s > not found, (top tip: check spelling)",
             field_name.c_str());
  }
 
  auto wrap_lambda_on_enties =
      [lambda](boost::shared_ptr<FieldEntity> field_entity_ptr) {
        MoFEMFunctionBeginHot;
 
        auto field_data = field_entity_ptr->getEntFieldData();
        for (auto &v : field_data)
          v = lambda(v);
 
        MoFEMFunctionReturnHot(0);
      };
 
  CHKERR fieldLambdaOnEntities(wrap_lambda_on_enties, field_name, ents_ptr);
  MoFEMFunctionReturn(0);
};

fieldLambdaOnValues() [2/2]

MoFEMErrorCode MoFEM::FieldBlas::fieldLambdaOnValues	(	FieldBlas::TwoFieldFunctionOnValues	lambda,
		const std::string	field_name_x,
		const std::string	field_name_y,
		bool	error_if_missing = false,
		Range *	ents_ptr = nullptr
	)

filed lambda

Do calculation on two fields and save result to field fy input function usees field values

 auto field_axpy = [&](const double val_y,
   const double val_x) {
   // y = 2 * x + y
   return 2 * val_x + val_y;
 };
CHKERR
m_field.getInterface<FieldBlas>()->fieldLambdaOnValues(field_axpy,
"U", "P" false, block_ents_ptr);

Parameters

function	f(double &x, double)
field_name_x	name of field_x
field_name_y	name of field_y
error_if_missing	throw error if missing entities of field y
ents_ptr	execute lambda function only on entities given by pointer to range

Definition at line 101 of file FieldBlas.cpp.

                                                                          {
  const MoFEM::Interface &m_field = cOre;
  auto fields_ptr = m_field.get_fields();
  MoFEMFunctionBegin;
 
  auto x_fit = fields_ptr->get<FieldName_mi_tag>().find(field_name_x);
  if (x_fit == fields_ptr->get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "x field < %s > not found, (top tip: check spelling)",
             field_name_x.c_str());
  }
  auto y_fit = fields_ptr->get<FieldName_mi_tag>().find(field_name_y);
  if (y_fit == fields_ptr->get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "y field < %s > not found, (top tip: check spelling)",
             field_name_y.c_str());
  }
  if ((*x_fit)->getSpace() != (*y_fit)->getSpace()) {
    SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "space for field < %s > and field <%s> are not compatible for "
             "fieldblas",
             field_name_x.c_str(), field_name_y.c_str());
  }
  if ((*x_fit)->getNbOfCoeffs() != (*y_fit)->getNbOfCoeffs()) {
    SETERRQ2(
        PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
        "rank for field < %s > and field <%s> are not compatible for fieldblas",
        field_name_x.c_str(), field_name_y.c_str());
  }
 
  auto wrap_lambda_on_enties =
      [lambda](boost::shared_ptr<FieldEntity> y_field_entity_ptr,
               const boost::shared_ptr<FieldEntity> x_field_entity_ptr) {
        MoFEMFunctionBeginHot;
 
        auto x_field_data = x_field_entity_ptr->getEntFieldData();
        auto y_field_data = y_field_entity_ptr->getEntFieldData();
        const auto size_x = x_field_data.size();
        const auto size_y = y_field_data.size();
 
        size_t dd = 0;
        for (; dd != std::min(size_x, size_y); ++dd)
          y_field_data[dd] = lambda(y_field_data[dd], x_field_data[dd]);
        for (; dd < size_y; ++dd)
          y_field_data[dd] = 0;
 
        MoFEMFunctionReturnHot(0);
      };
 
  CHKERR fieldLambdaOnEntities(wrap_lambda_on_enties, field_name_x,
                               field_name_y, error_if_missing, ents_ptr);
  MoFEMFunctionReturn(0);
};

fieldScale()

MoFEMErrorCode MoFEM::FieldBlas::fieldScale	(	const double	alpha,
		const std::string	field_name,
		Range *	ents_ptr = nullptr
	)

field scale

Parameters

scale	field by value
field_name	name of field
error_if_missing	throw error if missing entities of field y
ents_ptr	execute lambda function only on entities given by pointer to range

Definition at line 307 of file FieldBlas.cpp.

                                                      {
  MoFEMFunctionBeginHot;
 
  auto scale = [alpha](const double v) { return v * alpha; };
  CHKERR fieldLambdaOnValues(scale, field_name, ents_ptr);
 
  MoFEMFunctionReturnHot(0);
}

query_interface()

MoFEMErrorCode MoFEM::FieldBlas::query_interface ( boost::typeindex::type_index  type_index, UnknownInterface **  iface  ) const

virtual

Implements MoFEM::UnknownInterface.

Definition at line 10 of file FieldBlas.cpp.

                                                           {
  MoFEMFunctionBeginHot;
  *iface = const_cast<FieldBlas *>(this);
  MoFEMFunctionReturnHot(0);
}

setField() [1/3]

MoFEMErrorCode MoFEM::FieldBlas::setField	(	const double	val,
		const EntityType	type,
		const Range &	ents,
		const std::string	field_name
	)

set field

field_y = val

Parameters

val
entity	type
field_name

Definition at line 407 of file FieldBlas.cpp.

                                                               {
  const MoFEM::Interface &m_field = cOre;
  auto dofs_ptr = m_field.get_dofs();
  MoFEMFunctionBeginHot;
 
  const auto bit_number = m_field.get_field_bit_number(field_name);
  const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_min_type(type));
  const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_max_type(type));
 
  auto dit = dofs_ptr->get<Unique_mi_tag>().lower_bound(lo_uid);
  auto hi_dit = dofs_ptr->get<Unique_mi_tag>().upper_bound(hi_uid);
 
  EntityHandle ent, last = 0;
  bool cont = true;
  for (; dit != hi_dit; dit++) {
    ent = (*dit)->getEnt();
    if (ent != last) {
      if (ents.find(ent) == ents.end()) {
        cont = true;
      } else {
        cont = false;
      }
      last = ent;
    }
    if (!cont)
      (*dit)->getFieldData() = val;
  }
  MoFEMFunctionReturnHot(0);
}

setField() [2/3]

MoFEMErrorCode MoFEM::FieldBlas::setField	(	const double	val,
		const EntityType	type,
		const std::string	field_name
	)

Deprecated:

scale field

Parameters

val	is a set parameter \field_name is a field name

Definition at line 386 of file FieldBlas.cpp.

                                                               {
  const MoFEM::Interface &m_field = cOre;
  auto dofs_ptr = m_field.get_dofs();
  MoFEMFunctionBeginHot;
 
  const auto bit_number = m_field.get_field_bit_number(field_name);
  const auto lo_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_min_type(type));
  const auto hi_uid = FieldEntity::getLocalUniqueIdCalculate(
      bit_number, get_id_for_max_type(type));
 
  auto dit = dofs_ptr->get<Unique_mi_tag>().lower_bound(lo_uid);
  auto hi_dit = dofs_ptr->get<Unique_mi_tag>().upper_bound(hi_uid);
 
  for (; dit != hi_dit; dit++)
    (*dit)->getFieldData() = val;
 
  MoFEMFunctionReturnHot(0);
}

setField() [3/3]

MoFEMErrorCode MoFEM::FieldBlas::setField	(	const double	val,
		const std::string	field_name
	)

set field

field_y = val

Parameters

val
field_name

Definition at line 441 of file FieldBlas.cpp.

                                                               {
  const MoFEM::Interface &m_field = cOre;
  auto fields_ptr = m_field.get_fields();
  auto dofs_ptr = m_field.get_dofs();
  MoFEMFunctionBegin;
  auto fit = fields_ptr->get<FieldName_mi_tag>().find(field_name);
  if (fit == fields_ptr->get<FieldName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             " field < %s > not found, (top tip: check spelling)",
             field_name.c_str());
  }
 
  auto dit = dofs_ptr->get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId((*fit)->getBitNumber()));
  auto hi_dit = dofs_ptr->get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId((*fit)->getBitNumber()));
  for (; dit != hi_dit; dit++) {
    (*dit)->getFieldData() = val;
  }
  MoFEMFunctionReturn(0);
}

setVertexDofs()

MoFEMErrorCode MoFEM::FieldBlas::setVertexDofs	(	FieldBlas::VertexCoordsFunction	lambda,
		const std::string	field_name,
		Range *	verts = nullptr
	)

Set DOFs on vertices using user function.

Example:

auto do_something = [&](VectorAdaptor &field_data, double *x,
                        double *y, double *z) {
  MoFEMFunctionBegin;
  field_data[0] = (*x);
  field_data[1] = (*y);
  field_data[2] = (*z);
  MoFEMFunctionReturn(0);
};
CHKERR m_field.getInterface<FieldBlas>()->setVertexDofs(set_distance,
"DISP"); 

Note

Function works both ways, using it coordinates can be set from field.

Parameters

lambda	function evaluating field at points
field_name	is a field name
verts	pointer to vertices if null all vertices in the field are evaluated)

Definition at line 318 of file FieldBlas.cpp.

                                                          {
  const MoFEM::Interface &m_field = cOre;
  MoFEMFunctionBegin;
 
  EntityHandle meshset = m_field.get_field_meshset(field_name);
  Range verts;
  CHKERR m_field.get_moab().get_entities_by_type(meshset, MBVERTEX, verts,
                                                 true);
  if (sub_verts)
    verts = intersect(*sub_verts, verts);
 
  struct LambdaMethod : EntityMethod {
    LambdaMethod(MoFEM::Interface &m_field, Range &verts,
                 FieldBlas::VertexCoordsFunction lambda)
        : EntityMethod(), mField(m_field), verts(verts), lambda(lambda),
          count(0), total(0) {}
    MoFEMErrorCode preProcess() {
      vit = verts.begin();
      return 0;
    }
    MoFEMErrorCode operator()() {
      MoFEMFunctionBegin;
      if (*vit != entPtr->getEnt())
        SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "Inconsistent entity %ld != %ld", *vit, entPtr->getEnt());
      if (!count)
        CHKERR mField.get_moab().coords_iterate(vit, verts.end(), xCoord,
                                                yCoord, zCoord, count);
      CHKERR lambda(entPtr->getEntFieldData(), xCoord, yCoord, zCoord);
      ++xCoord;
      ++yCoord;
      ++zCoord;
      ++vit;
      ++total;
      --count;
      MoFEMFunctionReturn(0);
    }
    MoFEMErrorCode postProcess() {
      MoFEMFunctionBegin;
      if (total != verts.size())
        SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                 "Inconsistent number of vertices in field meshset and in the "
                 "field %d != %d",
                 total, verts.size());
      MoFEMFunctionReturn(0);
    }
 
  private:
    MoFEM::Interface &mField;
    Range &verts;
    FieldBlas::VertexCoordsFunction lambda;
    int count;
    int total;
    Range::iterator vit;
    double *xCoord;
    double *yCoord;
    double *zCoord;
  };
 
  LambdaMethod lambda_method(const_cast<MoFEM::Interface &>(m_field), verts,
                             lambda);
  CHKERR const_cast<MoFEM::Interface &>(m_field).loop_entities(
      field_name, lambda_method, &verts, QUIET);
  MoFEMFunctionReturn(0);
}

Member Data Documentation

cOre

const MoFEM::Interface& MoFEM::FieldBlas::cOre

Definition at line 26 of file FieldBlas.hpp.

dEbug

bool MoFEM::FieldBlas::dEbug

Definition at line 27 of file FieldBlas.hpp.

---

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

• src/interfaces/FieldBlas.hpp
• src/interfaces/impl/FieldBlas.cpp