gmpCell.h

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_PLUGIN_CELL_BASE_H_
#define _GEMA_PLUGIN_CELL_BASE_H_
 
#include <gmElement.h>
#include <gmMesh.h>
#include <assert.h>
 
#include <gmMemory.h>
#include <gmPropertySet.h>
#include <gmCellMesh.h>
#include <gmLuaCell.h>
 
#include <luaProxy.h>
 
#include <QVarLengthArray>
 
#include "gmpCellMeshData.h"
 
 // IMPORTANT: If this values are changed, please also change the GmpCell type specification on
 //            the gemaCoreLib.natvis file
 
 
#define GM_CELLBASE_ACTIVE_MASK (~(~0u >> 1))
 
#define GM_CELLBASE_MESH_MASK ((~(~0u >> GMP_GEMAMESH_CELL_MESH_BITS)) >> 1)
 
#define GM_CELLBASE_CELL_MASK (~(GM_CELLBASE_ACTIVE_MASK | GM_CELLBASE_MESH_MASK))
 
static_assert((GM_CELLBASE_ACTIVE_MASK | GM_CELLBASE_MESH_MASK | GM_CELLBASE_CELL_MASK) == ~0u, "Invalid masks");
static_assert((GM_CELLBASE_ACTIVE_MASK & GM_CELLBASE_MESH_MASK) == 0, "Invalid masks");
static_assert((GM_CELLBASE_ACTIVE_MASK & GM_CELLBASE_CELL_MASK) == 0, "Invalid masks");
static_assert((GM_CELLBASE_MESH_MASK   & GM_CELLBASE_CELL_MASK) == 0, "Invalid masks");
 
static inline bool GmpCellIsActive(int cellId) { return !(cellId & GM_CELLBASE_ACTIVE_MASK); }
 
static inline int GmpCellMakeActive(int cellId) { return cellId & (~GM_CELLBASE_ACTIVE_MASK); }
 
static inline int GmpCellMakeInactive(int cellId) { return cellId | GM_CELLBASE_ACTIVE_MASK; }
 
static inline int GmpCellSetActiveFlag(int cellId, bool active) { return active ? GmpCellMakeActive(cellId) : GmpCellMakeInactive(cellId); }
 
 
static inline int GmpCellMeshIndex(int cellId) { return (cellId & GM_CELLBASE_MESH_MASK) >> GMP_GEMAMESH_CELL_ID_BITS; }
 
static inline int GmpCellIndex(int cellId) { return (cellId & GM_CELLBASE_CELL_MASK); }
 
static inline int GmpCellUpdateMeshIndex(int id, int oldId) { return (id & ~GM_CELLBASE_MESH_MASK) | (oldId & GM_CELLBASE_MESH_MASK); }
 
