MOAB: Mesh Oriented datABase  (version 5.3.0)
mbex3.cpp File Reference

beginner tutorial, example 3: Demonstrates constructing/saving a simple 2x2x2 hex mesh using the structured mesh interface More...

#include "moab/Core.hpp"
#include "moab/ScdInterface.hpp"
#include <iostream>
+ Include dependency graph for mbex3.cpp:

Go to the source code of this file.

Functions

int main ()

Detailed Description

beginner tutorial, example 3: Demonstrates constructing/saving a simple 2x2x2 hex mesh using the structured mesh interface

Author:
Milad Fatenejad

In this example, we create a 2x2x2 mesh that is identical to the previous example. However, in this case we will use the structured mesh interface since the mesh we created is logically structured. There are many advantages to using the structured mesh interface...such as memory savings, speed, ease-of-use...

In the previous example, we had to create 27 vertexes manually, define the connectivity, then manually create 8 hexahedrons. With the structured mesh interface, we just have to create the 27 vertexes then tell MOAB that these define a 2x2x2 structured mesh and everything else is taken care of for us!

Definition in file mbex3.cpp.


Function Documentation

int main ( )

Definition at line 35 of file mbex3.cpp.

References moab::ScdInterface::construct_box(), ErrorCode, moab::ScdBox::get_element(), moab::ScdBox::get_vertex(), MB_CHK_SET_ERR, mbint, moab::Interface::query_interface(), vertex_coords(), and moab::Core::write_file().

{
    moab::ErrorCode rval;
    moab::Core mbint;

    // **********************************
    // *   Create the Structured Mesh   *
    // **********************************

    // As before, we have to create an array defining the coordinate of
    // each vertex:
    const unsigned NUMVTX                  = 27;
    const double vertex_coords[3 * NUMVTX] = {
        0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 1, 0, 1, 1, 0, 2, 1, 0, 0, 2, 0, 1, 2, 0, 2, 2, 0,

        0, 0, 1, 1, 0, 1, 2, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 1, 0, 2, 1, 1, 2, 1, 2, 2, 1,

        0, 0, 2, 1, 0, 2, 2, 0, 2, 0, 1, 2, 1, 1, 2, 2, 1, 2, 0, 2, 2, 1, 2, 2, 2, 2, 2
    };

    // moab::ScdInterface is the structured mesh interface class for
    // MOAB.
    moab::ScdInterface* scdint;

    // The query_interface method will create a structured mesh instance
    // for mbcore and will point scdint to it. This is how you tell moab
    // that our moab::Core instance is going to represent a structured
    // mesh.
    rval = mbint.query_interface( scdint );MB_CHK_SET_ERR( rval, "mbint.query_interface failed" );

    // Structured meshes a divided into "boxes". Each box represents a
    // little structured mesh. A single mesh, for example a
    // block-structured mesh, can contain many individual boxes. In this
    // example, we want to create a single, 2x2x2 box. The construct_box
    // method will do this for us.
    moab::ScdBox* scdbox = NULL;
    rval = scdint->construct_box( moab::HomCoord( 0, 0, 0 ), moab::HomCoord( 2, 2, 2 ), vertex_coords, NUMVTX, scdbox );MB_CHK_SET_ERR( rval, "scdint->construct_box failed" );

    // moab::HomCoord is a little class that is used to represent a
    // coordinate in logical space. Above, we told MOAB that we want
    // indexes which extend from 0,0,0 to 2,2,2 for vertexes. Since the
    // i,j,k start/end indexes are all different, MOAB knows that our
    // mesh consists of hexes. If we had gone from 0,0,0 to 1,1,0 then
    // MOAB would construct a 2x2x1 mesh of quadrilaterals.

    // ***************
    // *   Inspect   *
    // ***************

    // Our mesh now exists and contains a single box! Lets loop over
    // that box and manually print out the handle of each vertex/hex:
    unsigned i, j, k;

    // Print out the entity handle associated with each hex:
    for( i = 0; i < 2; ++i )
        for( j = 0; j < 2; ++j )
            for( k = 0; k < 2; ++k )
            {
                std::cout << "Hex (" << i << "," << j << "," << k << ") "
                          << "has handle: " << scdbox->get_element( i, j, k ) << std::endl;
            }

    // Print out the entity handle associated with each vertex:
    for( i = 0; i < 3; ++i )
        for( j = 0; j < 3; ++j )
            for( k = 0; k < 3; ++k )
            {
                std::cout << "Vertex (" << i << "," << j << "," << k << ") "
                          << "has handle: " << scdbox->get_vertex( i, j, k ) << std::endl;
            }

    // Of course, you can still use all of the functionality defined in
    // mbint to get coordinates, connectivity, etc...

    // ***************************
    // *   Write Mesh to Files   *
    // ***************************
    rval = mbint.write_file( "mbex3.vtk" );MB_CHK_SET_ERR( rval, "write_file(mbex3.vtk) failed" );

    return 0;
}
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines