MoFEM::PrismsFromSurfaceInterface Struct Reference

merge node from two bit levels More...

#include <src/interfaces/PrismsFromSurfaceInterface.hpp>

Inheritance diagram for MoFEM::PrismsFromSurfaceInterface:

Collaboration diagram for MoFEM::PrismsFromSurfaceInterface:

Public Types
enum	SwapType { NO_SWAP = 0, SWAP_TRI_NODE_ORDER = 1, SWAP_TOP_AND_BOT_TRI = 2 }
	List of types of node swapping performed on a created prism Node swapping is required to satisfy the canonical ordering for the prism in case the surface normal is pointing inwards rather than outwards Currently supported options (assuming canonical ordering of nodes 0-5): NO_SWAP : node swapping is not performed SWAP_TRI_NODE_ORDER : swap the order of nodes on prism's triangle faces (1 <-> 2, 4 <-> 5) SWAP_TOP_AND_BOT_TRI : swap nodes between the top and the bottom triangles (0 <-> 3, 1 <-> 4, 2 <-> 5) More...

Public Member Functions
MoFEMErrorCode	query_interface (boost::typeindex::type_index type_index, UnknownInterface **iface) const
	PrismsFromSurfaceInterface (const MoFEM::Core &core)
MoFEMErrorCode	createPrisms (const Range &ents, const SwapType swap_type, Range &prisms, int verb=-1)
	Make prisms from triangles. More...
DEPRECATED MoFEMErrorCode	createPrisms (const Range &ents, Range &prisms, int verb=-1)
MoFEMErrorCode	seedPrismsEntities (Range &prisms, const BitRefLevel &bit, int verb=-1)
	Seed prism entities by bit level. More...
MoFEMErrorCode	createPrismsFromPrisms (const Range &prisms, bool from_down, Range &out_prisms, int verb=-1)
	Make prisms by extruding top or bottom prisms. More...
MoFEMErrorCode	setThickness (const Range &prisms, const double director3[], const double director4[])
MoFEMErrorCode	setNormalThickness (const Range &prisms, double thickness3, double thickness4)
MoFEMErrorCode	updateMeshestByEdgeBlock (const Range &prisms)
	Add quads to bockset. More...
MoFEMErrorCode	updateMeshestByTriBlock (const Range &prisms)
	Add prism to bockset. 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
MoFEM::Core &	cOre
std::map< EntityHandle, EntityHandle >	createdVertices

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

merge node from two bit levels

Examples

prism_elements_from_surface.cpp, and prism_polynomial_approximation.cpp.

Definition at line 15 of file PrismsFromSurfaceInterface.hpp.

Member Enumeration Documentation

SwapType

enum MoFEM::PrismsFromSurfaceInterface::SwapType

List of types of node swapping performed on a created prism Node swapping is required to satisfy the canonical ordering for the prism in case the surface normal is pointing inwards rather than outwards Currently supported options (assuming canonical ordering of nodes 0-5): NO_SWAP : node swapping is not performed SWAP_TRI_NODE_ORDER : swap the order of nodes on prism's triangle faces (1 <-> 2, 4 <-> 5) SWAP_TOP_AND_BOT_TRI : swap nodes between the top and the bottom triangles (0 <-> 3, 1 <-> 4, 2 <-> 5)

Enumerator
NO_SWAP
SWAP_TRI_NODE_ORDER
SWAP_TOP_AND_BOT_TRI

Definition at line 37 of file PrismsFromSurfaceInterface.hpp.

                {
    NO_SWAP = 0,
    SWAP_TRI_NODE_ORDER = 1,
    SWAP_TOP_AND_BOT_TRI = 2
  };

Constructor & Destructor Documentation

PrismsFromSurfaceInterface()

MoFEM::PrismsFromSurfaceInterface::PrismsFromSurfaceInterface ( const MoFEM::Core &  core )

inline

Definition at line 21 of file PrismsFromSurfaceInterface.hpp.

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

Member Function Documentation

createPrisms() [1/2]

MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::createPrisms	(	const Range &	ents,
		const SwapType	swap_type,
		Range &	prisms,
		int	verb = -1
	)

