gmResultsTrackedData.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_RESULTS_TRACKED_DATA_H_
#define _GEMA_RESULTS_TRACKED_DATA_H_
 
#include "gmCoreConfig.h"
#include "gmVector.h"
#include "gmResultsEvalSet.h"
 
#include <QString>
#include <QVector>
 
struct GMC_API_EXPORT GmResultsTrackedData
{
  GmResultsTrackedData()                     {}
  GmResultsTrackedData(double val)  { _numValue.append(val); }
  GmResultsTrackedData(const double* val, int n) { _numValue.resize(n); memcpy(_numValue.data(), val, n*sizeof(double)); }
  GmResultsTrackedData(QString val) { _strValue = val; }
  GmResultsTrackedData(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 GmResultsTrackedIndexData
{
  enum IndexType
  {
    NODE_INDEX,  
    CELL_INDEX,  
    GAUSS_INDEX, 
  };
 
  enum IndexDataType
  {
    NODE_DATA,          
    GHOST_DATA,         
    CELL_CENTROID_DATA, 
    CELL_IP_DATA,       
    CELL_IP_AGGR_DATA,  
    CELL_POINT_DATA,    
    POINT_DATA,         
    // ----------------------------
    // NO adding  below 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");
 
  GmResultsTrackedIndexData() {}
 
  GmResultsTrackedIndexData(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 || type == CELL_IP_AGGR_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_IP_AGGR_DATA)
      return QString("Cell %1, %2(ip)").arg(index).arg(GmResultsEvalSet::aggregationRuleStr((GmResultsEvalSet::GmEvalSetAggregationRule)lineIp(line)));
    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