RFC_Window_base.h

Go to the documentation of this file.

/* *******************************************************************
 * Rocstar Simulation Suite                                          *
 * Copyright@2015, Illinois Rocstar LLC. All rights reserved.        *
 *                                                                   *
 * Illinois Rocstar LLC                                              *
 * Champaign, IL                                                     *
 * www.illinoisrocstar.com                                           *
 * sales@illinoisrocstar.com                                         *
 *                                                                   *
 * License: See LICENSE file in top level of distribution package or *
 * http://opensource.org/licenses/NCSA                               *
 *********************************************************************/
/* *******************************************************************
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,   *
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES   *
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND          *
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE CONTRIBUTORS OR           *
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER       *
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   *
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE    *
 * USE OR OTHER DEALINGS WITH THE SOFTWARE.                          *
 *********************************************************************/
// $Id: RFC_Window_base.h,v 1.30 2008/12/06 08:43:26 mtcampbe Exp $

//===============================================================
// This file defines RFC_Window_base and RFC_Pane_base. The class
//      RFC_Window_overlay, RFC_Pane_overlay, RFC_Window_transfer, 
//      and RFC_Pane_transfer are implemented based on these two.
// Author: Xiangmin Jiao
// Date:   06/14/2001
//===============================================================

#ifndef RFC_WINDOW_BASE_H
#define RFC_WINDOW_BASE_H

#include "rfc_basic.h"
#include "roccom_devel.h"
#include "Tuple.h"
#include "Vector_n.h"
#include <set>
#include <map>
#include <fstream>
#include "../Rocmap/include/Pane_communicator.h"
#include "Element_accessors.h"

RFC_BEGIN_NAME_SPACE


struct Node_ID {
  Node_ID() {}

  Node_ID( int p, int v) : pane_id( p), node_id( v) {}
  int pane_id;        
  int node_id;      

  bool operator==( const Node_ID &v) const 
  { return pane_id == v.pane_id && node_id == v.node_id; }
  bool operator<( const Node_ID &v) const {
    return (pane_id < v.pane_id ||
            pane_id == v.pane_id && node_id < v.node_id); 
  }
};
  

struct Face_ID { 
  Face_ID() {}

  Face_ID( int p, int f) : pane_id( p), face_id( f) {}

  int pane_id;        
  int face_id;        

  bool operator==( const Face_ID &v) const 
  { return pane_id == v.pane_id && face_id == v.face_id; }
  bool operator<( const Face_ID &v) const {
    return (pane_id < v.pane_id ||
            pane_id == v.pane_id && face_id < v.face_id); 
  }
};

class RFC_Window_base;
using MAP::Element_node_enumerator;

template < class _Pane> class RFC_Window_derived;

class RFC_Pane_base {
public:
  typedef RFC_Pane_base                                  Self;
  typedef COM::Pane                                      Base;
  typedef COM::Attribute                                 Attribute;
  typedef Base::Size                                     Size;
  typedef RFC::Real                                      Real;

  friend class RFC_Window_base;
  template <class _Pane> friend class RFC_Window_derived;


  struct Edge_ID { 
    Edge_ID() {}

    Edge_ID( int f, int e) : face_id( f), edge_id(e) {}
 
    int face_id;    
    int edge_id;    
    
    bool operator<( const Edge_ID &v) const {
      return (face_id < v.face_id ||
              face_id == v.face_id && edge_id < v.edge_id); 
    }
  };

  // Pane connectivity informaiton.
  typedef std::pair<int,int>  V2b;
  typedef std::map<int, V2b>  V2b_table;
  typedef std::vector<int>    B2v; 
  typedef std::map<int, B2v>  B2v_table;

  RFC_Pane_base( Base *b, int color);
  void init();

  virtual ~RFC_Pane_base() {}

  Base *base() { return _base; }
  const Base *base() const { return _base; }
  int id() const { return _base->id(); }

  bool is_master()    const { return _is_master; }
  bool is_replicate() const { return !_is_master; }
  bool is_quadratic() const { return _quadratic; }
  bool is_border_node( int i) const 
  { RFC_assertion( i>=1 && i<= size_of_nodes()); return _is_border[i-1]; }
  bool is_isolated_node( int i) const 
  { RFC_assertion( i>=1 && i<= size_of_nodes()); return _is_isolated[i-1]; }

  bool coincident( int i, int j) const;

  int size_of_nodes() const { return _base->size_of_nodes(); }
  int size_of_faces()    const { return _base->size_of_elements(); }

  // ! Obtain the number of isolated nodes in the pane
  int size_of_isolated_nodes() const { return _n_isolated; }
  // ! Obtain the number of border nodes in the pane
  int size_of_border_nodes() const { return _n_border; }

  Edge_ID get_edge_id( const int face_lid, const int vertex_lid) const;

