RFC_Window_transfer Class Reference

#include <RFC_Window_transfer.h>

Inheritance diagram for RFC_Window_transfer:

Collaboration diagram for RFC_Window_transfer:

Public Types
typedef RFC_Window_transfer	Self
typedef RFC_Window_derived < RFC_Pane_transfer >	Base
Public Types inherited from RFC_Window_base
typedef RFC_Window_base	Self
typedef COM::Window	Base
typedef COM::Attribute	Attribute
typedef RFC_Pane_base	Pane
typedef std::map< int, Pane * >	Pane_set

Public Member Functions
	RFC_Window_transfer (COM::Window *b, int color, MPI_Comm com, const char *pre=NULL, const char *format=NULL)
virtual	~RFC_Window_transfer ()
RFC_Pane_transfer &	pane (const int pid)
const RFC_Pane_transfer &	pane (const int pid) const
void	init_facial_buffers (const Facial_data &nd, int)
Facial_data	facial_buffer (int)
void	delete_facial_buffers ()
void	init_nodal_buffers (const Nodal_data &nd, int n, bool init_emm)
Nodal_data	nodal_buffer (int)
void	delete_nodal_buffers ()
void	set_tags (const COM::Attribute *tag)
bool	replicated () const
	Returns whether replication has been performed. More...
void	replicate_metadata (int *pane_ids, int n)
	Replicate the metadata of a remote pane only the local process. More...
void	clear_replicated_data ()
	Clear all the replicate data but keep metadata. More...
void	incident_panes (std::vector< int > &pane_ids)
	Determine the remote panes that are incident with local panes. More...
void	incident_faces (std::map< int, std::vector< int > > &) const
	Obtain the list of incident faces in each pane of the opposite mesh. More...
void	replicate_metadata (const RFC_Window_transfer &opp_win)
	Replicate the remote panes that are in contact with the local panes in opp_win. More...
void	replicate_data (const Facial_data_const &data, bool replicate_coor)
	Replicate the given data from remote processes onto local process. More...
void	replicate_data (const Nodal_data_const &data, bool replicate_coor)
void	reduce_to_all (Nodal_data &, MPI_Op)
void	reduce_maxabs_to_all (Nodal_data &)
void	barrier () const
	Block until all processes of the window have reached here. More...
bool	is_root () const
	Check whether the process has rank 0. More...
int	comm_rank () const
int	comm_size () const
void	wait_all (int n, MPI_Request *requests)
void	wait_any (int n, MPI_Request *requests, int *index, MPI_Status *stat=NULL)
void	allreduce (Array_n &arr, MPI_Op op) const
void	allreduce (Real *x, MPI_Op op) const
Public Member Functions inherited from RFC_Window_derived< RFC_Pane_transfer >
const Pane &	pane (const int pid) const
	Get a reference to the pane with give id pid. More...
Pane &	pane (const int pid)
std::pair< Pane *, int >	get_primary (Pane *p, int vid)
	Get a handle to the primary copy of a node contained in the pane p with local id vid. More...
std::pair< const Pane *, int >	get_primary (const Pane *p, int vid) const
void	panes (std::vector< Pane * > &ps)
	Get a vector of local panes contained in the window. More...
void	panes (std::vector< const Pane * > &ps) const
Public Member Functions inherited from RFC_Window_base
	RFC_Window_base (Base *b, int c, MPI_Comm)
	Construct an object with base b and color c. More...
virtual	~RFC_Window_base ()
	Default destructor. More...
std::string	name () const
	The name of the window. More...
const RFC_Pane_base &	pane (const int pid) const
RFC_Pane_base &	pane (const int pid)
const COM::Window *	base () const
	Get a reference to the base COM::Window object. More...
int	color () const
	The color of the window for overlay or for data transfer (BLUE or GREEN). More...
int	size_of_nodes () const
	Get the total number of nodes contained the window. More...
int	size_of_faces () const
	Get the total number of faces contained the window. More...
int	size_of_primary_nodes () const
	Get the total number of nodes contained the window. More...
Bbox_3	get_bounding_box () const
	Get the bounding box of the window. More...
int	size_of_panes () const
	Number of local panes in the window. More...
const Attribute *	attribute (const char *f) const
	Retrieve an attribute object from the base using the attribute name. More...
void	export_window (RFC_Window_base *) const
void	write_tec_ascii (const char *prefix) const
	Ouptut a mesh in Tecplot format. More...
void	write_tec_sub (const char *prefix) const
	Ouptut a subdivision of a mesh in Tecplot format. More...
void	new_sdv_attributes (const std::string &wname) const
	New attributes. More...
void	read_sdv (const char *prefix, const char *format=NULL)
	Read in local panes in native binary format or using Rocin. More...
void	write_sdv (const char *prefix, const char *format=NULL) const
	Write out panes in native binary format or using Rocout. More...
void	build_pc_tables ()
	Build the pane connectivity table. More...

Private Member Functions
void	allreduce (Real *, int n, MPI_Op op) const
void	counts_to_displs (const std::vector< int > &counts, std::vector< int > &displs) const
void	init_send_buffer (int pane_id, int to_rank)
void	init_recv_buffer (int pane_id, int from_rank)

Private Attributes
int	_buf_dim
MPI_Comm	_comm
std::map< int, std::pair< int, int > >	_pane_map
std::vector< int >	_num_panes
std::map< int, RFC_Pane_transfer * >	_replic_panes
bool	_replicated
std::set< std::pair< int, RFC_Pane_transfer * > >	_panes_to_send
const std::string	_prefix
const int	_IO_format

Additional Inherited Members
Protected Types inherited from RFC_Window_derived< RFC_Pane_transfer >
typedef RFC_Window_derived < RFC_Pane_transfer >	Self
typedef RFC_Window_base	Base
typedef RFC_Pane_transfer	Pane
Protected Types inherited from RFC_Window_base
enum	{ SDV_BINARY, SDV_HDF, SDV_CGNS }
Protected Member Functions inherited from RFC_Window_derived< RFC_Pane_transfer >
	RFC_Window_derived (COM::Window *b, int c, MPI_Comm comm)
	A constructor. More...
