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 "gmpMeshLoaderAllocator.h"

class GmPropertySet;
class GmCellBoundary;
class GmMesh;
class GmCellMesh;
class GmElementMesh;
class GmCell;
class GmValueInfo;
class GmValueSet;
class GmSimulationData;
class GmStateDump;
class GmLogCategory;

class UibhmTopologyBase;
class GmCellMeshTopology;

#include <gmSingleVector.h>
#include <gmDualVector.h>

#include <QScopedPointer>
#include <QVariantMap>

#define GmpCellMeshDataMaxHTypes 3


struct GMP_GEMAMESH_API_EXPORT GmpCellMeshDataBase
{
  GmpCellMeshDataBase(GmCellMesh* mesh)
  {
    _meshId            = newMeshId(mesh, this);
    _hierarchicalIndex = -1;
  }

  virtual ~GmpCellMeshDataBase() { _meshTable[_meshId] = NULL; }  

  bool hierarchicalElements() const { return _hierarchicalIndex >= 0; }

  static const int maxHTypes = GmpCellMeshDataMaxHTypes;

  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;

protected:
  static QPair<int, int>      _hTable[GmpCellMeshDataMaxHTypes];           
  static int                  _hTableNumUsedSlots;                         
  static GmCellMesh*          _meshTable[GMP_GEMAMESH_MAX_NUM_MESHES];     
  static GmpCellMeshDataBase* _meshDataTable[GMP_GEMAMESH_MAX_NUM_MESHES]; 
};



template <template <class> class Vector>
struct GMP_GEMAMESH_API_EXPORT GmpCellMeshData : public GmpCellMeshDataBase
{
  GmpCellMeshData(GmCellMesh* mesh);

  virtual ~GmpCellMeshData() { releaseMemory(); }  // Destructor: will always call our own version of releaseMemory even though virtual ...


  int* cellPropertiesPtr(int cellId) { assert(_propertySets.size() > 0); return _cellPropertyIndices.iptr(cellId * _propertySets.size()); }


  virtual int addCells(GmCellMesh* mesh, int* addedCellsByType, GmpMeshLoaderCellAllocator alloc,
                       QList<GmValueInfo*> infoList = QList<GmValueInfo*>());

  virtual int  addCellGroup(QString groupName);
  virtual bool addCellsToGroup(int groupId, const QVector<int>& cellIds);
  virtual bool addCellsToGroup(int groupId, const QVector<QPair<int, int>>& cellIds);

  virtual Vector<int>* cellNodesVector() { return NULL; }
  virtual void updateCellNodeOffset(GmCell* c, int offset) = 0;

  virtual void clear(GmCellMesh* mesh);

  virtual void releaseMemory(bool clearBoundaryData = true);

  void increaseNumCells(int nCells) { _numCells += nCells; _numActiveCells += nCells; }

  size_t cellGroupsMemory() const;
  size_t cellBoundariesMemory() const;

  void setGhostEnabled(bool state) { _ghostEnabled = state; }

  bool resizeValueSets     (const QList<GmValueSet*>& valueSets, int numAddedCells);
  bool resizeGaussValueSets(GmElementMesh* emesh, int* addedCellsByType);

  bool buildTopologyStructure(GmCellMesh* mesh);

  //---------------------------------------
  // State dump control functions
  //---------------------------------------

  virtual bool addStateGeometryData(GmSimulationData* simData, GmMesh* mesh, GmpMeshLoaderCellAllocator alloc, 
                                    GmStateDump* state, int groupId);

  virtual bool fillDumpControlMapData  (GmMesh* mesh, QVariantMap* map, const GmLogCategory& logger);
  virtual bool dumpControlMapDataLoaded(GmMesh* mesh, QVariantMap* map, const GmLogCategory& logger);

  bool fillAuxCellBuffers(int* cellSavedData, int* baseCellType, GmMesh* mesh, const GmLogCategory& logger);
  bool auxCellBuffersLoaded(GmSimulationData* simData, GmMesh* mesh, GmpMeshLoaderCellAllocator alloc, const GmLogCategory& logger);

  virtual void releaseDumpMemory();

  int             _numCells;       
  int             _numActiveCells; 
  Vector<GmCell*> _cells;          

  int _cellsByType[GM_NUM_CELL_TYPES];

  int _activeCellsByType[GM_NUM_CELL_TYPES];
  
  bool _singleCellType;

  int _maxNumNodes;

  bool _ghostEnabled;

  int _maxNumGhostNodes;

  int _maxTotalNumNodes;

  QStringList _cellGroupIds;

  QList<int> _numCellsInGroup;

  QList<int*> _cellGroupCells;

  QMap<QString, GmCellBoundary*> _boundaryGroups;

  QList<GmPropertySet*> _propertySets;


  Vector<int> _cellPropertyIndices;

  bool                _buildEdgeMap;
  UibhmTopologyBase*  _topology;
  GmCellMeshTopology* _topoQuery;

  //---------------------------------------------------------------------
  // Attributes used during mesh dumping
  //---------------------------------------------------------------------

  static_assert(GM_NUM_CELL_TYPES <= 127, "Number of cell types exceeds 7 bits");
  unsigned char* _cellDumpTypeActiveData;

  int  _cellDumpTypeActiveDataSize;

  int* _cellDumpGhostData;

  int  _cellDumpGhostDataSize;

  QVariantMap* _cellDumpLoadedMap;

  GmStateDump* _state;

  //---------------------------------------------------------------------
};

#endif