static inline int GmpCellEncodeId(int cellIndex, int meshIndex, bool active) 
{
  assert(cellIndex >= 0 && cellIndex < GMP_GEMAMESH_MAX_NUM_CELLS);
  assert(meshIndex >= 0 && meshIndex < GMP_GEMAMESH_MAX_NUM_MESHES);
  return GmpCellSetActiveFlag(cellIndex | (meshIndex << GMP_GEMAMESH_CELL_ID_BITS), active);
}
 
 
template <class Base, class Proxy, class CellMeshData, GmCellType T, int N> class GmpCell : public Base
{
public:
  GmpCell(int meshId, int cellId, int offset)
  {
    assert(N == geometry().numNodes());
    _cellId     = GmpCellEncodeId(cellId, meshId, true);  // cell is initially active
    _nodeOffset = offset;
  }
 
  // See comments on the base class
  virtual int cellId() const { return GmpCellIndex(_cellId); }
 
  // See comments on the base class
  virtual GmCellMesh* mesh() const { return CellMeshData::mesh(GmpCellMeshIndex(_cellId)); }
 
  // See comments on the base class
  virtual bool active() const { return GmpCellIsActive(_cellId); }
 
  // See comments on the base class
  virtual void setActive(bool active)
  {
    if(active == this->active())
      return;
 
    _cellId = GmpCellSetActiveFlag(_cellId, active);
    mesh()->activeCellUpdated(type(), active);
  }
 
  // See comments on the base class
  virtual void pushProxy(lua_State* L, const GmLogCategory& logger) { LuaProxy::pushObject(L, new Proxy(this, logger)); }
 
  // See comments on the base class
  virtual GmCellType type() const { return T; }
 
  // See comments on the base class
  virtual int numNodes() const { return N; }
 
  // See comments on the base class
  virtual int nodeIndex(int localIndex) const
  {
    assert(localIndex >= 0 && localIndex < N);
    return meshData()->cellNodesPtr(_nodeOffset)[localIndex];
  }
 
  // See comments on the base class.
  virtual void nodes(int* nodeList, bool ghost) const
  {
    Q_UNUSED(ghost); assert(!ghost);  // This class does not supports ghost nodes. This is handled by GmpGemaGhostCell
    memcpy(nodeList, meshData()->cellNodesPtr(_nodeOffset), N * sizeof(int));
  }
 
  // See comments on the base class
  virtual bool setNodes(const int* nodeList)
  {
    assert(nodeList);
 
#if 0 // Checked when first reading the mesh. Also tested at the API on the Lua binding.
    int nnodes = mesh()->numNodes();
    for(int i = 0; i < N; i++)
    {
      int node = nodeList[i];
      if(node < 0 || node >= nnodes)
        return false;
    }
#endif
    // If the mesh has a topology structure and the cell has already been added to that structure, 
    // we can't update the set of node cells.
    if(meshData()->cellIsTopologyIndexed(cellId()))
      return false;
 
    // Update!
    memcpy(meshData()->cellNodesPtr(_nodeOffset), nodeList, N * sizeof(int));
    return true;
  }
 
  // See comments on the base class
  virtual int propertyIndex(int propertySet) const
  {
    assert(propertySet >= 0 && propertySet < mesh()->propertySets().size());
    return meshData()->cellPropertiesPtr(cellId())[propertySet];
  }
 
  // See comments on the base class
  virtual bool setProperties(const int* propList, int nprop)
  {
    assert(propList);
    assert(nprop == mesh()->propertySets().size());
 
    memcpy(meshData()->cellPropertiesPtr(cellId()), propList, nprop*sizeof(int));
    return true;
  }
 
  void replaceCellId(int id, bool keepActiveFlag)
  {
    id = GmpCellUpdateMeshIndex(id, _cellId);
    if(keepActiveFlag)
      _cellId = GmpCellSetActiveFlag(id, active());
    else
      _cellId = id;
  }
 
  int offset() const { return _nodeOffset; }
 
  void setOffset(int offset) { _nodeOffset = offset; }
 
protected:
  CellMeshData* meshData() const { return (CellMeshData*)GmpCellMeshDataBase::meshData(GmpCellMeshIndex(_cellId)); }
 
  int _cellId;     
  int _nodeOffset; 
};
 
 
template <class Base, class Proxy, class CellMeshData, GmCellType T, int N> class GmpGhostCell
  : public GmpCell<Base, Proxy, CellMeshData, T, N>
{
public:
  GmpGhostCell(int meshId, int cellId, int offset)
    : GmpCell<Base, Proxy, CellMeshData, T, N>(meshId, cellId, offset) {}
 
  // See comments on the base class
  virtual int numGhostNodes() const { return _ghostList.size(); }
 
  // See comments on the base class
  virtual int addGhostNode(int globalIndex)
  {
    int index = GmMesh::clearGhostFlag(globalIndex);
    if(index < 0 || index >= mesh()->numGhostNodes())
      return -1;
 
    _ghostList.append(GmMesh::setGhostFlag(globalIndex));
 
    mesh()->ghostNodesUpdated(_ghostList.size(), _ghostList.size() + N);
    return N + _ghostList.size() - 1;
  }
 
  // See comments on the base class
  virtual void setGhostNodes(int* ghostNodes, int numNodes) 
  { 
    replaceGhostNodes(ghostNodes, numNodes);
    mesh()->ghostNodesUpdated(_ghostList.size(), _ghostList.size() + N);
  }
 
  // See comments on the base class
  virtual void removeGhostNode(int localIndex)
  {
    assert(localIndex >= N && localIndex < N + (int)_ghostList.size());
    _ghostList.remove(localIndex-N, 1);
  }
 
  // See comments on the base class
  virtual int nodeIndex(int localIndex) const
  {
    assert(localIndex >= 0 && localIndex < N + (int)_ghostList.size());
    return localIndex < N ? GmpCell<Base, Proxy, CellMeshData, T, N>::nodeIndex(localIndex) : _ghostList[localIndex-N];
  }
 
  // See comments on the base class.
  virtual void nodes(int* nodeList, bool ghost) const
  {
    GmpCell<Base, Proxy, CellMeshData, T, N>::nodes(nodeList, false); // Copy geometry nodes
    if(ghost)
      memcpy(nodeList+N, _ghostList.data(), _ghostList.size()*sizeof(int));
  }
 
  void replaceGhostNodes(int* ghostNodes, int numNodes)
  {
    _ghostList.resize(numNodes, GmPODVectorTightGrow);
    memcpy(_ghostList.data(), ghostNodes, numNodes * sizeof(int));
  }
 
protected:
  template <template <class> class Vector> friend class GmpCellMeshData; // Needs access to _ghostList...
 
  GmPODVector<int, uint32_t, GmPODVectorFastGrow<uint32_t>> _ghostList;
};
 
 
template <int H>
class GmpHElementBase : public GmHElement
{
public:
  // See comments on GmHElement::POrder()
  virtual int hPOrder() const { return GmpCellMeshDataBase::hierarchicalPOrder(H); }
 