  int size_of_subnodes() const { return _subnode_parents.size(); }
  int size_of_subfaces() const  { return _subfaces.size(); }

  Real *pointer( int i)
  { return (Real*)_base->attribute(i)->pointer(); }
  const Real *pointer( int i) const
  { return (Real*)_base->attribute(i)->pointer(); }

  bool is_primary_node( const int vid) const;

  int size_of_primary_nodes() const;

  const Point_3 &get_point( int id) const {
    RFC_assertion( sizeof( Point_3) == 3*sizeof( Real));
    return *reinterpret_cast<const Point_3*>(_base->coordinates()+3*(id-1));
  }
  const Point_3 &get_point( int id, int) const {
    RFC_assertion( sizeof( Point_3) == 3*sizeof( Real));
    return *reinterpret_cast<const Point_3*>(_base->coordinates()+3*id);
  }
  const Real *coordinates() const { return _base->coordinates(); }
  Point_3 get_point_of_subnode( int id) const;

  Bbox_3 get_bounding_box() const;

  int color() const { return _color; }

  int parent_type_of_subnode( int) const;

  int get_parent_node( int) const;

  int get_parent_face( int id) const { return _subface_parents[ id-1]; }

  template <class Point>
  void normalize_nat_coor( int idx, int e, Point &nc) const {
    if( e == 3) {
      switch( idx) {
      case 0: return; 
      case 1: nc = Point( 1.-nc[0]-nc[1], nc[0]); return;
      case 2: nc = Point( nc[1], 1.-nc[0]-nc[1]); return;
      default: RFC_assertion( false);
      }
    }
    else {
      switch( idx) {
      case 0: return; 
      case 1: nc = Point( 1-nc[1], nc[0]); return;
      case 2: nc = Point( 1-nc[0], 1-nc[1]); return; 
      case 3: nc = Point( nc[1], 1-nc[0]); return;
      default: RFC_assertion( false);
      }
    }
  }

  void
  get_host_element_of_subnode( int i, Element_node_enumerator &ene,
                               Point_2 &nc) const {
    int f=_subnode_parents[i-1].face_id;
    if ( ene.pane() != _base || ene.id() != f) 
      ene = Element_node_enumerator( _base, f);
    const Point_2S &p=_subnode_normalized_nc[i-1]; 
    nc[0]=p[0]; nc[1]=p[1];
  }

  void
  get_host_element_of_subface( int i, Element_node_enumerator &ene) const {
    int f=_subface_parents[i-1];
    if ( ene.pane() != _base || ene.id() != f) 
      ene = Element_node_enumerator( _base, f);
  }

  void get_nat_coor_in_element( const int eid, const int lid, Point_2 &nc) const {
    const Point_2S &p=_subface_nat_coors[eid-1][lid];
    nc[0] = p[0]; nc[1]=p[1];
  }

  void get_nat_coor_in_element( const int sn_id, 
                                Element_node_enumerator &ene, Point_2 &nc) const;

  std::pair< const COM::Connectivity*, int> get_element( int face_id) const {
    const int* p = std::lower_bound( &*_elem_offsets.begin(),
                                     &*_elem_offsets.end(), face_id)-1;
    return std::make_pair( _elem_conns[p-&_elem_offsets[0]],
                           face_id-_elem_offsets[*p]);
  }
  const Node_ID &get_subnode_counterpart( int i) const { 
    RFC_assertion( i>=1 && i<=(int)_subnode_counterparts.size());
    return _subnode_counterparts[i-1];
  }
  const Face_ID &get_subface_counterpart( int i) const { 
    RFC_assertion( i>=1 && i<=(int)_subface_counterparts.size());
    return _subface_counterparts[i-1];
  }

  int get_lvid( const Element_node_enumerator &ene, 
                const int v) const;

protected:
  void comp_nat_coors();

  void build_v2b_from_b2v( const RFC_Window_base *w);

protected:
  // Used by read_binary and read_rocin to create a pane
  class COM_Pane_friend : protected COM::Pane {
  protected:
    COM_Pane_friend();
  public:
    using COM::Pane::attribute;
    using COM::Pane::connectivity;
    using COM::Pane::set_size;
    using COM::Pane::reinit_conn;
  };

  //=========== IO Functions
  void write_tec_ij( std::ostream &, const COM::Attribute *a=0) const;
  void write_tec_tri( std::ostream &, const COM::Connectivity &,
                      const COM::Attribute *a=0) const;
  void write_tec_mixed( std::ostream&, 
                        const std::vector< const COM::Connectivity*>&,
                        const COM::Attribute *a=0) const;
  void write_tec_sub( std::ostream &) const;
  void write_tec_ascii( std::ostream &os, const COM::Attribute *attr=0) const;

  // Write in native binary format
  void write_binary( std::ostream &os) const;