virtual	~RFC_Window_derived ()
	A destructor. More...
void	init ()
Static Protected Member Functions inherited from RFC_Window_base
static std::string	get_sdv_fname (const char *prefix, int pane_id, const int format=SDV_BINARY)
static const char *	get_prefix_base (const char *prefix)
static int	get_sdv_format (const char *format)
Protected Attributes inherited from RFC_Window_base
Base *	_base
	A reference to its base COM::Window object. More...
Pane_set	_pane_set
	The set of panes contained in the window. More...
int	_verbose
int	_color
MAP::Pane_communicator	_map_comm
Static Protected Attributes inherited from RFC_Window_base
static const char *	_bufwin_prefix = "buf_"

Detailed Description

Definition at line 133 of file RFC_Window_transfer.h.

Member Typedef Documentation

typedef RFC_Window_derived<RFC_Pane_transfer> Base

Definition at line 136 of file RFC_Window_transfer.h.

typedef RFC_Window_transfer Self

Definition at line 135 of file RFC_Window_transfer.h.

Constructor & Destructor Documentation

RFC_Window_transfer	(	COM::Window *	b,
		int	color,
		MPI_Comm	com,
		const char *	pre = NULL,
		const char *	format = NULL
	)

Definition at line 40 of file RFC_Window_transfer.C.

References RFC_Window_base::_base, _num_panes, _pane_map, comm_size(), iend, and RFC_Window_derived< RFC_Pane_transfer >::panes().

  : Base(b,c,com), _buf_dim(0), _comm( com), _replicated(false), 
    _prefix( pre==NULL?b->name():pre), _IO_format( get_sdv_format(format)) {

  std::vector< Pane*> pns; panes(pns);
  std::vector< Pane*>::iterator pit=pns.begin(), piend=pns.end();
  for ( ; pit != piend; ++pit) {
    (*pit)->_window = this;
  }

  // Initialize pane_map
  int nprocs = comm_size();
  _num_panes.resize( nprocs,int(0));

  const COM::Window::Proc_map &proc_map = _base->proc_map();
  
  for ( COM::Window::Proc_map::const_iterator
          it=proc_map.begin(), iend=proc_map.end(); it!=iend; ++it) {
    int p=it->second;
    _pane_map[ it->first] = std::pair<int,int>(p, _num_panes[p]++);
  }
}

Here is the call graph for this function:

~RFC_Window_transfer ( )

virtual

Definition at line 66 of file RFC_Window_transfer.C.

References _replic_panes.

                                          {
  while ( !_replic_panes.empty()) {
    delete _replic_panes.begin()->second;
    _replic_panes.erase( _replic_panes.begin());
  }
}

Member Function Documentation

void allreduce ( Array_n &  arr, MPI_Op  op  ) const

inline

Definition at line 199 of file RFC_Window_transfer.h.

References Array_n::begin(), and Array_n::end().

Referenced by allreduce(), Transfer_base::dot(), Transfer_base::dot2(), Transfer_base::integrate(), Transfer_base::minmax(), and Transfer_base::norm2().

  { allreduce( arr.begin(), arr.end()-arr.begin(), op); }

Here is the call graph for this function:

Here is the caller graph for this function:

void allreduce ( Real *  x, MPI_Op  op  ) const

inline

Definition at line 201 of file RFC_Window_transfer.h.

References allreduce().

  { allreduce( x, 1, op); }

Here is the call graph for this function:

void allreduce ( Real *  data, int  n, MPI_Op  op  ) const

private

Definition at line 524 of file RFC_Window_transfer_comm.C.

References _comm, and RFC_assertion.

                                                                  {
  std::vector<Real>  buf( data, data+n);
  RFC_assertion( sizeof( Real) == sizeof( double));
  MPI_Allreduce( &buf[0], data, n, MPI_DOUBLE, op, _comm);
}

void barrier

(

)

const

Block until all processes of the window have reached here.

Definition at line 494 of file RFC_Window_transfer_comm.C.

References _comm, and RFC_assertion.

Referenced by Transfer_base::interpolate_fe(), Transfer_base::loadtransfer(), Interpolator::transfer(), Transfer_base::transfer_2f(), and Transfer_base::transfer_2n().

                                   {
  int ierr = MPI_Barrier( _comm); RFC_assertion( ierr==0);
}

Here is the caller graph for this function:

void clear_replicated_data

(

)

Clear all the replicate data but keep metadata.

Definition at line 590 of file RFC_Window_transfer_comm.C.

References _replic_panes, and iend.

Referenced by Transfer_base::loadtransfer(), Interpolator::transfer(), Transfer_base::transfer_2f(), and Transfer_base::transfer_2n().

                                           {
  // Loop through the replicated panes
  std::map< int, RFC_Pane_transfer*>::iterator it=_replic_panes.begin();
  std::map< int, RFC_Pane_transfer*>::iterator iend=_replic_panes.end();
  for ( ; it != iend; ++it) {
    it->second->_data_buf_id = -1;
    std::vector<Real> t;
    it->second->_data_buf.swap( t); // clear up the memory space
  }
}

Here is the caller graph for this function:

int comm_rank ( ) const

inline

Definition at line 191 of file RFC_Window_transfer.h.

References _comm, COMMPI_Comm_rank(), and COMMPI_Initialized().

Referenced by replicate_metadata().

  { return COMMPI_Initialized()?COMMPI_Comm_rank( _comm):0; }

Here is the call graph for this function:

Here is the caller graph for this function:

int comm_size ( ) const

inline

Definition at line 193 of file RFC_Window_transfer.h.

References _comm, COMMPI_Comm_size(), and COMMPI_Initialized().

Referenced by replicate_metadata(), and RFC_Window_transfer().

  { return COMMPI_Initialized()?COMMPI_Comm_size( _comm):1; }

Here is the call graph for this function:

Here is the caller graph for this function:

void counts_to_displs ( const std::vector< int > &  counts, std::vector< int > &  displs  ) const

inlineprivate

Definition at line 208 of file RFC_Window_transfer.h.

References i, and RFC_assertion.

