gmUserFunction.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_USER_FUNCTION_H_
#define _GEMA_USER_FUNCTION_H_
 
#include "gmCoreConfig.h"
#include "gmValueInfo.h"
#include "gmCell.h"
#include "gmInterpolator.h"
#include "gmThreadLocalBuffer.h"
#include "gmAggregator.h"
 
#include <QString>
#include <unit.h>
 
class GmMesh;
class GmSimulationData;
class GmLogCategory;
 
class GmValueAccessor;
class GmCellAccessor;
class GmGaussAccessor;
 
class GmPhysicsUserFunctions;
class GmPluginObjectFactory;
 
class GmDiscontinuitySet;
 
class LuaFunction;
class LuaEnv;
 
enum GmUserFunctionType
{
  GM_NODE_USER_FUNCTION,  
  GM_CELL_USER_FUNCTION,  
};
 
class GmUserFunctionContext;
 
typedef bool (GmPhysicsUserFunctions::*GmCUserMethod)(const GmUserFunctionContext* context, double* out);
 
class GMC_API_EXPORT GmUserFunction
{
public:
 
  struct GmUserFunctionParameter
  {
    GmUserFunctionParameter() : _dim(-1), _history(0) {}
 
    GmUserFunctionParameter(QString src, Unit u, int dim, int history, GmInterpolatorType interpType, QVariant interpParam, GmAggregationType aggType)
      : _src(src), _unit(u), _dim(dim), _history(history), _interpType(interpType), _interpParam(interpParam), _aggType(aggType) {}
 
    QString _src;     
    Unit    _unit;    
    int     _dim;     
    int     _history; 
    GmInterpolatorType _interpType;  
    QVariant           _interpParam; 
    GmAggregationType _aggType; 
  };
 
  GmUserFunction(QString id, GmUserFunctionType type, QString dsName);
  ~GmUserFunction();
 
  QString id() const { return _id; }
 
  GmUserFunctionType type() const { return _type; }
 
  QString discSetName()  const { return _dsName; }
 
  const GmDiscontinuitySet* discSet() const { return _discSet; }
 
  const QVector<GmUserFunctionParameter>& parameterList() const { return _parameters; }
 
  bool isCFunction() const { return _cFuncFactory; }
 
  LuaFunction* luaFunction() const { return _luaFunction ? _luaFunction->localData() : NULL; }
 
  QString cFunctionName() const { return _cFuncName; }
 
  QString cFunctionPlugin() const { return _cFuncPlugin; }
 
  GmPluginObjectFactory* cFunctionFactory() const { return _cFuncFactory; }
 
  void addParameter(QString src, Unit unit, int dim = -1, int history = -1,
                    GmInterpolatorType interpType = GM_NO_INTERPOLATOR, QVariant interpParam = QVariant(), GmAggregationType aggType = GM_NO_AGGREGATION);
 
  void setLuaMethod(int tid, LuaFunction* func);
  void setCMethod  (QString pluginName, QString methodName, GmPluginObjectFactory* factory);
  void setDiscSet(GmDiscontinuitySet* discSet);
 
private:
 
  QString                        _id;           
  GmUserFunctionType             _type;         
  QVector<GmUserFunctionParameter> _parameters;   
  GmTLS<LuaFunction*>*           _luaFunction;  
  QString                        _dsName;  //DiscontinuitySet name
  GmDiscontinuitySet*            _discSet;
  QString                        _cFuncName;    
  QString                        _cFuncPlugin;  
  GmPluginObjectFactory*         _cFuncFactory; 
};
 
class GmUserFunctionEvaluator
{
public:
  GmUserFunctionEvaluator(const GmUserFunction* ufInfo);
  ~GmUserFunctionEvaluator();
 
  bool setEvaluationContext(const GmValueInfo* resultInfo, GmSimulationData* simData, 
                            const GmMesh* mesh, const GmLogCategory& logger, QString& err);
 
  const double* eval(int index, const GmVector* coord, int ip, QString& err) const;
 
  const GmUserFunction* userFunction() const { return _functionInfo; }
 
private:
 
