gmpCellMeshBase.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_BASE_H_
#define _GEMA_PLUGIN_CELL_MESH_BASE_H_

#include "gmpGemaMesh.h"

#include "uibhmTopology.h"
#include "uibhmQuery.h"

#include <gmPropertySet.h>
#include <assert.h>

template <class BaseMesh, class NodeData, class CellData>
class GmpMeshBaseDataInterface : public BaseMesh
{
public:
  static_assert(std::is_same<BaseMesh, GmCellMesh>::value || std::is_same<BaseMesh, GmElementMesh>::value,
    "Unexpected base class");

  GmpMeshBaseDataInterface(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : BaseMesh(simulation, id, description, logger) {}

  virtual NodeData* theNodeData() { return NULL; }
  virtual CellData* theCellData() { return NULL; }
};


template <class Mesh, class CoordAcc, class CoordGhostAcc, class Data, class CellData, template <class> class Vector>
class GmpCellMeshBase : public GmpMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, Vector>
{
public:
  GmpCellMeshBase(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : GmpMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, Vector>(simulation, id, description, logger),
      _cd(this)
  {
    _oldNumCells = -1;
  }

  virtual ~GmpCellMeshBase()
  {
    clearCellAttributeSets();
  }

  // Comments on the base class
  virtual bool hasCapability(QString capabilityName) const
  {
    return (capabilityName == "addCells" || capabilityName == "editGroups" || capabilityName == "topology" ||
            GmpMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, 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._cells[cellIndex];
  }

  // Comments on the base class
  virtual GmCell* cell(int cellIndex)
  {
    assert(cellIndex >= 0 && cellIndex < numCells());
    return _cd._cells[cellIndex];
  }

  // Comments on the base class
  virtual const GmCellMeshTopology* topology(bool create = true) const 
  { 
    if(!_cd._topology && create)
    {
      // 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 libe and plugins, 
      // AND THAT would be a real PAIN... :(
      using MyType = GmpCellMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, Vector>;
      MyType* self = const_cast<MyType*>(this);
      if(!self->_cd.buildTopologyStructure(self))
        gmErrorMsg(logger(), QObject::tr("Error creating the topological structure for mesh %1.").arg(id()));
    }
    assert((_cd._topology && _cd._topoQuery) || (!_cd._topology && !_cd._topoQuery));
    return _cd._topoQuery;
  }

  // Comments on the base class
  virtual void clearTopology() 
  {
    assert((_cd._topology && _cd._topoQuery) || (!_cd._topology && !_cd._topoQuery));
    if(_cd._topology)
    {
      delete _cd._topology;  _cd._topology  = NULL;
      delete _cd._topoQuery; _cd._topoQuery = NULL;
    }
  }

  // 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(_cd._singleCellType)
    {
      // Lets make sure that the request only includes the actual cell type
      int type = -1;
      for(int i = 0; i<GM_NUM_CELL_TYPES; i++)
      {
        if(numCellTypes[i])
        {
          if(type != -1)
          {
            gmErrorMsg(logger(), QObject::tr("Error trying to add multiple cell types to a single cell type mesh."));
            return -1;
          }
          type = i;
        }
      }
      if(type >= 0 && _cd._cellsByType[type] != _cd._numCells)
      {
        gmErrorMsg(logger(), QObject::tr("Cell type mismatch while adding cells to a single cell type mesh."));
        return -1;
      }
    }

    if(_oldNumCells == -1)
      _oldNumCells = numCells();
    clearCellStatistics();
    return _cd.addCells(this, numCellTypes, cellAllocator(this->_nd.ghostEnabled(), _cd.hierarchicalElements()));
  }

  // 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._topology)
    {
      if(!_cd._topology->addNewCells())
      {
        clearTopology();
        gmWarnMsg(logger(), QObject::tr("Error updating the topological structure. The structure was removed."));
      }
    }
    emit meshChanged(); 
  }

  // Comments on the base class
  virtual void clear() 
  { 
    GmpMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, Vector>::clear();  
    _cd.clear(this); 
    clearAddedCells(); 
    clearCellStatistics(); 
  }

  // Comments on the base class
  virtual CellData* 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:
  //---------------------------------------
  // State dump control functions
  //---------------------------------------

  // See comments on the base GmMesh class
  virtual bool addStateGeometryData(GmStateDump* state, int groupId)
  {
    if(!GmpMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, Vector>::addStateGeometryData(state, groupId))
      return false;
    return _cd.addStateGeometryData(simulationData(), this, 
                                    cellAllocator(this->_nd.ghostEnabled(), _cd.hierarchicalElements()),
                                    state, groupId);
  }

  // See comments on the base GmMesh class
  virtual bool fillDumpControlMapData(QVariantMap* map, const GmLogCategory& logger)
  {
    if(!GmpMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, Vector>::fillDumpControlMapData(map, logger))
      return false;
    map->insert("CellMeshBase_oldNumCells", _oldNumCells);
    return _cd.fillDumpControlMapData(this, map, logger);
  }

  // See comments on the base GmMesh class
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger)
  {
    if(!GmpMeshBase<Mesh, CoordAcc, CoordGhostAcc, Data, CellData, Vector>::dumpControlMapDataLoaded(map, logger))
      return false;
    _oldNumCells = (*map)["CellMeshBase_oldNumCells"].toInt();
    return _cd.dumpControlMapDataLoaded(this, map, logger);
  }

  CellData _cd;          
  int      _oldNumCells; 
};

#endif