Rocin Class Reference

#include <Rocin.h>

Inheritance diagram for Rocin:

Collaboration diagram for Rocin:

Public Types
typedef void(*	RulesPtr )(const int &pane_id, const int &comm_rank, const int &comm_size, int *is_local)
	Pointer to a function to determine locality of a pane. More...

Public Member Functions
	Rocin ()
	Default constructor. More...
User interface
void	read_by_control_file (const char *control_file_name, const char *window_name, const MPI_Comm *comm=NULL, char *time_level=NULL, const int *str_len=NULL)
	Create a single Roccom window by reading in the files specified by the given control file. More...
void	read_window (const char *filename_patterns, const char *window_name, const MPI_Comm *comm=NULL, RulesPtr is_local=NULL, char *time_level=NULL, const int *str_len=NULL)
	Create a single Roccom window by reading in a list of files. More...
void	read_windows (const char *filename_patterns, const char *window_prefix, const char *material_names=NULL, const MPI_Comm *comm=NULL, RulesPtr is_local=NULL, char *time_level=NULL, const int *str_len=NULL)
	Create a series of Roccom windows by reading in a list of files. More...
void	obtain_attribute (const COM::Attribute *attribute_in, COM::Attribute *user_attribute, int *pane_id=NULL)
	Fill the destination (second) attribute from files using the data corresponding to the source (first) attribute. More...
void	read_parameter_file (const char *file_name, const char *window_name, const MPI_Comm *comm=NULL)
	Read in parameters from a given file into the given window. More...

Static Protected Member Functions
Initialization and finalization
static void	init (const std::string &mname)
	Initialize the module by registering it to Roccom with the given module name. More...
static void	finalize (const std::string &mname)
	Finalize the module by deregistering it from Roccom. More...

Protected Attributes
MemberRulePtr	m_is_local
std::set< int >	m_pane_ids
int	m_base
int	m_offset
std::map< int32, COM_Type >	m_HDF2COM

Friends
Module loading and unloading
void	Rocin_load_module (const char *name)
	Load the module Rocin into Roccom using the given module name. More...
void	Rocin_unload_module (const char *name)
	Unload the module Rocin from Roccom. More...

Pane distribution
Assign panes onto different processes.
typedef void(Rocin::*	MemberRulePtr )(const int &, const int &, const int &, int *)
void	explicit_local (const int &pid, const int &comm_rank, const int &comm_size, int *il)
void	cyclic_local (const int &pid, const int &comm_rank, const int &comm_size, int *il)
void	blockcyclic_local (const int &pid, const int &comm_rank, const int &comm_size, int *il)
void	register_panes (BlockMM_HDF4::iterator hdf4, const BlockMM_HDF4::iterator &hdf4End, const std::string &window, RulesPtr is_local, const MPI_Comm *comm, int rank, int nprocs)

Detailed Description

Definition at line 64 of file Rocin.h.

Member Typedef Documentation

typedef void(Rocin::* MemberRulePtr)(const int &, const int &, const int &, int *)

protected

Definition at line 191 of file Rocin.h.

typedef void(* RulesPtr)(const int &pane_id, const int &comm_rank, const int &comm_size, int *is_local)

Pointer to a function to determine locality of a pane.

Definition at line 70 of file Rocin.h.

Constructor & Destructor Documentation

Rocin ( )

inline

Default constructor.

Definition at line 67 of file Rocin.h.

Referenced by init().

: m_is_local( NULL), m_base(0), m_offset(0) {}

Here is the caller graph for this function:

Member Function Documentation

void blockcyclic_local ( const int &  pid, const int &  comm_rank, const int &  comm_size, int *  il  )

protected

Definition at line 2458 of file Rocin.C.

References m_base, and m_offset.

Referenced by read_by_control_file().

{
  int proc = (pid-m_offset) / m_base;
  if ( proc>=comm_size) proc %= comm_size;
  *il = proc == comm_rank;
}

Here is the caller graph for this function:

void cyclic_local ( const int &  pid, const int &  comm_rank, const int &  comm_size, int *  il  )

protected

Definition at line 2452 of file Rocin.C.

References m_offset.

Referenced by read_by_control_file().

{
  *il = (pid - m_offset) % comm_size == comm_rank;
}

Here is the caller graph for this function:

void explicit_local ( const int &  pid, const int &  comm_rank, const int &  comm_size, int *  il  )

protected

Definition at line 2446 of file Rocin.C.

References m_pane_ids.

Referenced by read_by_control_file().

{
  *il = m_pane_ids.count(pid);
}

Here is the caller graph for this function:

void finalize ( const std::string &  mname )

staticprotected

Finalize the module by deregistering it from Roccom.

See Also

Rochdf_unload_module()

Definition at line 2417 of file Rocin.C.

References COM_delete_window(), COM_get_object(), and HDF4::finalize().

