gmCellGroupSet.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_GROUP_SET_H_
#define _GEMA_CELL_GROUP_SET_H_
 
#include "gmCell.h"
#include "gmCellMesh.h"
 
#include <QString>
 
 
class GMC_API_EXPORT GmCellGroupSet
{
public:
  virtual ~GmCellGroupSet() {}
 
  virtual int numCells() const = 0;
 
  // PS: We don't have a numActiveCells() function since that would require some type of 
  // synchronization to update our statistics when a cell active flag is changed.
  // An option would be making the mesh emit a signal when activeCellUpdated() is called
  // (GmMesh already inherits QObject). That would require that GmCellGroupSet becomes a 
  // QObjects itself.  Maybe not a bad idea after all. Would simplify the codes in 
  // GmFileFilter::fillCellData() and GmFilteredCellSetGaussIndex::init() if we also 
  // implement numCellTypes() and numActiveCellTypes()
 
  virtual GmCell* cell(int setIndex) const = 0;
 
  virtual bool ordered() const = 0;
 
  virtual int numNodes() const = 0;
 
  virtual int node(int setIndex) const = 0;
 
  virtual void clear() = 0;
 
  virtual const QList<int>& cellGroups() const = 0;
 
  QStringList cellGroupNames() const;
 
  virtual GmCellMesh* mesh() const = 0;
 
  virtual size_t usedMemory() const = 0;
 
  virtual void applyTransform(std::function<int(int)>& t) = 0;
 
  static bool cellGroupIds(const GmCellMesh* mesh, const QStringList& groupNames, QList<int>& idList, QString& err);
};
 
class GMC_API_EXPORT GmCellMeshGroupSet : public GmCellGroupSet
{
public:
  GmCellMeshGroupSet(GmCellMesh* mesh) { assert(mesh); _mesh = mesh; }
 
  // See comments on the base class
  virtual int numCells() const { return _mesh->numCells(); }
 
  // See comments on the base class
  virtual GmCell* cell(int setIndex) const { return _mesh->cell(setIndex); }
 
  // See comments on the base class
  virtual bool ordered() const { return true; }
 
  // See comments on the base class
  virtual int numNodes() const { return _mesh->numNodes(); }
 
  // See comments on the base class
  virtual int node(int setIndex) const { return setIndex; }
 
  // See comments on the base class
  virtual void clear() {}
 
  // See comments on the base class
  virtual const QList<int>& cellGroups() const { static QList<int> emptyGroupList;  return emptyGroupList; }
 
  // See comments on the base class
  virtual GmCellMesh* mesh() const { return _mesh; }
 
  // See comments on the base class
  virtual size_t usedMemory() const { return 0; }
 
  virtual void applyTransform(std::function<int(int)>& t) { Q_UNUSED(t); }
 
private:
  Q_DISABLE_COPY(GmCellMeshGroupSet)
 
  GmCellMesh* _mesh;  
};
 
 
class GMC_API_EXPORT GmBaseCellGroupSet: public GmCellGroupSet
{
protected:
  typedef QPair<int, int*> NodeData;
 
public:
  virtual ~GmBaseCellGroupSet();
 
  // See comments on the base class
  virtual int numNodes() const { return nodeData()->first; }
 
  // See comments on the base class
  virtual int node(int setIndex) const 
  { 
    NodeData* d = nodeData();
    
    assert(setIndex >= 0 && setIndex < d->first); 
    return d->second[setIndex]; 
  }
 
  virtual void clear();
 
  // See comments on the base class
  virtual const QList<int>& cellGroups() const { return _groupList; }
 
  // See comments on the base class
  virtual GmCellMesh* mesh() const { return _mesh; }
 
  virtual size_t usedMemory() const;
 
protected:
  GmBaseCellGroupSet(GmCellMesh* mesh, const QList<int>& groups);
  GmBaseCellGroupSet(GmCellMesh* mesh);
 
  NodeData* buildNodeList() const;
  NodeData* nodeData() const;
 