Referenced by replicate_metadata().

                                                       {
    RFC_assertion( !displs.empty() && counts.size()>=displs.size()-1);
    displs[0]=0;
    for ( int i=1, size=displs.size(); i<size; ++i) {
      displs[i] = displs[i-1]+counts[i-1];
    }
  }

Here is the caller graph for this function:

void delete_facial_buffers

(

)

Definition at line 193 of file RFC_Window_transfer.C.

References RFC_Pane_transfer::_buffer, RFC_Window_base::_pane_set, free_vector(), pane(), and pi.

Referenced by Transfer_base::transfer_2f().

                        {
  // Loop through the panes to remove the buffer spaces
  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer &)*pi->second;

    free_vector( pane._buffer);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void delete_nodal_buffers

(

)

Definition at line 148 of file RFC_Window_transfer.C.

References RFC_Pane_transfer::_buffer, RFC_Pane_transfer::_emm_buffer, RFC_Pane_transfer::_emm_offset, RFC_Window_base::_pane_set, free_vector(), pane(), and pi.

Referenced by Transfer_base::transfer_2n().

                       {
  // Loop through the panes to remove the buffer spaces
  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer &)*pi->second;

    free_vector( pane._buffer);
    free_vector( pane._emm_offset);
    free_vector( pane._emm_buffer);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Facial_data facial_buffer

(

int

index

)

Definition at line 187 of file RFC_Window_transfer.C.

References _buf_dim, and RFC_assertion.

Referenced by Transfer_base::transfer_2f().

                          {
  RFC_assertion( index >= 0);
  return Facial_data( -index-1, _buf_dim);
}

Here is the caller graph for this function:

RFC_BEGIN_NAME_SPACE void incident_faces

(

std::map< int, std::vector< int > > &

opp_subface_lists

)

const

Obtain the list of incident faces in each pane of the opposite mesh.

Definition at line 36 of file RFC_Window_transfer_comm.C.

References RFC_Window_base::_pane_set, RFC_Pane_base::_subface_counterparts, Face_ID::face_id, for(), i, pane(), Face_ID::pane_id, pi, RFC_assertion, and RFC_Pane_base::size_of_subfaces().