Referenced by Rocin_unload_module().

                                           {
  // Retrieve Rocin object from Roccom
  Rocin *rin;
  std::string glb=mname+".global";

  COM_get_object( glb.c_str(), 0, &rin);

  COM_delete_window( mname.c_str());

  // Delete the object
  delete rin;
  HDF4::finalize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init ( const std::string &  mname )

staticprotected

Initialize the module by registering it to Roccom with the given module name.

This function is called Rocin_load_module.

See Also

Rocin_load_module()

This data structure maps HDF4 data types to roccom data types.

Definition at line 2351 of file Rocin.C.

References COM_CHAR, COM_DOUBLE, COM_FLOAT, COM_INT, COM_METADATA, COM_MPI_COMM, COM_new_attribute(), COM_new_window(), COM_OBJECT, COM_RAWDATA, COM_set_member_function(), COM_set_object(), COM_STRING, COM_VOID, COM_window_init_done(), DEBUG_MSG, HDF4::init(), m_HDF2COM, MPI_COMM_SELF, obtain_attribute(), read_by_control_file(), read_parameter_file(), read_window(), read_windows(), and Rocin().

Referenced by Rocin_load_module().

                                       {
  HDF4::init();

  Rocin *rin = new Rocin();

  rin->m_HDF2COM[DFNT_CHAR8] = COM_CHAR;
  rin->m_HDF2COM[DFNT_INT32] = COM_INT;
  rin->m_HDF2COM[DFNT_FLOAT32] = COM_FLOAT;
  rin->m_HDF2COM[DFNT_FLOAT64] = COM_DOUBLE;

#ifdef USE_CGNS
  rin->m_CGNS2COM[Character] = COM_CHAR;
  rin->m_CGNS2COM[Integer] = COM_INT;
  rin->m_CGNS2COM[RealSingle] = COM_FLOAT;
  rin->m_CGNS2COM[RealDouble] = COM_DOUBLE;
#endif // USE_CGNS

  COM_new_window( mname.c_str(), MPI_COMM_SELF);

  std::string glb=mname+".global";

  DEBUG_MSG("Calling COM_new_attribute( name == '" << glb << "', position == 'w', datatype == COM_OBJECT, nComp == 1, units == '' )");
  COM_new_attribute( glb.c_str(), 'w', COM_OBJECT, 1, "");
  COM_set_object( glb.c_str(), 0, rin);

  // Register the function read_windows
  COM_Type types[8] = { COM_RAWDATA, COM_STRING, COM_STRING, COM_STRING,
                        COM_MPI_COMM, COM_VOID, COM_STRING, COM_INT};
  COM_set_member_function( (mname+".read_windows").c_str(),
                           (Member_func_ptr)&Rocin::read_windows, 
                           glb.c_str(), "biiIIIBI", types);

  // Register the function read_window
  types[3] = COM_MPI_COMM; types[4] = COM_VOID;
  types[5] = COM_STRING; types[6] = COM_INT;
  COM_set_member_function( (mname+".read_window").c_str(),
                           (Member_func_ptr)&Rocin::read_window, 
                           glb.c_str(), "biiIIBI", types);

  // Register the function read_by_control_file
  types[4] = COM_STRING; types[5] = COM_INT;
  COM_set_member_function( (mname+".read_by_control_file").c_str(),
                           (Member_func_ptr)&Rocin::read_by_control_file, 
                           glb.c_str(), "biiIBI", types);

  // Register the function obtain_attribute
  types[1] = COM_METADATA;
  types[2] = COM_METADATA;
  types[3] = COM_INT;
  COM_set_member_function( (mname+".obtain_attribute").c_str(),
                           (Member_func_ptr)&Rocin::obtain_attribute, 
                           glb.c_str(), "bioI", types);

  // Regsister the function read_parameter_file
  types[1] = COM_STRING;
  types[2] = COM_STRING;
  types[3] = COM_MPI_COMM;
  COM_set_member_function( (mname+".read_parameter_file").c_str(),
                           (Member_func_ptr)&Rocin::read_parameter_file,
                           glb.c_str(), "biiI", types);

  COM_window_init_done( mname.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

void obtain_attribute	(	const COM::Attribute *	attribute_in,
		COM::Attribute *	user_attribute,
		int *	pane_id = NULL
	)

Fill the destination (second) attribute from files using the data corresponding to the source (first) attribute.

Note that the destination and the source attributes can be the same.

Parameters

attribute_in	source attribute
user_attribute	destination attribute
pane_id	if present, then copy only the specific pane

See Also

obtain_attribute()

Definition at line 2431 of file Rocin.C.

References COM_assertion_msg.

Referenced by init(), plag_initgenxinterface(), rflo_modinterfacessolver::RFLO_InitAvgCoeffs::rflo_initavgcoeffs(), rflo_initflowsolver(), rflo_initgenxinterface(), and rflo_modinterfacesexternal::RFLO_SendBoundaryValuesAlpha::rflo_sendboundaryvaluesalpha().

{
  // obtain a valid attribute object from user_attribute's name
  COM_assertion_msg((attribute_in != NULL && user_attribute != NULL),
                    "Null attributes are not valid arguments to Rocin::obtain_attribute\n");

  if ( attribute_in != user_attribute) {
    COM::Window *win = user_attribute->window();
    win->inherit(const_cast<Attribute*>(attribute_in), user_attribute->name(), 
                 COM::Pane::INHERIT_COPY, true, NULL, pane_id?*pane_id:0);
  }
}

Here is the caller graph for this function:

void read_by_control_file	(	const char *	control_file_name,
		const char *	window_name,
		const MPI_Comm *	comm = NULL,
		char *	time_level = NULL,
		const int *	str_len = NULL
	)

Create a single Roccom window by reading in the files specified by the given control file.

Parameters

control_file_name	specifies the control file.
window_name	the name of the window to be created.
comm	The MPI communicator to use. If is NULL, the default communicator of Roccom will be used.
time_level	the time stamp of the dataset to be read. If time level is NULL (default) or "", then the first time_level in the file will be assumed.
str_len	if present and positive, the time stamp of the dataset will be copied to the time_level string.

Definition at line 2466 of file Rocin.C.

References blockcyclic_local(), COM_assertion_msg, COM_get_default_communicator(), COMMPI_Initialized(), cyclic_local(), explicit_local(), files(), i, m_base, m_is_local, m_offset, m_pane_ids, min(), rank, read_window(), and sin.

Referenced by init().

{
  const MPI_Comm default_comm=COM_get_default_communicator();
  const MPI_Comm comm_null=MPI_COMM_NULL;
  const MPI_Comm* myComm;
  int myRank, comm_size;

  // Determine the directory name of the control_file_name
  std::string dir_name = control_file_name;
  std::string::size_type pos = dir_name.find_last_of('/');
  if ( pos == std::string::npos)
    dir_name = "";
  else
    dir_name.erase( pos+1);

  if ( comm && *comm == MPI_COMM_NULL || !comm) 
    myComm = COMMPI_Initialized() ? &default_comm : &comm_null;
  else
    myComm = comm;

  // Set myRank to a wild card if MPI is not initialized
  if ( !COMMPI_Initialized() || *myComm == MPI_COMM_NULL) {
    myRank = -1;
    comm_size = 1;
  }
  else {
    MPI_Comm_rank(*myComm, &myRank);
    MPI_Comm_size(*myComm, &comm_size);
    if(comm_size == 1)
      myRank = -1;
  }

  std::ifstream fin(control_file_name);
  if (!fin.is_open()) {
    std::cerr << "Rocstar: Error: read_by_control_file unable to open " << control_file_name
              << " for reading." << std::endl;
    return;
  }

  std::vector<std::string> patterns;
  std::string buffer;
  int rank = -54321;
  m_pane_ids.clear();

  while (!fin.eof()) {
    std::vector<std::string> local_patterns;
    while (!fin.eof() && (myRank<0 || rank != myRank) ) {
      if (buffer != "@Proc:") {
        fin >> buffer;
        continue;
      }

      while (fin.peek() == ' ' || fin.peek() == '\t' || fin.peek() == '\n')
        fin.get();

      if (fin.peek() == '*') {
        fin.get();
        rank = myRank;
        break;
      } else {
        fin >> rank;
        // If myRank is a wild card, then any rank will match with it.
        if (myRank < 0) {
          rank = myRank;
          break;
        } else if (rank == myRank)
          break;
      }

      buffer=""; 
    }

    if (fin.eof()) {
      if ( rank != myRank)
        std::cerr << "Rocstar: Error (read_by_control_file): control file " 
                  << control_file_name
                  << " does not contain information for process " << myRank
                  << std::endl;
      break;
    }

    fin >> buffer;
    if (buffer != "@Files:") {
      std::cerr << "Rocstar: Error (read_by_control_file): in control file "
                << control_file_name
                << ": expected '@Files' but found '" << buffer << '\''
                << std::endl;
      return;
    }

    fin >> buffer;

    while (buffer != "@Panes:" && buffer != "@Proc:") {
      // The @Panes section may not be present
      if (fin.eof()) break;

      std::string::size_type pos = buffer.find("%t");
      if (pos != std::string::npos)
        buffer.replace(pos, 2, time_level);

      pos = buffer.find('%');
      if ( pos != std::string::npos) {
        std::string::size_type pos_key = 
          buffer.find_first_not_of("0123456789", pos+1);

        COM_assertion_msg( pos_key != std::string::npos, 
                           (std::string("Incomplete placeholder in file name ")+buffer).c_str());

        std::string width = buffer.substr(pos+1, pos_key-pos-1);

        int w = 4; // The default rankwidth is 4, if width is empty     
        if ( !width.empty()) {
          std::istringstream sin(width);
          sin >> w;
        }

        std::ostringstream sout;

        switch( buffer[pos_key]) {
        case 'p': {
          // If myRank<0, then match the rank with any integer of width w
          if ( myRank<0)
            for ( int i=0; i<w; ++i) sout << "[0-9]";
          else
            sout << std::setfill('0') << std::setw(w) << myRank;

          break;
        }
        case 'i':
        case 'b': {
          // TODO: Use the mapping rule on the next line to distribute files.
          // For now, have all processes read all files that match the number
          // of digits for the block or pane ID in the filenames.
          for ( int i=0; i<w; ++i) sout << "[0-9]";
          break;
        }
        default:
          COM_assertion_msg( false, (std::string("Unknown keyword in file name ")+buffer).c_str());
        }

        buffer.replace(pos, pos_key - pos + 1, sout.str());
      }

      // Determine whether buffer has directory part. If not, prepend that
      // of the control file. If so, then use it as is.
      if ( !dir_name.empty()) {
/*
        std::string::size_type pos = buffer.find_last_of('/');
        if ( pos == std::string::npos) buffer.insert(0, dir_name);
*/
          // when it is not absolute path and does not have same prefix
        if (buffer[0] != '/' &&
             strncmp(buffer.c_str(), dir_name.c_str(), std::min(buffer.size(), dir_name.size())))   buffer.insert(0, dir_name);
      }

      // Insert buffer into patterns.
      local_patterns.push_back(buffer);

      fin >> buffer;
    }

    // The @Panes section may not be present
    if (buffer == "@Proc:") {
      patterns.insert(patterns.end(), local_patterns.begin(),
                      local_patterns.end());
      continue;
    }

    m_base = 0;
    m_offset = 0;
    m_is_local = NULL;

    if ( !fin.eof()) 
      fin >> buffer;
    else
      buffer = "-1";

    // Read in panes.
    if (buffer == "@Cyclic") {
      fin >> m_offset;
      m_is_local = &Rocin::cyclic_local;
    } else if (buffer == "@BlockCyclic") {
      fin >> m_base; 
      fin >> m_offset;
      m_is_local = &Rocin::blockcyclic_local;
    } else if (buffer == "@Block" || buffer == "@BlockBlockCyclic") {
      int block;
      fin >> block;
      fin >> m_base; 
      fin >> m_offset;
      int quot = block/comm_size, rem = block-quot*comm_size;
      if ( rank < rem) { 
        m_base *= quot+1;
      }
      else {
        m_offset += rem;
        m_base *= quot;
      }
      m_is_local = &Rocin::blockcyclic_local;
    } else if (buffer == "@All" || buffer == "*") {
      m_is_local = NULL;
    } else if (buffer[0] == '@' && buffer != "@Panes:" ) {
      if ( buffer != "@Proc:") { // Skip empty @Panes section.
        std::cerr << "Rocstar: Error (read_by_control_file): in control file "
                  << control_file_name << ": expected pane info but found '"
                  << buffer << '\'' << std::endl;
        return;
      } else {
        // ignore file when no pane
        local_patterns.clear();
      }
    } else {
      m_is_local = &Rocin::explicit_local;

      for (;;) {
        if (buffer[0] < '0' || buffer[0] > '9')
          break;

        std::istringstream sin(buffer);
        int p=-1;

        sin >> p;

        if ( p>=0) {
          m_pane_ids.insert(p);
        } else {
          break;
        }

        if (!fin.eof()) fin >> buffer;
        else break;
      }
    }

    patterns.insert(patterns.end(), local_patterns.begin(),
                    local_patterns.end());

    if ( myRank >= 0 && rank == myRank) break;
  }
  fin.close();

  if ( myRank>=0 && rank != myRank) 
    std::cerr << "Rocstar: Warning: Did not find matching control blocks for process " << myRank << std::endl;

  // If myRank is a wild card and panes aren't specified explicitly, then
  // make all panes local.
  if (myRank < 0 && m_is_local != &Rocin::explicit_local)
    m_is_local = NULL;

  // Convert the patterns into a single string
  std::string files;
  std::vector<std::string>::const_iterator p;
  for (p=patterns.begin(); p!=patterns.end(); ++p)
    files = files+" "+(*p).c_str();

  // Invoke read_window
  //std::cout << __FILE__ << __LINE__ << " files = " << files << std::endl;
  read_window(files.c_str(), window_name, myComm, NULL, time_level, str_len);

  m_pane_ids.clear();
  m_offset = 0;
  m_base = 0;
  m_is_local = NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_parameter_file	(	const char *	file_name,
		const char *	window_name,
		const MPI_Comm *	comm = NULL
	)

Read in parameters from a given file into the given window.

If the window exists, then only read in the values for the attributes which exist in the window. If not, then create the window and define all options as window attributes of base type of character strings. Process 0 of the communicator should read in the parameters, and then broadcast to all the processes. If comm is not specified, then use the communicator of the window as default. If an option is listed more than once in the parameter_file, then the last value for that option will overwrite the others.

Parameters

file_name	the file containing the parameters to be read in.
window_name	window where parameters will be placed
comm	The MPI communicator for parameter broadcast. If NULL, then the communicator of window_name will be used.

Definition at line 40 of file read_parameter_file.C.

References cimg_library::cimg::atof(), COM_assertion_msg, COM_BOOL, COM_CHAR, COM_DOUBLE, COM_DOUBLE_PRECISION, COM_FLOAT, COM_get_roccom(), COM_get_window_handle(), COM_INT, COM_INTEGER, COM_new_attribute(), COM_new_window(), COM_REAL, COM_resize_array(), COM_set_size(), COM_UNSIGNED, COM_window_init_done(), get_parameter_list(), i, and ni.

Referenced by init().

                                                            {

   // vector of (option,value) pairs
  std::vector<std::pair<std::string,std::string> > param_list;
  get_parameter_list(param_list, file_name);

  // Check to see if the window exists
  //  Roccom_base * rcom= COM_get_roccom();
  COM::Roccom_base * rbase = COM_get_roccom();
  int whandle = COM_get_window_handle(window_name);
  COM::Window* param_window = NULL;
  if(whandle >0)
    param_window = rbase->get_window_object(whandle);
  COM::Attribute* param_att = NULL;

  // if the parameter window already exists, then only read
  // in attributes which exist in the window
  if(param_window){
    for(uint i =0, ni = param_list.size(); i<ni; ++i){

      param_att = param_window->attribute(param_list[i].first);

      if (param_att) {
        COM_assertion_msg( param_att->location()=='w' &&
                           param_att->size_of_components()==1,
                           "The attribute must be a windowed scalar attribute.");
        // Obtain address for the current attribute.
        void *addr = param_att->pointer();
        COM_assertion_msg( addr, "Unexpected null pointer");

        // Map value based on its type.
        switch ( param_att->data_type()) {
        case COM_INTEGER:
        case COM_UNSIGNED:
        case COM_INT: {
          *(int*)addr = std::atoi( param_list[i].second.c_str());
          break;
        }
        case COM_DOUBLE_PRECISION:
        case COM_DOUBLE: {
          // replace 'd' or 'D' by 'e'
          char *p = const_cast< char* >(  strpbrk(param_list[i].second.c_str(), "dD") );
          if (p) *p = 'e';
          *(double*)addr = std::atof( param_list[i].second.c_str());
          break;
        }
        case COM_FLOAT:
        case COM_REAL: {
          char *p = const_cast< char* >( strpbrk(param_list[i].second.c_str(), "dD") );
          if (p) *p = 'e';
          *(float*)addr = std::atof( param_list[i].second.c_str());
          break;
        }
        case COM_CHAR: {
          int param_size = param_list[i].second.size();
          COM_assertion_msg( param_size<param_att->size_of_items(),
                             "Attribute does not have enough space");

          strcpy( (char*)addr, param_list[i].second.c_str());
          break;
        }
        case COM_BOOL: {
          int param_size = param_list[i].second.size();
          const char *str = param_list[i].second.c_str();
          char val = str[0];
          if (val == 'T') val = 1;
          if (val == 'F') val = 0;
          if (val == 'Y') val = 1;
          if (val == 'N') val = 0;
          if (val == '1') val = 1;
          if (val == '0') val = 0;
          COM_assertion_msg((val == 1 || val==0),
                             "Invalid boolean value (T or F)");

          *(char *)addr = val;
          break;
        }
        default:
          COM_assertion_msg(false, "Unsupported data type.");
        }
      }
    }
  }
  // if the parameter window doesn't exist, then create it
  // and populate it will all of the option value pairs
  else{
    if(param_comm)
      COM_new_window(window_name, *param_comm);
    else
      COM_new_window(window_name);
    std::string wname(window_name);
    for(uint i =0, ni = param_list.size(); i<ni; ++i){
      COM_new_attribute( (wname+"."+param_list[i].first).c_str(),
                         'w', COM_CHAR, 1, "");
      int param_size = param_list[i].second.size();
      COM_set_size( (wname+"."+param_list[i].first).c_str(),
                    0, param_size+1,0);
      void *addr;
      COM_resize_array( (wname+"."+param_list[i].first).c_str(), 0, &addr);
      strcpy( (char*)addr, param_list[i].second.c_str());
    }
    // Create an empty pane so that the window will be written out by Rocout
    COM_set_size((wname+".nc").c_str(),1,0);
    COM_window_init_done(window_name);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_window	(	const char *	filename_patterns,
		const char *	window_name,
		const MPI_Comm *	comm = NULL,
		RulesPtr	is_local = NULL,
		char *	time_level = NULL,
		const int *	str_len = NULL
	)

Create a single Roccom window by reading in a list of files.

Read in metadata from files, and optionally read in array data as well.

Parameters

filename_patterns	specifies the patterns of the files to be read in. Patterns take the form of regular expressions in the same format as the shell commands use. Separate multiple patterns with empty space.
window_name	the name of the window to be created.
comm	The MPI communicator to use. If is NULL, the default communicator of Roccom will be used.
is_local	a function pointer which determines wheter a pane should be read by a process.
time_level	the time stamp of the dataset to be read. If time level is NULL (default) or "", then the first time_level in the file will be assumed.
str_len	if present and positive, the time stamp of the dataset will be copied to the time_level string.
filename_patterns	Specifies patterns (reg. expressions) of files to be read in.
window_name	Specifies a name of the window to be created.
comm	The MPI communicator to use. If is NULL, the default communicator of Roccom will be used.
is_local	A function pointer, which determines wheter a pane should be read by a process.
time_level	the time stamp of the dataset to be read. If time level is NULL (default) or "", then the first time_level in the file will be used.
str_len	if present and positive, the time stamp of the dataset will be copied to the time_level string.

Definition at line 2750 of file Rocin.C.

References read_windows().

Referenced by init(), and read_by_control_file().

{
  read_windows( filename_patterns, window_name, "", comm, is_local,
                time_level, str_len);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_windows	(	const char *	filename_patterns,
		const char *	window_prefix,
		const char *	material_names = NULL,
		const MPI_Comm *	comm = NULL,
		RulesPtr	is_local = NULL,
		char *	time_level = NULL,
		const int *	str_len = NULL
	)

Create a series of Roccom windows by reading in a list of files.

Read in metadata from files, and optionally read in array data as well Read in metadata from files, and optionally read in array data as well.

Parameters

filename_patterns	specifies the patterns of the files to be read in. Patterns take the form of regular expressions in the same format as the shell commands use. Separate multiple patterns with empty space.
window_prefix	a prefix of the name(s) of the window(s) to be created. Actual window name is appended by a material name and there can be multiple materials per file.
material_names	a list of space-separated materials to be read from files. If material name is NULL (default), then "" will be used and it is assumed that files contain only one type of material.
comm	The MPI communicator to use. If is NULL, the default communicator of Roccom will be used.
is_local	a function pointer which determines wheter a pane should be read by a process.
time_level	the time stamp of the dataset to be read. If time level is NULL (default) or "", then the first time_level in the file will be assumed.
str_len	if present and positive, the time stamp of the dataset will be copied to the time_level string.
filename_patterns	Specifies patterns (reg. expressions) of files to be read in.
window_prefix	Specifies a prefix of the name(s) of the window(s) to be created.
material_names	Spcifies a space-delimited list of materials to be read from the files.
comm	The MPI communicator to use. If is NULL, the default communicator of Roccom will be used.
is_local	A function pointer, which determines wheter a pane should be read by a process.
time_level	the time stamp of the dataset to be read. If time level is NULL (default) or "", then the first time_level in the file will be used.
str_len	if present and positive, the time stamp of the dataset will be copied to the time_level string.

Definition at line 2786 of file Rocin.C.

References broadcast_win_attributes(), cast_err_func(), COM_get_default_communicator(), COM_new_window(), COM_window_init_done(), COMMPI_Initialized(), CWD(), DEBUG_MSG, free_blocks(), glob_error(), load_data_HDF4(), m_HDF2COM, new_attributes(), rank, register_panes(), scan_files_HDF4(), cimg_library::cimg::time(), and x.

Referenced by init(), and read_window().

{
  //std::cout << __FILE__ << __LINE__ 
  //          << " filename_patterns = " << filename_patterns
  //          << std::endl;
  const MPI_Comm default_comm=COM_get_default_communicator();
  const MPI_Comm comm_null=MPI_COMM_NULL;
  const MPI_Comm* myComm = 
    COMMPI_Initialized()? (comm ? comm : &default_comm ) : &comm_null;

  int rank, nprocs;
  if ( *myComm != MPI_COMM_NULL) {
    MPI_Comm_rank(*myComm, &rank);
    MPI_Comm_size(*myComm, &nprocs);
  }
  else {
    rank = 0; nprocs=1;
  }

  DEBUG_MSG("time_level == " << (time_level == NULL ? "<Null>" : time_level));
  std::string time( time_level?time_level:"");
  DEBUG_MSG("time == " << time);

  std::set<std::string> materials;
  char* buffer;
  char* token;

  // Insert list of material names into materials.
  if (material_names != NULL) {
    buffer = new char[strlen(material_names)+1];
    strcpy(buffer, material_names);

    token = strtok(buffer, " \t\n");
    while (token != NULL) {
      materials.insert(token);
      token = strtok(NULL, " \t\n");
    }
    delete[] buffer;
  }

  buffer = new char[strlen(filename_patterns)+1];
  strcpy(buffer, filename_patterns);

  BlockMM_HDF4 blocks_HDF4;
#ifdef USE_CGNS
  BlockMM_CGNS blocks_CGNS;
#endif // USE_CGNS

  token = strtok(buffer, " \t\n");
  if (token != NULL) {
#ifndef _NO_GLOB_
    glob_t globbuf;
    
    glob(token, 0, cast_err_func(glob,glob_error), &globbuf);
    token = strtok(NULL, " \t\n");
    while (token != NULL) {
      glob(token, GLOB_APPEND, cast_err_func(glob,glob_error), &globbuf);
      token = strtok(NULL, " \t\n");
    }

    if ( globbuf.gl_pathc==0 && buffer[0]!='\0') 
      std::cerr << "Rocstar: Warning: Found no matching files for pattern "
                << buffer << std::endl;

    // Extracts metadata from a list of files.
    // Opens each file, scans dataset, identifies windows, panes, and attribute
    // Puts this information into blocks.
    // MS
    //std::cout << __FILE__ << __LINE__ 
    //          << "gl_pathv = " << globbuf.gl_pathv[0]
    //          << std::endl;  
    // search for hdf or cgns
    bool isHDF = false; 
    bool isCGNS = false;
    if ((std::string(globbuf.gl_pathv[0])).find(".hdf") != std::string::npos){
       isHDF = true;
       std::cout << "npos = " << (std::string(globbuf.gl_pathv[0])).find(".hdf") <<std::endl; 
    }
    isCGNS = isHDF ? false:true;
    //std::cout << "isHdf = " << isHDF << " isCGNS = " << isCGNS << std::endl;
    // MS End
    if (isHDF){
       scan_files_HDF4(globbuf.gl_pathc, globbuf.gl_pathv, blocks_HDF4, time,
                       m_HDF2COM);
       //std::cout << "Read HDF!" << std::endl;
    } else {
#ifdef USE_CGNS 
    scan_files_CGNS(globbuf.gl_pathc, globbuf.gl_pathv, blocks_CGNS, time,
                    m_CGNS2COM);
    //std::cout << "Read CGNS!" << std::endl;
#endif
    }
// Original
//#ifndef USE_CGNS
//    scan_files_HDF4(globbuf.gl_pathc, globbuf.gl_pathv, blocks_HDF4, time,
//                    m_HDF2COM);
//#else 
//    scan_files_CGNS(globbuf.gl_pathc, globbuf.gl_pathv, blocks_CGNS, time,
//                    m_CGNS2COM);
//#endif
// Original End
    globfree(&globbuf);
#else // No glob function on this system
    // Create a char** of n filenames matching patterns stored in buffer
    //  each token is a new pattern
    std::list<std::string> matching_filenames;
    while (token != NULL) {
      std::string dirname(CWD());
      std::string tstring(token);
      std::string::size_type x = tstring.find_last_of("/");
      if(x != std::string::npos){
        dirname += ("/" + tstring.substr(0,x));
        tstring.erase(0,x+1);
      }
      Directory directory(dirname);
      if(directory){
        Directory::iterator di = directory.begin();
        while(di != directory.end()){
          if(!fnmatch(tstring.c_str(),di->c_str(),0))
            matching_filenames.push_back(dirname + "/" + *di);
          di++;
        }
      }
      token = strtok(NULL, " \t\n");
    }
    if(matching_filenames.empty() && buffer[0] != '\0')
      std::cerr << "Rocstar: Warning: Found no matching files for pattern "
                << buffer << std::endl;
    unsigned int nmatch = matching_filenames.size();
    std::vector<char *> matches(nmatch);
    std::list<std::string>::iterator li = matching_filenames.begin();
    unsigned int ccount = 0;
    while(li != matching_filenames.end()){
      unsigned int lis = li->size();
      matches[ccount++] = new char [lis+1];
      strcpy(matches[ccount-1],li->c_str());
      matches[ccount-1][lis] = '\0';
      li++;
    }
#ifndef USE_CGNS
    scan_files_HDF4(nmatch, &matches[0], blocks_HDF4, time,
                    m_HDF2COM);
#else 
    scan_files_CGNS(nmatch, &matches[0], blocks_CGNS, time,
                    m_CGNS2COM);
#endif
    ccount = 0;
    while(ccount < nmatch){
      if(matches[ccount])
        delete [] matches[ccount];
      ccount++;
    }
#endif
  }

  delete[] buffer;

  // Copy out time level
  if ( time_level && str_len && *str_len) { 
    // TODO: Run MPI_Allgather to send time level to those with no data
    // and check whether all processes obtained the same non-empty time level.
    std::strncpy( time_level, time.c_str(), *str_len-1); 
    time_level[*str_len-1] = '\0';
  }

  std::string name;
  std::set<std::string>::iterator p = materials.begin();
  std::pair<BlockMM_HDF4::iterator, BlockMM_HDF4::iterator> range_HDF4;
#ifdef USE_CGNS
  std::pair<BlockMM_CGNS::iterator, BlockMM_CGNS::iterator> range_CGNS;
#endif // USE_CGNS

  if (materials.empty()) {
    // Default value of material_names is NULL
    // we assume the file only contains one type of material, and 
    // the window name is the window_prefix.
    range_HDF4.first = blocks_HDF4.begin();
    range_HDF4.second = blocks_HDF4.end();
#ifdef USE_CGNS
    range_CGNS.first = blocks_CGNS.begin();
    range_CGNS.second = blocks_CGNS.end();
#endif // USE_CGNS
    name = window_prefix;

    COM_new_window(name.c_str(), *myComm);

    new_attributes( range_HDF4.first, range_HDF4.second,
#ifdef USE_CGNS
                    range_CGNS.first, range_CGNS.second,
#endif // USE_CGNS
                    name, myComm, rank, nprocs);
    register_panes( range_HDF4.first, range_HDF4.second,
#ifdef USE_CGNS
                    range_CGNS.first, range_CGNS.second,
#endif // USE_CGNS
                    name, is_local, myComm, rank, nprocs);

    load_data_HDF4(range_HDF4.first, range_HDF4.second,
                   name, myComm, rank, nprocs);
#ifdef USE_CGNS
    load_data_CGNS(range_CGNS.first, range_CGNS.second,
                   name, myComm, rank, nprocs);
#endif // USE_CGNS

    broadcast_win_attributes( range_HDF4.first == range_HDF4.second
#ifdef USE_CGNS
                              && range_CGNS.first == range_CGNS.second
#endif // USE_CGNS
                              , name, myComm, rank, nprocs);

    COM_window_init_done(name.c_str());
  } else {

    // Iterate through each material (one window per material).
    while (p != materials.end()) {
      if (blocks_HDF4.count(*p) == 0
#ifdef USE_CGNS
          && blocks_CGNS.count(*p) == 0
#endif // USE_CGNS
          ) {
        std::cerr << "Rocstar: Warning (read_windows): could not find '" << *p << "'."
                  << std::endl;
        ++p; // Increment p.
        continue;
      }

      range_HDF4 = blocks_HDF4.equal_range(*p);
#ifdef USE_CGNS
      range_CGNS = blocks_CGNS.equal_range(*p);
#endif // USE_CGNS
      name = window_prefix + *p;

      COM_new_window(name.c_str(), *myComm);

      new_attributes( range_HDF4.first, range_HDF4.second,
#ifdef USE_CGNS
                      range_CGNS.first, range_CGNS.second,
#endif // USE_CGNS
                      name, myComm, rank, nprocs);
      register_panes( range_HDF4.first, range_HDF4.second,
#ifdef USE_CGNS
                      range_CGNS.first, range_CGNS.second,
#endif // USE_CGNS
                      name, is_local, myComm, rank, nprocs);

      load_data_HDF4(range_HDF4.first, range_HDF4.second,
                     name, myComm, rank, nprocs);
#ifdef USE_CGNS
      load_data_CGNS(range_CGNS.first, range_CGNS.second,
                     name, myComm, rank, nprocs);
#endif // USE_CGNS

      broadcast_win_attributes( range_HDF4.first == range_HDF4.second
#ifdef USE_CGNS
                                && range_CGNS.first == range_CGNS.second
#endif // USE_CGNS
                                , name, myComm, rank, nprocs);

      COM_window_init_done(name.c_str());

      ++p;
    }
  }

  // Free memory.
  free_blocks(blocks_HDF4);
#ifdef USE_CGNS
  free_blocks(blocks_CGNS);
#endif // USE_CGNS
}

Here is the call graph for this function:

Here is the caller graph for this function:

void register_panes ( BlockMM_HDF4::iterator  hdf4, const BlockMM_HDF4::iterator &  hdf4End, const std::string &  window, RulesPtr  is_local, const MPI_Comm *  comm, int  rank, int  nprocs  )

protected

Definition at line 2200 of file Rocin.C.

References COM_DOUBLE, COM_new_attribute(), COM_set_array(), COM_set_size(), DEBUG_MSG, is_local(), Block_HDF4::m_gridInfo, m_is_local, Block_HDF4::m_numGhostNodes, Block_HDF4::m_numNodes, Block_HDF4::m_paneId, Block_HDF4::m_units, Block_HDF4::m_variables, and q.

Referenced by read_windows().

{
  int local;
  std::string name;
  bool is_first=true;
  for ( ; hdf4!=hdf4End; ++hdf4) {
    Block_HDF4* block = (*hdf4).second;

    // Panes are a local construct, so make sure that this pane is local.
    if ( m_is_local)
      (this->*m_is_local)(block->m_paneId, rank, nprocs, &local);
    else if (is_local)
      is_local(block->m_paneId, rank, nprocs, &local);
    else
      local = 1;

    if (!local) continue;

    // Register the mesh unit & number of nodes
    name = window + ".nc";
    if (is_first && !block->m_units.empty()) {

      DEBUG_MSG("Calling COM_new_attribute( name == '" << name << "', position == 'n', datatype == COM_DOUBLE, nComp == 3, units == '" << block->m_units << "' )");
      COM_new_attribute(name.c_str(),'n',COM_DOUBLE,3,block->m_units.c_str());
      is_first = false;
    }

    DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << block->m_numNodes << ", nghost == " << block->m_numGhostNodes << " )");
    COM_set_size(name.c_str(), block->m_paneId,
                 block->m_numNodes,block->m_numGhostNodes);      

    // Register the connectivity tables or the mesh dimensions
    // need to specify attribute names for multiple connectivity tables
    if (block->m_gridInfo.size() && 
        block->m_gridInfo.front().m_name.substr(0,3) == ":st") {
      int mysize[3], ndim = block->m_gridInfo.front().m_name[3] - '0';
      mysize[0] = block->m_gridInfo.front().m_size[2];
      mysize[1] = block->m_gridInfo.front().m_size[1];
      mysize[2] = block->m_gridInfo.front().m_size[0];
      name = window + '.' + block->m_gridInfo.front().m_name;

      DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << ndim << ", nghost == " << block->m_gridInfo.front().m_numGhostElements << " )");
      COM_set_size(name.c_str(), block->m_paneId, ndim,
                   block->m_gridInfo.front().m_numGhostElements);
      COM_set_array(name.c_str(),block->m_paneId,mysize);
    } else {
      std::vector<GridInfo_HDF4>::iterator q;
      for (q=block->m_gridInfo.begin(); q!=block->m_gridInfo.end(); ++q){
        name = window + "." + (*q).m_name;
        DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << (*q).m_numElements << ", nghost == " << (*q).m_numGhostElements << " )");
        COM_set_size(name.c_str(), block->m_paneId,
                     (*q).m_numElements, (*q).m_numGhostElements);
      }
    }

    // Set sizes for pane attributes.
    std::vector<VarInfo_HDF4> &vars = block->m_variables;
    std::vector<VarInfo_HDF4>::const_iterator q;

    for ( q=vars.begin(); q!=vars.end(); ++q) {
      if ( (*q).m_position == 'p' || (*q).m_position == 'c') {
        name = window + "." + (*q).m_name;
        DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << (*q).m_nitems << ", nghost == " << (*q).m_ng << " )");
        COM_set_size( name.c_str(), block->m_paneId, 
                      (*q).m_nitems, (*q).m_ng);
      }
    }
  }

#ifdef USE_CGNS
  for ( ; cgns!=cgnsEnd; ++cgns) {
    Block_CGNS* block = (*cgns).second;

    // Panes are a local construct, so make sure that this pane is local.
    if ( m_is_local)
      (this->*m_is_local)(block->m_paneId, rank, nprocs, &local);
    else if (is_local)
      is_local(block->m_paneId, rank, nprocs, &local);
    else
      local = 1;

    if (!local) continue;

    // Register the mesh unit & number of nodes
    name = window + ".nc";
    if (is_first && !block->m_units.empty()) {

      DEBUG_MSG("Calling COM_new_attribute( name == '" << name << "', position == 'n', datatype == COM_DOUBLE, nComp == 3, units == '" << block->m_units << "' )");
      COM_new_attribute(name.c_str(),'n',COM_DOUBLE,3,block->m_units.c_str());
      is_first = false;
    }

    DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << block->m_numNodes << ", nghost == " << block->m_numGhostNodes << " )");
    COM_set_size(name.c_str(), block->m_paneId,
                 block->m_numNodes,block->m_numGhostNodes);      

    // Register the connectivity tables or the mesh dimensions
    // need to specify attribute names for multiple connectivity tables
    if (block->m_gridInfo.size() && 
        block->m_gridInfo.front().m_name.substr(0,3) == ":st") {
      int ndim = block->m_gridInfo.front().m_name[3] - '0';
      name = window + '.' + block->m_gridInfo.front().m_name;

      DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << ndim << ", nghost == " << block->m_gridInfo.front().m_numGhostElements << " )");
      COM_set_size(name.c_str(), block->m_paneId, ndim,
                   block->m_gridInfo.front().m_numGhostElements);
      COM_set_array(name.c_str(), block->m_paneId,
                    block->m_gridInfo.front().m_size);
    } else {
      std::vector<GridInfo_CGNS>::iterator q;
      for (q=block->m_gridInfo.begin(); q!=block->m_gridInfo.end(); ++q){
        name = window + "." + (*q).m_name;
        DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << (*q).m_numElements << ", nghost == " << (*q).m_numGhostElements << " )");
        COM_set_size(name.c_str(), block->m_paneId,
                     (*q).m_numElements, (*q).m_numGhostElements);
      }
    }

    // Set sizes for pane attributes.
    std::vector<VarInfo_CGNS> &vars = block->m_variables;
    std::vector<VarInfo_CGNS>::const_iterator q;

    for ( q=vars.begin(); q!=vars.end(); ++q) {
      if ( (*q).m_position == 'p' || (*q).m_position == 'c') {
        name = window + "." + (*q).m_name;
        DEBUG_MSG("Calling COM_set_size( name == '" << name << "', paneid == " << block->m_paneId << ", nitems == " << (*q).m_nitems << ", nghost == " << (*q).m_ng << " )");
        COM_set_size( name.c_str(), block->m_paneId, 
                      (*q).m_nitems, (*q).m_ng);
      }
    }
  }
#endif // USE_CGNS
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

void Rocin_load_module ( const char *  name )

friend

Load the module Rocin into Roccom using the given module name.

This module provides three subroutines: "read_windows", "read_by_control_file", and "obtain_attribute".

Definition at line 3063 of file Rocin.C.

{ Rocin::init( std::string(name)); }

void Rocin_unload_module ( const char *  name )

friend

Unload the module Rocin from Roccom.

Definition at line 3066 of file Rocin.C.

{ Rocin::finalize( std::string(name)); }

Member Data Documentation

int m_base

protected

Definition at line 243 of file Rocin.h.

Referenced by blockcyclic_local(), and read_by_control_file().

std::map<int32, COM_Type> m_HDF2COM

protected

Definition at line 246 of file Rocin.h.

Referenced by init(), and read_windows().

MemberRulePtr m_is_local

protected

Definition at line 241 of file Rocin.h.

Referenced by read_by_control_file(), and register_panes().

int m_offset

protected

Definition at line 244 of file Rocin.h.

Referenced by blockcyclic_local(), cyclic_local(), and read_by_control_file().

std::set<int> m_pane_ids

protected

Definition at line 242 of file Rocin.h.

Referenced by explicit_local(), and read_by_control_file().

---

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

• Rocin.h
• read_parameter_file.C
• Rocin.C