  GmCellMesh*  _mesh;       
  QList<int>   _groupList;  
 
  mutable QAtomicPointer<NodeData> _nodeData; 
 
  mutable QMutex _nodeDataMutex;  
 
private:
  Q_DISABLE_COPY(GmBaseCellGroupSet)
};
 
class GMC_API_EXPORT GmCellDisjointGroupSet : public GmBaseCellGroupSet
{
public:
  GmCellDisjointGroupSet(GmCellMesh* mesh, const QList<int>& groups);
 
  virtual int numCells() const;
 
  virtual GmCell* cell(int setIndex) const;
 
  // See comments on the base class
  virtual bool ordered() const { return false; }
 
  virtual void clear();
 
  virtual void applyTransform(std::function<int(int)>& t) { Q_UNUSED(t); }
 
private:
  QMap<int, int> _groupMap;  
};
 
class GMC_API_EXPORT GmCellGenericGroupSet : public GmBaseCellGroupSet
{
public:
  GmCellGenericGroupSet(GmCellMesh* mesh, const QList<int>& groups);
 
  GmCellGenericGroupSet(GmCellMesh* mesh, const QVector<int>& cellIds);
 
  virtual ~GmCellGenericGroupSet();
 
  // See comments on the base class
  virtual int numCells() const { return _ncells; }
 
  // See comments on the base class
  virtual GmCell* cell(int setIndex) const { assert(setIndex >= 0 && setIndex < _ncells);  return _mesh->cell(_cells[setIndex]); }
 
  // See comments on the base class
  virtual bool ordered() const { return true; }
 
  virtual void clear();
 
  // See comments on the base class
  virtual size_t usedMemory() const { return GmBaseCellGroupSet::usedMemory() + _ncells * sizeof(int); }
 
  virtual void applyTransform(std::function<int(int)>& t);
 
private:
  // We can't store cell pointers since they can change when cells are added to the mesh
 
  int  _ncells; 
  int* _cells;  
 
  friend GmCellGroupSet;
};
 
class GMC_API_EXPORT GmCellSequentialGroupSet : public GmBaseCellGroupSet
{
public:
  GmCellSequentialGroupSet(GmCellMesh* mesh, int first, int last)
    : GmBaseCellGroupSet(mesh), _first(first), _last(last)
  {
    assert(first <= last && first >= 0 && last < mesh->numCells());
  }
 
  // See comments on the base class
  virtual int numCells() const { return _last - _first + 1; }
 
  // See comments on the base class
  virtual GmCell* cell(int setIndex) const { return _mesh->cell(_first + setIndex); }
 
  // See comments on the base class
  virtual bool ordered() const { return true; }
 
  // See comments on the base class
  virtual void clear() { GmBaseCellGroupSet::clear(); _first = -1; _last = -1; }
 
  virtual void applyTransform(std::function<int(int)>& t) { Q_UNUSED(t); }
 
private:
  int _first;  
  int _last;   
};
 
 
#define GmForeachActiveGroupCell(variable, gs) GmForeachCellHelper(variable, gs, GmCellGroupSet, GmCell, true)
 
#define GmForeachGroupCell(variable, gs, activeOnly) GmForeachCellHelper(variable, gs, GmCellGroupSet, GmCell, activeOnly) 
 
#define GmForeachActiveGroupElement(variable, gs) GmForeachCellHelper(variable, gs, GmCellGroupSet, GmElement, true)
 
#define GmForeachGroupElement(variable, gs, activeOnly) GmForeachCellHelper(variable, gs, GmCellGroupSet, GmElement, activeOnly) 
 
// IMPORTANT: There is no point in having additional macros that are equivalent to GmForeachOrderedCell() / Element().
// Those macros are used to traverse the mesh in the original model cell order when the list of cells was renumbered
// and reordered according to the new cell order numbers. For a cell group this is not necessary since the indices stored
// in the group where mapped to the new numbering, but where NOT REORDERED.
 
#endif