$extrastylesheet
libMesh::ExodusII_IO_Helper::ElementMaps Class Reference

#include <exodusII_io_helper.h>

List of all members.

Public Member Functions

 ElementMaps ()
ExodusII_IO_Helper::Conversion assign_conversion (std::string type_str)
ExodusII_IO_Helper::Conversion assign_conversion (const ElemType type)

Static Public Attributes

static const int edge2_node_map [2] = {0, 1}
static const int edge3_node_map [3] = {0, 1, 2}
static const int edge_edge_map [2] = {0, 1}
static const int edge_inverse_edge_map [2] = {1, 2}
static const int quad4_node_map [4] = {0, 1, 2, 3}
static const int quad8_node_map [8] = {0, 1, 2, 3, 4, 5, 6, 7}
static const int quad9_node_map [9] = {0, 1, 2, 3, 4, 5, 6, 7, 8}
static const int tri3_node_map [3] = {0, 1, 2}
static const int tri6_node_map [6] = {0, 1, 2, 3, 4, 5}
static const int tri_edge_map [3] = {0, 1, 2}
static const int quad_edge_map [4] = {0, 1, 2, 3}
static const int tri_inverse_edge_map [3] = {1, 2, 3}
static const int quad_inverse_edge_map [4] = {1, 2, 3, 4}
static const int hex8_node_map [8] = {0, 1, 2, 3, 4, 5, 6, 7}
static const int hex20_node_map [20]
static const int hex27_node_map [27]
static const int hex27_inverse_node_map [27]
static const int tet4_node_map [4] = {0, 1, 2, 3}
static const int tet10_node_map [10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
static const int prism6_node_map [6] = {0, 1, 2, 3, 4, 5}
static const int prism15_node_map [15]
static const int prism18_node_map [18]
static const int pyramid5_node_map [5] = {0, 1, 2, 3, 4}
static const int pyramid13_node_map [13] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
static const int pyramid14_node_map [14] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}
static const int hex_face_map [6] = {1, 2, 3, 4, 0, 5}
static const int hex27_face_map [6] = {1, 2, 3, 4, 0, 5}
static const int tet_face_map [4] = {1, 2, 3, 0}
static const int prism_face_map [5] = {1, 2, 3, 0, 4}
static const int pyramid_face_map [5] = {-1,-1,-1,-1,-1}
static const int hex_inverse_face_map [6] = {5, 1, 2, 3, 4, 6}
static const int hex27_inverse_face_map [6] = {5, 1, 2, 3, 4, 6}
static const int tet_inverse_face_map [4] = {4, 1, 2, 3}
static const int prism_inverse_face_map [5] = {4, 1, 2, 3, 5}
static const int pyramid_inverse_face_map [5] = {-1,-1,-1,-1,-1}

Detailed Description

Definition at line 741 of file exodusII_io_helper.h.


Constructor & Destructor Documentation

Constructor.

Definition at line 748 of file exodusII_io_helper.h.

{}

Member Function Documentation

Returns:
a conversion object given an element type name.

Definition at line 1813 of file exodusII_io_helper.C.

References libMesh::EDGE2.

Referenced by libMesh::Nemesis_IO_Helper::build_element_and_node_maps(), libMesh::Nemesis_IO_Helper::compute_internal_and_border_elems_and_internal_nodes(), libMesh::Nemesis_IO::read(), libMesh::ExodusII_IO::read(), libMesh::ExodusII_IO_Helper::write_elements(), libMesh::Nemesis_IO_Helper::write_elements(), libMesh::ExodusII_IO_Helper::write_sidesets(), and libMesh::Nemesis_IO_Helper::write_sidesets().

{
  init_element_equivalence_map();

  // Do only upper-case comparisons
  std::transform(type_str.begin(), type_str.end(), type_str.begin(), ::toupper);

  std::map<std::string, ElemType>::iterator it =
    element_equivalence_map.find(type_str);

  if (it != element_equivalence_map.end())
    return assign_conversion( it->second );
  else
    libmesh_error_msg("ERROR! Unrecognized element type_str: " << type_str);

  libmesh_error_msg("We'll never get here!");
  return assign_conversion (EDGE2);
}
Returns:
a conversion object given an element type.