  // Read in native binary format.
  void read_binary( std::istream &is, 
                    std::vector <int> *b2v_all=NULL, COM::Pane *p=NULL);
  
  // Register the attributes for the pane for output using Rocout.
  void register_sdv_attributes( const std::string &wname) const;
  
  void read_rocin( const std::string &sdv_wname, 
                   const std::string &parent_wname="", 
                   COM::Pane *p=NULL);

protected:
  // Data members
  Base                             *_base;      
  bool                              _is_master; 
  bool                              _quadratic; 

  std::vector< bool>                _is_border;  
  std::vector< bool>                _is_isolated; 
  int                               _n_border, _n_isolated;

  V2b_table                         _v2b_table;  
  B2v_table                         _b2v_table;  

  // Information about the subnodes contained in the pane
  std::vector< Edge_ID>             _subnode_parents;
  std::vector< Point_2S>            _subnode_nat_coors;
  std::vector< Point_2S >           _subnode_normalized_nc;
  std::vector< int>                 _subnode_subID;

  std::vector< Node_ID>             _subnode_counterparts;   

  // Information about the subfaces contained in the pane
  std::vector< Three_tuple<int> >   _subfaces;

  std::vector< int >                _subface_parents;
  std::vector< int>                  _subface_offsets;
  std::vector< Face_ID>             _subface_counterparts;

  // Natural coordiates of the subnodes of a subface in its parent face
  std::vector< Three_tuple<Point_2S> >   _subface_nat_coors;
private:
  int                                    _color;     

  std::vector< const COM::Connectivity*> _elem_conns;
  std::vector< int>                      _elem_offsets;

private:
  // Disable the following functions.
  RFC_Pane_base();
  RFC_Pane_base( const Self&);
  Self &operator=( const Self&);
};

//================ Filed data access operators ===================

class Nodal_coor_const {
public:
  typedef Point_3               Value;              
  typedef Point_3               Value_nonconst;     
  typedef const Point_3         Value_const;        
  typedef unsigned int          Size;               

  Value_const& get_value( const RFC_Pane_base *p, int i) const {
    return p->get_point(i);
  }
  Value_const& get_value( const Real *p, int i) const {
    return *reinterpret_cast<Value_const*>(p+3*(i-1));
  }
};


// Adpator for element-wise data container. 
//  This wrapper provides an interface to access data through the
//  element-wise local indices.
template < class _Cont, class _Enum>
class Field {
public:
  typedef typename _Cont::Value          Value;
  typedef typename _Cont::Value_nonconst Value_nonconst;
  typedef typename _Cont::Value_const    Value_const;
  typedef unsigned int                   Size;
private:
  _Cont             &_cont;
  Real              *_p;
  const _Enum       &_enum;
public:
  Field( _Cont & cont, Real *p, const _Enum &ids) 
    : _cont(cont), _p(p), _enum(ids) {}
  Size dimension() const { return _cont.dimension(); }
  Value_const operator[]( int i) const
  { return _cont.get_value(_p, _enum[i]); }
  Value_nonconst operator[]( int i)
  { return _cont.get_value(_p, _enum[i]); }
};

template < class _Cont, class _Enum>
class Field< const _Cont, _Enum> {
public:
  typedef typename _Cont::Value          Value;
  typedef typename _Cont::Value_nonconst Value_nonconst;
  typedef typename _Cont::Value_const    Value_const;
  typedef unsigned int                   Size;
private:
  const _Cont             &_cont;
  const Real              *_p;
  const _Enum             &_enum;
public:
  Field( const _Cont & cont, const Real *p, const _Enum &ids) 
    : _cont(cont), _p(p), _enum(ids) {}
  Size dimension() const { return _cont.dimension(); }
  Value_const operator[]( int i) const
  { return _cont.get_value(_p, _enum[i]); }
};


class RFC_Window_base {
public:
  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;

  RFC_Window_base( Base *b, int c, MPI_Comm);

  virtual ~RFC_Window_base();

  std::string name() const { return _base->name(); }

  const RFC_Pane_base & pane( const int pid) const {
    Pane_set::const_iterator pit = _pane_set.find( pid);
    RFC_assertion( pit != _pane_set.end());
    return *pit->second;
  }

  RFC_Pane_base &pane( const int pid) {
    Pane_set::iterator pit = _pane_set.find( pid);
    RFC_assertion( pit != _pane_set.end());
    return *pit->second;
  }

  const COM::Window *base() const { return _base; }

  int color() const { return _color; }

  int size_of_nodes() const;

  int size_of_faces() const;

  int size_of_primary_nodes() const;

  Bbox_3 get_bounding_box() const;
  
  int size_of_panes() const { return _pane_set.size(); }

  const Attribute *attribute( const char *f) const 
  { return _base->attribute(f); }

  void export_window( RFC_Window_base *) const;