  // See comments on GmHElement::QOrder()
  virtual int hQOrder() const { return GmpCellMeshDataBase::hierarchicalQOrder(H); }
};
 
// ---------------------------------------------------------------------------------------------------------------------------
// VERY IMPORTANT considerations:
//
// Sanity checks to make sure that the size and memory layout of a cell object class independs on the base cell class 
// (GmCell or GmElement), cell proxy, mesh data class, celltype (including hierarchical types) and number of nodes 
// template parameters.  This should hold true as long as we don't have added attributes to the base class.
//
// This is IMPORTANT to enable casting a GmCell* into a GmpCell<GmCell, GmLuaCell, GmpCellMeshData<GmSingleVector>, GM_BAR2, 2>
// or into a GmpGhostCell<GmCell, GmLuaCell, GmpCellMeshData<GmSingleVector>, GM_BAR2, 2> to have access to the 
// offset field and to the ghost nodes list. We need that on few localized places in GmpCellMeshData and in uibhmGeometry.
// Look for a cast to GmpCellMeshData::CellPrototype or GhostCellPrototype.
// Of course an object casted in this way CAN NOT safely access any virtual method. It can only access non virtual functions
// such as the offset handling methods or attributes directly.
//
// Notice that adding an attribute to the derived class is OK, so we can add an attribute to XfemGemaElement, 
// but not to XfemElement!
//
// Another assumed constraint (by GmpCellMeshData<Vector>::reorderCells()) is that already constructed cells can 
// be MOVED inside the cell vector by using memcpy(). This is ok for our cell classes, including cells with ghost 
// nodes. Derived classes MUST hold to this constraint.
// 
// ---------------------------------------------------------------------------------------------------------------------------
 
// Complete X with a set of common template parameters:
//   STD_TEMPLATE_PARS(GmpCell) expands to GmpCell<GmCell, GmLuaCell, GmpCellMeshData<GmSingleVector>, GM_BAR2, 2>
#define STD_TEMPLATE_PARS(X) X<GmCell, GmLuaCell, GmpCellMeshData<GmSingleVector>, GM_BAR2, 2>
 
static_assert(sizeof(GmCell) == sizeof(GmElement),  "Unexpected cell base class size");
static_assert(sizeof(GmCell) == sizeof(GmHElement), "Unexpected cell base class size");
static_assert(sizeof(STD_TEMPLATE_PARS(GmpCell))      == sizeof(GmpCell     <GmElement, GmLuaElement, GmpCellMeshData<GmSingleVector>, GM_BAR2, 2>), "Unexpected cell size");
static_assert(sizeof(STD_TEMPLATE_PARS(GmpCell))      == sizeof(GmpCell     <GmCell,    GmLuaCell,    GmpCellMeshData<GmSingleVector>, GM_HEX8, 8>), "Unexpected cell size");
static_assert(sizeof(STD_TEMPLATE_PARS(GmpGhostCell)) == sizeof(GmpGhostCell<GmElement, GmLuaElement, GmpCellMeshData<GmSingleVector>, GM_BAR2, 2>), "Unexpected cell size");
static_assert(sizeof(STD_TEMPLATE_PARS(GmpGhostCell)) == sizeof(GmpGhostCell<GmCell,    GmLuaCell,    GmpCellMeshData<GmSingleVector>, GM_HEX8, 8>), "Unexpected cell size");
static_assert(sizeof(GmpGhostCell<GmElement, GmLuaElement, GmpCellMeshData<GmSingleVector>, GM_QUAD4, 4>) == sizeof(GmpGhostCell<GmpHElementBase<0>, GmLuaHElement, GmpCellMeshData<GmSingleVector>, GM_HQUADP, 4>), "Unexpected cell size");
 
