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 <QString>
#include <unit.h>

class GmMesh;
class GmSimulationData;
class GmLogCategory;

class GmValueAccessor;
class GmCellAccessor;
class GmGaussAccessor;

class GmPhysicsUserFunctions;
class GmPluginObjectFactory;

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)
      : _src(src), _unit(u), _dim(dim), _history(history), _interpType(interpType), _interpParam(interpParam) {}

    QString _src;     
    Unit    _unit;    
    int     _dim;     
    int     _history; 
    GmInterpolatorType _interpType;  
    QVariant           _interpParam; 
  };

  GmUserFunction(QString id, GmUserFunctionType type);
  ~GmUserFunction();

  QString id() const { return _id; }

  GmUserFunctionType type() const { return _type; }

  const QList<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());

  void setLuaMethod(int tid, LuaFunction* func);
  void setCMethod  (QString pluginName, QString methodName, GmPluginObjectFactory* factory);

private:

  QString                        _id;           
  GmUserFunctionType             _type;         
  QList<GmUserFunctionParameter> _parameters;   
  GmTLS<LuaFunction*>*           _luaFunction;  
  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,       
    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;  

  class ParamContext
  {
  public:
    ParamContext();
    ~ParamContext();

    void setContext(ParamContextType type, void* ac, int size, int dim, bool nodeBased, 
                    GmInterpolatorType interpType, QVariant interpParam, Unit timeUnit);

    void evalParameter(int index, const GmVector* coord, int ip, const GmValueAccessor* coordAccessor, 
                       const GmSimulationData* simData, const GmMesh* mesh, 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, 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; 
  };

  ParamContext* _parInfo;   
  int           _ipRuleSet; 

  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