gmpCellMeshData.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_MESH_DATA_H_
#define _GEMA_PLUGIN_CELL_MESH_DATA_H_
 
#include "gmpGemaMeshConfig.h"
#include "gmpCellAllocator.h"
#include "uibhmTopology.h"
 
#include <gmShapeOrthogonalPol.h>
 
 
class GmPropertySet;
class GmCellBoundary;
class GmCellMesh;
class GmElementMesh;
class GmCell;
class GmLuaCell;
class GmCellMeshTopology;
class GmValueInfo;
class GmSimulationData;
class GmLogCategory;
 
template <template <class> class> class GmpCellDataDump;
template <class, class, class, GmCellType, int> class GmpCell;
template <class, class, class, GmCellType, int> class GmpGhostCell;
 
class GMP_GEMAMESH_API_EXPORT GmpCellMeshDataBase
{
public:
  GmpCellMeshDataBase(GmCellMesh* mesh)
  {
    _meshId            = newMeshId(mesh, this);
    _hierarchicalIndex = -1;
  }
 
  ~GmpCellMeshDataBase() { _meshTable[_meshId] = NULL; _meshDataTable[_meshId] = NULL;  }
 
  bool hierarchicalElements() const { return _hierarchicalIndex >= 0; }
 
  bool setHierarchicalIndex(int p, int q) 
  { 
    assert(p > 0 && p <= GM_MAX_ORTHOGONAL_POL_ORDER && q > 0 && q <= GM_MAX_ORTHOGONAL_POL_ORDER);
    _hierarchicalIndex = hierarchicalOrderIndex(p, q); 
    return (_hierarchicalIndex >= 0); 
  }
 
  static int hierarchicalOrderIndex(int P, int Q);
 
  static inline int hierarchicalPOrder(int index) { assert(index >= -1 && index < _hTableNumUsedSlots); return index == -1 ? 0 : _hTable[index].first; }
 
  static inline int hierarchicalQOrder(int index) { assert(index >= -1 && index < _hTableNumUsedSlots); return index == -1 ? 0 : _hTable[index].second; }
 
  static int newMeshId(GmCellMesh* mesh, GmpCellMeshDataBase* data);
 
  static inline GmCellMesh* mesh(int meshId) { assert(meshId >= 0 && meshId < GMP_GEMAMESH_MAX_NUM_MESHES); return _meshTable[meshId]; }
 
  static inline GmpCellMeshDataBase* meshData(int meshId) { assert(meshId >= 0 && meshId < GMP_GEMAMESH_MAX_NUM_MESHES); return _meshDataTable[meshId]; }
 
  int _meshId;  
 
  int _hierarchicalIndex;
 
  static QPair<int, int>      _hTable[GMP_GEMAMESH_MAX_HTYPES];            
  static int                  _hTableNumUsedSlots;                         
  static GmCellMesh*          _meshTable[GMP_GEMAMESH_MAX_NUM_MESHES];     
  static GmpCellMeshDataBase* _meshDataTable[GMP_GEMAMESH_MAX_NUM_MESHES]; 
};
 
 
 
template <template <class> class Vector>
class GMP_GEMAMESH_API_EXPORT GmpCellMeshData : public GmpCellMeshDataBase
{
public:
 
  // CellPrototype and GhostCellPrototype can be used to cast a GmCell* into the "real" 
  // implementation class. This derives from the fact that we know that the cell is a 
  // subclass of GmpCell or GmpGhostCell and that the memory layout is independent of
  // the template parameters. Of course the casted object can not be used to call any 
  // virtual functions. It can only be used to access attributes or call non virtual 
  // functions like offset(). See comments on the "IMPORTANT considerations:" comment 
  // on gmpCell.h, just above the GmpCellFactory() function definition.
  // Not needing this casts would be nice, but that is difficult to achieve without 
  // adding virtual functions to GmCell that would be tied to implementation details 
  // of how our data is structured, like the offset field. That information does not 
  // belong in GmCell since it might not even exist in another mesh implementation!
  using CellPrototype      = GmpCell     <GmCell, GmLuaCell, GmpCellMeshData<Vector>, GM_BAR2, 2>;
  using GhostCellPrototype = GmpGhostCell<GmCell, GmLuaCell, GmpCellMeshData<Vector>, GM_BAR2, 2>;
 
