gmpCellMesh.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_MESH_H_
#define _GEMA_PLUGIN_CELL_MESH_H_
 
#include "gmpNodeMesh.h"
#include "gmpCellDataDump.h"
#include "gmpCell.h"
 
#include "uibhmTopology.h"
#include "uibhmQuery.h"
 
#include <gmElementMesh.h>
#include <gmElement.h>
#include <gmLuaCell.h>
 
#include <assert.h>
 
 
template <class Mesh, template <class> class Vector>
class GmpCellMeshBase : public GmpNodeMesh<Mesh, Vector>
{
public:
  GmpCellMeshBase(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : GmpNodeMesh<Mesh, Vector>(simulation, id, description, logger), _cd(this)
  {
    _oldNumCells = -1;
  }
 
  virtual ~GmpCellMeshBase()
  {
    clearCellValueSets();
  }
 
  // Comments on the base class
  virtual bool hasCapability(QString capabilityName) const
  {
    return (capabilityName == "addCells" || capabilityName == "editGroups" || capabilityName == "topology" ||
            GmpNodeMesh<Mesh, Vector>::hasCapability(capabilityName));
  }
 
  // Comments on the base class
  virtual int numCells() const { return _cd._numCells; }
 
  // Comments on the base class
  virtual int numActiveCells() const { return _cd._numActiveCells; }
 
  // Comments on the base class
  virtual const GmCell* cell(int cellIndex) const
  {
    assert(cellIndex >= 0 && cellIndex < numCells());
    return _cd.cell(cellIndex);
  }
 
  // Comments on the base class
  virtual GmCell* cell(int cellIndex)
  {
    assert(cellIndex >= 0 && cellIndex < numCells());
    return _cd.cell(cellIndex);
  }
 
  // Comments on the base class
  virtual const GmCellMeshTopology* topology(bool create = true) const 
  { 
    if(!_cd._topology && create)
    {
      assert(GmThreadManager::inMainThread());
 
      // As commented in GmCellMesh, this function really should not be a const function since it
      // can spawn the topological data structure build process, BUT it is kept as const since removing 
      // it causes multiple problems with interpolator classes and solving that would require multiple 
      // changes in almost all of them and potentially in their uses throughout the core lib and plugins, 
      // AND THAT would be a real PAIN... :(
      GmpCellMeshBase<Mesh, Vector>* self = const_cast<GmpCellMeshBase<Mesh, Vector>*>(this);
      self->_cd.buildTopologyStructure(this, &self->_nd, simulationData(), logger());
    }
    return _cd._topoQuery;
  }
 
  // Comments on the base class
  virtual void clearTopology() { _cd.clearTopology(); }
 
  // Comments on the base class
  virtual bool hasSolidElements() const { return _cd._hasSolidElements; }
 
  // Comments on the base class
  virtual const int* numCellTypes() const { return _cd._cellsByType; }
 
  // Comments on the base class
  virtual const int* numActiveCellTypes() const { return _cd._activeCellsByType; }
 
  // Comments on the base class
  virtual int maxNumCellNodes() const { return _cd._maxNumNodes; }
 
  // Comments on the base class
  virtual int maxNumCellGhostNodes() const { return _cd._maxNumGhostNodes; }
 
  // Comments on the base class
  virtual int maxTotalNumCellNodes() const { return _cd._maxTotalNumNodes; }
 
  // Comments on the base class
  virtual void ghostNodesUpdated(int nghost, int ntotal)
  {
    if(nghost > _cd._maxNumGhostNodes)
      _cd._maxNumGhostNodes = nghost;
    if(ntotal > _cd._maxTotalNumNodes)
      _cd._maxTotalNumNodes = ntotal;
  }
 
  // Comments on the base class
  virtual void activeCellUpdated(GmCellType type, bool active)
  {
    int o = active ? 1 : -1;
    _cd._numActiveCells          += o;
    _cd._activeCellsByType[type] += o;
  }
 
  // Comments on the base class
  virtual QStringList cellGroupIds() const { return _cd._cellGroupIds; }
 
  // Comments on the base class
  virtual int numCellsInGroup(int groupIndex) const
  {
    return _cd._numCellsInGroup.at(groupIndex);
  }
 
  // Comments on the base class
  virtual const GmCell* cellInGroup(int groupIndex, int cellIndex) const
  {
    assert(cellIndex >= 0 && cellIndex < numCellsInGroup(groupIndex));
    return cell(_cd._cellGroupCells.at(groupIndex)[cellIndex]);
  }
 
  // Comments on the base class
  virtual GmCell* cellInGroup(int groupIndex, int cellIndex)
  {
    assert(cellIndex >= 0 && cellIndex < numCellsInGroup(groupIndex));
    return cell(_cd._cellGroupCells.at(groupIndex)[cellIndex]);
  }
 
  // Comments on the base class
  virtual int addCellGroup(QString groupName) { return _cd.addCellGroup(groupName); }
 
  // Comments on the base class
  virtual bool addCellsToGroup(int groupId, const QVector<int>& cellIds) { return _cd.addCellsToGroup(groupId, cellIds); }
 
  // Comments on the base class
  virtual bool addCellsToGroup(int groupId, const QVector<QPair<int, int>>& cellIds) { return _cd.addCellsToGroup(groupId, cellIds); }
 
  // Comments on the base class
  virtual const QMap<QString, GmCellBoundary*>& cellBoundaryGroups() const { return _cd._boundaryGroups; }
 
  // Comments on the base class
  virtual const QList<GmPropertySet*>& propertySets() const { return _cd._propertySets; }
 
  // Comments on the base class
  virtual int propertySetIndex(QString id) const
  {
    for(int i = 0, size = _cd._propertySets.size(); i<size; i++)
    {
      GmPropertySet* ps = _cd._propertySets.at(i);
      assert(ps);
      if(ps->propertyInfo(id))
        return i;
    }
    return -1;
  }
 
  // Comments on the base class
  virtual int addCells(int* numCellTypes)
  {
    if(_oldNumCells == -1)
      _oldNumCells = numCells();
    clearCellStatistics();
 
    // Add cells, also updating associated value sets and the PCR object. Makes
    // consistency checks to verify if the added types are compatible with the 
    // mesh, including _singleCellType checks. If not, logs a message with the 
    // provided logger.
    return _cd.addCells(this, numCellTypes, true, true, _pcr, logger());
  }
 
  // Comments on the base class
  virtual QList<int> addedCells() const
  {
    if(_oldNumCells == -1)
      return QList<int>();
 
    QList<int> addedList;
    for(int i = 0, n = numCells() - _oldNumCells; i<n; i++)
      addedList.append(_oldNumCells + i);
    return addedList;
  }
 
  // Comments on the base class
  virtual void clearAddedCells() { _oldNumCells = -1; }
 
  // Comments on the base class
  virtual void emitMeshChanged() 
  { 
    if(!_cd.topologyMeshChanged())
      gmWarnMsg(logger(), QObject::tr("Error updating the topological structure. The structure was removed."));
    emit meshChanged(); 
  }
 
  // Comments on the base class
  virtual void clear() 
  { 
    GmpNodeMesh<Mesh, Vector>::clear();
    _cd.clear(this); 
    clearAddedCells(); 
    clearCellStatistics(); 
  }
 
  // Comments on the base class
  virtual GmpCellMeshData<Vector>* cellData() { return &_cd; }
 
  // Comments on the base class
  virtual size_t cellMemory() const { return _cd.cellMemory(); }
 
  // Comments on the base class
  virtual size_t cellGroupsMemory() const { return _cd.cellGroupsMemory(); }
 
  // Comments on the base class
  virtual size_t cellBoundariesMemory() const { return _cd.cellBoundariesMemory(); }
 
protected:
 
  virtual GmpCellMeshData<Vector>* initCellData(LuaTable& table, bool* ghostSupport, bool* ok)
  {
    *ok = false;
 
    bool hSupport = false;
 
    if(pluginType() == QString("elem") || pluginType() == QString("elemd"))
    {
      LuaTable horderTable = table.getField("hOrder").value<LuaTable>();
      if(horderTable.isValid())
      {
        int p = horderTable.getField("P").toInt();   // Mesh script checks that if hOrder exists it contains fields P and Q
        int q = horderTable.getField("Q").toInt();
 
        if(p < 1 || p > GM_MAX_ORTHOGONAL_POL_ORDER || q < 1 || q > GM_MAX_ORTHOGONAL_POL_ORDER)
        {
          gmErrorMsg(logger(), QObject::tr("Error loading mesh hierarchical order. Invalid values for P and/or Q.\n"
                                           "Maximum supported polynomial order is %1").arg(GM_MAX_ORTHOGONAL_POL_ORDER));
          return NULL;
        }
 
        if(!_cd.setHierarchicalIndex(p, q))
        {
          gmErrorMsg(logger(), QObject::tr("Error loading mesh hierarchical order.\n"
                                           "A model can only have %1 different sets of hierarchical orders.")
                                           .arg(GMP_GEMAMESH_MAX_HTYPES));
          return NULL;
        }
 
        hSupport      = true;
        *ghostSupport = true; // Using hierarchical elements implies in supporting ghost nodes
      }
    }
 
    // Setup cell size and allocator
    _cd._cellAllocator = cellAllocator(*ghostSupport, hSupport);
    _cd._cellSize      = cellSize(*ghostSupport, hSupport);
    assert(_cd._cellSize > 0);
 
    *ok = true;
    return &_cd;
  }
 
  //---------------------------------------
  // Cell allocation and size control functions. Must be reimplemented by derived classes.
  //---------------------------------------
 
  virtual GmpCellAllocator cellAllocator(bool ghostSupport, bool hSupport) const = 0;
 
  virtual int cellSize(bool ghostSupport, bool hSupport) const = 0;
 
 
  //---------------------------------------
  // State dump control functions
  //---------------------------------------
 
  // See comments on the base GmMesh class
  virtual bool addStateGeometryData(GmStateDump* state, int groupId)
  {
    if(!GmpNodeMesh<Mesh, Vector>::addStateGeometryData(state, groupId))
      return false;
    return _cd._dumper->addStateGeometryData(simulationData(), this, state, groupId);
  }
 
  // See comments on the base GmMesh class
  virtual bool fillDumpControlMapData(QVariantMap* map, const GmLogCategory& logger)
  {
    if(!GmpNodeMesh<Mesh, Vector>::fillDumpControlMapData(map, logger))
      return false;
    map->insert("CellMeshBase_oldNumCells", _oldNumCells);
    return _cd._dumper->fillDumpControlMapData(this, map, logger);
  }
 
  // See comments on the base GmMesh class
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger)
  {
    if(!GmpNodeMesh<Mesh, Vector>::dumpControlMapDataLoaded(map, logger))
      return false;
    _oldNumCells = (*map)["CellMeshBase_oldNumCells"].toInt();
    return _cd._dumper->dumpControlMapDataLoaded(this, map, logger);
  }
 
