WriteGMV.cpp

Go to the documentation of this file.

/**
 * MOAB, a Mesh-Oriented datABase, is a software component for creating,
 * storing and accessing finite element mesh data.
 *
 * Copyright 2004 Sandia Corporation.  Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
 
#ifdef WIN32
#ifdef _DEBUG
// turn off warnings that say they debugging identifier has been truncated
// this warning comes up when using some STL containers
#pragma warning( disable : 4786 )
#endif
#endif
 
#include "WriteGMV.hpp"
 
#include "moab/Interface.hpp"
#include "Internals.hpp"
#include "moab/Range.hpp"
#include "moab/CN.hpp"
#include "MBTagConventions.hpp"
#include "moab/WriteUtilIface.hpp"
#include <fstream>
#include <cassert>
 
namespace moab
{
 
const char* WriteGMV::gmvTypeNames[] = { "", "line", "tri", "quad", "", "tet", "pyramid", "prism", "", "hex", "", "" };
 
WriterIface* WriteGMV::factory( Interface* iface )
{
    return new WriteGMV( iface );
}
 
WriteGMV::WriteGMV( Interface* impl ) : mbImpl( impl )
{
    assert( impl != NULL );
 
    impl->query_interface( mWriteIface );
 
    // initialize in case tag_get_handle fails below
    mMaterialSetTag   = 0;
    mDirichletSetTag  = 0;
    mNeumannSetTag    = 0;
    mHasMidNodesTag   = 0;
    mGeomDimensionTag = 0;
    mGlobalIdTag      = 0;
 
    //! get and cache predefined tag handles
    // initialize in case tag_get_handle fails below
    //! get and cache predefined tag handles
    int negone = -1;
    impl->tag_get_handle( MATERIAL_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mMaterialSetTag, MB_TAG_SPARSE | MB_TAG_CREAT,
                          &negone );
 
    impl->tag_get_handle( DIRICHLET_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mDirichletSetTag, MB_TAG_SPARSE | MB_TAG_CREAT,
                          &negone );
 
    impl->tag_get_handle( NEUMANN_SET_TAG_NAME, 1, MB_TYPE_INTEGER, mNeumannSetTag, MB_TAG_SPARSE | MB_TAG_CREAT,
                          &negone );
 
    mGlobalIdTag = impl->globalId_tag();
 
    int dum_val_array[] = { -1, -1, -1, -1 };
    impl->tag_get_handle( HAS_MID_NODES_TAG_NAME, 4, MB_TYPE_INTEGER, mHasMidNodesTag, MB_TAG_SPARSE | MB_TAG_CREAT,
                          dum_val_array );
}
 
WriteGMV::~WriteGMV()
{
    mbImpl->release_interface( mWriteIface );
}
 
ErrorCode WriteGMV::write_file( const char* file_name,
                                const EntityHandle output_set,
                                const int user_dimension,
                                const bool mesh,
                                const bool poly_mesh )
{
    // general function for writing a mesh
 
    ErrorCode result = MB_SUCCESS;
 
    // initialize file
 
    if( mesh )
    {
        result = local_write_mesh( file_name, output_set, user_dimension, true, false );
        if( MB_SUCCESS != result ) return result;
    }
 
    if( poly_mesh )
    {
        result = local_write_mesh( file_name, output_set, user_dimension, false, true );
        if( MB_SUCCESS != result ) return result;
    }
 
    return result;
}
 
ErrorCode WriteGMV::write_file( const char* filename,
                                const bool,
                                const FileOptions& /*opts*/,
                                const EntityHandle* output_sets,
                                const int num_output_sets,
                                const std::vector< std::string >&,
                                const Tag*,
                                int,
                                int dimension )
{
    EntityHandle output_set = 0;
    if( output_sets && num_output_sets > 0 )
    {
        if( num_output_sets > 1 ) return MB_FAILURE;
        output_set = output_sets[0];
    }
 
    if( dimension == 0 )
    {
        mbImpl->get_dimension( dimension );
    }
 
    return write_file( filename, output_set, dimension, true, true );
}
 