  GmpCellMeshData(GmCellMesh* mesh);
 
  ~GmpCellMeshData();
 
  void clear(GmCellMesh* mesh);
  void releaseMemory(bool clearBoundaryData = true);
 
  GmCell* cell(int cellId) const { return (GmCell*)_cells.iptr(cellId * _cellSize); }
 
  int* cellPropertiesPtr(int cellId) { assert(_propertySets.size() > 0); return _cellPropertyIndices.iptr(cellId * _propertySets.size()); }
 
  int* cellNodesPtr(int offset) { return _cellNodeIndices.iptr(offset); }
 
  int addCells(GmCellMesh* mesh, int* addedCellsByType, bool allocCells, 
               bool updateValueSets, GmPCR* pcr, const GmLogCategory& logger)
  {
    assert(addedCellsByType);
    return addCellsImpl(mesh, addedCellsByType, 0, 0, allocCells, updateValueSets, pcr, logger);
  }
 
  int addCells(GmCellMesh* mesh, int numCells, int numCellNodes, GmPCR* pcr, const GmLogCategory& logger)
  {
    return addCellsImpl(mesh, NULL, numCells, numCellNodes, false, false, pcr, logger);
  }
 
  bool reorderCells(GmPCR* pcr, const QMap<int, int>& partOrigToLocOrder, const QVector<int>& partLocToOrigOrder);
  void adjustCellIncidences(GmPCR* pcr, bool ghostSupport);
 
  bool checkAndCollectStatistics(GmCellMesh* mesh, int* addedCellsByType, int* nAddedCells,
                                 int* nAddedNodes, int* maxNumCellNodes, bool* hasSolidElements, 
                                 const GmLogCategory& logger);
 
  void destroyCellsInRange(int first);
 
  void updateCellNodeOffset(GmCell* c, int offset);
 
  int  addCellGroup(QString groupName);
  bool addCellsToGroup(int groupId, const QVector<int>& cellIds);
  bool addCellsToGroup(int groupId, const QVector<QPair<int, int>>& cellIds);
 
  bool cellIsTopologyIndexed(int cellId) const { return _topology && _topology->cellIsIndexed(cellId); }
 
  bool buildTopologyStructure(const GmCellMesh* mesh, GmpNodeMeshData<Vector>* nodeData, 
                              GmSimulationData* simData, const GmLogCategory& logger);
  void clearTopology();
  bool topologyMeshChanged();
 
  size_t cellMemory() const;
  size_t cellGroupsMemory() const;
  size_t cellBoundariesMemory() const;
 
private:
  int addCellsImpl(GmCellMesh* mesh, int* addedCellsByType, int numCells, int numCellNodes,
                   bool allocCells, bool updateValueSets, GmPCR* pcr, const GmLogCategory& logger);
 
  bool resizeGaussValueSets (GmElementMesh* emesh, int* addedCellsByType, int offset = 0);
  void restoreGaussValueSets(GmElementMesh* emesh, int oldNumCells);
 
public:
  int _numCells;       
  int _numActiveCells; 
 
  GmpCellAllocator _cellAllocator; 
 
  int _cellSize;
 
  Vector<char> _cells;
 
  int _numConstructed;
 
  Vector<int> _cellNodeIndices;
 
  QList<GmPropertySet*> _propertySets;
 
  Vector<int> _cellPropertyIndices;
 
  int _cellsByType[GM_NUM_CELL_TYPES];
 
  int _activeCellsByType[GM_NUM_CELL_TYPES];
  
  bool _singleCellType;
 
  bool _hasSolidElements;
 
  int _maxNumNodes;
 
  int _maxNumGhostNodes;
 
  int _maxTotalNumNodes;
 
  QStringList _cellGroupIds;
 
  QList<int> _numCellsInGroup;
 
  QList<int*> _cellGroupCells;
 
  QMap<QString, GmCellBoundary*> _boundaryGroups;
 
  UibhmTopologyBase*              _topology;         
  GmCellMeshTopology*             _topoQuery;        
  bool                            _topoBuildError;   
  bool                            _topoBuildEdgeMap; 
  UibhmTopologyBase::CheckOptions _topoCheckOptions; 
 
  GmpCellDataDump<Vector>* _dumper; 
};
 
#endif