Definition at line 1834 of file exodusII_io_helper.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI3SUBDIVISION, and libMesh::TRI6.

{
  switch (type)
    {
    case EDGE2:
      {
        const Conversion conv(edge2_node_map,
                              ARRAY_LENGTH(edge2_node_map),
                              edge2_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(edge2_node_map),
                              edge_edge_map,
                              ARRAY_LENGTH(edge_edge_map),
                              edge_inverse_edge_map,
                              ARRAY_LENGTH(edge_inverse_edge_map),
                              EDGE2, "EDGE2");
        return conv;
      }
    case EDGE3:
      {
        const Conversion conv(edge3_node_map,
                              ARRAY_LENGTH(edge3_node_map),
                              edge3_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(edge3_node_map),
                              edge_edge_map,
                              ARRAY_LENGTH(edge_edge_map),
                              edge_inverse_edge_map,
                              ARRAY_LENGTH(edge_inverse_edge_map),
                              EDGE3, "EDGE3");
        return conv;
      }
    case QUAD4:
      {
        const Conversion conv(quad4_node_map,
                              ARRAY_LENGTH(quad4_node_map),
                              quad4_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(quad4_node_map),
                              quad_edge_map,
                              ARRAY_LENGTH(quad_edge_map),
                              quad_inverse_edge_map,
                              ARRAY_LENGTH(quad_inverse_edge_map),
                              QUAD4,
                              "QUAD4");
        return conv;
      }

    case QUAD8:
      {
        const Conversion conv(quad8_node_map,
                              ARRAY_LENGTH(quad8_node_map),
                              quad8_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(quad8_node_map),
                              quad_edge_map,
                              ARRAY_LENGTH(quad_edge_map),
                              quad_inverse_edge_map,
                              ARRAY_LENGTH(quad_inverse_edge_map),
                              QUAD8,
                              "QUAD8");
        return conv;
      }

    case QUAD9:
      {
        const Conversion conv(quad9_node_map,
                              ARRAY_LENGTH(quad9_node_map),
                              quad9_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(quad9_node_map),
                              quad_edge_map,
                              ARRAY_LENGTH(quad_edge_map),
                              quad_inverse_edge_map,
                              ARRAY_LENGTH(quad_inverse_edge_map),
                              QUAD9,
                              "QUAD9");
        return conv;
      }

    case TRI3:
      {
        const Conversion conv(tri3_node_map,
                              ARRAY_LENGTH(tri3_node_map),
                              tri3_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(tri3_node_map),
                              tri_edge_map,
                              ARRAY_LENGTH(tri_edge_map),
                              tri_inverse_edge_map,
                              ARRAY_LENGTH(tri_inverse_edge_map),
                              TRI3,
                              "TRI3");
        return conv;
      }

    case TRI3SUBDIVISION:
      {
        const Conversion conv(tri3_node_map,
                              ARRAY_LENGTH(tri3_node_map),
                              tri3_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(tri3_node_map),
                              tri_edge_map,
                              ARRAY_LENGTH(tri_edge_map),
                              tri_inverse_edge_map,
                              ARRAY_LENGTH(tri_inverse_edge_map),
                              TRI3SUBDIVISION,
                              "TRI3");
        return conv;
      }

    case TRI6:
      {
        const Conversion conv(tri6_node_map,
                              ARRAY_LENGTH(tri6_node_map),
                              tri6_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(tri6_node_map),
                              tri_edge_map,
                              ARRAY_LENGTH(tri_edge_map),
                              tri_inverse_edge_map,
                              ARRAY_LENGTH(tri_inverse_edge_map),
                              TRI6,
                              "TRI6");
        return conv;
      }

    case HEX8:
      {
        const Conversion conv(hex8_node_map,
                              ARRAY_LENGTH(hex8_node_map),
                              hex8_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(hex8_node_map),
                              hex_face_map,
                              ARRAY_LENGTH(hex_face_map),
                              hex_inverse_face_map,
                              ARRAY_LENGTH(hex_inverse_face_map),
                              HEX8,
                              "HEX8");
        return conv;
      }

    case HEX20:
      {
        const Conversion conv(hex20_node_map,
                              ARRAY_LENGTH(hex20_node_map),
                              hex20_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(hex20_node_map),
                              hex_face_map,
                              ARRAY_LENGTH(hex_face_map),
                              hex_inverse_face_map,
                              ARRAY_LENGTH(hex_inverse_face_map),
                              HEX20,
                              "HEX20");
        return conv;
      }

    case HEX27:
      {
        const Conversion conv(hex27_node_map,
                              ARRAY_LENGTH(hex27_node_map),
                              hex27_inverse_node_map, // different inverse node map for Hex27!
                              ARRAY_LENGTH(hex27_inverse_node_map),
                              hex27_face_map,
                              ARRAY_LENGTH(hex27_face_map),
                              hex27_inverse_face_map,
                              ARRAY_LENGTH(hex27_inverse_face_map),
                              HEX27,
                              "HEX27");
        return conv;
      }

    case TET4:
      {
        const Conversion conv(tet4_node_map,
                              ARRAY_LENGTH(tet4_node_map),
                              tet4_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(tet4_node_map),
                              tet_face_map,
                              ARRAY_LENGTH(tet_face_map),
                              tet_inverse_face_map,
                              ARRAY_LENGTH(tet_inverse_face_map),
                              TET4,
                              "TETRA4");
        return conv;
      }

    case TET10:
      {
        const Conversion conv(tet10_node_map,
                              ARRAY_LENGTH(tet10_node_map),
                              tet10_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(tet10_node_map),
                              tet_face_map,
                              ARRAY_LENGTH(tet_face_map),
                              tet_inverse_face_map,
                              ARRAY_LENGTH(tet_inverse_face_map),
                              TET10,
                              "TETRA10");
        return conv;
      }

    case PRISM6:
      {
        const Conversion conv(prism6_node_map,
                              ARRAY_LENGTH(prism6_node_map),
                              prism6_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(prism6_node_map),
                              prism_face_map,
                              ARRAY_LENGTH(prism_face_map),
                              prism_inverse_face_map,
                              ARRAY_LENGTH(prism_inverse_face_map),
                              PRISM6,
                              "WEDGE");
        return conv;
      }

    case PRISM15:
      {
        const Conversion conv(prism15_node_map,
                              ARRAY_LENGTH(prism15_node_map),
                              prism15_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(prism15_node_map),
                              prism_face_map,
                              ARRAY_LENGTH(prism_face_map),
                              prism_inverse_face_map,
                              ARRAY_LENGTH(prism_inverse_face_map),
                              PRISM15,
                              "WEDGE15");
        return conv;
      }

    case PRISM18:
      {
        const Conversion conv(prism18_node_map,
                              ARRAY_LENGTH(prism18_node_map),
                              prism18_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(prism18_node_map),
                              prism_face_map,
                              ARRAY_LENGTH(prism_face_map),
                              prism_inverse_face_map,
                              ARRAY_LENGTH(prism_inverse_face_map),
                              PRISM18,
                              "WEDGE18");
        return conv;
      }

    case PYRAMID5:
      {
        const Conversion conv(pyramid5_node_map,
                              ARRAY_LENGTH(pyramid5_node_map),
                              pyramid5_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(pyramid5_node_map),
                              pyramid_face_map,
                              ARRAY_LENGTH(pyramid_face_map),
                              pyramid_inverse_face_map,
                              ARRAY_LENGTH(pyramid_inverse_face_map),
                              PYRAMID5,
                              "PYRAMID5");
        return conv;
      }

    case PYRAMID13:
      {
        const Conversion conv(pyramid13_node_map,
                              ARRAY_LENGTH(pyramid13_node_map),
                              pyramid13_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(pyramid13_node_map),
                              pyramid_face_map,
                              ARRAY_LENGTH(pyramid_face_map),
                              pyramid_inverse_face_map,
                              ARRAY_LENGTH(pyramid_inverse_face_map),
                              PYRAMID13,
                              "PYRAMID13");
        return conv;
      }

    case PYRAMID14:
      {
        const Conversion conv(pyramid14_node_map,
                              ARRAY_LENGTH(pyramid14_node_map),
                              pyramid14_node_map, // inverse node map same as forward node map
                              ARRAY_LENGTH(pyramid14_node_map),
                              pyramid_face_map,
                              ARRAY_LENGTH(pyramid_face_map),
                              pyramid_inverse_face_map,
                              ARRAY_LENGTH(pyramid_inverse_face_map),
                              PYRAMID14,
                              "PYRAMID14");
        return conv;
      }

    default:
      libmesh_error_msg("Unsupported element type: " << type);
    }

  libmesh_error_msg("We'll never get here!");
  const Conversion conv(tri3_node_map,
                        ARRAY_LENGTH(tri3_node_map),
                        tri3_node_map, // inverse node map same as forward node map
                        ARRAY_LENGTH(tri3_node_map),
                        tri_edge_map,
                        ARRAY_LENGTH(tri_edge_map),
                        tri_inverse_edge_map,
                        ARRAY_LENGTH(tri_inverse_edge_map),
                        TRI3,
                        "TRI3");
  return conv;
}

