gmCellMesh.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_CELL_MESH_H_
#define _GEMA_CELL_MESH_H_

#include "gmMesh.h"
#include "gmCell.h"
#include <assert.h>
#include <float.h>

class GmCellAccessor;
class GmPropertySet;
class GmCellBoundary;
class GmCellGroupSet;
class GmCellMeshTopology;

class GMC_API_EXPORT GmCellMesh : public GmMesh
{
public:
  GmCellMesh(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger);
  virtual ~GmCellMesh();

  virtual int numCells() const = 0;

  virtual int numActiveCells() const = 0;

  virtual const GmCell* cell(int cellIndex) const = 0;

  virtual GmCell* cell(int cellIndex) = 0;

  virtual const GmCellMeshTopology* topology(bool create = true) const { Q_UNUSED(create); return NULL; }

  virtual void clearTopology() {}

  virtual const int* numCellTypes() const = 0;

  virtual const int* numActiveCellTypes() const = 0;

  virtual int maxNumCellNodes() const = 0;

  virtual int maxNumCellGhostNodes() const { return 0; }

  virtual int maxTotalNumCellNodes() const { return maxNumCellNodes(); }

  virtual void ghostNodesUpdated(int nghost, int ntotal) { Q_UNUSED(nghost); Q_UNUSED(ntotal); }

  virtual void activeCellUpdated(GmCellType type, bool active) = 0;

  virtual bool isValid(QList<int>* nonValidIds = NULL, double tol = 1e-3) const;

  virtual bool isQualityGT(double minQuality) const;

  virtual void qualityHistogram(QVector<int>& hist, int nbins = 10) const;

  virtual double edgeMinLength() { return edgeStatistics()->_edgeMinLength; }

  virtual double edgeMaxLength() { return edgeStatistics()->_edgeMaxLength; }

  virtual double cellBboxMinLength() { return bboxStatistics()->_bboxMinLength; }

  virtual double cellBboxMaxLength() { return bboxStatistics()->_bboxMaxLength; }

  void clearCellStatistics();

  void printQualityHistogram(bool activeOnly = true) const;

  virtual QStringList cellGroupIds() const { return QStringList(); }

  virtual int numCellsInGroup(int groupIndex) const { Q_UNUSED(groupIndex);  assert(0);  return 0; }

  virtual const GmCell* cellInGroup(int groupIndex, int cellIndex) const { Q_UNUSED(groupIndex); Q_UNUSED(cellIndex); assert(0); return NULL; }

  virtual GmCell* cellInGroup(int groupIndex, int cellIndex) { Q_UNUSED(groupIndex); Q_UNUSED(cellIndex); assert(0); return NULL; }


  virtual const QMap<QString, GmCellBoundary*>& cellBoundaryGroups() const = 0;

  virtual const QList<GmPropertySet*>& propertySets() const = 0;

  virtual int propertySetIndex(QString id) const = 0;

  virtual GmValueInfo*    cellPropertyInfo    (QString id) const;
  virtual GmCellAccessor* cellPropertyAccessor(QString id, Unit desiredUnit, const GmLogCategory& logger) const;

  virtual QStringList cellAttributeIds() const;

  virtual GmValueInfo*    cellAttributeInfo    (QString id) const;
  virtual GmCellAccessor* cellAttributeAccessor(QString id, Unit desiredUnit, const GmLogCategory& logger) const;
  virtual GmCellAccessor* cellAttributeAccessor(QString id, int snum, bool locked, Unit desiredUnit, const GmLogCategory& logger) const;

  virtual int addCells(int* numCellTypes) { Q_UNUSED(numCellTypes);  return -1; }

  virtual QList<int> addedCells() const { return QList<int>(); }

  virtual void clearAddedCells() {}
  
  virtual int  addCellGroup(QString groupName) { Q_UNUSED(groupName);  return -1; }

  virtual bool addCellsToGroup(int groupId, const QVector<int>& cellIds) { Q_UNUSED(groupId); Q_UNUSED(cellIds); return false; }

