gmGaussIndex.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_GAUSSINDEX_H_
#define _GEMA_GAUSSINDEX_H_
 
#include "gmCoreConfig.h"
 
#include <QVarLengthArray>
 
class GmElementMesh;
class GmCellGroupSet;
 
class GMC_API_EXPORT GmGaussIndex
{
public:
  virtual ~GmGaussIndex() {}
 
  virtual int numPoints() const = 0; 
 
  virtual int numCells() const = 0;
 
  virtual int numPoints(int cellId) const = 0; 
 
  virtual int pointIndex(int cellId, int ip) const = 0;
 
  virtual int cellIp(int gpIndex, int* ip) const = 0;
};
 
template <class T>
class GmGaussIndexProxy : public GmGaussIndex
{
public:
  GmGaussIndexProxy(T* proxy, bool ownership) : _proxy(proxy), _ownsProxy(ownership) {}
 
  virtual ~GmGaussIndexProxy() { if(_ownsProxy) delete _proxy; }
 
  // Comments on the base class
  virtual int numPoints() const                    { return _proxy->numPoints(); }
  virtual int numCells() const                     { return _proxy->numCells(); }
  virtual int numPoints(int cellId) const          { return _proxy->numPoints(cellId); }
  virtual int pointIndex(int cellId, int ip) const { return _proxy->pointIndex(cellId, ip); }
  virtual int cellIp(int gpIndex, int* ip) const   { return _proxy->cellIp(gpIndex, ip); }
 
private:
  T*   _proxy;     
  bool _ownsProxy; 
};
 
class GMC_API_EXPORT GmUnfilteredGaussIndexBase
{
public:
  int numPoints() const { return _numIp ? _numCells * _numIp : _cellOffset.last(); }
 
  int numCells() const { return _numCells; }
 
  int numPoints(int cellId) const
  {
    assert(cellId >= 0 && cellId < _numCells);
    return _numIp ? _numIp : _cellOffset[cellId + 1] - _cellOffset[cellId];
  }
 
  int pointIndex(int cellId, int ip) const
  {
    assert(cellId >= 0 && cellId < _numCells);
    assert(ip >= 0 && ip < numPoints(cellId));
    return ip + (_numIp ? cellId * _numIp : _cellOffset[cellId]);
  }
 
  int cellIp(int gpIndex, int* ip) const
  {
    assert(gpIndex >= 0 && gpIndex < numPoints());
    assert(ip);
    
    if(_numIp)
    {
      *ip = gpIndex % _numIp;
      return gpIndex / _numIp;
    }
 
    int pos = qUpperBound(_cellOffset, gpIndex) - _cellOffset.data();
    assert(pos >= 0 && pos < _cellOffset.size());  // The last sentinel guarantees that searched value is less than the last vector value
 
    if(gpIndex < _cellOffset[pos])
      pos--;  // if gpIndex < _cellOffset[pos], pos must be > 0
 
    *ip = gpIndex - _cellOffset[pos];
    return pos;
  }
 
  void clear() { _numIp = _numCells = 0; _cellOffset.clear(); _cellOffset.append(0); }
 
  size_t usedMemory() const { return _numIp ? 0 : _cellOffset.capacity() * sizeof(int); }
 
#if defined ENABLE_TESTS || defined ENABLE_VALUESET_TESTS
  void validateInternalStructure() const;
#endif
 
protected:
  GmUnfilteredGaussIndexBase() : _numIp(0), _numCells(0) { _cellOffset.append(0); }
 
  int _numIp;    
  int _numCells; 
 
  QVarLengthArray<int, 2> _cellOffset;  
 
private:
  Q_DISABLE_COPY(GmUnfilteredGaussIndexBase);
};
 
class GMC_API_EXPORT GmFilteredGaussIndexBase : public GmGaussIndex
{
public:
  virtual int numPoints() const { return _cellOffset.last(); }
 
  virtual int numCells() const { return _numCells; }
 
  virtual int numPoints(int cellId) const
  {
    assert(cellId >= 0 && cellId < _cellOffset.size()-1);
    return _cellOffset[cellId + 1] - _cellOffset[cellId];
  }
 
  virtual int pointIndex(int cellId, int ip) const
  {
    assert(cellId >= 0 && cellId < _cellOffset.size()-1);
    assert((ip >= 0 && ip < numPoints(cellId)) || (_cellOffset[cellId + 1] == _cellOffset[cellId]));
    return (_cellOffset[cellId + 1] != _cellOffset[cellId]) ? ip + _cellOffset[cellId] : -1;
  }
 
 
  virtual int cellIp(int gpIndex, int* ip) const
  {
    assert(gpIndex >= 0 && gpIndex < numPoints());
    assert(ip);
 
    int pos = qUpperBound(_cellOffset, gpIndex) - _cellOffset.data();
    assert(pos >= 0 && pos < _cellOffset.size());  // The last sentinel guarantees that searched value is less than the last vector value
 
    if(gpIndex < _cellOffset[pos])
      pos--;  // if gpIndex < _cellOffset[pos], pos must be > 0
 
    *ip = gpIndex - _cellOffset[pos];
    return pos;
  }
 
  void clear() { _numCells = 0; _cellOffset.clear(); _cellOffset.append(0); }
 
  size_t usedMemory() const { return _cellOffset.capacity() * sizeof(int); }
 
#if defined ENABLE_TESTS || defined ENABLE_VALUESET_TESTS
  void validateInternalStructure() const;
#endif
 
protected:
  GmFilteredGaussIndexBase() : _numCells(0) { _cellOffset.append(0); }
 
 
  int _numCells; 
 
  QVarLengthArray<int, 2> _cellOffset;
 
private:
  Q_DISABLE_COPY(GmFilteredGaussIndexBase);
};
 
 
class GMC_API_EXPORT GmMeshGaussIndex : public GmUnfilteredGaussIndexBase
{
public:
  GmMeshGaussIndex(const GmElementMesh* mesh, int ruleSet);
 
  bool init();
 
  bool addValues(const int* numAddedValues);
  bool addValues(int firstAddedElement);
 
  void restoreSize(int oldNumCells);
 
  const GmElementMesh* mesh() const { return _mesh; }
 
private:
  bool addValuesWorker(const int* numAddedValues, int firstAddedElement);
 
  int numAddedGaussPoints(const int* numTypes, int* pointsPerCell, int* numElem);
  int numAddedGaussPoints(int firstElement,    int* pointsPerCell, int* numElem);
 
  int fixedAddedElements(const int* numTypes, int firstElement, int* numElem) const;
 
  void fillOffsetVectorFromMesh (int firstCell = 0);
  void fillOffsetVectorFromTypes(int firstCell, const int* numTypes, int newFixed);
 
  const GmElementMesh* _mesh; 
  int                  _rule; 
};
 
class GMC_API_EXPORT GmFixedMeshSetGaussIndex : public GmUnfilteredGaussIndexBase
{
public:
  GmFixedMeshSetGaussIndex(const GmElementMesh* mesh, const int* cellSet, int numCells, int ruleSet);
 
  bool init();
 
private:
  const GmElementMesh* _mesh;  
  const int*           _cells; 
  int                  _rule;  
};
 
class GMC_API_EXPORT GmFilteredCellSetGaussIndex : public GmFilteredGaussIndexBase
{
public:
  GmFilteredCellSetGaussIndex(const GmCellGroupSet* group, bool activeOnly, int ruleSet);
 
  bool init();
 
private:
  const GmCellGroupSet* _group;      
  bool                  _activeOnly; 
  int                   _rule;       
};
 
 
#endif