  GmpCellMeshData<Vector> _cd;          
  int                     _oldNumCells; 
};
 
 
template <template <class> class Vector>
class GMP_GEMAMESH_API_EXPORT GmpCellMesh : public GmpCellMeshBase<GmCellMesh, Vector>
{
public:
  GmpCellMesh(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : GmpCellMeshBase<GmCellMesh, Vector>(simulation, id, description, logger) {}
 
  // Comments on the base class
  virtual const char* pluginType() const { if constexpr(std::is_same<Vector<int>, GmSingleVector<int>>::value) return "cell"; else return "celld"; }
 
  // Comments on the base class
  virtual void pushProxy(lua_State* L, const GmLogCategory& logger) { LuaProxy::pushObject(L, new GmLuaCellMesh(this, logger)); }
 
protected:
  virtual GmpCellAllocator cellAllocator(bool ghostSupport, bool hSupport) const
  {
    Q_UNUSED(hSupport);
    assert(!hSupport); // A cell mesh does not support hierarchical elements!
 
    return ghostSupport ? GmpCellFactory<GmpGhostCell, GmCell, GmLuaCell, GmpCellMeshData<Vector>> :
                          GmpCellFactory<GmpCell,      GmCell, GmLuaCell, GmpCellMeshData<Vector>>;
  }
 
  virtual int cellSize(bool ghostSupport, bool hSupport) const
  {
    Q_UNUSED(hSupport);
    assert(!hSupport); // A cell mesh does not support hierarchical elements!
 
    return ghostSupport ? GmpCellSize<GmpGhostCell, GmCell, GmLuaCell, GmpCellMeshData<Vector>>() :
                          GmpCellSize<GmpCell,      GmCell, GmLuaCell, GmpCellMeshData<Vector>>();
  }
 
  // See comments on the base class and on the enum definition
  virtual int controlMapStateItemType() { return GMP_GEMA_CMESH_DUMP_ITEM; }
};
 
template <template <class> class Vector>
class GMP_GEMAMESH_API_EXPORT GmpElementMesh: public GmpCellMeshBase<GmElementMesh, Vector>
{
public:
  GmpElementMesh(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : GmpCellMeshBase<GmElementMesh, Vector>(simulation, id, description, logger) {}
 
  // Comments on the base class
  virtual const char* pluginType() const { if constexpr(std::is_same<Vector<int>, GmSingleVector<int>>::value) return "elem"; else return "elemd"; }
 
  // Comments on the base class
  virtual void pushProxy(lua_State* L, const GmLogCategory& logger) { LuaProxy::pushObject(L, new GmLuaElementMesh(this, logger)); }
 
  // Comments on the base class
  virtual int hPOrder() const { return GmpCellMeshData<Vector>::hierarchicalPOrder(_cd._hierarchicalIndex); }
 
  // Comments on the base class
  virtual int hQOrder() const { return GmpCellMeshData<Vector>::hierarchicalQOrder(_cd._hierarchicalIndex); }
 
protected:
  virtual GmpCellAllocator cellAllocator(bool ghostSupport, bool hSupport) const
  { 
    if(hSupport)
    {
      assert(ghostSupport); // There is no point in having hierarchical elements without ghost support
      return GmpHElementFactory<GmpGhostCell, GmpCellMeshData<Vector>>;
    }
    else
    {
      return ghostSupport ? GmpCellFactory<GmpGhostCell, GmElement, GmLuaElement, GmpCellMeshData<Vector>> :
                            GmpCellFactory<GmpCell,      GmElement, GmLuaElement, GmpCellMeshData<Vector>>;
    }
  }
 
  virtual int cellSize(bool ghostSupport, bool hSupport) const 
  { 
    if(hSupport)
    {
      assert(ghostSupport); // There is no point in having hierarchical elements without ghost support
      return GmpHElementSize<GmpGhostCell, GmpCellMeshData<Vector>>();
    }
    else
    {
      return ghostSupport ? GmpCellSize<GmpGhostCell, GmElement, GmLuaElement, GmpCellMeshData<Vector>>() :
                            GmpCellSize<GmpCell,      GmElement, GmLuaElement, GmpCellMeshData<Vector>>();
    }
  }
 
  // See comments on the base class and on the enum definition
  virtual int controlMapStateItemType() 
  { 
    return _cd.hierarchicalElements() ? GMP_GEMA_HMESH_DUMP_ITEM : GMP_GEMA_EMESH_DUMP_ITEM; 
  }
};
 
 
#endif