Member Data Documentation

1D node maps. These define mappings from ExodusII-formatted element numberings. The Edge2 node map. Use this map for linear elements in 1D.

Definition at line 758 of file exodusII_io_helper.h.

The Edge3 node map. Use this map for quadratic elements in 1D.

Definition at line 763 of file exodusII_io_helper.h.

1D edge maps Maps the Exodus edge numbering for line elements. Useful for reading sideset information.

Definition at line 774 of file exodusII_io_helper.h.

Maps the Exodus edge numbering for line elements. Useful for writing sideset information.

Definition at line 780 of file exodusII_io_helper.h.

Initial value:
 { 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,
                                                                  10, 11, 12, 13, 14, 15, 16, 17, 18, 19}

The Hex20 node map. Use this map for serendipity hexahedral elements in 3D.

Definition at line 859 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::hex27_face_map = {1, 2, 3, 4, 0, 5} [static]

Maps the Exodus face numbering for 27-noded hexahedrals. Useful for reading sideset information.

Definition at line 934 of file exodusII_io_helper.h.

Maps the Exodus face numbering for 27-noded hexahedrals. Useful for writing sideset information.

Definition at line 964 of file exodusII_io_helper.h.

Initial value:
 {
  
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
  
  26, 20, 25, 24, 22, 21, 23}

