ex5.C File Reference

#include "roccom.h"
#include <cstdio>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cstring>
#include <string>
#include <cassert>
#include "commpi.h"

Include dependency graph for ex5.C:

Go to the source code of this file.

Functions
	COM_EXTERN_MODULE (Rocface)
	COM_EXTERN_MODULE (Rocout)
int	read_obj (std::istream &is, vector< double > &coors, vector< int > &elems)
int	main (int argc, char *argv[])

Function Documentation

COM_EXTERN_MODULE

(

Rocface

)

COM_EXTERN_MODULE

(

Rocout

)

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

Definition at line 44 of file ex5.C.

References COM_call_function(), COM_delete_window(), COM_finalize(), COM_get_attribute_handle(), COM_get_function_handle(), COM_init(), COM_LOAD_MODULE_STATIC_DYNAMIC, COM_new_window(), COM_print_profile(), COM_set_array(), COM_set_profiling(), COM_set_size(), COM_set_verbose(), COM_window_init_done(), i, MPI_COMM_WORLD, and read_obj().

                                 {
  COM_init( &argc, &argv);

  if ( argc < 7) {
    std::cout << "Usage: " << argv[0] 
              << " <t1_prefix> <t1_num_blocks> <t1_suffix> <t2_prefix>"
              << " <t2_num_blocks> <t2_suffix>" << std::endl;
    exit(-1);
  }

  COM_set_verbose( 1);
  COM_set_profiling( 1);

  COM_LOAD_MODULE_STATIC_DYNAMIC( Rocface, "RFC");

  MPI_Comm comm = MPI_COMM_WORLD;
  const int comm_rank=0;
  const int comm_size=1;
 
  const char *t1_prefix = argv[1];
  const int   t1_num_blocks=atoi(argv[2]);
  const char *t1_suffix = argv[3];
  assert( t1_num_blocks <= 5);

  std::vector<double>  t1_mesh_coors[5];
  std::vector<int>     t1_mesh_elems[5];

  for ( int i=0; i<t1_num_blocks; ++i) if ( i%comm_size==comm_rank) {
    char fname[100];
    std::sprintf( fname, "%s%d%s", t1_prefix, i+1, t1_suffix);
    std::ifstream is( fname);
    assert( is != NULL);
    read_obj( is, t1_mesh_coors[i], t1_mesh_elems[i]);
  }

  COM_new_window("tri1");
  for ( int i=0; i<t1_num_blocks; ++i) if ( i%comm_size==comm_rank) {
    COM_set_size( "tri1.nc", i+1, t1_mesh_coors[i].size()/3);
    COM_set_array( "tri1.nc", i+1, &t1_mesh_coors[i][0]);
    COM_set_size( "tri1.:t3:", i+1, t1_mesh_elems[i].size()/3);
    COM_set_array( "tri1.:t3:", i+1, &t1_mesh_elems[i][0]);
  }
  COM_window_init_done( "tri1");

  const char *t2_prefix = argv[4];
  const int   t2_num_blocks=atoi(argv[5]);
  const char *t2_suffix = argv[6];
  assert( t2_num_blocks <= 5);

  std::vector<double>  t2_mesh_coors[5];
  std::vector<int>     t2_mesh_elems[5];

  for ( int i=0; i<t2_num_blocks; ++i) if ( i%comm_size==comm_rank) {
    char fname[100];
    std::sprintf( fname, "%s%d%s", t2_prefix, i+1, t2_suffix);
    std::ifstream is( fname);
    assert( is != NULL);
    read_obj( is, t2_mesh_coors[i], t2_mesh_elems[i]);
  }
  COM_new_window("tri2");
  for ( int i=0; i<t2_num_blocks; ++i) if ( i%comm_size==comm_rank) {
    COM_set_size( "tri2.nc", i+1, t2_mesh_coors[i].size()/3);
    COM_set_array( "tri2.nc", i+1, &t2_mesh_coors[i][0]);
    COM_set_size( "tri2.:t3:", i+1, t2_mesh_elems[i].size()/3); 
    COM_set_array( "tri2.:t3:", i+1, &t2_mesh_elems[i][0]);
 }
  COM_window_init_done( "tri2");

  int tri1_mesh = COM_get_attribute_handle( "tri1.mesh");
  int tri2_mesh = COM_get_attribute_handle( "tri2.mesh");
  int RFC_clear = COM_get_function_handle( "RFC.clear_overlay");
  int RFC_write = COM_get_function_handle( "RFC.write_overlay");
    
  if ( comm_size==1) {
    int RFC_overlay = COM_get_function_handle( "RFC.overlay");

    COM_call_function( RFC_overlay, &tri1_mesh, &tri2_mesh, &comm);
    COM_call_function( RFC_write, &tri1_mesh, &tri2_mesh, "tri1", "tri2", "HDF" );
    COM_call_function( RFC_clear, "tri1", "tri2");
  }
  
  int RFC_read = COM_get_function_handle( "RFC.read_overlay");
  COM_call_function( RFC_read, &tri1_mesh, &tri2_mesh, &comm,
                     "tri1", "tri2", "HDF");

  char prefix1[100], prefix2[100];
  std::sprintf(prefix1, "tri1_%d", comm_rank);
  std::sprintf(prefix2, "tri2_%d", comm_rank);
  
  COM_call_function( RFC_clear, "tri1", "tri2");

  COM_delete_window( "tri1");
  COM_delete_window( "tri2");

  COM_print_profile( "", "");

  COM_finalize();
}

Here is the call graph for this function:

int read_obj	(	std::istream &	is,
		vector< double > &	coors,
		vector< int > &	elems
	)

Definition at line 39 of file meshio.C.

References i, j, MAXLEN, p0, and p1.

                                  {
  const int MAXLEN=255;
  char  buf[MAXLEN];
  int   face_type = 3;

  is.getline( buf, MAXLEN);
  if ( strncmp( buf, "#OBJ", 4)==0 && !is.eof()) { 
    face_type = buf[4] - '0';
    assert( face_type == 3 || face_type == 4 || face_type == 6);
    do { is.getline( buf, MAXLEN); } while ( buf[0]=='#' && !is.eof());
  }
  int np=0, nf=0;
  if ( strcmp( buf, "off")==0 || strcmp( buf, "OFF")==0 )
    do { is.getline( buf, MAXLEN); } while ( buf[0]=='#' && !is.eof());
  sscanf( buf, "%d %d", &np, &nf);

  // Allocate space for points and faces.
  coors.reserve( np*3); elems.reserve( nf*face_type); 

  // Read in the coordinates
  for ( int i=0; i<np; ++i) {
    do { is.getline( buf, MAXLEN); } while ( buf[0]=='#' && !is.eof());
    double p0, p1, p2;
    sscanf( buf, "%lf %lf %lf", &p0, &p1, &p2);
    coors.push_back( p0); coors.push_back( p1); coors.push_back( p2);
  }

  // Read in faces
  vector<int> f( face_type);
  while( is.peek() == '#' && !is.eof()) is.getline( buf, MAXLEN);
  for ( int i=0; i<nf; ++i) {
    for ( int j=0; j<face_type; ++j) {
      is >> f[j];  assert( f[j] >= 1 && f[j] <= np);
      elems.push_back( f[j]); 
    }
  }

  return face_type;
}