gmValueAccessor.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_ACCESSOR_H_
#define _GEMA_VALUE_ACCESSOR_H_
 
#include "gmCoreConfig.h"
#include "gmValueInfo.h"
#include "gmMatrix.h"
#include "gmVector.h"
 
#include "gmThreadLocalBuffer.h"
 
class GmValueSetEvalContext;
class GmLogCategory;
 
class Unit;
class UnitConverter;
 
class GmUserFunction;
class GmUserFunctionEvaluator;
 
class QVariant;
 
class GmMesh;
 
class GMC_API_EXPORT GmValueAccessor
{
public:
  virtual ~GmValueAccessor() {}
 
  virtual int size() const = 0;
 
  virtual GmValueInfo* info() const = 0;
 
  bool isScalar() const { return info()->isScalar(); }
 
  virtual bool isDefValue(int index) const = 0;
 
  virtual const double* defValue() const { return convertToAccessorUnit(info()->defValue()); }
 
  virtual Unit unit() const = 0;
 
  virtual bool hasUnitConversion() const = 0;
 
  int valueSize() const { return info()->size(); }
 
  virtual int adjustLinearIndex(int index, const GmMesh* m) { Q_UNUSED(m); return (index < size()) ? index : -1; }
 
  virtual int adjustLinearIndex(int index, int firstGhostIndex) { 
          Q_UNUSED(firstGhostIndex); return (index < size()) ? index : -1; 
  }
 
  virtual const double* valueAt(int index, const GmVector* coord) const = 0;
 
  const double* value(int index) const { return valueAt(index, NULL); }
 
  virtual double scalarValueAt(int index, const GmVector* coord) const = 0;
 
  double scalarValue(int index) const { return scalarValueAt(index, NULL); }
 
  void matrixValueAt(int index, const GmVector* coord, GmCRMatrix& mat) const
  {
    mat.setMemory(valueAt(index, coord), info()->nlin(), info()->ncol());
  }
 
  void matrixValue(int index, GmCRMatrix& mat) const { matrixValueAt(index, NULL, mat); }
 
  void vectorValueAt(int index, const GmVector* coord, GmCRVector& vec) const
  {
    vec.setMemory(valueAt(index, coord), info()->size());
  }
 
  void vectorValue(int index, GmCRVector& vec) const { vectorValueAt(index, NULL, vec); }
 
  virtual bool setValue(int index, const double* value) = 0;
 
  virtual bool setScalarValue(int index, double value) = 0;
 
  virtual bool setScalarValueAtDim(int index, int dim, double val)
  {
    int n = valueSize();
    assert(dim >= 0 && dim < n);
    QVarLengthArray<double, 128> data(n); // If size < 128, allocated on the stack
    memcpy(data.data(), value(index), n * sizeof(double));
    data[dim] = val;
    return setValue(index, data.data());
  }
 
  virtual bool setValueAsDef(int index) = 0;
 
  bool setMatrixValue(int index, const GmMatrix& mat)
  {
    assert(info()->dimType() == GM_MATRIX_VALUE && info()->nlin() == (int)mat.n_rows && info()->ncol() == (int)mat.n_cols);
    return setValue(index, mat.memptr());
  }
 
  bool setVectorValue(int index, const GmVector& vec)
  {
    assert(info()->dimType() != GM_MATRIX_VALUE && info()->nlin() == (int)vec.n_rows);
    return setValue(index, vec.memptr());
  }
 
  bool addScalarToValue(int index, double value)
  {
    return setScalarValue(index, scalarValue(index) + value);
  }
 
  bool addToValue(int index, const double* val)
  {
    int n = valueSize();
    QVarLengthArray<double, 128> data(n); // If size < 128, allocated on the stack
    const double* v = value(index);
    for(int i = 0; i<n; i++)
      data[i] = v[i] + val[i];
    return setValue(index, data.data());
  }
  
  virtual bool setFunctionValue(int index, GmUserFunction* functionDef) = 0;
 
