gmValueInfo.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_VALUE_INFO_H_
#define _GEMA_VALUE_INFO_H_
 
#include "gmCoreConfig.h"
#include "gmLog.h"
 
class LuaTable;
class GmValueAccessor;
 
#include <QString>
#include <unit.h>
 
enum GmValueSetKind
{
  GM_NODE_COORDINATES,     
  GM_NODE_ATTRIBUTE,       
  GM_NODE_STATEVAR,        
  GM_CELL_ATTRIBUTE,       
  GM_CELL_STATEVAR,        
  GM_GAUSS_ATTRIBUTE,      
  GM_PSET_PROPERTY,        
  GM_BC_NODE_PROPERTY,     
  GM_BC_BOUNDARY_PROPERTY, 
  GM_DS_ATTRIBUTE,         
  GM_USER,                 
  // --- DO NOT INSERT ANYTHING BELLOW THIS LINE ---
  GM_NUM_VALUESET_KIND
};
 
enum GmStorageType
{
  GM_DOUBLE_TYPE,  
  GM_FLOAT_TYPE,   
  GM_INT32_TYPE,   
  GM_INT16_TYPE,   
  GM_BYTE_TYPE,    
  GM_UINT32_TYPE,  
  GM_UINT16_TYPE,  
  GM_UBYTE_TYPE,   
  // --- DO NOT INSERT ANYTHING BELLOW THIS LINE ---
  // IMPORTANT: When adding an entry to this enum or if changing enum order, please make sure
  //            to update the sizeofStorageType() function
  GM_NUM_STORAGE_TYPE
};
 
enum GmDimType
{
  GM_SCALAR_VALUE,  
  GM_VECTOR_VALUE,  
  GM_MATRIX_VALUE,  
};
 
enum GmAllocMode
{
  GM_ALLOC_FULL,    
  GM_ALLOC_SPARSE,  
  GM_ALLOC_AUTO,    
};
 
enum GmAllocStrategy
{
  GM_STRATEGY_AUTO,           
  GM_STRATEGY_SPARSE_HASH,    
  GM_STRATEGY_SPARSE_LINKED,  
  GM_STRATEGY_SPARSE_RLE,     
};
 
enum GmAffectedNodes
{
  GM_GEOMETRY_NODE, 
  GM_GHOST_NODE,    
  GM_BOTH,          
};
 
#define GM_VALUE_INFO_DEFAULT_FORMAT_WIDTH 12      
#define GM_VALUE_INFO_DEFAULT_FORMAT       'f'     
#define GM_VALUE_INFO_DEFAULT_FORMAT_PREC  2       
#define GM_VALUE_INFO_DEFAULT_FORMAT_STR  "12.2f"  
 
 
struct GMC_API_EXPORT GmBcTagInfo
{
  GmBcTagInfo(int size);
  ~GmBcTagInfo();
 
  int* _tags;       
  bool _ignoreDef;  
  bool _ignoreZero; 
private:
  Q_DISABLE_COPY(GmBcTagInfo)
};
 
 
class GMC_API_EXPORT GmValueInfo
{
public:
  GmValueInfo(QString id, QString description, Unit unit, GmValueSetKind kind,
              GmDimType dimType = GM_SCALAR_VALUE, int nlin = 1, int ncol = 1);
  GmValueInfo(const GmValueInfo &);
 
  virtual ~GmValueInfo();
 
  QString id() const { return _id; }
 
  QString description() const { return _description;  }
 
  Unit unit() const { return _unit;  }
 
  GmValueSetKind kind() const { return _setKind; }
 
  QString kindStr() const { return dataKindToStr(_setKind); }
 
  bool isNodeBased() const { return _setKind == GM_NODE_COORDINATES || _setKind == GM_NODE_ATTRIBUTE || _setKind == GM_NODE_STATEVAR; }
 
  bool isCellBased() const { return _setKind == GM_CELL_ATTRIBUTE || _setKind == GM_CELL_STATEVAR || _setKind == GM_GAUSS_ATTRIBUTE; }
 
  GmStorageType storageType() const { return _storageType; }
 
  int sizeofStorageType() const;
 
  QString storageTypeStr() const { return storageTypeToStr(_storageType); }
 
  GmDimType dimType() const { return _dimType;  }
 
  QString dimTypeStr() const { return dimTypeToStr(_dimType, _nlin, _ncol); }
 
  int size() const { return _nlin * _ncol; }
 