  enum ParamContextType
  {
    VALUE_AC_PARAM,      
    CELL_AC_PARAM,       
    GAUSS_AC_PARAM,      
    IPOINT_PARAM,        
    NIPOINT_PARAM,       
    ID_PARAM,            
    MESH_ID_PARAM,       
    CELL_TYPE_PARAM,     
    CURRENT_TIME_PARAM,  
    DELTA_TIME_PARAM,    
  };
  
  const double* callFunction(int index, const GmVector* coord, int npars, LuaEnv* env, QString& err) const;
 
  bool loadCFunction(GmSimulationData* simData, const GmMesh* mesh, QString& err);
  bool parseParameterType(QString parName, ParamContextType* parType, GmValueInfo** info, QString& err);
 
  bool acceptsInterpolatorType(const GmCell* c, GmInterpolatorType type) const;
 
  friend class GmUserFunctionContext; // Allows the function context to access the parameter buffer and metadata
 
  const GmSimulationData* _simData;        
  const GmUserFunction*   _functionInfo;   
  const GmValueInfo*      _resultInfo;     
  const GmMesh*           _mesh;           
  const GmValueAccessor*  _coordAccessor;  
  bool                    _evalNeedsCoord; 
  bool                    _warnOnInvalidIndex;  
  bool                    _isAggregationOnly; 
 
  class ParamContext
  {
  public:
    ParamContext();
    ~ParamContext();
 
    void setContext(ParamContextType type, void* ac, int size, int dim, bool nodeBased, 
                    GmInterpolatorType interpType, QVariant interpParam, GmAggregationType aggType, Unit timeUnit);
 
    void evalParameter(int index, const GmVector* coord, int ip, const GmValueAccessor* coordAccessor, 
                       const GmSimulationData* simData, const GmMesh* mesh, const GmDiscontinuitySet* discSet,
                       double* result, bool warnOnInvalidIndex, QString& err) const;
 
    void pushParameter(int index, const GmVector* coord, int ip, const GmValueAccessor* coordAccessor, 
                       const GmSimulationData* simData, const GmMesh* mesh, const GmDiscontinuitySet* discSet,
                       LuaEnv* env, bool warnOnInvalidIndex, QString& err) const;
 
    GmValueInfo* info() const;
 
    ParamContextType   _type;        
    void*              _accessor;    
    int                _dim;         
    int                _size;        
    bool               _nodeBased;   
    Unit               _timeUnit;    
    GmInterpolatorType _interpType;  
    QVariant           _interpParam; 
    GmAggregationType  _aggType;     
  };
 
  ParamContext* _parInfo;   
  int           _ipRuleSet; 
  int           _evalProgressItem; 
 
  GmPhysicsUserFunctions*          _cObj;     
  GmCUserMethod                    _cMethod;  
  GmTLS<GmUserFunctionContext*>*   _cContext; 
 
  GmTLS<double**>*                 _input;    
  mutable GmTLBuffer<double, true> _result;   
};
 
class GmUserFunctionContext
{
public:
  int id() const { return _id; }
 
  const GmMesh* mesh() const { return _eval->_mesh; }
 
  const GmVector* coord() const { return _coord; }
 
  const GmUserFunction* functionInfo() const { return _eval->_functionInfo; }
 
  const GmValueInfo* resultInfo() const { return _eval->_resultInfo; }
 
  int resultSize() const { return _eval->_resultInfo->size(); }
 
  int numPars() const { return _eval->_functionInfo->parameterList().size(); }
 
  const double* par(int i) const { assert(i >= 0 && i < numPars());  return _eval->_input->localData()[i]; }
 
  double scalarPar(int i) const { assert(i >= 0 && i < numPars());  return *_eval->_input->localData()[i]; }
 
  int parSize(int i) const { assert(i >= 0 && i < numPars());  return _eval->_parInfo[i]._size; }
 
private:
  friend class GmUserFunctionEvaluator;  
 
  GmUserFunctionContext(GmUserFunctionEvaluator* eval) : _eval(eval) {}
 
  void setId(int index) { _id = index; }
  
  void setCoord(const GmVector* coord) { _coord = coord; }
 
  int                      _id;    
  const GmVector*          _coord; 
  GmUserFunctionEvaluator* _eval;  
};
 
 
#endif