The Hex27 inverse node map. Use this map for writing tri-quadratic hexahedral elements in 3D.

Definition at line 871 of file exodusII_io_helper.h.

Initial value:
 {
  
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
  
  21, 25, 24, 26, 23, 22, 20}

The Hex27 node map. Use this map for reading tri-quadratic hexahedral elements in 3D.

Definition at line 865 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::hex8_node_map = {0, 1, 2, 3, 4, 5, 6, 7} [static]

3D maps. These define mappings from ExodusII-formatted element numberings. The Hex8 node map. Use this map for bi-linear hexahedral elements in 3D.

Definition at line 853 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::hex_face_map = {1, 2, 3, 4, 0, 5} [static]

3D face maps. Maps the Exodus face numbering for general hexahedrals. Useful for reading sideset information.

Definition at line 928 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::hex_inverse_face_map = {5, 1, 2, 3, 4, 6} [static]

Maps the Exodus face numbering for general hexahedrals. Useful for writing sideset information.

Definition at line 958 of file exodusII_io_helper.h.

Initial value:
 {0, 1, 2, 3, 4, 5, 6,  7,  8,  9,
                                                                     10, 11, 12, 13, 14}

The Prism15 node map. Use this map for "serendipity" prisms in 3D.

Definition at line 894 of file exodusII_io_helper.h.

