Pane.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: Pane.h,v 1.8 2008/12/06 08:43:24 mtcampbe Exp $

/* Author: Xiangmin Jiao */

#ifndef __ROCCOM_PANE_H__
#define __ROCCOM_PANE_H__

#include <string>
#include <vector>
#include "Connectivity.h"

COM_BEGIN_NAME_SPACE

class Pane {
public:
  typedef std::vector<Attribute*>      Attr_set; 
  typedef std::vector<Connectivity*>   Cnct_set; 
  typedef unsigned int                 Size;     
  enum OP_Init { OP_SET=1, OP_SET_CONST, OP_ALLOC, OP_RESIZE, OP_DEALLOC};
  enum Inherit_Modes { INHERIT_USE=0, INHERIT_CLONE, INHERIT_COPY };

  class Attribute_friend : public Attribute {
    explicit Attribute_friend( Attribute&);
  public:
    Attribute_friend( Pane *p, int i) : Attribute(p, i) {}
    using Attribute::set_pointer;
    using Attribute::inherit;
  };

  class Connectivity_friend : public Connectivity {
    explicit Connectivity_friend( Connectivity&);
  public:
    using Connectivity::set_pointer;
    using Connectivity::set_offset;
    using Connectivity::inherit;
  };

  Pane(Window *w, int i);

  Pane(Pane *p, int i);

  virtual ~Pane();
  //\}

  void init_done() throw(COM_exception);
  //\}

  const Window *window()  const { return _window; }
  Window       *window()        { return _window; }

  int     id() const      { return _id; }

  int  dimension() const 
  { return _cnct_set.empty()?0:_cnct_set[0]->dimension(); }

  bool is_unstructured() const 
  { return _cnct_set.size()!=1 || !_cnct_set[0]->is_structured(); }

  bool is_mixed()   const { return _cnct_set.size()>1; }
  
  bool is_structured()   const 
  { return _cnct_set.size()==1 && _cnct_set[0]->is_structured(); }
  //\}

  Size size_of_nodes() const 
  { return _attr_set[COM_NC]->size_of_items(); }

  Size maxsize_of_nodes() const 
  { return _attr_set[COM_NC]->maxsize_of_items(); }

  Size size_of_ghost_nodes() const 
  { return _attr_set[COM_NC]->size_of_ghost_items(); }

  Size maxsize_of_ghost_nodes() const 
  { return _attr_set[COM_NC]->maxsize_of_ghost_items(); }

  Size size_of_real_nodes() const 
  { return _attr_set[COM_NC]->size_of_real_items(); }

  Size maxsize_of_real_nodes() const 
  { return _attr_set[COM_NC]->maxsize_of_real_items(); }

  Size size_of_elements() const 
  { return _attr_set[COM_CONN]->size_of_items(); }

  Size maxsize_of_elements() const 
  { return _attr_set[COM_CONN]->maxsize_of_items(); }

  Size size_of_ghost_elements() const 
  { return _attr_set[COM_CONN]->size_of_ghost_items(); }

  Size maxsize_of_ghost_elements() const 
  { return _attr_set[COM_CONN]->maxsize_of_ghost_items(); }

  Size size_of_real_elements() const 
  { return _attr_set[COM_CONN]->size_of_real_items(); }

  Size maxsize_of_real_elements() const 
  { return _attr_set[COM_CONN]->maxsize_of_real_items(); }

  double *coordinates()   { return (double *)_attr_set[COM_NC]->pointer(); }
  double *x_coordinates() { return (double *)_attr_set[COM_NC1]->pointer(); }
  double *y_coordinates() { return (double *)_attr_set[COM_NC2]->pointer(); }
  double *z_coordinates() { return (double *)_attr_set[COM_NC3]->pointer(); }