  void write_tec_ascii( const char *prefix) const;
  void write_tec_sub( const char *prefix) const;

  void new_sdv_attributes( const std::string &wname) const;

  void read_sdv( const char *prefix, const char *format=NULL);

  void write_sdv( const char* prefix, const char *format=NULL) const;

  void build_pc_tables();

protected:
  enum { SDV_BINARY, SDV_HDF, SDV_CGNS};

  // Obtain the file name for a specific pane.
  static std::string get_sdv_fname( const char *prefix, int pane_id, 
                                    const int format=SDV_BINARY);

  // Get the basename of the prefix without the directory part and suffix.
  static const char *get_prefix_base( const char *prefix);

  // Convert from string into the code.
  static int get_sdv_format( const char *format);

  // Prefix to be added in front of buffer windows.
  static const char *_bufwin_prefix;

protected:  // Data members
  Base           *_base;       
  Pane_set        _pane_set;   
  int             _verbose;
  int             _color;

  MAP::Pane_communicator  _map_comm;

private:
  // Disable the following functions.
  RFC_Window_base();
  RFC_Window_base(const Self&);
  Self &operator=( const Self&);
};


template <class _Pane>
class RFC_Window_derived : public RFC_Window_base {
protected:
  typedef RFC_Window_derived<_Pane>               Self;
  typedef RFC_Window_base                         Base;
  typedef _Pane                                   Pane;

  RFC_Window_derived( COM::Window *b, int c, MPI_Comm comm) : Base(b,c, comm) 
  { init(); }
  virtual ~RFC_Window_derived();
  void init();

public:
  const Pane &pane( const int pid) const;
  Pane &pane( const int pid);

  std::pair< Pane*, int> get_primary( Pane *p, int vid);

  std::pair< const Pane*, int> get_primary( const Pane *p, int vid) const;

  void panes( std::vector<Pane*> &ps);
  void panes( std::vector<const Pane*> &ps) const;
};

template < class _Pane>
RFC_Window_derived<_Pane>::~RFC_Window_derived() {}

template < class _Pane>
void
RFC_Window_derived<_Pane>::init() {
  std::vector< COM::Pane*>  ps;
  _base->panes( ps);   

  for (std::vector< COM::Pane*>::const_iterator 
         it=ps.begin(); it!=ps.end(); ++it) {
    // Insert a pane with given id
    (_pane_set[(*it)->id()] = new Pane(*it, color()))->init();
  }
}

template < class _Pane>
const _Pane &
RFC_Window_derived<_Pane>::pane( const int pid) const {
  Pane_set::const_iterator pit = _pane_set.find( pid);
  RFC_assertion( pit != _pane_set.end());
  return reinterpret_cast<const _Pane&>(*pit->second);
}

template < class _Pane>
_Pane &
RFC_Window_derived<_Pane>::pane( const int pid) {
  Pane_set::iterator pit = _pane_set.find( pid);
  RFC_assertion( pit != _pane_set.end());
  return reinterpret_cast<_Pane&>(*pit->second);
}

template < class _Pane>
void 
RFC_Window_derived<_Pane>::panes( std::vector<Pane*> &ps) {
  const_cast<Self*>(this)->panes( (std::vector<const Pane*>&)ps);
}

template < class _Pane>
void 
RFC_Window_derived<_Pane>::panes( std::vector<const Pane*> &ps) const {
  ps.resize(0);
  ps.reserve( _pane_set.size());
  Pane_set::const_iterator it=_pane_set.begin();
  for ( ; it != _pane_set.end(); ++it) 
    ps.push_back( reinterpret_cast<const Pane*>(it->second));
}

template < class _Pane>
std::pair< _Pane*, int> 
RFC_Window_derived<_Pane>::get_primary( Pane *p, int vid) {
  RFC_Pane_base::V2b_table::iterator it;
  
  //  points to a border halfedge.
  if ( !p->is_border_node( vid) || 
       (it = p->_v2b_table.find( vid))==p->_v2b_table.end()) {
    RFC_assertion( !p->is_isolated_node( vid));
    return std::make_pair(p, vid);
  }

  RFC_Pane_base::V2b &v2b = it->second;

  Pane &p2 =  pane( v2b.first);
  Node_ID v2( v2b.first, p2._b2v_table.find(p->id())->second[v2b.second]);

  RFC_assertion( v2 < Node_ID( p->id(), vid) || p->is_isolated_node(vid));
  RFC_assertion( !p2.is_isolated_node( v2.node_id));
  return std::make_pair( &p2, v2.node_id);
}

template < class _Pane>
std::pair< const _Pane*, int> 
RFC_Window_derived<_Pane>::get_primary( const Pane *p, int vid) const {
  return const_cast<Self*>(this)->get_primary( const_cast<Pane*>(p), vid);
}

RFC_END_NAME_SPACE

#endif