Make prisms from triangles.

Parameters

ents	Range of triangles
swap_type	Defines how the nodes of the created prism are swapped (required for canonical ordering if the surface normal is pointing inwards)
prisms	Returned range of prisms
verb	Verbosity level

Returns

Error code

Examples

prism_elements_from_surface.cpp.

Definition at line 22 of file PrismsFromSurfaceInterface.cpp.

                                                                          {
  MoFEMFunctionBegin;
  Interface &m_field = cOre;
  Range tris = ents.subset_by_type(MBTRI);
  for (Range::iterator tit = tris.begin(); tit != tris.end(); tit++) {
    const EntityHandle *conn;
    int number_nodes = 0;
    CHKERR m_field.get_moab().get_connectivity(*tit, conn, number_nodes, false);
    double coords[3 * number_nodes];
    CHKERR m_field.get_moab().get_coords(conn, number_nodes, coords);
    EntityHandle prism_nodes[6];
    for (int nn = 0; nn < 3; nn++) {
      prism_nodes[nn] = conn[nn];
      if (createdVertices.find(conn[nn]) != createdVertices.end()) {
        prism_nodes[3 + nn] = createdVertices[prism_nodes[nn]];
      } else {
        CHKERR m_field.get_moab().create_vertex(&coords[3 * nn],
                                                prism_nodes[3 + nn]);
        createdVertices[conn[nn]] = prism_nodes[3 + nn];
        CHKERR m_field.get_moab().tag_set_data(cOre.get_th_RefParentHandle(),
                                               &prism_nodes[3 + nn], 1,
                                               &prism_nodes[nn]);
      }
    }
    switch (swap_type) {
    case SWAP_TRI_NODE_ORDER:
      std::swap(prism_nodes[1], prism_nodes[2]);
      std::swap(prism_nodes[4], prism_nodes[5]);
      break;
    case SWAP_TOP_AND_BOT_TRI:
      std::swap(prism_nodes[0], prism_nodes[3]);
      std::swap(prism_nodes[1], prism_nodes[4]);
      std::swap(prism_nodes[2], prism_nodes[5]);
      break;
    case NO_SWAP:
    default:
      break;
    }
    EntityHandle prism;
    CHKERR m_field.get_moab().create_element(MBPRISM, prism_nodes, 6, prism);
    Range edges;
    CHKERR m_field.get_moab().get_adjacencies(&prism, 1, 1, true, edges,
                                              moab::Interface::UNION);
    Range faces;
    CHKERR m_field.get_moab().get_adjacencies(&prism, 1, 2, true, faces,
                                              moab::Interface::UNION);
    prisms.insert(prism);
    for (int ee = 0; ee <= 2; ee++) {
      EntityHandle e1;
      CHKERR m_field.get_moab().side_element(prism, 1, ee, e1);
      EntityHandle e2;
      CHKERR m_field.get_moab().side_element(prism, 1, ee + 6, e2);
      CHKERR m_field.get_moab().tag_set_data(cOre.get_th_RefParentHandle(), &e2,
                                             1, &e1);
    }
    EntityHandle f3, f4;
    {
      CHKERR m_field.get_moab().side_element(prism, 2, 3, f3);
      CHKERR m_field.get_moab().side_element(prism, 2, 4, f4);
      CHKERR m_field.get_moab().tag_set_data(cOre.get_th_RefParentHandle(), &f4,
                                             1, &f3);
    }
    if (number_nodes > 3) {
      EntityHandle meshset;
      CHKERR m_field.get_moab().create_meshset(MESHSET_SET, meshset);
      CHKERR m_field.get_moab().add_entities(meshset, &f4, 1);
      for (int ee = 0; ee <= 2; ee++) {
        EntityHandle e2;
        CHKERR m_field.get_moab().side_element(prism, 1, ee + 6, e2);
        CHKERR m_field.get_moab().add_entities(meshset, &e2, 1);
      }
      CHKERR m_field.get_moab().convert_entities(meshset, true, false, false);
      CHKERR m_field.get_moab().delete_entities(&meshset, 1);
      const EntityHandle *conn_f4;
      int number_nodes_f4 = 0;
      CHKERR m_field.get_moab().get_connectivity(f4, conn_f4, number_nodes_f4,
                                                 false);
      if (number_nodes_f4 != number_nodes) {
        SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
                "data inconsistency");
      }
      CHKERR m_field.get_moab().set_coords(&conn_f4[3], 3, &coords[9]);
    }
  }
  MoFEMFunctionReturn(0);
}