static_assert(sizeof(STD_TEMPLATE_PARS(GmpCell))      == 16, "Unexpected cell size value");
static_assert(sizeof(STD_TEMPLATE_PARS(GmpGhostCell)) == 32, "Unexpected cell size value");
 
template <template<class, class, class, GmCellType, int> class T, class Base, class Proxy, class CellMeshData>
GmCell* GmpCellFactory(void* addr, int meshId, GmCellType type, int hindex, int id, int offset)
{
  Q_UNUSED(hindex);
  assert(!GmCellGeometry(type).isHierarchical());
  assert(hindex == -1);
 
  // Make sure that T inherits from GmpCell or from GmpGhostCell
  static_assert(std::is_base_of<STD_TEMPLATE_PARS(GmpGhostCell), STD_TEMPLATE_PARS(T)>::value ||
                std::is_base_of<STD_TEMPLATE_PARS(GmpCell),      STD_TEMPLATE_PARS(T)>::value,
                "Expecting T to inherit from GmpCell or from GmpGhostCell");
 
  // Make sure that Base has a size equal to GmCell or GmElement
  static_assert(sizeof(Base) == sizeof(GmCell), "Unexpected cell base class size");
 
#ifdef CREATE_CELL
#error Create Cell macro already defined
#endif
 
  // Use placement new to call the cell constructor on the given address
#define CREATE_CELL(type, nn) new (addr) T<Base, Proxy, CellMeshData, type, nn>(meshId, id, offset)
 
  switch(type)
  {
    // The first macro parameter after the cell type is the number of nodes of that type.
    case GM_BAR2:     return CREATE_CELL(GM_BAR2,      2);
    case GM_BAR3:     return CREATE_CELL(GM_BAR3,      3);
    case GM_BAR3D2:   return CREATE_CELL(GM_BAR3D2,    2);
    case GM_BAR3D3:   return CREATE_CELL(GM_BAR3D3,    3);
    case GM_QUAD4:    return CREATE_CELL(GM_QUAD4,     4);
    case GM_QUAD8:    return CREATE_CELL(GM_QUAD8,     8);
    case GM_QUAD9:    return CREATE_CELL(GM_QUAD9,     9);
    case GM_QUAD3D4:  return CREATE_CELL(GM_QUAD3D4,   4);
    case GM_QUAD3D8:  return CREATE_CELL(GM_QUAD3D8,   8);
    case GM_TRI3:     return CREATE_CELL(GM_TRI3,      3);
    case GM_TRI6:     return CREATE_CELL(GM_TRI6,      6);
    case GM_TRI3D3:   return CREATE_CELL(GM_TRI3D3,    3);
    case GM_TRI3D6:   return CREATE_CELL(GM_TRI3D6,    6);
    case GM_INT2DL4:  return CREATE_CELL(GM_INT2DL4,   4);
    case GM_INT2DL6:  return CREATE_CELL(GM_INT2DL6,   6);
    case GM_INT2DQ6:  return CREATE_CELL(GM_INT2DQ6,   6);
    //case GM_INT2DQ8:  return CREATE_CELL(GM_INT2DQ8,   8);
    case GM_HEX8:     return CREATE_CELL(GM_HEX8,      8);
    case GM_HEX20:    return CREATE_CELL(GM_HEX20,    20);
    case GM_HEX27:    return CREATE_CELL(GM_HEX27,    27);
    case GM_TET4:     return CREATE_CELL(GM_TET4,      4);
    case GM_TET10:    return CREATE_CELL(GM_TET10,    10);
    case GM_INT3DL8:  return CREATE_CELL(GM_INT3DL8,   8);
    case GM_INT3DL12: return CREATE_CELL(GM_INT3DL12, 12);
    case GM_INT3DQ16: return CREATE_CELL(GM_INT3DQ16, 16);
    //case GM_INT3DQ20: return CREATE_CELL(GM_INT3DQ20, 20);
    case GM_INT3DL6:  return CREATE_CELL(GM_INT3DL6,   6);
    case GM_INT3DL9:  return CREATE_CELL(GM_INT3DL9,   9);
    case GM_INT3DQ12: return CREATE_CELL(GM_INT3DQ12, 12);
    //case GM_INT3DQ15: return CREATE_CELL(GM_INT3DQ15, 15);
    case GM_WEDGE6:   return CREATE_CELL(GM_WEDGE6,    6);
    case GM_WEDGE15:  return CREATE_CELL(GM_WEDGE15,  15);
    case GM_PYRA5:    return CREATE_CELL(GM_PYRA5,     5);
    case GM_PYRA13:   return CREATE_CELL(GM_PYRA13,   13);
    default:
      assert(0);
  }
 
#undef CREATE_CELL
  return NULL;
}
 
