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