Referenced by replicate_metadata().

                                                                        {
  RFC_assertion(opp_subface_lists.empty());

  // Loop through the panes to generate subface list
  for (Pane_set::const_iterator 
         pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    const RFC_Pane_transfer &pane = (const RFC_Pane_transfer &)*pi->second;
    
    for ( int i=0, size=pane.size_of_subfaces(); i<size; ++i) {
      Face_ID oppf = pane._subface_counterparts[i];
      opp_subface_lists[ oppf.pane_id].push_back( oppf.face_id);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void incident_panes

(

std::vector< int > &

pane_ids

)

Determine the remote panes that are incident with local panes.

Definition at line 203 of file RFC_Window_transfer.C.

References RFC_Window_base::_pane_set, RFC_Pane_base::_subface_counterparts, RFC_Pane_base::_subnode_counterparts, for(), i, pane(), pi, and RFC_assertion.

                                                             {
  std::set<int>  ids;

  // Loop through the panes to detect incident panes
  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer &)*pi->second;

    for ( int i=0, size=pane._subface_counterparts.size(); i<size; ++i) {
      ids.insert( pane._subface_counterparts[i].pane_id);
    }
    for ( int i=0, size=pane._subnode_counterparts.size(); i<size; ++i) {
      RFC_assertion(ids.find( pane._subnode_counterparts[i].pane_id) != ids.end());
    }
  }

  pane_ids.resize(0); pane_ids.reserve( ids.size());
  pane_ids.insert( pane_ids.end(), ids.begin(), ids.end());
}

Here is the call graph for this function:

void init_facial_buffers	(	const Facial_data &	nd,
		int	size
	)

Definition at line 172 of file RFC_Window_transfer.C.

References _buf_dim, RFC_Pane_transfer::_buffer, RFC_Window_base::_pane_set, RFC_Data_const< _Tag >::dimension(), i, pane(), pi, and RFC_Pane_base::size_of_faces().

Referenced by Transfer_base::transfer_2f().

                                                      {
  _buf_dim = nd.dimension();

  // Loop through the panes
  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer&)*pi->second;
 
    pane._buffer.resize( size);

    for ( int i=0; i<size; ++i) 
      pane._buffer[i].resize(pane.size_of_faces()*_buf_dim);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init_nodal_buffers	(	const Nodal_data &	nd,
		int	n,
		bool	init_emm
	)

Definition at line 97 of file RFC_Window_transfer.C.

References RFC_Pane_base::_base, _buf_dim, RFC_Pane_transfer::_buffer, RFC_Pane_transfer::_emm_buffer, RFC_Pane_transfer::_emm_offset, RFC_Window_base::_pane_set, RFC_Data_const< _Tag >::dimension(), i, k, n, pane(), pi, RFC_Pane_base::size_of_faces(), and RFC_Window_base::size_of_nodes().

Referenced by Transfer_base::transfer_2n().

                                                                   {
  _buf_dim = nd.dimension();

  // Loop through the panes
  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer&)*pi->second;

    pane._buffer.resize( size);
      
    for ( int i=0; i<size; ++i) 
      pane._buffer[i].resize(pane._base->size_of_nodes()*_buf_dim);
      
    int n=pane.size_of_faces();

    if ( !init_emm) continue;

    pane._emm_offset.resize( n+1);
    // Initialize space for the mass matrix
    pane._emm_offset[0] = 0;
    
    int k=0;
    // Loop through the connectivity table to mark their nodes as false.
    if ( pane._base->is_structured()) {
      for ( int i=0; i<n; ++i, ++k) {
        pane._emm_offset[k+1] = pane._emm_offset[k] +  16;
      }
    }
    else {
      std::vector< const COM::Connectivity*>  elems;
      pane._base->elements( elems);
      
      for ( std::vector<const COM::Connectivity*>::const_iterator
              it = elems.begin(); it != elems.end(); ++it) {
        const int nn = (*it)->size_of_nodes_pe();
        for ( int i=1,size=(*it)->size_of_elements(); i<=size; ++i, ++k) {
          pane._emm_offset[k+1] = pane._emm_offset[k] +  nn*nn;
        }
      }
    }
    
    pane._emm_buffer.resize( pane._emm_offset[n], 0);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init_recv_buffer ( int  pane_id, int  from_rank  )

private

Definition at line 539 of file RFC_Window_transfer_comm.C.

References RFC_Window_base::_bufwin_prefix, _IO_format, RFC_Window_base::_pane_set, _prefix, _replic_panes, RFC_Window_base::color(), COM_call_function(), COM_delete_window(), COM_get_attribute_handle(), COM_get_function_handle(), COM_LOAD_MODULE_STATIC_DYNAMIC, COM_UNLOAD_MODULE_STATIC_DYNAMIC, RFC_Window_base::get_prefix_base(), RFC_Window_base::get_sdv_fname(), RFC_Pane_base::init(), MPI_COMM_SELF, pane(), RFC_Pane_base::read_binary(), RFC_Pane_base::read_rocin(), RFC_assertion, and RFC_Window_base::SDV_BINARY.

Referenced by replicate_metadata().

                                                                 {

  RFC_assertion( _pane_set.find( pane_id) == _pane_set.end());

  COM::Pane *base_pane = new COM::Pane( (COM::Window*)NULL, pane_id);
  RFC_Pane_transfer *pane = new RFC_Pane_transfer( base_pane, color());
  _replic_panes[ pane_id] = pane;

  std::string fname = get_sdv_fname( _prefix.c_str(), pane_id, _IO_format);
  if ( _IO_format == SDV_BINARY) {
    std::ifstream is( fname.c_str()); RFC_assertion( is);

    pane->read_binary( is, NULL, base_pane);
  }
  else {
    // Read in using Rocin.
    COM_LOAD_MODULE_STATIC_DYNAMIC( Rocin, "RFC_IN");
    int hdl_read = COM_get_function_handle( "RFC_IN.read_windows");
    int hdl_obtain = COM_get_function_handle( "RFC_IN.obtain_attribute");

    // Define the base-window and sdv-window names
    std::string base_material = get_prefix_base( _prefix.c_str());
    std::string sdv_material = base_material+"_sdv";

    std::string buf_wname(_bufwin_prefix); buf_wname.append( base_material);
    std::string sdv_wname=buf_wname+"_sdv";

    // Read the parent pane and the subdivided pane from the given file.
    MPI_Comm comm_self = MPI_COMM_SELF;
    COM_call_function( hdl_read, fname.c_str(), _bufwin_prefix, 
                       (base_material+" "+sdv_material).c_str(), &comm_self);

    int hdl_all = COM_get_attribute_handle( (buf_wname+".all").c_str());
    COM_call_function( hdl_obtain, &hdl_all, &hdl_all, &pane_id);
    hdl_all = COM_get_attribute_handle( (sdv_wname+".all").c_str());
    COM_call_function( hdl_obtain, &hdl_all, &hdl_all, &pane_id);

    pane->read_rocin( sdv_wname, buf_wname, base_pane);

    // Delete the windows created by Rocin.
    COM_delete_window( buf_wname.c_str());
    COM_delete_window( sdv_wname.c_str());

    // Unload Rocin
    COM_UNLOAD_MODULE_STATIC_DYNAMIC( Rocin, "RFC_IN");
  }

  pane->init();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void init_send_buffer ( int  pane_id, int  to_rank  )

private

Definition at line 531 of file RFC_Window_transfer_comm.C.

References _panes_to_send, and pane().

Referenced by replicate_metadata().

                                                               {
  _panes_to_send.insert( std::pair<int,RFC_Pane_transfer*>( to_rank, 
                                                            &pane(pane_id)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool is_root

(

)

const

Check whether the process has rank 0.

Definition at line 499 of file RFC_Window_transfer_comm.C.

References _comm, and rank.

Referenced by Transfer_base::interpolate_fe(), Transfer_base::loadtransfer(), Interpolator::transfer(), Transfer_base::transfer_2f(), and Transfer_base::transfer_2n().

                                   { 
  int rank; MPI_Comm_rank( _comm, &rank);
  return (rank==0);
}

Here is the caller graph for this function:

Nodal_data nodal_buffer

(

int

index

)

Definition at line 142 of file RFC_Window_transfer.C.

References _buf_dim, and RFC_assertion.

Referenced by Transfer_base::transfer_2n().

                         {
  RFC_assertion( index >= 0);
  return Nodal_data( -index-1, _buf_dim);
}

Here is the caller graph for this function:

RFC_Pane_transfer & pane

(

const int

pid

)

Definition at line 74 of file RFC_Window_transfer.C.

References RFC_Window_base::_pane_set, and _replic_panes.

Referenced by delete_facial_buffers(), delete_nodal_buffers(), Transfer_base::get_src_pane(), Transfer_base::get_trg_pane(), incident_faces(), incident_panes(), init_facial_buffers(), init_nodal_buffers(), init_recv_buffer(), init_send_buffer(), reduce_maxabs_to_all(), reduce_to_all(), replicate_metadata(), and set_tags().

                                        {
  Pane_set::iterator pit = _pane_set.find( pid);
  if ( pit != _pane_set.end()) {
    return reinterpret_cast<RFC_Pane_transfer&>(*pit->second);
  }
  else {
    return *_replic_panes.find( pid)->second; 
  }
}

Here is the caller graph for this function:

const RFC_Pane_transfer & pane

(

const int

pid

)

const

Definition at line 85 of file RFC_Window_transfer.C.

References RFC_Window_base::_pane_set, and _replic_panes.

                                              {
  Pane_set::const_iterator pit = _pane_set.find( pid);
  if ( pit != _pane_set.end()) {
    return reinterpret_cast<const RFC_Pane_transfer&>(*pit->second);
  }
  else {
    return *_replic_panes.find( pid)->second; 
  }
}

void reduce_maxabs_to_all

(

Nodal_data &

data

)

Definition at line 476 of file RFC_Window_transfer_comm.C.

References RFC_Window_base::_map_comm, RFC_Window_base::_pane_set, COM_DOUBLE, RFC_Data_const< _Tag >::dimension(), RFC_Data_const< _Tag >::id(), pane(), pi, and RFC_Pane_transfer::pointer().

Referenced by Transfer_base::interpolate_fe(), and Transfer_base::transfer_2n().

                                                           {
  std::vector<void *> ptrs; ptrs.reserve( _pane_set.size());

  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer&)*pi->second;

    ptrs.push_back( pane.pointer( data.id()));
  }

  _map_comm.init( &ptrs[0], COM_DOUBLE, data.dimension());

  _map_comm.begin_update_shared_nodes();
  _map_comm.reduce_maxabs_on_shared_nodes();
  _map_comm.end_update_shared_nodes();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void reduce_to_all	(	Nodal_data &	data,
		MPI_Op	op
	)

Definition at line 459 of file RFC_Window_transfer_comm.C.

References RFC_Window_base::_map_comm, RFC_Window_base::_pane_set, COM_DOUBLE, RFC_Data_const< _Tag >::dimension(), RFC_Data_const< _Tag >::id(), pane(), pi, and RFC_Pane_transfer::pointer().

Referenced by Transfer_base::init_load_vector(), and Transfer_base::multiply_mass_mat_and_x().

                                                               {
  std::vector<void *> ptrs; ptrs.reserve( _pane_set.size());

  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer&)*pi->second;

    ptrs.push_back( pane.pointer( data.id()));
  }

  _map_comm.init( &ptrs[0], COM_DOUBLE, data.dimension());

  _map_comm.begin_update_shared_nodes();
  _map_comm.reduce_on_shared_nodes( op);
  _map_comm.end_update_shared_nodes();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void replicate_data	(	const Facial_data_const &	data,
		bool	replicate_coor
	)

Replicate the given data from remote processes onto local process.

Replicate coordinates only if replicate_coor is true.

Definition at line 228 of file RFC_Window_transfer_comm.C.

References _comm, RFC_Pane_transfer::_coor_buf, RFC_Pane_transfer::_data_buf, RFC_Pane_transfer::_data_buf_id, _pane_map, _panes_to_send, RFC_Pane_transfer::_recv_faces, _replic_panes, RFC_Pane_transfer::_send_buffers, RFC_Pane_transfer::_send_faces, RFC_Pane_transfer::coordinates(), d, RFC_Data_const< _Tag >::dimension(), i, RFC_Pane_base::id(), RFC_Data_const< _Tag >::id(), iend, j, MPI_BYTE, RFC_Pane_transfer::pointer(), QUIET_NAN, RFC_assertion, s, RFC_Pane_base::size_of_faces(), RFC_Pane_base::size_of_nodes(), and wait_all().

Referenced by Transfer_base::loadtransfer(), Interpolator::transfer(), Transfer_base::transfer_2f(), and Transfer_base::transfer_2n().

                                                          {
  std::vector< MPI_Request> other_requests, recv_requests;

  other_requests.reserve( _replic_panes.size()+_panes_to_send.size());
  recv_requests.reserve( _replic_panes.size());

  std::vector< RFC_Pane_transfer*> recv_panes; 
  recv_panes.reserve(_replic_panes.size());

  int totalNumPanes = _pane_map.size();
  int d = data.dimension(), ierr;

  // Loop through the replicated panes
  // Initiate receive of data buffers from remote processes
  for (std::map< int, RFC_Pane_transfer*>::iterator 
         it=_replic_panes.begin(),iend=_replic_panes.end(); it != iend; ++it) {
    RFC_Pane_transfer *p=it->second;
    p->_data_buf_id = data.id();

    p->_data_buf.reserve( p->size_of_faces()*d);
    p->_data_buf.resize( p->_recv_faces.size()*d, QUIET_NAN);

    std::pair< int, int>  s = _pane_map.find( p->id())->second;
    MPI_Request req;
    ierr = MPI_Irecv( &p->_data_buf[0], p->_data_buf.size()*sizeof(Real), 
                      MPI_BYTE, s.first, 100+s.second, _comm, &req);
    RFC_assertion( ierr==0);
    recv_requests.push_back( req);
    recv_panes.push_back( it->second);
    
    if ( replicate_coor) {
      p->_coor_buf.resize( p->size_of_faces()*3);
      ierr = MPI_Irecv( &p->_coor_buf[0], 
                        p->_recv_faces.size()*3*sizeof(Real), MPI_BYTE, 
                        s.first, 100+totalNumPanes+s.second, _comm, &req);
      RFC_assertion( ierr==0);
      other_requests.push_back( req);
    }
  }

  // Initiate send of data buffers to remote processes
  for (std::set< std::pair<int, RFC_Pane_transfer*> >::const_iterator
         it=_panes_to_send.begin(),iend=_panes_to_send.end(); it!=iend; ++it){
    RFC_Pane_transfer *p=it->second;

    std::pair< int, int>  s = _pane_map.find( p->id())->second;

    // Initialize the send buffer
    std::vector<int>  &send_faces=p->_send_faces[it->first];
    std::vector<Real> &data_buf=p->_send_buffers[it->first];
    const Real *addr = p->pointer(data.id());

    // We only allocate buffer if all entries are not sent
    if ( int(p->_send_faces.size()) != p->size_of_faces()) {
      data_buf.resize( send_faces.size()*d, QUIET_NAN);

      for ( int i=send_faces.size()-1; i>=0; --i) {
        for ( int j=d-1; j>=0; --j) {
          data_buf[i*d+j] = addr[(send_faces[i]-1)*d+j];
        }
      }
      addr = &data_buf[0];
    }

    MPI_Request req;
    ierr = MPI_Isend( const_cast<Real*>(addr), send_faces.size()*d*sizeof(Real), 
                      MPI_BYTE, it->first, 100+s.second, _comm, &req);

    RFC_assertion( ierr==0);
    other_requests.push_back( req);

    if ( replicate_coor) {
      ierr = MPI_Isend( const_cast<Real*>(p->coordinates()), 
                        p->_send_faces[it->first].size()*3*sizeof(Real), MPI_BYTE,
                        it->first, 100+totalNumPanes+s.second, _comm, &req);
      RFC_assertion( ierr==0);
      other_requests.push_back( req);
    }
  }

  // Processing received data arrays
  while ( !recv_requests.empty()) {
    int        index;
    MPI_Status stat;

    ierr = MPI_Waitany(recv_requests.size(), &recv_requests[0], &index, &stat);
    RFC_assertion( ierr==0);
    RFC_Pane_transfer *p=recv_panes[index];

    // Reorganize the data buffer as a dense array, and fill
    // unused entries by NaN.
    std::vector<Real> &buf = p->_data_buf;
    buf.resize( p->size_of_nodes()*d, QUIET_NAN);
      
    std::vector<int>  &faces = p->_recv_faces;
    for ( int i=faces.size()-1; i>=0; --i) {
      if ( i==faces[i]-1) break;
      for ( int j=d-1; j>=0; --j) {
        buf[(faces[i]-1)*d+j] = buf[i*d+j];
        buf[i*d+j] = QUIET_NAN;
      }
    }

    // Remove the received message from the list
    recv_requests.erase( recv_requests.begin()+index);
    recv_panes.erase( recv_panes.begin()+index);
  }

  // Wait for all send requests to finish
  wait_all( other_requests.size(), &other_requests[0]);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void replicate_data	(	const Nodal_data_const &	data,
		bool	replicate_coor
	)

Definition at line 344 of file RFC_Window_transfer_comm.C.

References _comm, RFC_Pane_transfer::_coor_buf, RFC_Pane_transfer::_data_buf, RFC_Pane_transfer::_data_buf_id, _pane_map, _panes_to_send, RFC_Pane_transfer::_recv_nodes, _replic_panes, RFC_Pane_transfer::_send_buffers, RFC_Pane_transfer::_send_nodes, RFC_Pane_transfer::coordinates(), d, RFC_Data_const< _Tag >::dimension(), i, RFC_Pane_base::id(), RFC_Data_const< _Tag >::id(), iend, j, MPI_BYTE, RFC_Pane_transfer::pointer(), QUIET_NAN, RFC_assertion, s, RFC_Pane_base::size_of_nodes(), and wait_all().

                                                          {
  std::vector< MPI_Request> other_requests, recv_requests;

  other_requests.reserve( _replic_panes.size()+_panes_to_send.size());
  recv_requests.reserve( _replic_panes.size());

  std::vector< RFC_Pane_transfer*> recv_panes; 
  recv_panes.reserve(_replic_panes.size());

  int totalNumPanes = _pane_map.size();
  int d = data.dimension(), ierr;

  // Loop through the replicated panes
  // Initiate receive of data buffers from remote processes
  for (std::map< int, RFC_Pane_transfer*>::iterator 
         it=_replic_panes.begin(),iend=_replic_panes.end(); it != iend; ++it) {
    RFC_Pane_transfer *p=it->second;
    p->_data_buf_id = data.id();

    p->_data_buf.reserve( p->size_of_nodes()*d);
    p->_data_buf.resize( p->_recv_nodes.size()*d);

    std::pair< int, int>  s = _pane_map.find( p->id())->second;
    MPI_Request req;
    ierr = MPI_Irecv( &p->_data_buf[0], p->_data_buf.size()*sizeof(Real), 
                      MPI_BYTE, s.first, 100+s.second, _comm, &req);
    RFC_assertion( ierr==0);
    recv_requests.push_back( req);
    recv_panes.push_back( it->second);
    
    if ( replicate_coor) {
      p->_coor_buf.resize( p->size_of_nodes()*3);
      ierr = MPI_Irecv( &p->_coor_buf[0], 
                        p->_recv_nodes.size()*3*sizeof(Real), MPI_BYTE, 
                        s.first, 100+totalNumPanes+s.second, _comm, &req);
      RFC_assertion( ierr==0);
      other_requests.push_back( req);
    }
  }

  // Initiate send of data buffers to remote processes
  for (std::set< std::pair<int, RFC_Pane_transfer*> >::const_iterator
         it=_panes_to_send.begin(),iend=_panes_to_send.end(); it!=iend; ++it){
    RFC_Pane_transfer *p=it->second;

    std::pair< int, int>  s = _pane_map.find( p->id())->second;

    // Initialize the send buffer
    std::vector<int>  &send_nodes=p->_send_nodes[it->first];
    std::vector<Real> &data_buf=p->_send_buffers[it->first];
    const Real *addr = p->pointer(data.id());

    // We only allocate buffer if all entries are not sent
    if ( int(p->_send_nodes.size()) != p->size_of_nodes()) {
      data_buf.resize( send_nodes.size()*d);

      for ( int i=send_nodes.size()-1; i>=0; --i) {
        for ( int j=d-1; j>=0; --j) {
          data_buf[i*d+j] = addr[(send_nodes[i]-1)*d+j];
        }
      }
      addr = &data_buf[0];
    }

    MPI_Request req;
    ierr = MPI_Isend( const_cast<Real*>(addr), send_nodes.size()*d*sizeof(Real), 
                      MPI_BYTE, it->first, 100+s.second, _comm, &req);
    RFC_assertion( ierr==0);
    other_requests.push_back( req);

    if ( replicate_coor) {
      ierr = MPI_Isend( const_cast<Real*>(p->coordinates()), 
                        p->_send_nodes[it->first].size()*3*sizeof(Real), MPI_BYTE,
                        it->first, 100+totalNumPanes+s.second, _comm, &req);
      RFC_assertion( ierr==0);
      other_requests.push_back( req);
    }
  }

  // Processing received data arrays
  while ( !recv_requests.empty()) {
    int        index;
    MPI_Status stat;

    ierr = MPI_Waitany(recv_requests.size(), &recv_requests[0], &index, &stat);
    RFC_assertion( ierr==0);

    RFC_Pane_transfer *p=recv_panes[index];
    std::vector<Real> &buf = p->_data_buf;

    // Reorganize the data buffer as a dense array, and fill
    // unused entries by NaN.
    std::vector<int>  &nodes = p->_recv_nodes;
    buf.resize( p->size_of_nodes()*d, QUIET_NAN);
    
    for ( int i=nodes.size()-1; i>=0; --i) {
      int lid = nodes[i]-1;
      if ( i==lid) break;
      for ( int j=d-1; j>=0; --j) {
        buf[lid*d+j] = buf[i*d+j];
        buf[i*d+j] = QUIET_NAN;
      }
    }

    // Remove the received message from the list
    recv_requests.erase( recv_requests.begin()+index);
    recv_panes.erase( recv_panes.begin()+index);
  }

  // Wait for all send requests to finish
  wait_all( other_requests.size(), &other_requests[0]);
}

Here is the call graph for this function:

void replicate_metadata	(	int *	pane_ids,
		int	n
	)

Replicate the metadata of a remote pane only the local process.

Definition at line 174 of file RFC_Window_transfer_comm.C.

References _comm, _pane_map, _replicated, comm_rank(), comm_size(), counts_to_displs(), i, init_recv_buffer(), init_send_buffer(), j, k, n, rank, and RFC_assertion.

Referenced by replicate_metadata().

                                                             {
  // Determine the owners of the panes
  std::vector< int>  npanes_recv( comm_size(), 0);
  std::vector< int>  npanes_send( comm_size(), 0);
  int rank=comm_rank();

  for ( int i=0; i<n; ++i) {
    RFC_assertion( _pane_map.find(pane_ids[i]) != _pane_map.end());
    std::pair< int, int>  p = _pane_map.find( pane_ids[i])->second;
    if ( p.first != rank) ++npanes_recv[ p.first];
  }

  MPI_Alltoall( &npanes_recv[0], 1, MPI_INT, 
                &npanes_send[0], 1, MPI_INT, _comm);

  // Create a buffer for the displacements of the buffer for pane ids.
  std::vector<int> displs_recv( npanes_recv.size()+1); 
  counts_to_displs( npanes_recv, displs_recv);
  std::vector<int> displs_send( npanes_send.size()+1);
  counts_to_displs( npanes_send, displs_send);

  std::vector< int>  ids_recv( displs_recv.back());
  for ( int i=0; i<n; ++i) {
    std::pair< int, int>  p = _pane_map.find( pane_ids[i])->second;
    if ( p.first != rank) ids_recv[ displs_recv[p.first]++] = pane_ids[i];
  }
  counts_to_displs( npanes_recv, displs_recv);

  std::vector< int>  ids_send( displs_send.back());

  MPI_Alltoallv(&ids_recv[0], &npanes_recv[0],&displs_recv[0], MPI_INT,
                &ids_send[0], &npanes_send[0],&displs_send[0], MPI_INT, _comm);

  
  // Prepare the data structures for sending. 
  for ( int i=0, size=npanes_send.size(), k=0; i<size; ++i) {
    for ( int j=0; j<npanes_send[i]; ++j, ++k) {
      init_send_buffer( ids_send[k], i);
    }
  }

  // Prepare the data structures for receiving data (replication)
  for ( int i=0, size=npanes_recv.size(), k=0; i<size; ++i) {
    for ( int j=0; j<npanes_recv[i]; ++j, ++k) {
      init_recv_buffer( ids_recv[k], i);
    }
  }

  _replicated = true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void replicate_metadata

(

const RFC_Window_transfer &

opp_win

)

Replicate the remote panes that are in contact with the local panes in opp_win.

Definition at line 54 of file RFC_Window_transfer_comm.C.

References _pane_map, RFC_Window_base::_pane_set, RFC_Pane_transfer::_recv_faces, RFC_Pane_transfer::_recv_nodes, RFC_Pane_transfer::_send_faces, RFC_Pane_transfer::_send_nodes, RFC_Pane_base::_subface_counterparts, RFC_Pane_base::_subface_parents, RFC_Pane_base::_subfaces, RFC_Pane_base::_subnode_parents, RFC_Pane_base::base(), comm_rank(), for(), i, incident_faces(), RFC_Pane_transfer::is_master(), j, k, pane(), Face_ID::pane_id, pi, rank, replicate_metadata(), RFC_assertion, and RFC_Pane_base::size_of_subfaces().

                                                        {

  std::map< int, std::vector<int> > opp_subface_lists;
  opp_win.incident_faces( opp_subface_lists);

  // First, make local copies of topology information of remote panes.
  std::vector< int> pane_ids; pane_ids.reserve( opp_subface_lists.size());

  for ( std::map< int, std::vector<int> >::const_iterator 
          it=opp_subface_lists.begin(); it!=opp_subface_lists.end(); ++it) {
    pane_ids.push_back( it->first);
  }
  replicate_metadata( &pane_ids[0], pane_ids.size());
  
  // Fill in _recv_faces and _recv_nodes for each remote pane.
  // Loop through the subface_lists
  for ( std::map< int, std::vector<int> >::const_iterator 
          it=opp_subface_lists.begin(); it!=opp_subface_lists.end(); ++it) {

    RFC_Pane_transfer &pn = pane( it->first);
    if (pn.is_master()) continue;

    RFC_assertion(pn._recv_faces.empty());
    // Loop through the subfaces of pn
    const std::vector< int> &subface_list = it->second;
    std::set<int> face_list;
    std::set<int> node_list;
    for ( int i=0, size=subface_list.size(); i<size; ++i) {
      int parent = pn._subface_parents[ subface_list[i]-1];
      face_list.insert( parent);

      Element_node_enumerator  ene( pn.base(), parent);

      for ( int k=0, kn=ene.size_of_nodes(); k<kn; ++k)
        node_list.insert( ene[k]);

      // Loop through the subnodes of the subface, and insert the nodes 
      // in their host facets.
      Three_tuple<int>  &f = pn._subfaces[ subface_list[i]-1];
      for ( int j=0; j<3; ++j) {
        int parent = pn._subnode_parents[ f[j]-1].face_id;
        Element_node_enumerator  ene( pn.base(), parent);

        for ( int k=0, kn=ene.size_of_nodes(); k<kn; ++k)
          node_list.insert( ene[k]);
      }
    }

    pn._recv_faces.reserve( face_list.size());
    pn._recv_faces.insert( pn._recv_faces.end(), face_list.begin(), face_list.end());
    pn._recv_nodes.reserve( node_list.size());
    pn._recv_nodes.insert( pn._recv_nodes.end(), node_list.begin(), node_list.end());
  }

  // Fill in _send_faces and _send_nodes for each local pane.
  const std::map<int, std::pair<int, int> > &opp_panemap = opp_win._pane_map;
  int rank=comm_rank();

  // Loop through the panes. 
  for (Pane_set::iterator pi=_pane_set.begin(); pi!=_pane_set.end(); ++pi) {

    // For the current pane, obtain a list of its faces that
    //  need to be sent to each remote process.
    RFC_Pane_transfer &pane = (RFC_Pane_transfer &)*pi->second;

    // Creaet a list and put into the following object
    std::map< int, std::set<int> > sfs;
    std::map< int, std::set<int> > sns;
    
    for ( int i=0, size=pane.size_of_subfaces(); i<size; ++i) {
      // If the counterpart of a subface is owned by a remote process P,
      // insert the parent of the subface into the face list for P.
      Face_ID oppf = pane._subface_counterparts[i];
      int remote_rank = opp_panemap.find( oppf.pane_id)->second.first;

      if ( remote_rank != rank) {
        int parent = pane._subface_parents[i];
        sfs[ remote_rank].insert( parent);

        std::set<int>  &ns=sns[remote_rank];
        Element_node_enumerator  ene( pane.base(), parent);

        for ( int k=0, kn=ene.size_of_nodes(); k<kn; ++k)
          ns.insert( ene[k]);

        // Loop through the subnodes of the subface, and insert the nodes 
        // in their host facets.
        Three_tuple<int>  &f = pane._subfaces[ i];
        for ( int j=0; j<3; ++j) {
          int parent = pane._subnode_parents[ f[j]-1].face_id;
          Element_node_enumerator  ene( pane.base(), parent);

          for ( int k=0, kn=ene.size_of_nodes(); k<kn; ++k)
            ns.insert( ene[k]);
        }
      }
    }

    // Copy from sfs to pane._send_faces
    RFC_assertion(pane._send_faces.empty());
    for ( std::map<int, std::set<int> >::const_iterator
            it=sfs.begin(); it!=sfs.end(); ++it) {
      std::vector<int> &vec=pane._send_faces[ it->first]; 
      vec.reserve(it->second.size()); 
      vec.insert( vec.end(), it->second.begin(), it->second.end());
    }

    // Copy from sns to pane._send_nodes
    RFC_assertion(pane._send_nodes.empty());
    for ( std::map<int, std::set<int> >::const_iterator
            it=sns.begin(); it!=sns.end(); ++it) {
      std::vector<int> &vec=pane._send_nodes[ it->first]; 
      vec.reserve(it->second.size()); 
      vec.insert( vec.end(), it->second.begin(), it->second.end());
    }
  }
}

Here is the call graph for this function:

bool replicated ( ) const

inline

Returns whether replication has been performed.

Definition at line 161 of file RFC_Window_transfer.h.

References _replicated.

{ return _replicated; }

void set_tags

(

const COM::Attribute *

tag

)

Definition at line 160 of file RFC_Window_transfer.C.

References RFC_Pane_base::_base, RFC_Window_base::_pane_set, RFC_Pane_transfer::_to_recv, RFC_Window_base::attribute(), pane(), and pi.

                                   {
  // Loop through the panes to set the tags
  for (Pane_set::iterator pi=_pane_set.begin(); pi != _pane_set.end(); ++pi) {
    RFC_Pane_transfer &pane = (RFC_Pane_transfer &)*pi->second;

    pane._to_recv = ( tag == NULL) ? (int *)NULL : 
      (int *)(pane._base->attribute( tag->id())->pointer());
  }
}

Here is the call graph for this function:

void wait_all	(	int	n,
		MPI_Request *	requests
	)

Definition at line 505 of file RFC_Window_transfer_comm.C.

References RFC_assertion.

Referenced by replicate_data().

                                                           {
  if ( n>0) {
    std::vector<MPI_Status>   statuses(n);
    int ierr = MPI_Waitall( n, requests, &statuses[0]);
    RFC_assertion( ierr==0);
  }
}

Here is the caller graph for this function:

void wait_any	(	int	n,
		MPI_Request *	requests,
		int *	index,
		MPI_Status *	stat = NULL
	)

Definition at line 514 of file RFC_Window_transfer_comm.C.

References RFC_assertion, and s.

                                                             {
  if ( n>0) {
    MPI_Status s; if ( stat==NULL) stat = &s;
    int ierr = MPI_Waitany( n, requests, index, stat);
    RFC_assertion( ierr==0);
  }
}

Member Data Documentation

int _buf_dim

private

Definition at line 221 of file RFC_Window_transfer.h.

Referenced by facial_buffer(), init_facial_buffers(), init_nodal_buffers(), and nodal_buffer().

MPI_Comm _comm

private

Definition at line 222 of file RFC_Window_transfer.h.

Referenced by allreduce(), barrier(), comm_rank(), comm_size(), is_root(), replicate_data(), and replicate_metadata().

const int _IO_format

private

Definition at line 230 of file RFC_Window_transfer.h.

Referenced by init_recv_buffer().

std::vector<int> _num_panes

private

Definition at line 224 of file RFC_Window_transfer.h.

Referenced by RFC_Window_transfer().

std::map< int, std::pair<int, int> > _pane_map

private

Definition at line 223 of file RFC_Window_transfer.h.

Referenced by replicate_data(), replicate_metadata(), and RFC_Window_transfer().

std::set< std::pair<int, RFC_Pane_transfer*> > _panes_to_send

private

Definition at line 228 of file RFC_Window_transfer.h.

Referenced by init_send_buffer(), and replicate_data().

const std::string _prefix

private

Definition at line 229 of file RFC_Window_transfer.h.

Referenced by init_recv_buffer().

std::map< int, RFC_Pane_transfer*> _replic_panes

private

Definition at line 225 of file RFC_Window_transfer.h.

Referenced by clear_replicated_data(), init_recv_buffer(), pane(), replicate_data(), and ~RFC_Window_transfer().

bool _replicated

private

Definition at line 226 of file RFC_Window_transfer.h.

Referenced by replicate_metadata(), and replicated().

---

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

• RFC_Window_transfer.h
• RFC_Window_transfer.C
• RFC_Window_transfer_comm.C