gmResultsEvalSet.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_EVALSET_H_
#define _GEMA_RESULTS_EVALSET_H_
 
#include "gmCoreConfig.h"
 
#include "gmValueInfo.h"
#include "gmVector.h"
 
class GmMesh;
class GmCellMesh;
class GmNodeSet;
class GmCellBoundary;
class GmLogCategory;
class GmSpatialIndex;
class GmFixedMeshSetGaussIndex;
class LuaTable;
 
struct GmResultsTrackedIndexData;
 
#include "QVector"
 
class GMC_API_EXPORT GmResultsEvalSet
{
public:
 
  // Aggregation options for values evaluated at Gauss points
  enum GmEvalSetAggregationRule
  {
    GM_EVALSET_NONE,     
    GM_EVALSET_MIN,      
    GM_EVALSET_MAX,      
    GM_EVALSET_AVG,      
    GM_EVALSET_SUM,      
    GM_EVALSET_MINNORM,  
    GM_EVALSET_MAXNORM,  
    // -------------------------------------------------
    // IMPORTANT: No Adding  below this line. When changing the enum,
    //            also change the aggregationRuleStr() implementation.
    //--------------------------------------------------
    GM_NUM_EVALSET_AGGR_RULES
  };
 
  ~GmResultsEvalSet();
 
  bool prepare(GmSpatialIndex* si, bool natural, GmAffectedNodes nodeTypes,
               QString ruleId, const GmLogCategory& logger);
 
  bool hasIpBasedLines() const;
  bool hasPosBasedLines() const;
 
  int numLines() const
  {
    assert(_numNodeLines >= 0 && _numCellLines >= 0); // prepare() has been called
    return _numNodeLines + _numCellLines + _numPoints;
  }
 
  bool isNodeBased(int line) const
  {
    assert(_numNodeLines >= 0 && _numCellLines >= 0); // prepare() has been called
    assert(line >= 0 && line < numLines());
    return line < _numNodeLines;
  }
 
  bool isIpBased(int line) const
  {
    assert(_numNodeLines >= 0 && _numCellLines >= 0); // prepare() has been called
    assert(line >= 0 && line < numLines());
    return (_evalAt != -1) && (line >= _numNodeLines) && line < (_numNodeLines + _numCellLines);
  }
 
  bool isPosBased(int line) const { return !isNodeBased(line) && !isIpBased(line); }
 
  bool isUserPointBased(int line) const
  {
    assert(_numNodeLines >= 0 && _numCellLines >= 0); // prepare() has been called
    assert(line >= 0 && line < numLines());
    return line >= (_numNodeLines + _numCellLines);
  }
 
  bool isSimple() const { return !_nodes && (!_cells || _allCellsFromGroup) && !_points; }
 
  const QStringList& simpleGroups() const { return _cellGroups; }
 
  int nodeIndex  (int line) const;
  int cellIpIndex(int line, int* ip, int* ruleSet = NULL) const;
  int cellPos    (int line, bool naturalCoord, GmVector& coord) const;
 
  GmEvalSetAggregationRule aggregationRule() const { return _evalAggr; }
 
  static const char* aggregationRuleStr(GmEvalSetAggregationRule rule)
  { 
    assert(rule >= 0 && rule < GM_NUM_EVALSET_AGGR_RULES);
    static const char* ruleNames[GM_NUM_EVALSET_AGGR_RULES] = { "none", "min", "max", "avg", "sum", "minnorm", "maxnorm"}; // Order MUST match enum order
    return ruleNames[rule]; 
  }
 
  const char* aggregationRuleStr() const { return aggregationRuleStr(_evalAggr); }
 
  QString explain(int line) const;
  void    explainToIndex(GmResultsTrackedIndexData* indexData, int line) const;
 
  bool changed() const { return _changed; }
 
  void resetChanges() { _changed = false; }
 
  void print(const GmLogCategory& logger, GmLogLevel level) const;
 
  static GmResultsEvalSet* loadFromTable(LuaTable& tab, GmMesh* mesh, QString tabPrefix, 
                                         QString ruleId, bool nodeBased, int defEvalAt, 
                                         int ruleSet, const GmLogCategory& logger);
private:
  Q_DISABLE_COPY(GmResultsEvalSet);
 
  GmResultsEvalSet(GmMesh* mesh, bool nodeBased, int defEvalAt, int defRuleSet);
 
  bool parseNodes (LuaTable& tab, const GmMesh* mesh, QString& err);
  bool parseCells (LuaTable& tab, const GmCellMesh* mesh, bool userRuleSet, QString& err);
  bool parsePoints(LuaTable& tab, const GmMesh* mesh, QString& err);
 
  bool buildIpIndex   (QString& err);
  bool buildPointIndex(GmSpatialIndex* si, bool natural, QString& err);
 
  bool cellData(int line, int* cellId, GmVector& coord) const;
 
  GmMesh*          _mesh;    
  GmValueAccessor* _nodeAc;  
  int              _nodeDim; 
 
  // Data storing node definitions
  bool _allMeshNodes; 
  int* _nodes;        
  int  _numNodes;     
  QVector<GmNodeSet*>      _nodeSets;     
  QVector<GmCellBoundary*> _nodeBorders;  
 
  // Data storing cell definitions
  bool                     _allMeshCells; 
  int*                     _cells;        
  int                      _numCells;     
  int                      _evalAt;       
  GmEvalSetAggregationRule _evalAggr;     
  int                      _ruleSet;      
  QVector<GmCellBoundary*> _cellBorders; 
  QStringList              _cellGroups;  
  bool                     _allCellsFromGroup; 
 
  // Data storing extra point definitions
  GmVector* _points;    
  int       _numPoints; 
 
  // Control data 
  bool                      _changed;       
  GmAffectedNodes           _nodeTypes;     
  int                       _numNodeLines;  
  int                       _numCellLines;  
  GmFixedMeshSetGaussIndex* _ipIndex;       
  int*                      _pointCells;    
  GmVector*                 _pointNaturalCoordinates; 
};
 
 
 
#endif