Rocout Class Reference

#include <Rocout.h>

Inheritance diagram for Rocout:

Collaboration diagram for Rocout:

Public Member Functions
User interface
void	write_attribute (const char *filename_pre, const COM::Attribute *attr, const char *material, const char *timelevel, const char *mfile_pre=NULL, const MPI_Comm *comm=NULL, const int *pane_id=NULL)
	Write a (possibly aggregate) attribute to a file. More...
void	put_attribute (const char *filename_pre, const COM::Attribute *attr, const char *material, const char *timelevel, const char *mfile_pre=NULL, const MPI_Comm *comm=NULL, const int *pane_id=NULL)
	Write a (possibly aggregate) attribute to a new file. More...
void	add_attribute (const char *filename_pre, const COM::Attribute *attr, const char *material, const char *timelevel, const char *mfile_pre=NULL, const MPI_Comm *comm=NULL, const int *pane_id=NULL)
	Append a (possibly aggregate) attribute to a file. More...
void	sync ()
	Wait for the completion of an asychronous write operation. More...
void	write_rocin_control_file (const char *window_name, const char *file_prefixes, const char *control_file_name)
	Generate a control file for Rocin. More...
void	set_option (const char *option_name, const char *option_val)
	Set an option for Rocout, such as controlling the output format. More...
void	write_parameter_file (const char *file_name, const char *window_name, const MPI_Comm *comm=NULL)
	Write out the parameters defined in the fiven window into a parameter file. More...
void	read_control_file (const char *filename)
	Set options for Rocout via a control file. 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
std::map< std::string, std::string >	_options

Friends
Module loading and unloading
void	Rocout_load_module (const char *name)
	Load the module Rocout into Roccom using the given module name. More...
void	Rocout_unload_module (const char *name)
	Unload the module Rocout from Roccom. More...

Implementation
static void *	write_attr_internal (void *attrInfo)
	Does the actual writing to file. More...
std::string	get_fname (const std::string &pre, int rank=-1, const int paneId=0, bool check=false)
	Builds a filename from the given prefix and rank. More...

Detailed Description

Definition at line 81 of file Rocout.h.

Member Function Documentation

void add_attribute	(	const char *	filename_pre,
		const COM::Attribute *	attr,
		const char *	material,
		const char *	timelevel,
		const char *	mfile_pre = NULL,
		const MPI_Comm *	comm = NULL,
		const int *	pane_id = NULL
	)

Append a (possibly aggregate) attribute to a file.

Append an attribute to a file.

Parameters

filename_pre	the prefix of the file name.
attr	a reference to the attribute to be written.
material	the name of the material (usually the window name).
time_level	the time stamp of the dataset.
mfile_pre	the prefix of the file that contains the mesh data.
comm	The MPI communicator to use. If is NULL, the default communicator of the Roccom window will be used.
pane_id	the pane to be written.
filename_pre	the prefix of the file name.
attr	a reference to the attribute to be written.
material	the name of the material (usually the window name).
time_level	the time stamp of the dataset.
mfile_pre	the prefix of the file that contains the mesh data.
pComm	The MPI communicator to use. If is NULL, the default communicator of the Roccom window will be used.
pane_id	the pane to be written.

Definition at line 329 of file Rocout.C.

References _options, id(), and write_attr_internal().

Referenced by init().

{
  //std::cout << __FILE__ << __LINE__ << std::endl;
  //std::cout << "Attribute = " << (attr)->fullname() << std::endl;
  //std::cout << "Size = " << (attr)->size_of_items() << std::endl;
  WriteAttrInfo* pWAI;

#ifdef USE_PTHREADS
  if (_options["async"] == "off") {
#endif // USE_PTHREADS
    pWAI = new WriteAttrInfo(this, filename_pre, attr, material, timelevel, 
                             mfile_pre, pComm, pane_id, 1);
    write_attr_internal(pWAI);
#ifdef USE_PTHREADS
  } else {
    pWAI = new WriteAttrInfo(this, filename_pre, attr, material, timelevel, 
                             mfile_pre, pComm, pane_id, 1, true);
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

    pthread_t id;
    pthread_create(&id, &attr, write_attr_internal, pWAI);
    pthread_attr_destroy(&attr);
    _writers.push_back(id);
  }
#endif // USE_PTHREADS
}

