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