hdf2plt.C File Reference

#include <cstdlib>
#include <cassert>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <cstring>
#include "roccom.h"

Include dependency graph for hdf2plt.C:

Go to the source code of this file.

Classes
struct	AttrInfo
struct	ConnInfo
struct	Patch
struct	Block
struct	SGStr
struct	globarg
	Holds some global program arguments. More...

Namespaces
	HDF2PLT

Macros
#define	SwitchOnDataType(dType, funcCall)

Functions
int	getBlockNumber (const int zonenumber, const int NBlocks)
	Gets the block number by parsing the leading significant digits. More...
void	resolveConnectivity ()
void	readBlock (std::ifstream &ifs)
void	readTopFile (const std::string file)
template<typename TT >
void	PrintStructured (const TT *pData, const int ndims, const int *dims_nodes, int ghost, char loc, std::ostream &out)
template<typename TT >
void	PrintUnstructured (const TT *pData, int size, bool panel, std::ostream &out)
void	PrintConn (const int *pConn, const ConnInfo &ci, char type, std::ostream &out)
void	COM_print_window (const std::string &wName, const std::string &timeStr, std::ostream &out, bool with_ghost, bool useTopFile)
	COM_EXTERN_MODULE (Rocin)
static void	remove_arg (int *argc, char ***argv, int i)
	Remove an argument from the argument list. More...
void	showUsage ()
	Prints usage and examples to STDOUT. More...
void	parseArguments (int argc, char **argv)
	Parses the command line arguments. More...
int	main (int argc, char *argv[])
	Program main. More...

Variables
struct HDF2PLT::SGStr	StructuredGrid
struct globarg	Program

Macro Definition Documentation

#define SwitchOnDataType	(		dType,
			funcCall
	)

Definition at line 45 of file hdf2plt.C.

Referenced by COM_print_window().

Function Documentation

COM_EXTERN_MODULE

(

Rocin

)

void COM_print_window	(	const std::string &	wName,
		const std::string &	timeStr,
		std::ostream &	out,
		bool	with_ghost,
		bool	useTopFile
	)

Definition at line 401 of file hdf2plt.C.

References blocks, SGStr::blocks, COM_free_buffer(), COM_get_attribute(), COM_get_attributes(), COM_get_connectivities(), COM_get_panes(), COM_get_size(), getBlockNumber(), i, paneIds, PrintConn(), PrintStructured(), PrintUnstructured(), resolveConnectivity(), sin, HDF2PLT::StructuredGrid, SwitchOnDataType, and x.

