gmResultTrackedData.h

/************************************************************************
**
** 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_RESULT_TRACKED_DATA_H_
#define _GEMA_RESULT_TRACKED_DATA_H_

#include "gmCoreConfig.h"
#include "gmVector.h"

#include <QString>
#include <QVector>

struct GMC_API_EXPORT GmResultTrackedData
{
  GmResultTrackedData()                     {}
  GmResultTrackedData(double val) { _numValue.append(val); }
  GmResultTrackedData(double val1, double val2) { _numValue.append(val1); _numValue.append(val2);}
  GmResultTrackedData(double val1, double val2, double val3) { _numValue.append(val1); _numValue.append(val2); _numValue.append(val3); }
  GmResultTrackedData(QString val) { _strValue = val; }
  GmResultTrackedData(QVector<double>& val) { _numValue = val; } 

  QString         _strValue; 
  QVector<double> _numValue; 
};

#define GM_RESULTTRACK_TYPE_BITS 3

#define GM_RESULTTRACK_TYPE_MASK (~0u >> GM_RESULTTRACK_TYPE_BITS)

struct GMC_API_EXPORT GmResultTrackedIndexData
{
  enum IndexType
  {
    NODE_INDEX,  
    CELL_INDEX,  
    GAUSS_INDEX, 
  };

  enum IndexDataType
  {
    NODE_DATA,          
    GHOST_DATA,         
    CELL_CENTROID_DATA, 
    CELL_IP_DATA,       
    CELL_POINT_DATA,    
    POINT_DATA,         
    // ----------------------------
    // NO adding bellow this line
    // When adding types, please check that GM_RESULTTRACK_TYPE_BITS is still enough
    // ----------------------------
    NUM_DATA_TYPES
  };

  static_assert((1 << GM_RESULTTRACK_TYPE_BITS) >= NUM_DATA_TYPES, "Invalid size for GM_RESULTTRACK_TYPE_BITS");

  GmResultTrackedIndexData() {}

  GmResultTrackedIndexData(IndexType type, int coordDim) 
  { 
    _indexType   = type; 
    _coordDim    = coordDim; 
    _firstIpLine = _firstCoordLine = -1; 
  }

  void addLine(IndexDataType type, int index)
  {
    assert(type == NODE_DATA || type == GHOST_DATA || type == CELL_CENTROID_DATA);
    assert(index >= 0);  // Ghost nodes should have their high bit cleared
    assert(_firstIpLine == -1 && _firstCoordLine == -1);

    _index.append(encode(type, index));
  }

  void addLine(IndexDataType type, int index, int ip)
  {
    assert(type == CELL_IP_DATA);
    assert(_firstCoordLine == -1);

    if(_firstIpLine == -1)
      _firstIpLine = _index.size();
    _index.append(encode(type, index));
    _ip.append(ip);
  }

  void addLine(IndexDataType type, int index, const GmVector& coord)
  {
    assert(type == CELL_POINT_DATA || type == POINT_DATA);
    assert(coord.size() == _coordDim);

    if(_firstCoordLine == -1)
      _firstCoordLine = _index.size();
    _index.append(encode(type, index));
    for(int i = 0; i < _coordDim; i++)
      _coordinates.append(coord[i]);
  }

  int coordDim() const { return _coordDim; }

  int numLines() const { return _index.size(); }

  IndexDataType lineType(int line) const { assert(line >= 0 && line < numLines()); return decodeType(_index[line]); }

  int lineIndex(int line) const { assert(line >= 0 && line < numLines()); return decodeIndex(_index[line]); }

  int lineIp(int line) const 
  { 
    assert(_firstIpLine >= 0); 
    line -= _firstIpLine;  
    assert(line >= 0 && line < _ip.size()); 
    return _ip[line]; 
  }

  const double* lineCoord(int line) const 
  { 
    assert(_firstCoordLine >= 0);  
    line -= _firstCoordLine;  
    assert(line >= 0 && line*_coordDim < _coordinates.size()); 
    return &_coordinates[line*_coordDim]; 
  }

  QString lineStr(int line) const
  {
    IndexDataType t     = lineType(line);
    int           index = lineIndex(line) + 1;  // +1 to 1 based. Ghost nodes are already with the ghost bit cleared
    if(t == NODE_DATA)
      return QString("Node %1").arg(index);
    else if(t == GHOST_DATA)
      return QString("Ghost node %1").arg(index);
    else if(t == CELL_IP_DATA)
      return QString("Cell %1 @ ip %2").arg(index).arg(lineIp(line)+1);
    else if(t == CELL_CENTROID_DATA)
      return QString("Cell %1 @ centroid").arg(index);
    else if(t == CELL_POINT_DATA)
      return QString("Cell %1 @ %2").arg(index).arg(GmVectorUtils::toString(GmCRVector(lineCoord(line), _coordDim)));
    else if(t == POINT_DATA)
      return QString("@ %1").arg(GmVectorUtils::toString(GmCRVector(lineCoord(line), _coordDim)));
    assert(0);
    return "";
  }

  IndexType       _indexType;      
  int             _coordDim;       
  QVector<int>    _index;          
  QVector<short>  _ip;             
  QVector<double> _coordinates;    
  int             _firstIpLine;    
  int             _firstCoordLine; 

private:
  int encode(IndexDataType type, int index) const
  {
    assert((index & GM_RESULTTRACK_TYPE_MASK) == index); // Check that index fits in the allowed bits
    return ((int)type << (32 - GM_RESULTTRACK_TYPE_BITS)) | index;
  }

  IndexDataType decodeType(int v) const { return (IndexDataType)((unsigned)v >> (32 - GM_RESULTTRACK_TYPE_BITS)); }

  int decodeIndex(int v) const { return v & GM_RESULTTRACK_TYPE_MASK; }
};



#endif