createPrisms() [2/2]

DEPRECATED MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::createPrisms	(	const Range &	ents,
		Range &	prisms,
		int	verb = -1
	)

Deprecated:

Use the function with the same name and a parameter swap_type, permitting to swap the order of each triangle's nodes or alternatively swap nodes between top and bottom triangles, which is required for the canonical ordering if surface normal is pointing inwards

Definition at line 15 of file PrismsFromSurfaceInterface.cpp.

                                                {
  MoFEMFunctionBegin;
  CHKERR createPrisms(ents, NO_SWAP, prisms, verb);
  MoFEMFunctionReturn(0);
}

createPrismsFromPrisms()

MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::createPrismsFromPrisms	(	const Range &	prisms,
		bool	from_down,
		Range &	out_prisms,
		int	verb = -1
	)

Make prisms by extruding top or bottom prisms.

Parameters

prisms	Input prisms
from_down	Use top or down face, if true from f3
out_prisms	Returned prisms entities
verb	Verbosity level

Returns

Error code

Examples

prism_elements_from_surface.cpp.

Definition at line 143 of file PrismsFromSurfaceInterface.cpp.

                                                                      {
  MoFEMFunctionBegin;
  Interface &m_field = cOre;
  Range tris;
  for (Range::iterator pit = prisms.begin(); pit != prisms.end(); pit++) {
    EntityHandle face;
    if (from_down) {
      CHKERR m_field.get_moab().side_element(*pit, 2, 3, face);
    } else {
      CHKERR m_field.get_moab().side_element(*pit, 2, 4, face);
    }
    tris.insert(face);
  }
  CHKERR createPrisms(tris, NO_SWAP, out_prisms, verb);
  MoFEMFunctionReturn(0);
}

query_interface()

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

virtual

Implements MoFEM::UnknownInterface.

Definition at line 9 of file PrismsFromSurfaceInterface.cpp.

                                                                         {
  *iface = const_cast<PrismsFromSurfaceInterface *>(this);
  return 0;
}

seedPrismsEntities()

MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::seedPrismsEntities	(	Range &	prisms,
		const BitRefLevel &	bit,
		int	verb = -1
	)

Seed prism entities by bit level.

Parameters

prisms	Range of entities
bit	BitRefLevel
verb	Verbosity level

Returns

Error code

Examples

prism_elements_from_surface.cpp, and prism_polynomial_approximation.cpp.

Definition at line 110 of file PrismsFromSurfaceInterface.cpp.

                                                     {
  Interface &m_field = cOre;
  auto ref_ents_ptr = m_field.get_ref_ents();
  MoFEMFunctionBegin;
  MPI_Comm comm = m_field.get_comm();
  RefEntity_multiIndex *refined_entities_ptr;
  refined_entities_ptr =
      const_cast<RefEntity_multiIndex *>(ref_ents_ptr);
  if (!prisms.empty()) {
    int dim = m_field.get_moab().dimension_from_handle(prisms[0]);
    for (int dd = 0; dd <= dim; dd++) {
      Range ents;
      CHKERR m_field.get_moab().get_adjacencies(prisms, dd, true, ents,
                                                moab::Interface::UNION);
      Range::iterator eit = ents.begin();
      for (; eit != ents.end(); eit++) {
        std::pair<RefEntity_multiIndex::iterator, bool> p_ent =
            refined_entities_ptr->insert(boost::shared_ptr<RefEntity>(
                new RefEntity(m_field.get_basic_entity_data_ptr(), *eit)));
        *(const_cast<RefEntity *>(p_ent.first->get())->getBitRefLevelPtr()) |=
            bit;
        if (verb >= VERY_VERBOSE) {
          std::ostringstream ss;
          ss << *(p_ent.first);
          PetscSynchronizedPrintf(comm, "%s\n", ss.str().c_str());
        }
      }
    }
  }
  MoFEMFunctionReturn(0);
}

