uibhmGeometry.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 _UIBHM_GEOMETRY_H_
#define _UIBHM_GEOMETRY_H_

#include "uibhmTemplate.h"

#include <gmpGemaMeshData.h>
#include <gmpGemaCellMeshData.h>
#include <gmpGemaCellMesh.h>


template <bool Hybrid, template <class> class Vector>
class GMP_GEMAMESH_API_EXPORT UibhmGemaCellMeshDataGeometry 
{
public:

  template <typename U> using VectorType = Vector<U>;

  // Casting a cell from GmCell* to RealCell* works based on two (ugly but true) assumptions:
  // 1) That our cells are implemented by GmpGemaCell or by GmpGemaGhostCell. This is already implicit by
  //    working with a GmpGemaCellMeshData object
  // 2) That the size and memory layout of a cell object class independs on the base cell class (GmCell or 
  //    GmElement), celltype and number of nodes template parameters as further detailed and tested in 
  //    GmpGemaCellMeshData::cellMemory().
  //    We might make this a little less ugly by removing the cell type and number of nodes temaplate 
  //    parameters from the base cell class and adding them to a last level in the inheritance chain for a 
  //    cell!
  // IMPORTANT: obviously, any type or number of nodes dependent method can NOT be called on a cell casted 
  // to a RealCell.
  using RealCell = GmpGemaCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>;

  using ElemMeshBase = GmpMeshBaseDataInterface<GmElementMesh, GmpGemaMeshData<Vector>, GmpGemaCellMeshData<Vector>>;
  using CellMeshBase = GmpMeshBaseDataInterface<GmCellMesh,    GmpGemaMeshData<Vector>, GmpGemaCellMeshData<Vector>>;

  enum { IsHybrid = Hybrid };

  // The basic constructor as expected by UibhmTopology
  UibhmGemaCellMeshDataGeometry(GmCellMesh* mesh) 
    : UibhmGemaCellMeshDataGeometry(dynamic_cast<GmElementMesh*>(mesh) ? ((ElemMeshBase*)mesh)->theNodeData() : ((CellMeshBase*)mesh)->theNodeData(),
                                    dynamic_cast<GmElementMesh*>(mesh) ? ((ElemMeshBase*)mesh)->theCellData() : ((CellMeshBase*)mesh)->theCellData())
  {}

  UibhmGemaCellMeshDataGeometry(GmpGemaMeshData<Vector>* nodeData, GmpGemaCellMeshData<Vector>* cellData);

  bool updateCellTypes(int numAddedCells);

  int numNodes() const { return _nodeData->_numNodes; }

  int numCells() const { return _cellData->_numCells; }

  GmCell* cell(int cellId) { assert(cellId >= 0 && cellId < _cellData->_numCells);  return _cellData->_cells[cellId]; }

  bool solid() const { return _solid; }

  bool hybrid() const { return Hybrid; }

  bool strange() const { return _strange; }

  const UibhmGemaTemplate* const* typeTemplates() const { return _typeTemplateList; }

  void faceVertices(int cellId, int face, QVarLengthArray<int, 10>& nodeList) const;
  void faceNodes   (int cellId, int face, bool mid, QVarLengthArray<int, 10>& nodeList) const;

  void faceEdgeVertices(int cellId, int face, int edge, int* first, int* last) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->faceEdgeVertices(face, edge, first, last, cn(cellId));
  }

  void faceEdgeNodes(int cellId, int face, int edge, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->faceEdgeNodes(face, edge, nodeList, cn(cellId));
  }

  int findNodeIndex(int cellId, int v) const;
  int findFaceEdge (int cellId, int face, int  v1, int  v2) const;
  int findFaceEdge (int cellId, int face, int* v1, int* v2) const;

  void edgeVertices(int cellId, int edge, int* first, int* last) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->edgeVertices(edge, first, last, cn(cellId));
  }
  
  void edgeNodes(int cellId, int edge, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->edgeNodes(edge, nodeList, cn(cellId));
  }

  int numSides(int cellId) const { const UibhmGemaTemplate* t = tt(cellId); return t ? t->numSides() : 0; }

  void sideVertices(int cellId, int side, QVarLengthArray<int, 10>& nodeList) const;

  int midCellNode(int cellId) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    if(t && t->midNode() != -1)
      return cn(cellId)[t->midNode()];
    return -1;
  }

  bool quadraticMidEdgeNodeAdjacentVertices(int cellId, int localNode, int* v1, int* v2) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    return t->quadraticMidEdgeNodeAdjacentVertices(localNode, v1, v2, cn(cellId));
  }

  void vertexAdjacentVertices(int cellId, int localNode, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->vertexAdjacentVertices(localNode, nodeList, cn(cellId));
  }

  void vertexAdjacentNodes(int cellId, int localNode, QVarLengthArray<int, 4>& nodeList) const
  {
    const UibhmGemaTemplate* t = tt(cellId);
    assert(t);
    t->vertexAdjacentNodes(localNode, nodeList, cn(cellId));
  }

  static size_t encodeEdge(int v1, int v2)
  {
    if(v1 > v2) qSwap(v1, v2);
    return (((size_t)v1) << 32) | ((size_t)v2);
  }

  static void decodeEdge(size_t edge, int* v1, int* v2)
  {
    *v1 = (int)(edge >> 32);
    *v2 = (int)(edge & 0xFFFFFFFF);
  }

  const UibhmGemaTemplate* tt(int cellId) const 
  { 
    assert(cellId >= 0 && cellId < numCells());
    if constexpr(Hybrid)
      return _typeTemplateList[_cellData->_cells[cellId]->type()];
    else
    {
      Q_UNUSED(cellId);
      return _typeTemplate;
    }
  }

  int co(int cellId) const { return ((RealCell*)_cellData->_cells[cellId])->offset(); }

  const int* cn(int cellId) const { return _cellData->cellNodesPtr(co(cellId)); }

  GmpGemaMeshData<Vector>*     _nodeData;     
  GmpGemaCellMeshData<Vector>* _cellData;     
  bool                         _solid;        
  bool                         _strange;      
  const UibhmGemaTemplate*     _typeTemplate; 

  const UibhmGemaTemplate* _typeTemplateList[GM_NUM_CELL_TYPES];
};


#endif