{

        if( useTopFile )
        {
                std::cout << "Resolving inter-partition connectivity....";
                resolveConnectivity( );
                std::cout << "[DONE]\n";
        }

  // Obtain the list of panes
  int nPanes;
  int* paneIds;
  COM_get_panes(wName.c_str(), &nPanes, &paneIds);

  // Obtain the list of attributes
  int nAttrs;   // Number of attributes
  char* attrStr;  // names of attributes separated by spaces
  COM_get_attributes(wName.c_str(), &nAttrs, &attrStr);

  // First get the nodal coordinate info.
  int i;
  std::string name;
  std::vector<AttrInfo> attrs(nAttrs+1);
  attrs[0].m_name = "nc";
  COM_get_attribute((wName + '.' + attrs[0].m_name).c_str(),
                    &(attrs[0].m_location), &(attrs[0].m_dataType),
                    &(attrs[0].m_numComp), &(attrs[0].m_units));

  // Then get the basic attribute info.
  {
    std::istringstream sin(attrStr);
    for (i=1; i<nAttrs+1; ++i) {
      sin >> attrs[i].m_name;
      COM_get_attribute((wName + '.' + attrs[i].m_name).c_str(),
                        &(attrs[i].m_location), &(attrs[i].m_dataType),
                        &(attrs[i].m_numComp), &(attrs[i].m_units));
    }
  }

  if ( nPanes > 0 )
  {
    out << "TITLE=\"" << wName << ". Time: " << timeStr << ".\"" << std::endl;
    out << "VARIABLES= \"x\", \"y\", \"z\"";
  }

  // Eliminate window and pane attributes, note element attributes.
  // EDIT: pane attributes with one item are used as element data.
  // We might as well get rid of vectors and tensors, too.
  std::vector<int> elemCentered;
  int var = 4;
  std::vector<AttrInfo>::iterator p = attrs.begin();
  ++p;
  while (p != attrs.end()) {
    if ((*p).m_location == 'w') {
      p = attrs.erase(p);
      continue;
    }

    if ((*p).m_location == 'p') {
      bool okay = true;
      int nItems, nGItems;
      for (i=0; i<nPanes && okay; ++i) {
        COM_get_size((wName + '.' + (*p).m_name).c_str(), paneIds[i], &nItems,
                     &nGItems);
        if (nItems - nGItems != 1)
          okay = false;
      }
      if (!okay) {
        p = attrs.erase(p);
        continue;
      }
    }

    if ((*p).m_numComp == 1)
    {
      out << ", \"" << (*p).m_name << '"';
      if ((*p).m_location != 'n')
        elemCentered.push_back(var);
      ++var;
    }
    else {
      int x;
      for (x=1; x<=(*p).m_numComp; ++x) {
        out << ", \"" << x << '-' << (*p).m_name << '"';
        if ((*p).m_location != 'n')
          elemCentered.push_back(var);
        ++var;
      }
    }
    ++p;
  }
  out << std::endl;

  // Loop through the panes to find the meshes
  for ( i=0; i < nPanes; ++i )
  {

    int nElems, ngElems;
    name = wName + ".conn";
    COM_get_size(name.c_str(), paneIds[i], &nElems, &ngElems);
    if ( with_ghost) ngElems = 0;
    if ( nElems-ngElems==0) continue; // Skip empty panes

    out << "ZONE T=\"" << std::setw(5) << std::setfill('0')
        << paneIds[i] << "\", ";

    // Obtain the size of nodes
    int  nNodes;  // total number of nodes
    int  ghost; // Number of ghost nodes
    name = wName + ".nc";
    COM_get_size(name.c_str(), paneIds[i], &nNodes, &ghost);
    if ( with_ghost) ghost=0;

    // Obtain pane connectivity
//    int nPcon; // total number of pane connectivities
//    name = wName +".pconn";
//    COM_get_size( name.c_str( ), paneIds[ i ], &nPcon );
//              // Obtain a reference to the pconn array.
//              const int* pconnArray = NULL;
//              COM_get_array_const( pConnName.c_str( ), paneIds[ i ], &pconnArray );

    // Obtain the connectivity tables
    int nConn;       // Number of connectivity tables
    char* connNames; // Names of connectivity tables separated by space
    COM_get_connectivities(wName.c_str(), paneIds[i], &nConn, &connNames);

    int   ndims;
    const int* dims = NULL;
    char elemType = '\0';
    int eTotal = 0;
    std::vector<ConnInfo> connInfo(nConn);
    if (nConn == 1 && std::strncmp(connNames, ":st", 3) == 0)
    {
        // Structured mesh

      connInfo.clear();

      name = wName + '.' + connNames;
      COM_get_size(name.c_str(), paneIds[i], &ndims, &ghost);
      if ( with_ghost) ghost=0;

      // Obtain the dimensions (must be a const array) of the pane
      COM_get_array_const(name.c_str(), paneIds[i], &dims);

//      // Obtain the size of the pconn array
//      std::string pConnName = wName + ".pconn";
//      int pconnsize;
//      COM_get_size( pConnName.c_str( ), paneIds[ i ], &pconnsize );
//
//      std::cout << "Here is the pane connectivity size: " << pconnsize << std::endl;
//      // Obtain a reference to the pconn array.
//      const int* pconnArray = NULL;
//      COM_get_array_const( pConnName.c_str( ), paneIds[ i ], &pconnArray );
//
//      for( int panecon=0; panecon <  pconnsize; panecon++ )
//      {
//              std::cout << pconnArray[ panecon ] << "\n";
//      }

      out << "I=" << dims[0] - 2 * ghost;
      if ( ndims>=2) out << ", J=" << dims[1] - 2 * ghost;
      if ( ndims>=3) out << ", K=" << dims[2] - 2 * ghost;

      out << ", ZONETYPE=ORDERED, ";

      if( useTopFile )
      {
        std::cout << "Processing paneId: " << paneIds[ i ] << std::endl;
        int blockNum = getBlockNumber( paneIds[ i ], HDF2PLT::StructuredGrid.numBlocks );
        std::cout << "Here is the block number: " << blockNum << std::endl;
        assert( HDF2PLT::StructuredGrid.blocks.find( blockNum ) != HDF2PLT::StructuredGrid.blocks.end( ) );
        HDF2PLT::Block b = HDF2PLT::StructuredGrid.blocks[ blockNum ];
        std::cout << dims[ 0 ] << " == " << HDF2PLT::StructuredGrid.blocks[ blockNum ].Ni+7 << std::endl;
        std::cout << dims[ 1 ] << " == " << HDF2PLT::StructuredGrid.blocks[ blockNum ].Nj+7     << std::endl;
        std::cout << dims[ 2 ] << " == " << HDF2PLT::StructuredGrid.blocks[ blockNum ].Nk+7 << std::endl;
      }

    }
    else
    { // Unstructured mesh
      // Obtain the sizes of connectivity tables
      std::istringstream sin(connNames);
      std::vector<ConnInfo>::iterator c;
      for (c=connInfo.begin(); c!=connInfo.end(); ++c)
      {
        sin >> (*c).m_type;
        (*c).m_name = wName + '.' + (*c).m_type;
        (*c).m_type.erase(0, 1);
        std::string::size_type x = (*c).m_type.find(':', 2);
        if (x != std::string::npos)
           (*c).m_type.erase(x);

        COM_get_size((*c).m_name.c_str(), paneIds[i], &((*c).m_numElements),
                     &((*c).m_numGhost));
        if ( with_ghost) (*c).m_numGhost = 0;
        eTotal += (*c).m_numElements - (*c).m_numGhost;

        // Tecplot can't do mixed elements, so we have to use the biggest
        // and fudge the rest.
        if (elemType == '\0' || elemType == 't'
            || ((elemType == 'q' || elemType == 'T')
                && (*c).m_type[0] > 'A' && (*c).m_type[0] < 'Z')
            || (*c).m_type[0] == 'B' || (*c).m_type[0] == 'H')
           elemType = (*c).m_type[0];
      }
      out << "N=" << nNodes - ghost << ", E=" << eTotal << ", ZONETYPE=";
      switch (elemType) {
        case 't':
          out << "FETRIANGLE, ";
          break;

        case 'q':
          out << "FEQUADRILATERAL, ";
          break;

        case 'T':
          out << "FETETRAHEDRON, ";
          break;

        case 'P':
        case 'W':
        case 'H':
          elemType = 'B';
          // Intentional fall-through

        case 'B':
          out << "FEBRICK, ";
          break;
      }

      // free the buffer of connNames
      COM_free_buffer(&connNames);
    }

    out << "DATAPACKING=BLOCK";
    if (!elemCentered.empty()) {
      std::vector<int>::iterator cv = elemCentered.begin();
      out << ", VARLOCATION=([" << *cv;
      ++cv;
      while (cv != elemCentered.end()) {
        out << ',' << *cv;
        ++cv;
      }
      out << "]=CELLCENTERED)";
    }
    out << std::endl;

    for (p=attrs.begin(); p!=attrs.end(); ++p)
    {
      const void* pArray = NULL;
      if ((*p).m_numComp == 1)
      {
        out << "# Begin " << (*p).m_name << std::endl;
        COM_get_array_const((wName + '.' + (*p).m_name).c_str(), paneIds[i],
                            &pArray);
        if (dims != NULL)
        { // Structured
          SwitchOnDataType((*p).m_dataType,
                           PrintStructured((TT*)pArray, ndims, dims, ghost,
                                           (*p).m_location, out));
        }
        else
        {
          SwitchOnDataType((*p).m_dataType,
                           PrintUnstructured((TT*)pArray,
                                      ((*p).m_location != 'n' ? eTotal
                                                              : nNodes - ghost),
                                      (*p).m_location == 'p', out));
        }

      } // End if m_numComp == 1
      else
      {
        int comp;
        for (comp=1; comp<=(*p).m_numComp; ++comp)
        {
          std::ostringstream sout;
          sout << wName << '.' << comp << '-' << (*p).m_name;
          out << "# Begin " << comp << '-' << (*p).m_name << std::endl;
          COM_get_array_const(sout.str().c_str(), paneIds[i], &pArray);
          if (dims != NULL) { // Structured
            SwitchOnDataType((*p).m_dataType,
                             PrintStructured((TT*)pArray, ndims, dims, ghost,
                                             (*p).m_location, out));
          }
          else
          {
            SwitchOnDataType((*p).m_dataType,
                             PrintUnstructured((TT*)pArray,
                                      ((*p).m_location != 'n' ? eTotal
                                                              : nNodes - ghost),
                                      (*p).m_location == 'p', out));
          }

        }// End for comp

      } // End else

    } // End for attrs.begin

    if (!connInfo.empty( ) )
    {
      std::vector<ConnInfo>::iterator c = connInfo.begin();
      while (c != connInfo.end())
      {
        const int* pConn = NULL;
        COM_get_array_const((*c).m_name.c_str(), paneIds[i], &pConn);
        PrintConn(pConn, *c, elemType, out);
        ++c;
      }

    }

  } // for all panes

  // Free buffers for pane ids and attribute names
  COM_free_buffer(&paneIds);
  COM_free_buffer(&attrStr);

}

