gmpCellBase.h

Go to the documentation of this file.

/************************************************************************
**
** 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 <gmPropertySet.h>
#include <gmCellMesh.h>
#include <gmLuaCell.h>

#include <luaProxy.h>

#include <QVarLengthArray>

#include "gmpCellMeshData.h"


#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, int VN> class GmpCellBase : public Base
{
public:
  GmpCellBase()
  {
    assert(N  == geometry().numNodes());
    assert(VN == geometry().numVertices());
  }

  // See comments on the base class
  virtual int numNodes() const { return N; }

  // 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 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;
  }

protected:
  CellMeshData* meshData() const { return (CellMeshData*)GmpCellMeshDataBase::meshData(meshId()); }
};


/* The memory layout for GmpCellBaseWithId is the virtual table pointer followed by the cellId integer, 
   usually followed by a 4 bytes packing to align the structure to 8 bytes (due to the vtable poniter).

   In Visual studio, when this class is later inherited by GmpGemaCell, which adds another int to the 
   structure, the packing is NOT reused to hold that additional int, and so the cell size grows from 
   16 to 24 bytes. Compiling with GCC, that packing is discarded and the offset int from GmpGemaCell is
   stored just after the id, with a size of 16 bytes.

   By adding a pragma pack(4) directive in Windows, we force the struct alignment to 4 bytes, meaning 
   that in this context, the size of a GmCellBaseWithId structure will be 12 bytes, with no packing and 
   so when inherited by GmpGemaCell it will result in the desired 16 bytes structure.

   We can get away with that since a GmpCellBaseWithId struct will NEVER be instanced directly and always 
   be derived. The derived class then MUST take care of the alignment as is done by GmpGemaCell.
   This is ugly and prone to introducing problems if changing the class layouts but is a really worthy
   space optimization.

   IMPORTANT: If the layout for GmpCellBaseWithId or for GmpGemaCell is changed in any way, this 
   optimization should be reviewed.

*/
#ifdef Q_OS_WIN
#pragma pack(push, 4)
#endif

template <class Base, class Proxy, class CellMeshData, GmCellType T, int N, int VN> class GmpCellBaseWithId
  : public GmpCellBase<Base, Proxy, CellMeshData, T, N, VN>
{
public:
  // 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 int meshId() const { return 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. For the bold who really know what they are doing
  virtual void replaceCellId(int id, bool keepActiveFlag)
  {
    id = GmpCellUpdateMeshIndex(id, _cellId);
    if(keepActiveFlag)
      _cellId = GmpCellSetActiveFlag(id, active());
    else
      _cellId = id;
  }

protected:
  GmpCellBaseWithId(int cellId, int meshId)
    : GmpCellBase<Base, Proxy, CellMeshData, T, N, VN>()
  {
    _cellId = GmpCellEncodeId(cellId, meshId, true);  // cell is initially active
  }

  int  _cellId; 
};

#ifdef Q_OS_WIN
#pragma pack(pop)
#endif



template <template<class, class, class, GmCellType, int, int> class CellBase, 
          class Base, class Proxy, class CellMeshData, GmCellType T, int N, int VN>
class GmpGhostCellBase : public CellBase<Base, Proxy, CellMeshData, T, N, VN>
{
public:
  GmpGhostCellBase(GmCellMesh* mesh, int meshId, int id, int offset)
    : CellBase<Base, Proxy, CellMeshData, T, N, VN>(mesh, meshId, id, offset)
  {
    Q_UNUSED(mesh); // Needed by the surface mesh plugin  
  }

  // 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 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 ? CellBase<Base, Proxy, CellMeshData, T, N, VN>::nodeIndex(localIndex) : _ghostList[localIndex-N];
  }

  // See comments on the base class.
  virtual void nodes(int* nodeList, bool ghost) const
  {
    CellBase<Base, Proxy, CellMeshData, T, N, VN>::nodes(nodeList, false); // Copy geometry nodes
    if(ghost)
      memcpy(nodeList+N, _ghostList.data(), _ghostList.size()*sizeof(int));
  }

  // See comments on the base class
  virtual void replaceGhostNodes(int* ghostNodes, int numNodes)
  {
    _ghostList.resize(numNodes, GmPODVectorTightGrow);
    memcpy(_ghostList.data(), ghostNodes, numNodes * sizeof(int));
  }

protected:
  template <template <class> class Vector> friend struct GmpGemaCellMeshData;

  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); }
};


