gmMatrixSet.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_MATRIX_SET_H_
#define _GEMA_MATRIX_SET_H_
 
#include "gmMatrix.h"
#include "gmThreadLocalBuffer.h"
 
#include <assert.h>
 
#include <QStringList>
 
/* \brief This class holds a fixed size set of square matrices, whose sizes
          can vary inside a maximum limit. 
*/
class GMC_API_EXPORT GmMatrixSet
{
public:
  GmMatrixSet(int maxMatrixTypes, const QStringList& typeNames);
  ~GmMatrixSet();
 
  bool init(int maxNodes, int numMatrices, ...);
  bool adjustSizes(int maxNodes);
  void clear();
 
  void prepareSet(int nnodes);
 
  bool containsType(int type) const { return (index(type) >= 0 && _typeEnabled[type]); }
 
  void setTypeEnabled(int type, bool enabled) 
  { 
    assert(type >= 0 && type < _nTypes); 
    if(enabled == _typeEnabled[type])
      return;
    _typeEnabled[type] = enabled; 
    _nEnabled += (enabled ? 1 : -1);
  }
 
  int numEnabledTypes() const { return _nEnabled; }
 
  GmMatrix& matrix   (int type);
  GmMatrix& useMatrix(int type);
  GmMatrix& useMatrix(int type, bool fill, bool sym);
 
  void setSymmetric(int type, bool symmetric) 
  {
          assert(index(type) >= 0); 
          _symmetric.localBuffer()[index(type)] = symmetric; 
  }
 
  void setFilled(int type, bool filled) { assert(index(type) >= 0); _filled.localBuffer()[index(type)] = filled; }
 
  bool symmetric(int type) const { assert(index(type) >= 0); return _symmetric.localBuffer()[index(type)]; }
 
  bool filledSymmetric() const;
 
  bool filled(int type) const { assert(index(type) >= 0); return _filled.localBuffer()[index(type)]; }
 
  int index(int type) const { assert(type >= 0 && type < _nTypes);  return _typeIndex[type]; }
 
  int typeFromIndex(int index) const { assert(index >= 0 && index < _nMatrices); return _indexType[index]; }
 
  QString typeName(int type) const
  {
    assert(type >= 0 && type < _nTypes);  
    return type < _typeNames.size() ? _typeNames.at(type) : "";
  }
 
  int numMatrices() const { return _nMatrices; }
 
  const GmMatrix& matrixFromIndex(int index) const { assert(index >= 0 && index < _nMatrices); return _matrices.localBuffer()[index]; }
 
  bool symmetricFromIndex(int index) const { assert(index >= 0 && index < _nMatrices); return _symmetric.localBuffer()[index]; }
 
  bool filledFromIndex(int index) const { assert(index >= 0 && index < _nMatrices); return _filled.localBuffer()[index]; }
 
protected:
  bool initTypes(int numMatrices, va_list typeList);
 
  int         _nTypes;      
  int*        _typeIndex;   
  int*        _indexType;   
  bool*       _typeEnabled; 
  int         _nEnabled;    
  QStringList _typeNames;   
 
  int         _nMatrices;     
  int         _maxNodes;      
  GmTLBuffer<double, true>   _matrixMemory;  
  GmTLBuffer<GmMatrix, true> _matrices;      
  GmTLBuffer<bool, true>     _symmetric;     
  GmTLBuffer<bool, true>     _filled;        
};
 
 
#endif