ErrorCode WriteGMV::local_write_mesh( const char* file_name,
                                      const EntityHandle output_set,
                                      const int user_dimension,
                                      const bool mesh,
                                      const bool poly_mesh )
{
    std::ofstream ofile;
    ErrorCode result;
 
    if( mesh )
    {
        // need to insert ".gmv"
        std::string tmp_name( file_name );
        tmp_name += ".gmv";
        ofile.open( tmp_name.c_str() );
    }
    else if( poly_mesh )
    {
        // need to insert ".poly.gmv"
        std::string tmp_name( file_name );
        tmp_name += ".poly.gmv";
        ofile.open( tmp_name.c_str() );
    }
 
    ofile << "gmvinput ascii" << std::endl;
 
    // get elements to be output
    Range dum_range, elements, all_verts;
    EntityType otype;
    if( poly_mesh )
    {
        result = mbImpl->get_entities_by_type( output_set, MBPOLYGON, elements, true );
        if( MB_SUCCESS != result ) return result;
    }
    else
    {
        for( otype = CN::TypeDimensionMap[user_dimension].first; otype <= CN::TypeDimensionMap[user_dimension].second;
             otype++ )
        {
            if( otype == MBPOLYGON || otype == MBPOLYHEDRON ) continue;
            dum_range.clear();
            result = mbImpl->get_entities_by_type( output_set, otype, dum_range, true );
            if( MB_SUCCESS != result ) return result;
 
            std::copy( dum_range.begin(), dum_range.end(), range_inserter( elements ) );
        }
    }
 
    // gather the vertices in these elements
    result = mbImpl->get_adjacencies( elements, 0, false, all_verts, Interface::UNION );
    if( MB_SUCCESS != result ) return result;
 
    int num_verts = all_verts.size();
 
    // allocate coordinate arrays and put pointers to them in a list
    double* xcoord = new double[num_verts];
    double* ycoord = new double[num_verts];
    double* zcoord = new double[num_verts];
    std::vector< double* > coord_arrays;
    coord_arrays.push_back( xcoord );
    coord_arrays.push_back( ycoord );
    coord_arrays.push_back( zcoord );
 
    // fill them in, writing id tags at the same time
    result = mWriteIface->get_node_coords( 3, num_verts, all_verts, mGlobalIdTag, 1, coord_arrays );
    if( MB_SUCCESS != result ) return result;
 
    int i, j;
 
    //========================================
    // WRITE COORDINATE DATA TO FILE HERE
 
    ofile << "nodev " << num_verts << std::endl;
    for( i = 0; i < num_verts; i++ )
        ofile << xcoord[i] << " " << ycoord[i] << " " << zcoord[i] << std::endl;
 
    //========================================
 
    delete[] xcoord;
    delete[] ycoord;
    delete[] zcoord;
 
    // iterate over types in selected dimension
 
    std::vector< int > connect;
    std::vector< EntityHandle > connecth;
 
    if( mesh )
    {
        Range sub_range;
 
        ofile << "cells " << elements.size() << std::endl;
 
        for( otype = CN::TypeDimensionMap[user_dimension].first; otype <= CN::TypeDimensionMap[user_dimension].second;
             otype++ )
        {
 
            if( otype == MBPOLYGON || otype == MBPOLYHEDRON ) continue;
 
            // get the first element of this type in the range, and one past the last
            Range::iterator lower =
                Range::lower_bound( elements.begin(), elements.end(), CREATE_HANDLE( otype, MB_START_ID, i ) );
            Range::iterator upper =
                Range::lower_bound( elements.begin(), elements.end(), CREATE_HANDLE( otype + 1, MB_START_ID, i ) );
 
            if( lower == upper ) continue;
 
            // copy these elements into a subrange
            sub_range.clear();
            std::copy( lower, upper, range_inserter( sub_range ) );
 
            // make sure the connectivity array is big enough
            int verts_per = CN::VerticesPerEntity( otype );
            if( connect.size() < verts_per * sub_range.size() ) connect.resize( verts_per * sub_range.size() );
 
            // get the connectivity
            result = mWriteIface->get_element_connect( sub_range.size(), verts_per, mGlobalIdTag, sub_range,
                                                       mGlobalIdTag, 1, &connect[0] );
            if( MB_SUCCESS != result ) return result;
 
            //========================================
            // WRITE CONNECTIVITY DATA TO FILE HERE
 
            for( i = 0; i < (int)sub_range.size(); i++ )
            {
                ofile << gmvTypeNames[otype] << " " << verts_per << std::endl;
                for( j = i * verts_per; j < (int)( i + 1 ) * verts_per; j++ )
                    ofile << connect[j] << " ";
                ofile << std::endl;
            }
 
            //========================================
        }
    }
 
    else if( poly_mesh )
    {
 
        // write polygons/hedra, if any
        Range polygons, polyhedra;
        result = mbImpl->get_entities_by_type( output_set, MBPOLYGON, polygons, true );
        if( MB_SUCCESS != result ) return result;
 
        result = mbImpl->get_entities_by_type( output_set, MBPOLYHEDRON, polyhedra, true );
        if( MB_SUCCESS != result ) return result;
 
        if( polygons.size() == 0 ) return result;
 
        // mark polyhedra with global ids
        result = mWriteIface->assign_ids( polyhedra, mGlobalIdTag, 1 );
        if( MB_SUCCESS != result ) return result;
 
        ofile << "faces " << polygons.size() << " " << polyhedra.size() << std::endl;
 
        for( Range::iterator rit = polygons.begin(); rit != polygons.end(); ++rit )
        {
            // get the vertices
            connecth.clear();
            result = mbImpl->get_connectivity( &( *rit ), 1, connecth, true );
            if( MB_SUCCESS != result ) return result;
 
            if( 0 == connecth.size() ) continue;
 
            // get the polyhedra, if any
            if( user_dimension == 3 )
            {
                polyhedra.clear();
                result = mbImpl->get_adjacencies( Range( *rit, *rit ), 3, false, polyhedra );
                if( MB_SUCCESS != result ) return result;
 
                // put them in the connect array
                connecth.push_back( ( polyhedra.size() > 0 ? *polyhedra.begin() : 0 ) );
                connecth.push_back( ( polyhedra.size() > 1 ? *polyhedra.rbegin() : 0 ) );
            }
 
            // replace handles with ids
            connect.resize( connecth.size() + 2 );
 
            // pre-set polyhedra ids in case there aren't any
            connect[connecth.size()]     = 0;
            connect[connecth.size() + 1] = 0;
            result =
                mbImpl->tag_get_data( mGlobalIdTag, &connecth[0], connecth.size() - 2 + polyhedra.size(), &connect[0] );
            if( MB_SUCCESS != result ) return result;
 
            // write the data
            ofile << connecth.size() - 2;
 
            for( i = 0; i < (int)connecth.size(); i++ )
                ofile << " " << connect[i];
 
            ofile << std::endl;
        }
    }
 
    ofile << std::endl << "endgmv" << std::endl;
 
    ofile.close();
 
    return MB_SUCCESS;
}
 
}  // namespace moab