Initial value:
 {0, 1, 2, 3, 4, 5, 6,  7,  8,  9,
                                                                     10, 11, 12, 13, 14, 15, 16, 17}

The Prism18 node map.

Definition at line 899 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::prism6_node_map = {0, 1, 2, 3, 4, 5} [static]

The Prism6 node map.

Definition at line 888 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::prism_face_map = {1, 2, 3, 0, 4} [static]

Maps the Exodus face numbering for general prisms. Useful for reading sideset information.

Definition at line 946 of file exodusII_io_helper.h.

Maps the Exodus face numbering for general prisms. Useful for writing sideset information.

Definition at line 976 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::pyramid13_node_map = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12} [static]

The Pyramid13 node map. Use this map for "serendipity" pyramid elements in 3D.

Definition at line 911 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::pyramid14_node_map = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13} [static]

The Pyramid14 node map. Use this map for biquadratic pyramid elements in 3D.

Definition at line 917 of file exodusII_io_helper.h.

The Pyramid5 node map. Use this map for linear pyramid elements in 3D.

Definition at line 905 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::pyramid_face_map = {-1,-1,-1,-1,-1} [static]

Maps the Exodus face numbering for general pyramids. Useful for reading sideset information.

Definition at line 952 of file exodusII_io_helper.h.

Maps the Exodus face numbering for general pyramids. Useful for writing sideset information.

Definition at line 982 of file exodusII_io_helper.h.

2D node maps. These define mappings from ExodusII-formatted element numberings. The Quad4 node map. Use this map for bi-linear quadrilateral elements in 2D.

Definition at line 791 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::quad8_node_map = {0, 1, 2, 3, 4, 5, 6, 7} [static]

The Quad8 node map. Use this map for serendipity quadrilateral elements in 2D.

Definition at line 797 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::quad9_node_map = {0, 1, 2, 3, 4, 5, 6, 7, 8} [static]

The Quad9 node map. Use this map for bi-quadratic quadrilateral elements in 2D.

Definition at line 803 of file exodusII_io_helper.h.

Maps the Exodus edge numbering for quadrilaterals. Useful for reading sideset information.

Definition at line 830 of file exodusII_io_helper.h.

Maps the Exodus edge numbering for quadrilaterals. Useful for writing sideset information.

Definition at line 842 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::tet10_node_map = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} [static]

The Tet10 node map. Use this map for quadratic tetrahedral elements in 3D.

Definition at line 883 of file exodusII_io_helper.h.

The Tet4 node map. Use this map for linear tetrahedral elements in 3D.

Definition at line 877 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::tet_face_map = {1, 2, 3, 0} [static]

Maps the Exodus face numbering for general tetrahedrals. Useful for reading sideset information.

Definition at line 940 of file exodusII_io_helper.h.

Maps the Exodus face numbering for general tetrahedrals. Useful for writing sideset information.

Definition at line 970 of file exodusII_io_helper.h.

The Tri3 node map. Use this map for linear triangles in 2D.

Definition at line 808 of file exodusII_io_helper.h.

const int libMesh::ExodusII_IO_Helper::ElementMaps::tri6_node_map = {0, 1, 2, 3, 4, 5} [static]

The Tri6 node map. Use this map for quadratic triangular elements in 2D.

Definition at line 814 of file exodusII_io_helper.h.

2D edge maps Maps the Exodus edge numbering for triangles. Useful for reading sideset information.

Definition at line 824 of file exodusII_io_helper.h.

Maps the Exodus edge numbering for triangles. Useful for writing sideset information.

Definition at line 836 of file exodusII_io_helper.h.


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