setNormalThickness()

MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::setNormalThickness	(	const Range &	prisms,
		double	thickness3,
		double	thickness4
	)

Set normal thickness

Parameters

prisms	Range of prisms
thickness	normal thickness

Returns

Definition at line 195 of file PrismsFromSurfaceInterface.cpp.

                                                               {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
 
  auto add_normal = [&](std::map<EntityHandle, std::array<double, 3>> &nodes,
                        EntityHandle face) {
    MoFEMFunctionBeginHot;
    const EntityHandle *conn;
    int number_nodes;
    CHKERR m_field.get_moab().get_connectivity(face, conn, number_nodes, false);
    std::array<double, 9> coords;
    CHKERR m_field.get_moab().get_coords(conn, number_nodes, coords.data());
    std::array<double, 3> normal;
    CHKERR Tools::getTriNormal(coords.data(), normal.data());
    double a = sqrt(normal[0] * normal[0] + normal[1] * normal[1] +
                    normal[2] * normal[2]);
    for (auto d : {0, 1, 2})
      normal[d] /= a;
    for (auto n : {0, 1, 2}) {
      try {
        for (auto d : {0, 1, 2})
          nodes.at(conn[n])[d] += normal[d];
      } catch (...) {
        nodes.insert(
            std::pair<EntityHandle, std::array<double, 3>>(conn[n], normal));
      }
    }
    MoFEMFunctionReturnHot(0);
  };
 
  auto apply_map = [&](auto &nodes, double t) {
    MoFEMFunctionBeginHot;
    for (auto &m : nodes) {
      std::array<double, 3> coords;
      CHKERR m_field.get_moab().get_coords(&m.first, 1, coords.data());
      auto &normal = m.second;
      double a = sqrt(normal[0] * normal[0] + normal[1] * normal[1] +
                      normal[2] * normal[2]);
      for (auto d : {0, 1, 2})
        coords[d] += (normal[d] / a) * t;
      CHKERR m_field.get_moab().set_coords(&m.first, 1, coords.data());
    }
    MoFEMFunctionReturnHot(0);
  };
 
  map<EntityHandle, std::array<double, 3>> nodes_f3, nodes_f4;
  for (Range::iterator pit = prisms.begin(); pit != prisms.end(); pit++) {
    for (int ff = 3; ff <= 4; ff++) {
      EntityHandle face;
      CHKERR m_field.get_moab().side_element(*pit, 2, ff, face);
      if (ff == 3)
        CHKERR add_normal(nodes_f3, face);
      else
        CHKERR add_normal(nodes_f4, face);
    }
  }
 
  CHKERR apply_map(nodes_f3, thickness3);
  CHKERR apply_map(nodes_f4, thickness4);
 
  MoFEMFunctionReturn(0);
}

setThickness()

MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::setThickness	(	const Range &	prisms,
		const double	director3[],
		const double	director4[]
	)

Set uniform thickness

Parameters

prisms	Range of prisms
director3	Displacement of face 3
director4	Displacement of face 4

Returns

Examples

prism_elements_from_surface.cpp.