  const double *coordinates()   const 
  { return (const double *)_attr_set[COM_NC]->pointer(); }
  const double *x_coordinates() const
  { return (const double *)_attr_set[COM_NC1]->pointer(); }
  const double *y_coordinates() const
  { return (const double *)_attr_set[COM_NC2]->pointer(); }
  const double *z_coordinates() const
  { return (const double *)_attr_set[COM_NC3]->pointer(); }

  int *pane_connectivity() 
  { return (int*)_attr_set[COM_PCONN]->pointer(); }

  const int *pane_connectivity() const
  { return (const int *)_attr_set[COM_PCONN]->pointer(); }

  bool ignore_ghost() const { return _ignore_ghost; }

  void set_ignore_ghost(bool ignore){ _ignore_ghost = ignore; }
  //\}

  Size size_of_ghost_layers() const 
  { return _cnct_set.empty()?0:_cnct_set[0]->size_of_ghost_items(); }

  Size size_i() const 
  { return !is_structured()?0:_cnct_set[0]->size_i(); }
  Size size_j() const 
  { return !is_structured()?0:_cnct_set[0]->size_j(); }
  Size size_k() const 
  { return !is_structured()?0:_cnct_set[0]->size_k(); }
  //\}

  void attributes( std::vector<Attribute*> &as);

  void attributes( std::vector< const Attribute*> &as) const
  { const_cast<Pane*>(this)->attributes((std::vector<Attribute*>&)as); }

  Attribute *attribute( const std::string &a); // Locate by name.
  const Attribute *attribute( const std::string &a) const
  { return const_cast<Pane*>(this)->attribute(a); }

  Attribute *attribute( int i);

  const Attribute *attribute( int i) const
  { return const_cast<Pane*>(this)->attribute(i); }
  //\}

  void connectivities( std::vector<Connectivity*> &es) 
  { es = _cnct_set; }

  void connectivities( std::vector<const Connectivity*> &es) const 
  { const_cast<Pane*>(this)->connectivities
      ( (std::vector<Connectivity*> &)es); }

  Connectivity *connectivity( Size i) throw(COM_exception);
  const Connectivity *connectivity( Size i) const throw(COM_exception)
  { return const_cast<Pane*>(this)->connectivity( i); }

  void elements( std::vector<Connectivity*> &es) { connectivities(es); }
  void elements( std::vector< const Connectivity*> &es) const
  { connectivities(es); }

  void refresh_connectivity() throw(COM_exception);
  //\}

protected: // The following functions to be called by the Window class.
  // Add a new attribute into the pane.
  Attribute *new_attribute( const std::string &aname, int aid, 
                            const char loc, const int type, int ncomp, 
                            const std::string &unit) throw(COM_exception);

  void insert( Attribute *attr) throw(COM_exception);

  void delete_attribute( int id) throw (COM_exception);

  void reinit_attr( int aid, OP_Init op, void **addr, 
                    int strd, int cap) throw(COM_exception);

  const Connectivity *connectivity( const std::string &a) 
    const throw(COM_exception)
  { return const_cast<Pane*>(this)->connectivity( a); }

  Connectivity *connectivity( const std::string &a, 
                              bool insert=false) throw(COM_exception);

  void reinit_conn( Connectivity *con, OP_Init op, int **addr, 
                    int strd, int cap) throw (COM_exception);

  Attribute *inherit( Attribute *from, const std::string &aname,
                      int mode, bool withghost) throw(COM_exception);

  void set_size( Attribute *a, int nitems, int ng) throw( COM_exception);

  void set_size( Connectivity *con, int nitems, int ng) throw( COM_exception);

protected:
  Window*     _window;     
  int         _id;         
  Attr_set    _attr_set;   
  Cnct_set    _cnct_set;   
  bool        _ignore_ghost;  

private:
#ifdef DOXYGEN
  // This is to fool DOXYGEN to generate the correct collabration diagram
  Attribute    *_attr_set;
  Connectivity *_cnct_set;
#endif
  // Disable the following two functions (they are dangerous)
  Pane( const Pane&);
  Pane &operator=( const Pane&);
};

COM_END_NAME_SPACE

#endif