Here is the call graph for this function:

int getBlockNumber ( const int  zonenumber, const int  NBlocks  )

inline

Gets the block number by parsing the leading significant digits.

Parameters

zonenumber	the zone number.
NBlocks	the total number of blocks.

Returns

N the number without the trailing zeros.

Definition at line 154 of file hdf2plt.C.

References s.

Referenced by COM_print_window().

{
        std::stringstream iss;
        iss << zonenumber;
        std::string s    = iss.str( );
        bool found                       = false;
        int reduceFactor = 4;
        int B                                            = -1;
        while( !found )
        {
                s.resize( reduceFactor );
                B = std::atoi( s.c_str( ) );
                if( B <= NBlocks )
                {
                        found = true;
                }
                --reduceFactor;
        }
        return( B );
}

Here is the caller graph for this function:

int main	(	int	argc,
		char *	argv[]
	)

Program main.

Parameters

argc	argument counter.
argv	argument vector.

Returns

rc return code.

Postcondition

if rc >= 0 program terminated normally.

Definition at line 863 of file hdf2plt.C.

References COM_call_function(), COM_finalize(), COM_get_attribute_handle(), COM_get_function_handle(), COM_init(), COM_LOAD_MODULE_STATIC_DYNAMIC, COM_print_window(), parseArguments(), and readTopFile().