  int nlin() const { return _nlin; }
 
  int ncol() const { return _ncol; }
 
  bool isScalar() const { return _dimType == GM_SCALAR_VALUE; }
 
  const double* defValue() const { return _defValue; }
 
  double defScalarValue() const { assert(_dimType == GM_SCALAR_VALUE); return *_defValue; }
 
  bool defIsFunction() const { return !_defFunction.isEmpty(); }
 
  QString defFunction() const { return _defFunction; }
 
  bool canStoreFunctions() const { return _canStoreFunction; }
 
  GmAllocMode allocMode() const { return _allocMode; }
 
  QString allocModeStr() const { return allocModeToStr(_allocMode); }
 
  GmAllocStrategy allocStrategy() const { return _allocStrategy; }
 
  QString allocStrategyStr() const { return allocStrategyToStr(_allocStrategy); }
 
  GmAffectedNodes affectedNodes() const { return _affectedNodes; }
 
  QString affectedNodesStr() const { return affectedNodesToStr(_affectedNodes); }
 
  int history() const { return _history; }
 
  int ruleSet() const { return _ruleSet; }
 
  int pack() const { return _pack; }
 
  const GmBcTagInfo* tagInfo() const { return _tagInfo; }
 
  char format() const { return _format; }
 
  int fieldWidth() const { return _fieldWidth; }
 
  int  precision() const { return _precision; }
 
  QString formatStr() const;
 
  const QMap<QString, double>& constantMap() const { return _constantMap; }
 
  void setKind(GmValueSetKind kind) { _setKind = kind; }
 
  void setUnit(Unit unit) { _unit = unit; }
 
  void setStorageType(GmStorageType storageType) { _storageType = storageType; }
 
  void setDimType(GmDimType type, int nlin = 1, int ncol = 1);
 
  void setDefValue(const double* val);
  void setDefFunction(QString functionId);
 
  void setCanStoreFunctions(bool mode) { _canStoreFunction = mode;  }
 
  void setAllocMode(GmAllocMode mode) { _allocMode = mode; }
 
  void setAllocStrategy(GmAllocStrategy strategy) { _allocStrategy = strategy; }
 
  void setAffectedNodes(GmAffectedNodes affNodes) { assert(isNodeBased()); _affectedNodes = affNodes; }
 
  void setHistory(int mode) { _history = mode; }
 
  void setRuleSet(int ruleSet) { _ruleSet = ruleSet; }
 
  void setPack(int packId) { assert(packId >= -1);  _pack = packId; }
 
  void setTagInfo(GmBcTagInfo* info) { delete _tagInfo; _tagInfo = info; }
 
  void setFormat(int fieldWidth, char format, int precision)
  {
    _fieldWidth = fieldWidth;
    _format     = format;
    _precision  = precision;
  }
 
  void setConstantMap(const QMap<QString, double>& map) { assert(isScalar());  _constantMap = map; }
 
  void print(const GmLogCategory& logger, GmLogLevel level) const;
 
  static QString dataKindToStr     (GmValueSetKind kind);
  static QString storageTypeToStr  (GmStorageType type);
  static QString dimTypeToStr      (GmDimType type, int nlin = -1, int ncol = -1);
  static QString allocModeToStr    (GmAllocMode mode);
  static QString allocStrategyToStr(GmAllocStrategy strategy);
  static QString affectedNodesToStr(GmAffectedNodes affNodes);
 
  static GmValueInfo*        loadFromTable    (LuaTable& tab, GmValueSetKind kind);
  static QList<GmValueInfo*> loadFromTableList(LuaTable& tab, GmValueSetKind kind);
 
private:
  GmValueInfo& operator=(const GmValueInfo &);
 
  QString         _id;            
  QString         _description;   
  Unit            _unit;          
  GmValueSetKind  _setKind;       
  GmStorageType   _storageType;   
  GmDimType       _dimType;       
  GmAllocMode     _allocMode;     
  GmAllocStrategy _allocStrategy; 
  GmAffectedNodes _affectedNodes; 
 
  double*      _defValue;         
  QString      _defFunction;      
  int          _nlin;             
  int          _ncol;             
  bool         _canStoreFunction; 
  int          _history;          
  int          _ruleSet;          
  int          _pack;             
  GmBcTagInfo* _tagInfo;          
  int          _fieldWidth;       
  char         _format;           
  int          _precision;        
 
  QMap<QString, double> _constantMap;  
};
 
#endif