template <template<class, class, class, GmCellType, int> class T, class Base, class Proxy, class CellMeshData>
int GmpCellSize()
{
  // Assumes that the size of a cell independs on its type or number of nodes
  return sizeof(T<Base, Proxy, CellMeshData, GM_BAR2, 2>);
}
 
template <template<class, class, class, GmCellType, int> class T, class CellMeshData>
GmCell* GmpHElementFactory(void* addr, int meshId, GmCellType type, int hindex, int id, int offset)
{
  assert(GmCellGeometry(type).isHierarchical());
  assert(hindex >= 0 && hindex < GMP_GEMAMESH_MAX_HTYPES);
 
#if GMP_GEMAMESH_MAX_HTYPES != 3
#error Unexpected value for GMP_GEMAMESH_MAX_HTYPES
#endif
 
#ifdef CREATE_CELL
#error Create Cell macro already defined
#endif
 
  // Use placement new to call the cell constructor on the given address
#define CREATE_CELL(i, type, nn) new (addr) T<GmpHElementBase<i>, GmLuaHElement, CellMeshData, type, nn>(meshId, id, offset)
 
  switch(type)
  {
    case GM_HQUADP: // Can someone find a better way for doing this?  Please, pretty please...
                  if     (hindex == 0) return CREATE_CELL(0, GM_HQUADP, 4);
                  else if(hindex == 1) return CREATE_CELL(1, GM_HQUADP, 4);
                  else if(hindex == 2) return CREATE_CELL(2, GM_HQUADP, 4);
                  else
                        assert(0);
          case GM_DGQUAD:
      if     (hindex == 0) return CREATE_CELL(0, GM_DGQUAD, 4);
      else if(hindex == 1) return CREATE_CELL(1, GM_DGQUAD, 4);
      else if(hindex == 2) return CREATE_CELL(2, GM_DGQUAD, 4);
      else
        assert(0);
    case GM_HHEXP:
                  if     (hindex == 0) return CREATE_CELL(0, GM_HHEXP, 8);
      else if(hindex == 1) return CREATE_CELL(1, GM_HHEXP, 8);
      else if(hindex == 2) return CREATE_CELL(2, GM_HHEXP, 8);
                  else
                        assert(0);
          case GM_DGHEX:
      if     (hindex == 0) return CREATE_CELL(0, GM_DGHEX, 8);
      else if(hindex == 1) return CREATE_CELL(1, GM_DGHEX, 8);
      else if(hindex == 2) return CREATE_CELL(2, GM_DGHEX, 8);
      else
        assert(0);
    default:
      assert(0);
  }
#undef CREATE_CELL
 
  return NULL;
}
 
template <template<class, class, class, GmCellType, int> class T, class CellMeshData>
int GmpHElementSize()
{
  // Assumes that the size of a cell independs on its hierarchical index, type or number of nodes
  return sizeof(T<GmpHElementBase<0>, GmLuaHElement, CellMeshData, GM_HQUADP, 4>);
}
 
 
#endif