Here is the call graph for this function:

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 213 of file Rocout.C.

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

Referenced by Rocout_unload_module().

                                            {
  Rocout *rout;
  std::string glb=mname+".global";

  COM_get_object( glb.c_str(), 0, &rout);
  
  COM_delete_window( mname.c_str());

#ifdef USE_PTHREADS
  // Wait for any writer threads to finish.
  void* ret;
  std::vector<pthread_t>::iterator p = rout->_writers.begin();
  while (p != rout->_writers.end()) {
    pthread_join(*p, &ret);
    ++p;
  }
# endif // USE_PTHREADS

  delete rout;
  HDF4::finalize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string get_fname ( const std::string &  prefix, int  rank = -1, const int  paneId = 0, bool  check = false  )

protected

Builds a filename from the given prefix and rank.

Build a filename.

Parameters

pre	Filename prefix.
rank	The rank of this MPI process.
pPaneId	A pointer to the pane id.
check	Check for an existing file.

Get a file name by appending an underscore, a 4-digit rank id, and an extension to the "localdir" and given prefix. If the pre contains .hdf or .cgns, then use it as the file name.

Definition at line 825 of file Rocout.C.

References _options, ERROR_MSG, cimg_library::cimg::fclose(), cimg_library::cimg::fopen(), MPI_COMM_WORLD, n, rank, s, and sin.

Referenced by write_attr_internal().

{
  // Modify the prefix using the "localdir" option.
  std::string pre(_options["localdir"]);
  if (!pre.empty()) {
    // Make sure there's exactly one '/' between the localdir and given prefix.
    if (prefix[0] == '/') {
      if (pre[pre.length()-1] == '/')
        pre.erase(pre.length() - 1);
    } else {
      if (pre[pre.length()-1] != '/')
        pre += '/';
    }
  }
  pre += prefix;

  if (_options["rankdir"] == "on") {   // write output file in <rank> dir
    std::ostringstream rank_prefix; 
    rank_prefix << "/" << rank;
    std::string::size_type s = pre.find_last_of('/');
    if (s != std::string::npos)
      pre.insert(s, rank_prefix.str());
  }

  // Make sure the directory exists.  Ignore any errors except for the last.
  int result = 0;
  std::string::size_type s = pre.find('/', 1);
  while (s != std::string::npos) {
    result = mkdir(pre.substr(0, s).c_str(), 0755);
    s = pre.find('/', s + 1);
  }
  if (result < 0 && errno != EEXIST) {
    ERROR_MSG("Rocout::write_attribute(): could not create directory '" 
              << pre.substr(0, pre.rfind('/') + 1) << "'.");
  }

  if ( pre.find(".hdf") == pre.size()-4) {
    _options["format"] = "HDF4";
    return pre;
  }
  else if (pre.find(".cgns") == pre.size()-5) {
    _options["format"] = "CGNS";
    return pre;
  }
  
  if (rank < 0) {
    int flag = 0;
    MPI_Initialized(&flag);
    if (flag)
      MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    else
      rank = 0; 
  }             
                
  std::string name;
    
  if (!pre.empty()) {
    int rw, pw;
    {
      std::istringstream sin(_options["rankwidth"]);
      sin >> rw;
    }
    {
      std::istringstream sin(_options["pnidwidth"]);
      sin >> pw;
    }
    
    std::ostringstream sout;
    sout << pre;
    if (rw > 0)
      sout << std::setw(rw) << std::setfill('0') << rank;
    if (pw > 0 && paneId > 0) {
      if (rw > 0)
        sout << _options["separator"];
      sout << std::setw(pw) << std::setfill('0') << paneId;
    }
  
    const std::string fmt = _options["format"];
    if ( fmt == "HDF" || fmt == "HDF4")
      sout << ".hdf";
    else if (fmt == "HDF5")
      sout << ".hdf5";
    else if (fmt == "CGNS")
      sout << ".cgns";
    
    name = sout.str();
    
    if (check) {
      std::FILE* f;
      if ((f = std::fopen(name.c_str(), "r")) != NULL) 
        std::fclose(f);
      else if ((f = std::fopen(name.c_str(), "w")) != NULL) {
        std::fclose(f);
        std::remove(name.c_str());
      } else {
        // Change the directory to current directory
        std::string::size_type n = name.rfind('/');
        if (n != std::string::npos)
          name.erase(0, n + 1);
      }
    }
  }

  return name;
}

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 Rocout_load_module.

See Also

Rocout_load_module()

Definition at line 139 of file Rocout.C.

References _options, add_attribute(), COM_METADATA, COM_MPI_COMM, COM_new_attribute(), COM_new_window(), COM_RAWDATA, COM_set_member_function(), COM_set_object(), COM_STRING, COM_VOID, COM_window_init_done(), HDF4::init(), MPI_COMM_SELF, put_attribute(), read_control_file(), set_option(), sync(), write_attribute(), write_parameter_file(), and write_rocin_control_file().

Referenced by Rocout_load_module().

                                        {

  HDF4::init();

  Rocout *rout = new Rocout();

  // Masoud, changing default to CGNS
  //rout->_options["format"] = "HDF4";
  rout->_options["format"] = "CGNS";
  //
  rout->_options["async"] = "off";
  rout->_options["mode"] = "w";
  rout->_options["localdir"] = "";
  rout->_options["rankwidth"] = "4";
  rout->_options["pnidwidth"] = "0";
  rout->_options["separator"] = "_";
  rout->_options["errorhandle"] = "abort";
  rout->_options["rankdir"] = "off";
  rout->_options["ghosthandle"] = "write";

  COM_new_window( mname.c_str(), MPI_COMM_SELF);

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

  COM_new_attribute( glb.c_str(), 'w', COM_VOID, 1, "");
  COM_set_object( glb.c_str(), 0, rout);


  // Register the function write_attribute
  COM_Type types[8] = { COM_RAWDATA, COM_STRING, COM_METADATA, COM_STRING, 
                        COM_STRING, COM_STRING, COM_MPI_COMM, COM_VOID};
  COM_set_member_function( (mname+".write_attribute").c_str(),
                           (Member_func_ptr)&Rocout::write_attribute, 
                           glb.c_str(), "biiiiIII", types);
  COM_set_member_function( (mname+".put_attribute").c_str(),
                           (Member_func_ptr)&Rocout::put_attribute, 
                           glb.c_str(), "biiiiIII", types);
  COM_set_member_function( (mname+".add_attribute").c_str(),
                           (Member_func_ptr)&Rocout::add_attribute, 
                           glb.c_str(), "biiiiIII", types);
  COM_set_member_function( (mname+".write_window").c_str(),
                           (Member_func_ptr)&Rocout::write_attribute,
                           glb.c_str(), "biiiiIII", types);

  // Register the function write_rocin_control_file
  types[2] = types[3] = COM_STRING;
  COM_set_member_function( (mname+".write_rocin_control_file").c_str(),
                           (Member_func_ptr)&Rocout::write_rocin_control_file,
                           glb.c_str(), "biii", types);

  // Register the function sync
  COM_set_member_function( (mname+".sync").c_str(),
                           (Member_func_ptr)&Rocout::sync, 
                           glb.c_str(), "b", types);

  // Register the function set_option
  COM_set_member_function( (mname+".set_option").c_str(), 
                           (Member_func_ptr)&Rocout::set_option, 
                           glb.c_str(), "bii", types);

  // Register the function write_parameter_file
  types[3] = COM_MPI_COMM;
  COM_set_member_function( (mname+".write_parameter_file").c_str(),
                           (Member_func_ptr)&Rocout::write_parameter_file,
                           glb.c_str(), "biiI", types);

  // Register the function read_control_file
  COM_set_member_function( (mname+".read_control_file").c_str(), 
                           (Member_func_ptr)&Rocout::read_control_file, 
                           glb.c_str(), "bi", 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 put_attribute	(	const char *	filename_pre,
		const COM::Attribute *	attr,
		const char *	material,
		const char *	timelevel,
		const char *	mfile_pre = NULL,
		const MPI_Comm *	comm = NULL,
		const int *	pane_id = NULL
	)

Write a (possibly aggregate) attribute to a new file.

Write an attribute to a new file.

Parameters

filename_pre	the prefix of the file name.
attr	a reference to the attribute to be written.
material	the name of the material (usually the window name).
time_level	the time stamp of the dataset.
mfile_pre	the prefix of the file that contains the mesh data.
comm	The MPI communicator to use. If is NULL, the default communicator of the Roccom window will be used.
pane_id	the pane to be written.
filename_pre	the prefix of the file name.
attr	a reference to the attribute to be written.
material	the name of the material (usually the window name).
time_level	the time stamp of the dataset.
mfile_pre	the prefix of the file that contains the mesh data.
pComm	The MPI communicator to use. If is NULL, the default communicator of the Roccom window will be used.
pane_id	the pane to be written.

Definition at line 286 of file Rocout.C.

References _options, id(), and write_attr_internal().

Referenced by init().

{
  //std::cout << __FILE__ << __LINE__ << std::endl;
  //std::cout << "Attribute = " << (attr)->fullname() << std::endl;
  //std::cout << "Size = " << (attr)->size_of_items() << std::endl;
  WriteAttrInfo* pWAI;

#ifdef USE_PTHREADS
  if (_options["async"] == "off") {
#endif // USE_PTHREADS
    pWAI = new WriteAttrInfo(this, filename_pre, attr, material, timelevel, 
                             mfile_pre, pComm, pane_id, 0);
    write_attr_internal(pWAI);
#ifdef USE_PTHREADS
  } else {
    pWAI = new WriteAttrInfo(this, filename_pre, attr, material, timelevel, 
                             mfile_pre, pComm, pane_id, 0, true);
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

    pthread_t id;
    pthread_create(&id, &attr, write_attr_internal, pWAI);
    pthread_attr_destroy(&attr);
    _writers.push_back(id);
  }
#endif // USE_PTHREADS
}

Here is the call graph for this function:

Here is the caller graph for this function:

void read_control_file

(

const char *

filename

)

Set options for Rocout via a control file.

Parameters

filename

the path to the control file.

Definition at line 580 of file Rocout.C.

References ERROR_MSG, is_option_name(), is_option_value(), and set_option().

Referenced by init().

{
  // Attempt to open the control file.
  std::ifstream fin(filename);
  if (!fin.is_open()) {
    ERROR_MSG("Rocout::read_control_file(): could not open file \""
              << filename << "\".");
    return;
  }

  // Each line of the control file should be of the form "option_name=value",
  // e.g. "format=HDF4".  White space at the beginning, end, and around the
  // '=' is ignored, as are empty lines and comments (lines that start with
  // '#').
  int lineNum = 0;
  char buffer[256];
  std::string line, name, val;
  std::string::size_type eq;
  while (!fin.eof()) {
    ++lineNum;
    // Read a line.
    fin.getline(buffer, sizeof(buffer));
    line = buffer;

    // Skip empty lines and comments.
    if (line.empty() || line.find_first_not_of(" \t\n") == std::string::npos
        || line[line.find_first_not_of(" \t\n")] == '#')
      continue;

    // Find the '='.  It's mandatory.
    eq = line.find('=');
    if (eq == std::string::npos) {
      ERROR_MSG("Rocout::read_control_file(): option without value at line "
                << lineNum << " of " << filename << '.');
      continue;
    }

    // Split the line into an option name and a value.
    name = line.substr(0, eq);
    val = line.substr(eq + 1);

    // Remove leading whitespace from the option name.
    if (name.find_first_not_of(" \t\n") != 0)
      name.erase(0, name.find_first_not_of(" \t\n"));

    // Check for an empty option name.
    if (name.empty()) {
      ERROR_MSG("Rocout::read_control_file(): missing option name at line "
                << lineNum << " of " << filename << '.');
      continue;
    }

    // Remove trailing whitespace from the option name.
    if (name.find_last_not_of(" \t\n") != name.length() - 1)
      name.erase(name.find_last_not_of(" \t\n") + 1);

    // Make sure it is a valid option name.
    if (!is_option_name(name)) {
      ERROR_MSG("Rocout::read_control_file(): unknown option name \"" << name
                << "\" at line " << lineNum << " of " << filename << '.');
      continue;
    }

    // Remove leading whitespace from the option value.
    if (val.find_first_not_of(" \t\n") != 0)
      val.erase(0, val.find_first_not_of(" \t\n"));

    // Check for an empty option value.
    if (val.empty()) {
      ERROR_MSG("Rocout::read_control_file(): option without value at line " 
                << lineNum << " of " << filename << '.');
      continue;
    }

    // Remove trailing whitespace from the option value.
    if (val.find_last_not_of(" \t\n") != val.length() - 1)
      val.erase(val.find_last_not_of(" \t\n") + 1);

    // Make sure it is a valid value for the named option.
    if (!is_option_value(name, val)) {
      ERROR_MSG("Rocout::read_control_file(): invalid value \"" << val
                << "\" for option \"" << name << "\" at line " << lineNum
                << " of " << filename << '.');
      continue;
    }

    set_option(name.c_str(), val.c_str());
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void set_option	(	const char *	option_name,
		const char *	option_val
	)

Set an option for Rocout, such as controlling the output format.

Parameters

option_name	the option name: "format", "async", "mode", "localdir", "rankwidth", "pnidwidth", "separator" or "errorhandle".
option_val	the option value.
option_name	the option name: "format", "async", "mode", "localdir", "rankdir", "rankwidth", "pnidwidth", "errorhandle" or "ghosthandle".
option_val	the option value.

Definition at line 552 of file Rocout.C.

References _options, COM_assertion_msg, ERROR_MSG, is_option_name(), and is_option_value().

Referenced by genxwritesolution(), init(), mesh2d(), mesh2doverlay(), read_control_file(), and rocfracprep().

{
  const std::string name(option_name);
  const std::string val(option_val);

  if (!is_option_name(name)) {
    ERROR_MSG("Rocout::set_option(): unknown option name \"" << name << "\".");
    return;
  }

  if (!is_option_value(name, val)) {
    ERROR_MSG("Rocout::set_option(): invalid value \"" << val
              << "\" for option \"" << name << "\".");
    return;
  }

#ifndef USE_CGNS
  COM_assertion_msg(name != "format" || val != "CGNS",
                    "Roccom not built with option CGNS=1.\n");
#endif // USE_CGNS

  _options[name] = val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sync

(

)

Wait for the completion of an asychronous write operation.

Definition at line 491 of file Rocout.C.

Referenced by init().

{
#ifdef USE_PTHREADS
  void* ret;
  std::vector<pthread_t>::iterator p = _writers.begin();
  while (p != _writers.end()) {
    pthread_join(*p, &ret);
    ++p;
  }
  _writers.clear();
#endif // USE_PTHREADS
}

Here is the caller graph for this function:

void * write_attr_internal ( void *  attrInfo )

staticprotected

Does the actual writing to file.

Parameters

attrInfo

Information on what to write and where to write it.

Definition at line 670 of file Rocout.C.

References _options, COM_get_panes(), Window::get_communicator(), get_fname(), Window::inherit(), Pane::INHERIT_CLONE, WriteAttrInfo::m_append, WriteAttrInfo::m_attr, WriteAttrInfo::m_cloned, WriteAttrInfo::m_material, WriteAttrInfo::m_meshPrefix, WriteAttrInfo::m_pComm, WriteAttrInfo::m_pPaneId, WriteAttrInfo::m_prefix, WriteAttrInfo::m_rout, WriteAttrInfo::m_timelevel, Window::name(), paneIds, rank, Attribute::window(), write_attr_CGNS(), and write_attr_HDF4().

Referenced by add_attribute(), put_attribute(), and write_attribute().

{
  WriteAttrInfo* ai = static_cast<WriteAttrInfo*>(attrInfo);
  const Attribute* attr = ai->m_attr;
  Window* tempWin = NULL;

  if (ai->m_cloned) {
#ifdef USE_PTHREADS
    _writesem.Wait();
#endif // USE_PTHREADS
    tempWin = new Window(attr->window()->name(),
                         attr->window()->get_communicator());
    attr = tempWin->inherit(const_cast<Attribute*>(attr), attr->name(),
                            Pane::INHERIT_CLONE, true, NULL, 0);
  }

  int flag = 0; MPI_Initialized(&flag);

  // Obtain process rank
  int rank;
  if ( flag) {
    MPI_Comm wcomm;
    const MPI_Comm* pComm;

    if ( ai->m_pComm) 
      pComm = ai->m_pComm;
    else { 
      wcomm = attr->window()->get_communicator();
      pComm = &wcomm;
    }

    if (*pComm != MPI_COMM_NULL)
      MPI_Comm_rank(*pComm, &rank); 
    else
      rank = 0;
  }
  else 
    rank = 0;

  int append = ai->m_append;
  //std::cout << " ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ " << std::endl;
  //std::cout << __FILE__ << __LINE__
  //          << " append = " << append << std::endl;
  if (append < 0) {
    if (ai->m_rout->_options["mode"] == "w")
      append = 0;
    else
      append = 1;
  }

  std::vector<int> paneIds;
  COM_get_panes(attr->window()->name().c_str(), paneIds);

  std::vector<int>::iterator begin = paneIds.begin(), end = paneIds.end(), p;
  if (ai->m_pPaneId != NULL && *(ai->m_pPaneId) > 0) {
    begin = std::find(begin, end, *(ai->m_pPaneId));
    if (begin != end)
      end = begin + 1;
  }

  // MS
  /*
  std::cout << __FILE__ << __LINE__ << std::endl;
  std::cout << "Attribute requested = " << attr->fullname() << std::endl;
  std::cout << "Location = " << attr->location() << std::endl;
  std::cout << "Size of items = " << attr->size_of_items() << std::endl;
  std::cout << "Size of components = " << attr->size_of_components() << std::endl;
  std::cout << "Window information :" << std::endl;
  std::string wname = attr->window()->name();
  int nNde; 
  for (p=begin; p!=end; ++p) {
    std::cout << " pane = " << *p << std::endl;
    COM_get_size((wname+".nc").c_str(), *p, &nNde);
    std::cout << " number of nodes = " << nNde << std::endl;
    std::string stringNames;
    int numConn;
    COM_get_connectivities(wname.c_str(), *p, &numConn, stringNames);
    std::istringstream ConnISS(stringNames);
    std::vector<std::string> connNames;
    std::cout << "\t # \t Type \t #Elm \t #ElmNde \t Loc \n";
    std::cout << "\t---\t------\t------\t---------\t-----\n";
    for (int i=0; i<numConn; ++i) {
       std::string name;
       ConnISS >> name;
       connNames.push_back(name);
       std::string fullConnName(wname+"."+name);
       int nElm;
       COM_get_size(fullConnName, *p, &nElm);
       int nElmNde;
       std::string dataItemUnits;
       char dataItemLoc;
       COM_Type dataItemType;
       COM_get_attribute(fullConnName, &dataItemLoc, &dataItemType,
                      &nElmNde, &dataItemUnits);
       std::cout << "\t " << i+1
                 << "\t " << name
                 << "\t  " << nElm
                 << "\t    " << nElmNde
                 << "\t          " << dataItemLoc
                 << std::endl;
    }
  }
  std::cout << " ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ " << std::endl;
  */
  // MS End

  std::set<std::string> written;
  for (p=begin; p!=end; ++p) {
    //std::cout << __FILE__ << __LINE__
    //          << " pane = " << *p << std::endl;
    std::string fname, mfile;
    fname = ai->m_rout->get_fname(ai->m_prefix, rank, *p, true);
    //std::cout << " fname = " << fname << std::endl;
    if (!ai->m_meshPrefix.empty())
      mfile = ai->m_rout->get_fname(ai->m_meshPrefix, rank, *p);

    int ap = append + written.count(fname);
    written.insert(fname);

    const std::string fmt = ai->m_rout->_options["format"];
    if ( fmt == "HDF4" || fmt == "HDF") {

      write_attr_HDF4(fname, mfile, attr, ai->m_material.c_str(),
                      ai->m_timelevel.c_str(), *p,
                      ai->m_rout->_options["errorhandle"], ap);

    } else if ( fmt == "CGNS") {
#ifdef USE_CGNS
     write_attr_CGNS(fname, mfile, attr, ai->m_material.c_str(),
                     ai->m_timelevel.c_str(), *p,
                     ai->m_rout->_options["ghosthandle"],
                     ai->m_rout->_options["errorhandle"], ap);
#endif // USE_CGNS

    }
  }

  if (ai->m_cloned) {
#ifdef USE_PTHREADS
    _writesem.Post();
#endif // USE_PTHREADS
    delete tempWin;
  }

  delete ai;

  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void write_attribute	(	const char *	filename_pre,
		const COM::Attribute *	attr,
		const char *	material,
		const char *	timelevel,
		const char *	mfile_pre = NULL,
		const MPI_Comm *	comm = NULL,
		const int *	pane_id = NULL
	)

Write a (possibly aggregate) attribute to a file.

Write an attribute to file.

Parameters

filename_pre	the prefix of the file name.
attr	a reference to the attribute to be written.
material	the name of the material (usually the window name).
time_level	the time stamp of the dataset.
mfile_pre	the prefix of the file that contains the mesh data.
comm	The MPI communicator to use. If is NULL, the default communicator of the Roccom window will be used.
pane_id	the pane to be written.
filename_pre	the prefix of the file name.
attr	a reference to the attribute to be written.
material	the name of the material (usually the window name).
time_level	the time stamp of the dataset.
mfile_pre	the prefix of the file that contains the mesh data.
pComm	The MPI communicator to use. If is NULL, the default communicator of the Roccom window will be used.
pane_id	the pane to be written.

Definition at line 246 of file Rocout.C.

References _options, id(), and write_attr_internal().

Referenced by init().

{
  WriteAttrInfo* pWAI;

#ifdef USE_PTHREADS
  if (_options["async"] == "off") {
#endif // USE_PTHREADS
    pWAI = new WriteAttrInfo(this, filename_pre, attr, material, timelevel, 
                             mfile_pre, pComm, pane_id);
    write_attr_internal(pWAI);
#ifdef USE_PTHREADS
  } else {
    pWAI = new WriteAttrInfo(this, filename_pre, attr, material, timelevel, 
                             mfile_pre, pComm, pane_id, -1, true);
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

    pthread_t id;
    pthread_create(&id, &attr, write_attr_internal, pWAI);
    pthread_attr_destroy(&attr);
    _writers.push_back(id);
  }
#endif // USE_PTHREADS
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Write out the parameters defined in the fiven window into a parameter file.

Only process 0 of the communicator writes the parameter file.

Parameters

file_name	the file to which the parameters will be written.
window_name	the window to read parameters from
comm	the MPI_communicator to use. If NULL, then the communicator of the window associated with window_name is used.

Definition at line 36 of file write_parameter_file.C.

References COM_assertion_msg, COM_CHAR, COM_get_roccom(), COM_get_window_handle(), i, ni, and cimg_library::cimg::option().

Referenced by init().

                                                      {

  // Check to see if the window exists
  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_assertion_msg(param_window, 
                    "Parameter window does not exist");

  //open parameter file for output
  std::ofstream param_file(file_name);
  COM_assertion_msg(file_name,
                    "Specified parameter file can't be opened for writing.");

  // Get all the attributes of the window
  std::vector<Attribute*> atts;
  param_window->attributes(atts);

  // Loop through all the attributes
  // print out those with the correct format.
  for(uint i =0, ni = atts.size(); i<ni; ++i){
    if(atts[i]->location()=='w'
       && atts[i]->data_type() == COM_CHAR
       && atts[i]->size_of_components() == 1){

      std::string option = atts[i]->name();
      std::string value ("");
      value.assign((const char*)atts[i]->pointer(), 
                   atts[i]->size_of_items());

      param_file << option << " = ";

      if(value.find(" ") != std::string::npos)
        param_file << "\"" << value << "\"\n";
      else
        param_file << value << "\n";
    }
  }
} // file closed automatically

Here is the call graph for this function:

Here is the caller graph for this function:

void write_rocin_control_file	(	const char *	window_name,
		const char *	file_prefixes,
		const char *	control_file_name
	)

Generate a control file for Rocin.

Parameters

window_name	The name of the Roccom window.
file_prfixes	The prefixes of the data files.
control_file_name	The name of the file to be written.

Definition at line 361 of file Rocout.C.

References _options, COM_assertion_msg, COM_get_default_communicator(), COM_get_panes(), COMMPI_Initialized(), empty(), i, paneIds, rank, 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 = COMMPI_Initialized() ? &default_comm : &comm_null;


  // Obtain process rank
  int flag = 0, rank = 0, size = 1;
  MPI_Initialized(&flag);

  if (flag) {
    MPI_Comm_rank(*myComm, &rank);
    MPI_Comm_size(*myComm, &size);
  }
 
  if (rank == 0) {
    std::vector<std::vector<int> > paneIds(size);

    /* Get list of panes local each process */
    int i;
    for (i=0; i<size; ++i)
      COM_get_panes(window_name, paneIds[i], i);
 
    int rw, pw;
    {
      std::istringstream sin(_options["rankwidth"]);
      sin >> rw;
    }
    {
      std::istringstream sin(_options["pnidwidth"]);
      sin >> pw;
    }

/*
    std::ostringstream sout;
    sout << "@Files:";

    // Write out file name pattern only if number of panes is nonzero.
    std::istringstream sin(file_prefixes);
    while (!sin.eof()) {
      std::string prefix;
      sin >> prefix;
      if (prefix.empty())
        continue;

      sout << ' ' << prefix;
      if (rw > 0)
        sout << "%0" << rw << 'p';
      if (pw > 0) {
        if (rw > 0)
          sout << _options["separator"];
        sout << "%0" << pw << 'i';
      }

      const std::string fmt = _options["format"];
      if ( fmt == "HDF4" || fmt == "HDF")
        sout << ".hdf";
      else if (fmt == "HDF5")
        sout << ".hdf5";
      else if (fmt == "CGNS")
        sout << ".cgns";
    }
*/

    /* Now write data into control file */
    std::ofstream fout(control_file_name);
    COM_assertion_msg( fout.is_open(),
                       (std::string("Rocout cannot open control file:")+control_file_name+" for writing.\n").c_str());
    
    const std::string fmt = _options["format"];
    for (i=0; i<size; i++) {
      fout << "@Proc: " << i << std::endl;
      if ( !paneIds[i].empty()) {
        std::ostringstream sout;
        sout << "@Files:";

        // Write out file name pattern only if number of panes is nonzero.
        std::istringstream sin(file_prefixes);
        while (!sin.eof()) {
          std::string prefix;
          sin >> prefix;
          if (prefix.empty())
            continue;

          sout << ' ';
            // write output file in <rank> dir
          if (_options["rankdir"] == "on") {
            std::ostringstream rank_prefix; 
            rank_prefix << i << "/";
            sout << rank_prefix.str();
          }
          sout << prefix;
          if (rw > 0)
            sout << "%0" << rw << 'p';
          if (pw > 0) {
            if (rw > 0)
              sout << _options["separator"];
            sout << "%0" << pw << 'i';
          }

          if ( fmt == "HDF4" || fmt == "HDF")
            sout << ".hdf";
          else if (fmt == "HDF5")
            sout << ".hdf5";
          else if (fmt == "CGNS")
            sout << ".cgns";
        }
        fout << sout.str() << std::endl;
      }
      else // Write out an empty block
        fout << "@Files: " << std::endl;

      fout << "@Panes:";
      
      /* Write all the panes of this process to control file */
      std::vector<int>::iterator p;
      for (p=paneIds[i].begin(); p!=paneIds[i].end(); ++p)
        fout << ' ' << *p;
      fout << '\n' << std::endl;
    }

    fout.close();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

void Rocout_load_module ( const char *  name )

friend

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

This module provides one subroutine: "write_attribute".

Definition at line 934 of file Rocout.C.

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

void Rocout_unload_module ( const char *  name )

friend

Unload the module Rocout from Roccom.

Definition at line 937 of file Rocout.C.

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

Member Data Documentation

std::map<std::string, std::string> _options

protected

Definition at line 235 of file Rocout.h.

Referenced by add_attribute(), get_fname(), init(), put_attribute(), set_option(), write_attr_internal(), write_attribute(), and write_rocin_control_file().

---

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

• Rocout.h
• Rocout.C
• write_parameter_file.C