template <template<class, class, class, GmCellType, int, int> class T, class Base, class Proxy, class CellMeshData>
GmCell* GmpCellFactory(GmCellMesh* mesh, int meshId, GmCellType type, int hindex, int id, int offset)
{
  Q_UNUSED(hindex);
  assert(!GmCellGeometry(type).isHierarchical());
  assert(hindex == -1);

#ifdef CREATE_CELL
#error Create Cell macro already defined
#endif

#define CREATE_CELL(type, nn, nv) new T<Base, Proxy, CellMeshData, type, nn, nv>(mesh, meshId, id, offset)

  switch(type)
  {
    // The first macro parameter after the cell type is the number of nodes of that type.
    // The second, is the number of element vertices (or "topological" nodes), ignoring any 
    // mid edge, face or volume nodes that do not contribute for the cell topology. For a Quad8 
    // element, for example, the number of nodes is 8 but the number of vertices is 4. This 
    // parameter is needed by the surface mesh implementation.
    case GM_BAR2:     return CREATE_CELL(GM_BAR2,      2, 2);
    case GM_BAR3:     return CREATE_CELL(GM_BAR3,      3, 2);
    case GM_BAR3D2:   return CREATE_CELL(GM_BAR3D2,    2, 2);
    case GM_BAR3D3:   return CREATE_CELL(GM_BAR3D3,    3, 2);
    case GM_QUAD4:    return CREATE_CELL(GM_QUAD4,     4, 4);
    case GM_QUAD8:    return CREATE_CELL(GM_QUAD8,     8, 4);
    case GM_QUAD9:    return CREATE_CELL(GM_QUAD9,     9, 4);
    case GM_QUAD3D4:  return CREATE_CELL(GM_QUAD3D4,   4, 4);
    case GM_QUAD3D8:  return CREATE_CELL(GM_QUAD3D8,   8, 4);
    case GM_TRI3:     return CREATE_CELL(GM_TRI3,      3, 3);
    case GM_TRI6:     return CREATE_CELL(GM_TRI6,      6, 3);
    case GM_TRI3D3:   return CREATE_CELL(GM_TRI3D3,    3, 3);
    case GM_TRI3D6:   return CREATE_CELL(GM_TRI3D6,    6, 3);
    case GM_INT2DL4:  return CREATE_CELL(GM_INT2DL4,   4, 4);
    case GM_INT2DL6:  return CREATE_CELL(GM_INT2DL6,   6, 4);
    case GM_INT2DQ6:  return CREATE_CELL(GM_INT2DQ6,   6, 4);
    //case GM_INT2DQ8:  return CREATE_CELL(GM_INT2DQ8,   8, 4);
    case GM_HEX8:     return CREATE_CELL(GM_HEX8,      8, 8);
    case GM_HEX20:    return CREATE_CELL(GM_HEX20,    20, 8);
    case GM_HEX27:    return CREATE_CELL(GM_HEX27,    27, 8);
    case GM_TET4:     return CREATE_CELL(GM_TET4,      4, 4);
    case GM_TET10:    return CREATE_CELL(GM_TET10,    10, 4);
    case GM_INT3DL8:  return CREATE_CELL(GM_INT3DL8,   8, 8);
    case GM_INT3DL12: return CREATE_CELL(GM_INT3DL12, 12, 8);
    case GM_INT3DQ16: return CREATE_CELL(GM_INT3DQ16, 16, 8);
    //case GM_INT3DQ20: return CREATE_CELL(GM_INT3DQ20, 20, 8);
    case GM_INT3DL6:  return CREATE_CELL(GM_INT3DL6,   6, 6);
    case GM_INT3DL9:  return CREATE_CELL(GM_INT3DL9,   9, 6);
    case GM_INT3DQ12: return CREATE_CELL(GM_INT3DQ12, 12, 6);
    //case GM_INT3DQ15: return CREATE_CELL(GM_INT3DQ15, 15, 6);
    case GM_WEDGE6:   return CREATE_CELL(GM_WEDGE6,    6, 6);
    case GM_WEDGE15:  return CREATE_CELL(GM_WEDGE15,  15, 6);
    case GM_PYRA5:    return CREATE_CELL(GM_PYRA5,     5, 5);
    case GM_PYRA13:   return CREATE_CELL(GM_PYRA13,   13, 5);

    default:
      assert(0);
  }
#undef CREATE_CELL

  return NULL;
}

template <template<class, class, class, GmCellType, int, int> class T, class CellMeshData>
GmCell* GmpHElementFactory(GmCellMesh* mesh, int meshId, GmCellType type, int hindex, int id, int offset)
{
  assert(GmCellGeometry(type).isHierarchical());
  assert(hindex >= 0 && hindex < GmpCellMeshDataMaxHTypes);

#if GmpCellMeshDataMaxHTypes != 3
#error Unexpected value for GmpCellMeshDataMaxHTypes
#endif

#ifdef CREATE_CELL
#error Create Cell macro already defined
#endif

#define CREATE_CELL(i, type, nn, nv) new T<GmpHElementBase<i>, GmLuaHElement, CellMeshData, type, nn, nv>(mesh, 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, 4);
                  else if(hindex == 1) return CREATE_CELL(1, GM_HQUADP, 4, 4);
                  else if(hindex == 2) return CREATE_CELL(2, GM_HQUADP, 4, 4);
                  else
                        assert(0);
          case GM_DGQUAD:
      if     (hindex == 0) return CREATE_CELL(0, GM_DGQUAD, 4, 4);
      else if(hindex == 1) return CREATE_CELL(1, GM_DGQUAD, 4, 4);
      else if(hindex == 2) return CREATE_CELL(2, GM_DGQUAD, 4, 4);
      else
        assert(0);
    case GM_HHEXP:
                  if     (hindex == 0) return CREATE_CELL(0, GM_HHEXP, 8, 8);
      else if(hindex == 1) return CREATE_CELL(1, GM_HHEXP, 8, 8);
      else if(hindex == 2) return CREATE_CELL(2, GM_HHEXP, 8, 8);
                  else
                        assert(0);
          case GM_DGHEX:
      if     (hindex == 0) return CREATE_CELL(0, GM_DGHEX, 8, 8);
      else if(hindex == 1) return CREATE_CELL(1, GM_DGHEX, 8, 8);
      else if(hindex == 2) return CREATE_CELL(2, GM_DGHEX, 8, 8);
      else
        assert(0);
    default:
      assert(0);
  }
#undef CREATE_CELL

  return NULL;
}


#endif