  virtual bool setFunctionValue(int index, GmUserFunctionEvaluator* functionEval) = 0;
 
  virtual QString valueStr(int index, bool evalFunctions, bool printDefAsNil,
                           int fieldWidth = 0, char format = 'g', int precision = -1,
                           const GmVector* coord = NULL) const = 0;
 
  virtual bool setFunctionFromName(int index, QString userFunctionId, QString& err) = 0;
  
  virtual bool setValueFromVariant(int index, const QVariant& v, bool acceptMissingDimension, QString& err) = 0;
 
  virtual bool isFunction(int index) const = 0;
 
  virtual QString functionId(int index) const = 0;
 
  virtual void setEvalContext(GmValueSetEvalContext* context, bool ownsContext) = 0;
 
  virtual GmValueSetEvalContext* evalContext() const = 0;
 
protected:
 
  virtual double convertToAccessorUnit(double val) const = 0;
 
  virtual const double* convertToAccessorUnit(const double* p) const = 0;
 
  virtual void convertFromAccessorUnit(double val, double* dst) const = 0;
 
  virtual void convertFromAccessorUnit(const double* val, double* dst) const = 0;
 
  friend class GmAccessorProxy;     // GmAccessorProxy & GmGhostNodeAccessor needs access to unit
  friend class GmGhostNodeAccessor; // conversion functions and those methods should not be general public ones...
};
 
 
class GMC_API_EXPORT GmValueAccessorBase : public GmValueAccessor
{
public:
  GmValueAccessorBase(GmValueInfo* info, const GmLogCategory& logger, UnitConverter* conv, QString desiredUnit);
 
  virtual ~GmValueAccessorBase();
 
  // See comments on the base class
  virtual GmValueInfo* info() const { return _info; }
 
  // See comments on the base class
  virtual Unit unit() const { return Unit(_unit); }
 
  // See comments on the base class
  virtual bool hasUnitConversion() const { return _conv; }
 
  virtual QString valueStr(int index, bool evalFunctions, bool printDefAsNil,
                           int fieldWidth = 0, char format = 'g', int precision = -1,
                           const GmVector* coord = NULL) const;
 
  virtual bool setFunctionFromName(int index, QString userFunctionId, QString& err);
  virtual bool setValueFromVariant(int index, const QVariant& v, bool acceptMissingDimension, QString& err);
 
  virtual void setEvalContext(GmValueSetEvalContext* context, bool ownsContext);
  virtual GmValueSetEvalContext* evalContext() const { return _evalContext; }
 
  static bool fillMatrixFromLuaTable(double* m, int nlin, int ncol, LuaTable& t, const GmValueInfo* info, const double* defVal, QString& err);
 
protected:
  friend class GmDiscontinuityAccessor; // Discontinuity Accessor needs access to tha AccessorBase logger
 
  const double* evalValue(GmUserFunctionEvaluator* functionEval, int index, const GmVector* coord) const;
  const double* evalValue(GmUserFunction* functionDef, int index, const GmVector* coord) const;
  const double* evalDefValue(int index, const GmVector* coord) const;
 
  virtual double        convertToAccessorUnit(double val) const;
  virtual const double* convertToAccessorUnit(const double* p) const;
  virtual void          convertFromAccessorUnit(double  val, double* dst) const;
  virtual void          convertFromAccessorUnit(const double* val, double* dst) const;
 
  double* convData() const { assert(_convData);  return _convData->localBuffer(); }
 
  GmValueInfo*         _info;      
  const GmLogCategory& _logger;    
 
  mutable GmTLBuffer<double, true>* _convData; 
 
  UnitConverter*       _conv;      
  UnitConverter*       _rconv;     
  QString              _unit;      
 
private:
  Q_DISABLE_COPY(GmValueAccessorBase)
 
  GmValueSetEvalContext* _evalContext;     
  bool                   _ownsEvalContext; 
};
 
#endif