{
        /* Parse the command line arguments */
         parseArguments( argc, argv );

         Program.printInfo( );

        /* Initialize the COM Environment */
  COM_init(&argc, &argv);

  /* Load Rocin for reading the HDF files */
  COM_LOAD_MODULE_STATIC_DYNAMIC(Rocin, "IN");

  std::cout << "Reading top file: " << Program.topfile << "...";
  if( Program.useTopFile )
        readTopFile( Program.topfile );
  std::cout << "[DONE]\n";

  /* Obtain function handle to the obtain attribute function */
  int IN_obtain = COM_get_function_handle("IN.obtain_attribute");

  std::string win_in;
  if( Program.readControlFile )
        win_in = Program.cntrlfile;
  else
        win_in = Program.fileregx;

  std::string::size_type st = win_in.find_last_of('/');
  if (st != std::string::npos)
    win_in.erase(0, st+1);
  st = win_in.find_first_not_of("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
  if (st != std::string::npos)
    win_in.erase(st);

  // Initialize an empty time string
  int  len = 15;
  char timeStr[16];
  timeStr[0] = '\0';

  if( Program.readControlFile )
  {
    std::cout << "Reading by control file " << Program.cntrlfile << " into window " << win_in << "...";

    int IN_read = COM_get_function_handle("IN.read_by_control_file");
    COM_call_function(IN_read,
                      Program.cntrlfile.c_str(),
                      win_in.c_str(),
                      NULL,
                      timeStr,
                      &len);

    std::cout << "[DONE]\n";

  }
  else
  {
    std::cout << "Reading HDF file(s) " << Program.fileregx << " into window " << win_in << "...";

    int IN_read = COM_get_function_handle("IN.read_window");
    COM_call_function(IN_read,
                      Program.fileregx.c_str(),
                      win_in.c_str(),
                      NULL,
                      NULL,
                      timeStr,
                      &len);

    std::cout << "[DONE]\n";

  }

  std::string win_all(win_in + ".all");
  int IN_all = COM_get_attribute_handle(win_all.c_str());

  std::cout << "Obtaining data attributes for window  " << win_in << "...";
  COM_call_function(IN_obtain, &IN_all, &IN_all);
  std::cout << "[DONE]\n";

  if( Program.outputfile == "" )
  {
    std::cout << "Writing window out to standard output " << "...";
    COM_print_window(win_in, timeStr, std::cout, Program.withGhost, Program.useTopFile );
    std::cout << "[DONE]\n";
  }
  else
  {
    std::cout << "Writing window out to " << Program.outputfile << "...";
    std::ofstream fout( Program.outputfile.c_str( ) );
    COM_print_window(win_in, timeStr, fout, Program.withGhost, Program.useTopFile );
    std::cout << "[DONE]\n";
  }

  // COM_UNLOAD_MODULE_STATIC_DYNAMIC(Rocin);

  COM_finalize();
  return 0;
}

Here is the call graph for this function:

void parseArguments	(	int	argc,
		char **	argv
	)

Parses the command line arguments.

Parses the user-supplied command line arguments.

Parameters

argc	the argument counter.
argv	the argument vector.
argc	the argument counter
argv	the argument vector

Definition at line 805 of file hdf2plt.C.

References i, and showUsage().

Referenced by main().

{
        Program.useTopFile                      = false;
        Program.withGhost                 = false;
        Program.readControlFile = false;

        Program.cntrlfile = "";
        Program.topfile         = "";
        Program.fileregx  = "";

        for( int i=1; i < argc; ++i )
        {
                if( std::strcmp( argv[ i ], "-top" ) == 0 )
                {
                        Program.useTopFile = true;
                        Program.topfile          = std::string( argv[ ++i ] );
                }
                else if( std::strcmp( argv[ i ], "-g" ) == 0 )
                {
                        Program.withGhost = true;
                }
                else if( std::strcmp( argv[ i ], "-c" ) == 0 )
                {
                        Program.readControlFile = true;
                        Program.cntrlfile = std::string( argv[ ++i ] );
                }
                else if( std::strcmp( argv[ i ], "-o" ) == 0 )
                {
                        Program.outputfile = std::string( argv[ ++i ] );
                }
                else if( std::strcmp( argv[ i ], "-regex") == 0 )
                {
                        Program.fileregx = std::string( argv[ ++i ] );
                }
                else if( std::strcmp( argv[ i ], "-h") == 0  )
                {
                        showUsage( );
                        exit( 0 );
                }

        }

        if( Program.cntrlfile == "" && Program.fileregx == "" )
        {
                std::cerr << "Error parsing command line input!\n";
                showUsage( );
                exit( -1 );
        }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void PrintConn	(	const int *	pConn,
		const ConnInfo &	ci,
		char	type,
		std::ostream &	out
	)

Definition at line 331 of file hdf2plt.C.

References ConnInfo::m_numElements, ConnInfo::m_numGhost, ConnInfo::m_type, and sin.

{
  int nn;
  std::istringstream sin(ci.m_type.substr(1));
    sin >> nn;

  int elem;
  for (elem=0; elem<ci.m_numElements-ci.m_numGhost; ++elem) {
    switch (type) {
      case 't': // The overall type is 't', so all the tables must be 't'
        out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
            << "  " << pConn[elem+2*ci.m_numElements] << std::endl;
        break;

      case 'q':
        if (ci.m_type[0] == 't')
          out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
              << "  " << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+2*ci.m_numElements] << std::endl;
        else // must be q4, q8 or q9.
          out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
              << "  " << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << std::endl;
        break;

      case 'T': // The overall type is 'T', so all the tables must be 'T'
        out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
            << "  " << pConn[elem+2*ci.m_numElements] << "  "
            << pConn[elem+3*ci.m_numElements] << std::endl;
        break;

      case 'B':
        if (ci.m_type[0] == 'T')
          out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
              << "  " << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << std::endl;
        else if (ci.m_type == "P5")
          out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
              << "  " << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << "  "
              << pConn[elem+4*ci.m_numElements] << "  "
              << pConn[elem+4*ci.m_numElements] << "  "
              << pConn[elem+4*ci.m_numElements] << "  "
              << pConn[elem+4*ci.m_numElements] << std::endl;
        else if (ci.m_type == "P6" || ci.m_type == "W6")
          out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
              << "  " << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << "  "
              << pConn[elem+4*ci.m_numElements] << "  "
              << pConn[elem+5*ci.m_numElements] << "  "
              << pConn[elem+5*ci.m_numElements] << std::endl;
        else
          out << "  " << pConn[elem] << "  " << pConn[elem+ci.m_numElements]
              << "  " << pConn[elem+2*ci.m_numElements] << "  "
              << pConn[elem+3*ci.m_numElements] << "  "
              << pConn[elem+4*ci.m_numElements] << "  "
              << pConn[elem+5*ci.m_numElements] << "  "
              << pConn[elem+6*ci.m_numElements] << "  "
              << pConn[elem+7*ci.m_numElements] << std::endl;
        break;
    }
  }
}

void PrintStructured	(	const TT *	pData,
		const int	ndims,
		const int *	dims_nodes,
		int	ghost,
		char	loc,
		std::ostream &	out
	)

Definition at line 263 of file hdf2plt.C.

References i, j, and k.

{
  const int dims[3] = { dims_nodes[0] - (loc!='n'),
                        ndims>=2 ? dims_nodes[1] - (loc!='n') : 0,
                        ndims>=3 ? dims_nodes[2] - (loc!='n') : 0};

  const int last[3] = { dims[0] - ghost,
                        ndims>=2 ? dims[1] - ghost : 0,
                        ndims>=3 ? dims[2] - ghost : 0};
  int count = 0;

  if ( ndims==3)
  {
    for (int k=ghost; k<last[2]; ++k)
    {
      for (int j=ghost; j<last[1]; ++j)
      {
        for (int i=ghost; i<last[0]; ++i,++count)
        {
          out << "  " << std::scientific
              << (!pData ? (TT)-987654321
                         : (loc=='p' ? pData[0]
                                     : pData[i+j*dims[0]+k*dims[0]*dims[1]]));
          if (count % 10 == 9) out << std::endl;
        }
      }
    }
  }
  else if (ndims==2)
  {
    for (int j=ghost; j<last[1]; ++j)
    {
      for (int i=ghost; i<last[0]; ++i,++count)
      {
        out << "  " << std::scientific
            << (!pData ? (TT)-987654321
                       : (loc=='p' ? pData[0] : pData[i+j*dims[0]]));
        if (count % 10 == 9) out << std::endl;
      }
    }

  }
  else
  {
    for (int i=ghost; i<last[0]; ++i,++count)
    {
      out << "  " << std::scientific << (!pData ? (TT)-987654321 : (loc=='p' ? pData[0] : pData[i]));
      if (count % 10 == 9)
        out << std::endl;
    }
  }
  out << std::endl;
}

void PrintUnstructured	(	const TT *	pData,
		int	size,
		bool	panel,
		std::ostream &	out
	)

Definition at line 319 of file hdf2plt.C.

References i.

{
  int i;
  for (i=0; i<size; ++i) {
    out << "  " << std::scientific << (!pData ? (TT)-987654321
                                              : (panel ? pData[0]
                                                       : pData[i]));
    if (i % 10 == 9) out << std::endl;
  }
  out << std::endl;
}

void readBlock ( std::ifstream &  ifs )

inline

Definition at line 180 of file hdf2plt.C.

References Block::blockNumber, blocks, SGStr::blocks, Patch::boundaryCondition, Patch::coupled, Block::gridLevels, i, Patch::L1BEGIN, Patch::L1END, Patch::L2BEGIN, Patch::L2END, Patch::localBlockFaceNumer, Block::Ni, Block::Nj, Block::Nk, Block::pathces, Patch::remoteBlockFaceNumber, Patch::remoteBlockNumber, Patch::remoteL1BEGIN, Patch::remoteL1END, Patch::remoteL2BEGIN, Patch::remoteL2END, and HDF2PLT::StructuredGrid.

Referenced by readTopFile().

{
        std::string dummyline;
        int N;

        if( !ifs.is_open( ) )
        {
                std::cerr << "Error opening reading file!"<< std::endl;
                std::cerr << "FILE: " << __FILE__ << std::endl;
                std::cerr << "LINE: " << __LINE__ << std::endl;
                exit( -1 );
        }

        HDF2PLT::Block b;
        ifs >> b.blockNumber >> b.gridLevels;
//      std::cout << "# " << b.blockNumber << " ";

        std::getline( ifs, dummyline );

        ifs >> N >> b.Ni >> b.Nj >> b.Nk;
//      std::cout << b.Ni << " " << b.Nj << " " << b.Nk << std::endl;

        std::getline( ifs,dummyline );

        b.pathces.resize( N );
        for( int i=0; i < N; ++i )
        {
                HDF2PLT::Patch p;
                ifs >> p.boundaryCondition;
                ifs >> p.localBlockFaceNumer;
                ifs >> p.L1BEGIN;
                ifs >> p.L1END;
                ifs >> p.L2BEGIN;
                ifs >> p.L2END;
                ifs >> p.remoteBlockNumber;
                ifs >> p.remoteBlockFaceNumber;
                ifs >> p.remoteL1BEGIN;
                ifs >> p.remoteL1END;
                ifs >> p.remoteL2BEGIN;
                ifs >> p.remoteL2END;
                ifs >> p.coupled;
                std::getline( ifs, dummyline );
                b.pathces[ i ] = p;
        }

        assert( HDF2PLT::StructuredGrid.blocks.find( b.blockNumber ) ==
                                        HDF2PLT::StructuredGrid.blocks.end( ) );
        HDF2PLT::StructuredGrid.blocks[ b.blockNumber ] = b;


}

Here is the caller graph for this function:

void readTopFile ( const std::string  file )

inline

Definition at line 232 of file hdf2plt.C.

References i, SGStr::numBlocks, readBlock(), and HDF2PLT::StructuredGrid.

Referenced by main().

{
        std::ifstream ifs;
        std::string dummyline;

        ifs.open( file.c_str( ) );

        if( !ifs.is_open( ) )
        {
                std::cerr << "Error opening file " << file << std::endl;
                std::cerr << "FILE: " << __FILE__ << std::endl;
                std::cerr << "LINE: " << __LINE__ << std::endl;
                exit( -1 );
        }

        std::getline( ifs, dummyline );
        std::getline( ifs, dummyline );

        ifs >> HDF2PLT::StructuredGrid.numBlocks;

        std::getline( ifs, dummyline );

        int blockId;

        for( int i=0; i < HDF2PLT::StructuredGrid.numBlocks; ++i )
                readBlock( ifs );

        ifs.close( );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void remove_arg ( int *  argc, char ***  argv, int  i  )

inlinestatic

Remove an argument from the argument list.

Definition at line 727 of file hdf2plt.C.

References j.

                                                               {
  for ( int j=i; j<*argc-1; ++j) (*argv)[j]=(*argv)[j+1];
  --*argc;
}

void resolveConnectivity ( )

inline

Definition at line 175 of file hdf2plt.C.

Referenced by COM_print_window().

{
        // TODO: implement this
}

Here is the caller graph for this function:

void showUsage

(

)

Prints usage and examples to STDOUT.

Definition at line 785 of file hdf2plt.C.

Referenced by main(), parseArguments(), and parseCmdParameters().

{
        std::cout << "HDF2PLT OPTIONS:\n";
        std::cout << "-regex \"{somestring}*.hdf\" : Specifies a set of hdf files\n";
        std::cout << "-top {topfile} : Specifies a top file to use to resolve the connectivity\n";
        std::cout << "-g : Enables ghost node inclusion in the output file\n";
        std::cout << "-c {cntrlfile} : Specifies a control file to use\n";
        std::cout << "-o {outputfile} : Specifies output file. Output is printed to STDOUT by default.\n";
        std::cout << "-h : Prints this help menu.\n";
        std::cout << "Examples:\n";
        std::cout << "\thdf2plt -g -regex \"fluid*.hdf\" -o output.plt\n";
        std::cout << "\thdf2plt -regex \"fluid*.hdf\" -top fluid.top -o output.plt\n";
        std::cout.flush( );
}

Here is the caller graph for this function:

Variable Documentation

struct globarg Program

Referenced by convertWindow(), getPaneConnectivity(), getWindow(), main(), maskPoints(), printWindow(), stitchGrids(), stitchSolutionData(), updateHash(), writePlotFile(), Mesh::writeVtkData(), and writeVtkFiles().