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 int numGlobalCells() const { return pcrObject()->numGlobalCells(); }
 
  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 bool hasSolidElements() const = 0;
 
  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(QMap<int, int>& nonValidIds, bool valNonPlanar = false, bool print = true, 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 cellValueIds(int filter = -1) const;
 
  virtual GmValueInfo*    cellValueInfo    (QString id, int filter = -1) const;
  virtual GmCellAccessor* cellValueAccessor(QString id, Unit desiredUnit, const GmLogCategory& logger) const;
  virtual GmCellAccessor* cellValueAccessor(QString id, int snum, bool locked, Unit desiredUnit, const GmLogCategory& logger) const;
 
  virtual GmCellAccessor* cellStateVarAccessorFromDof(int dof, Unit desiredUnit, GmStateVar** stateVar) 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 addCellValueSet(GmValueInfo* info);
  virtual void removeCellValueSet(QString id);
  virtual bool initCellValueSets();
  virtual void beginAddingCellValueSets();
  virtual bool endAddingCellValueSets();
  virtual void clearCellValueSets();
  virtual void clearCellValueSetsData();
 
 
  virtual bool    saveState            (GmValueSet::SaveStateMode mode, const GmLogCategory& logger);
  virtual bool    saveCellValueState   (QString id, GmValueSet::SaveStateMode mode, const GmLogCategory& logger);
  virtual int     numCellValueStates   (QString id) const;
  virtual QString cellValueStateTag    (QString id, int snum) const;
  virtual double  cellValueStateTime   (QString id, int snum) const;
  virtual void    setCellValueStateTag (QString id, int snum, QString tag);
  virtual void    setCellValueStateTime(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;
 
 
  GmValueSetGroup* cellValueSetGroup() const { return _cellValuesGroup; }
 
  GmValueSet* cellValueSet(QString id) const { return _cellValuesGroup->valueSet(id); }
 
  const GmCellGroupSet* cellGroupSet(const QList<int>& groupIdList, bool disjoint);
 
  const QVector<GmCellGroupSet*>& cellGroupSets() const { return _cellGroups; }
 
  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);
 
  GmValueSetGroup* _cellValuesGroup;   
 
  QVector<GmCellGroupSet*> _cellGroups; 
 
  QAtomicPointer<GmCellEdgeStatistics> _meshEdgeStats;  
  QAtomicPointer<GmCellBboxStatistics> _meshBboxStats;  
  QMutex                               _meshStatsMutex; 
};
 
template <class T> class GmForeachCellHelperClassBase
{
public:
  const T* _container;  
  bool     _activeOnly; 
  int      _index;      
  int      _n;          
  int      _control;    
 
protected:
  // Helper constructor so that derived classes can initialize the object without searching for the first index
  GmForeachCellHelperClassBase(const T* container, bool activeOnly)
  {
    _container  = container;
    _activeOnly = activeOnly;
    _n          = container->numCells();
    _control    = 1;
    _index      = -1; // Set to -1 so that we can position the first cell by calling inc()
  }
};
 
template <class T, class C> class GmForeachCellHelperClass : public GmForeachCellHelperClassBase<T>
{
public:
  GmForeachCellHelperClass(const T* container, bool activeOnly)
    : GmForeachCellHelperClassBase<T>(container, activeOnly) { inc(); }
 
  void inc() { for(_index++; _activeOnly && _index < _n && !cell()->active(); _index++); }
 
  C* cell() const { return (C*)_container->cell(_index); }
};
 
#include "gmPCR.h" // Must be added here to avoid cyclic dependencies due to gmPCR.h including gmCellMesh :(
 
template <class T, class C> class GmForeachOrderedCellHelperClass : public GmForeachCellHelperClassBase<T>
{
public:
  GmForeachOrderedCellHelperClass(const T* container, bool activeOnly, GmPCR* pcr)
    : GmForeachCellHelperClassBase<T>(container, activeOnly), _pcr(pcr) { inc(); }
 
  void inc() { for(_index++; _activeOnly && _index < _n && !cell()->active(); _index++); }
 
  C* cell() const { return (C*)_container->cell(_pcr ? _pcr->originalCellTraversalOrder(_index) : _index); }
 
  GmPCR* _pcr; 
};
 
 
#define GmForeachCellHelper(variable, container, contType, cellType, activeOnly)  \
for(GmForeachCellHelperClass<contType, cellType> it(container, activeOnly); it._control && it._index<it._n; it.inc(), it._control ^= 1) \
  for(variable = it.cell(); it._control; it._control = 0)
 
// Similar to GmForeachCellHelper but with an additional PCR argument to allow for optional traversal in model order
#define GmForeachOrderedCellHelper(variable, container, contType, cellType, activeOnly, pcr)  \
for(GmForeachOrderedCellHelperClass<contType, cellType> it(container, activeOnly, pcr); it._control && it._index<it._n; it.inc(), it._control ^= 1) \
  for(variable = it.cell(); 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)
 
#define GmForeachOrderedCell(variable, mesh, activeOnly, modelOrder) \
GmForeachOrderedCellHelper(variable, mesh, GmCellMesh, GmCell, activeOnly, modelOrder ? (mesh)->pcrObject() : NULL)
 
 
#endif