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