Definition at line 161 of file PrismsFromSurfaceInterface.cpp.

                                                                             {
  MoFEMFunctionBegin;
  Interface &m_field = cOre;
  Range nodes_f3, nodes_f4;
  for (Range::iterator pit = prisms.begin(); pit != prisms.end(); pit++) {
    for (int ff = 3; ff <= 4; ff++) {
      EntityHandle face;
      CHKERR m_field.get_moab().side_element(*pit, 2, ff, face);
      const EntityHandle *conn;
      int number_nodes = 0;
      CHKERR m_field.get_moab().get_connectivity(face, conn, number_nodes,
                                                 false);
      if (ff == 3) {
        nodes_f3.insert(&conn[0], &conn[number_nodes]);
      } else {
        nodes_f4.insert(&conn[0], &conn[number_nodes]);
      }
    }
  }
  double coords[3];
  for (Range::iterator nit = nodes_f3.begin(); nit != nodes_f3.end(); nit++) {
    CHKERR m_field.get_moab().get_coords(&*nit, 1, coords);
    cblas_daxpy(3, 1, director3, 1, coords, 1);
    CHKERR m_field.get_moab().set_coords(&*nit, 1, coords);
  }
  for (Range::iterator nit = nodes_f4.begin(); nit != nodes_f4.end(); nit++) {
    CHKERR m_field.get_moab().get_coords(&*nit, 1, coords);
    cblas_daxpy(3, 1, director4, 1, coords, 1);
    CHKERR m_field.get_moab().set_coords(&*nit, 1, coords);
  }
  MoFEMFunctionReturn(0);
}

updateMeshestByEdgeBlock()

MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::updateMeshestByEdgeBlock

(

const Range &

prisms

)

Add quads to bockset.

If quad is adjacent to extruded edge, is added to given blockset

Parameters

prisms

Returns

MoFEMErrorCode

Definition at line 260 of file PrismsFromSurfaceInterface.cpp.

                                                                        {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  Range prisms_edges;
  CHKERR m_field.get_moab().get_adjacencies(prisms, 1, true, prisms_edges,
                                            moab::Interface::UNION);
  Range prisms_faces;
  CHKERR m_field.get_moab().get_adjacencies(prisms, 2, true, prisms_faces,
                                            moab::Interface::UNION);
  for (_IT_CUBITMESHSETS_FOR_LOOP_(m_field, it)) {
    Range edges;
    CHKERR m_field.get_moab().get_entities_by_type(it->meshset, MBEDGE, edges,
                                                   true);
    edges = intersect(edges, prisms_edges);
    if (!edges.empty()) {
      Range edges_faces;
      CHKERR m_field.get_moab().get_adjacencies(edges, 2, false, edges_faces,
                                                moab::Interface::UNION);
      edges_faces = intersect(edges_faces, prisms_faces.subset_by_type(MBQUAD));
      EntityHandle meshset = it->getMeshset();
      CHKERR m_field.get_moab().add_entities(meshset, edges_faces);
    }
  }
  MoFEMFunctionReturn(0);
}

updateMeshestByTriBlock()

MoFEMErrorCode MoFEM::PrismsFromSurfaceInterface::updateMeshestByTriBlock

(

const Range &

prisms

)

Add prism to bockset.

If prism is adjacent to extruded triangle, is added to given blockset

Parameters

prisms

Returns

MoFEMErrorCode

Definition at line 287 of file PrismsFromSurfaceInterface.cpp.

                                                                       {
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  Range prisms_tris;
  CHKERR m_field.get_moab().get_adjacencies(prisms, 2, true, prisms_tris,
                                            moab::Interface::UNION);
  prisms_tris = prisms_tris.subset_by_type(MBTRI);
  for (_IT_CUBITMESHSETS_FOR_LOOP_(m_field, it)) {
    Range tris;
    CHKERR m_field.get_moab().get_entities_by_type(it->meshset, MBTRI, tris,
                                                   true);
    tris = intersect(tris, prisms_tris);
    if (!tris.empty()) {
      Range tris_ents;
      CHKERR m_field.get_moab().get_adjacencies(tris, 3, false, tris_ents,
                                                moab::Interface::UNION);
      tris_ents = intersect(tris_ents, prisms);
      EntityHandle meshset = it->getMeshset();
      CHKERR m_field.get_moab().add_entities(meshset, tris_ents);
    }
  }
  MoFEMFunctionReturn(0);
}

Member Data Documentation

cOre

MoFEM::Core& MoFEM::PrismsFromSurfaceInterface::cOre

Definition at line 20 of file PrismsFromSurfaceInterface.hpp.

createdVertices

std::map<EntityHandle, EntityHandle> MoFEM::PrismsFromSurfaceInterface::createdVertices

Examples

prism_elements_from_surface.cpp.

Definition at line 24 of file PrismsFromSurfaceInterface.hpp.

---

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

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