  virtual bool addCellsToGroup(int groupId, const QVector<QPair<int, int>>& cellIds) { Q_UNUSED(groupId); Q_UNUSED(cellIds); return false; }

  virtual bool addCellAttributeSet(GmValueInfo* info);
  virtual void removeCellAttributeSet(QString id);
  virtual void clearCellAttributeSets();
  virtual void clearCellAttributeSetsData();


  virtual bool    saveState                (GmValueSet::SaveStateMode mode, const GmLogCategory& logger);
  virtual bool    saveCellAttributeState   (QString id, GmValueSet::SaveStateMode mode, const GmLogCategory& logger);
  virtual int     numCellAttributeStates   (QString id) const;
  virtual QString cellAttributeStateTag    (QString id, int snum) const;
  virtual double  cellAttributeStateTime   (QString id, int snum) const;
  virtual void    setCellAttributeStateTag (QString id, int snum, QString tag);
  virtual void    setCellAttributeStateTime(QString id, int snum, double time);

  virtual void printParameters(const GmLogCategory& logger);
  virtual void printValues    (const GmLogCategory& logger, int options = GM_PRINT_DEFAULT);

  virtual size_t cellMemory() const = 0;

  virtual size_t cellGroupsMemory() const = 0;

  virtual size_t cellBoundariesMemory() const = 0;


  const QList<GmValueSet*>& cellValueSets() const { return _cellAttributesData; }

  const GmCellGroupSet* cellGroupSet(const QList<int>& groupIdList, bool disjoint);
  void clearCellGroupSetsData(bool keepMeshSet);

protected:
  virtual bool addStateAccessorData    (GmStateDump* state, int groupId);
  virtual bool fillDumpControlMapData  (QVariantMap* map, const GmLogCategory& logger);
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger);

private:

  // Structure collecting mesh edge statistics
  struct GmCellEdgeStatistics
  {
    double _edgeMinLength;  
    double _edgeMaxLength;  

    GmCellEdgeStatistics() : _edgeMinLength(DBL_MAX), _edgeMaxLength(-DBL_MAX) {}
  };

  // Structure collecting mesh bbox statistics
  struct GmCellBboxStatistics
  {
    double _bboxMinLength;  
    double _bboxMaxLength;  

    GmCellBboxStatistics() : _bboxMinLength(DBL_MAX), _bboxMaxLength(-DBL_MAX) {}
  };

  GmCellEdgeStatistics* edgeStatistics();
  GmCellBboxStatistics* bboxStatistics();

  void computeEdgeLength    (GmCellEdgeStatistics* stat);
  void computeCellBboxLength(GmCellBboxStatistics* stat);

  QMap<QString, int> _cellAttributesMap;   
  QList<GmValueSet*> _cellAttributesData;  

  QList<GmCellGroupSet*> _cellGroups; 

  QAtomicPointer<GmCellEdgeStatistics> _meshEdgeStats;  
  QAtomicPointer<GmCellBboxStatistics> _meshBboxStats;  
  QMutex                               _meshStatsMutex; 
};


template <class T> class GmForeachCellHelperClass
{
public:
  GmForeachCellHelperClass(const T* container, bool activeOnly)
  {
    _control = 1;
    _n       = container->numCells();
    for(_index = 0; activeOnly && _index<_n && !container->cell(_index)->active(); _index++);
  }

  void inc(const T* container, bool activeOnly) { for(_index++; activeOnly && _index<_n && !container->cell(_index)->active(); _index++); }

  int _index;   
  int _n;       
  int _control; 
};

#define GmForeachCellHelper(variable, container, contType, cellType, activeOnly)  \
for(GmForeachCellHelperClass<contType> it(container, activeOnly); it._control && it._index<it._n; it.inc(container, activeOnly), it._control ^= 1) \
  for(variable = (cellType*)container->cell(it._index); it._control; it._control = 0)


#define GmForeachActiveCell(variable, mesh) GmForeachCellHelper(variable, mesh, GmCellMesh, GmCell, true)

#define GmForeachCell(variable, mesh, activeOnly)  GmForeachCellHelper(variable, mesh, GmCellMesh, GmCell, activeOnly)


#endif