gmAcResultsDataSrc.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_AC_RESULTS_DATASRC_H_
#define _GEMA_AC_RESULTS_DATASRC_H_
 
#include "gmResultsDataSrcInfo.h"
 
#include "gmInterpolator.h"
#include "gmValueAccessor.h"
#include "gmCellAccessor.h"
#include "gmGaussAccessor.h"
 
#include <luaFunction.h>
#include <unitConverter.h>
 
 
class GMC_API_EXPORT GmAcResultsDataSrcBase : public GmResultsDataSrcInfo
{
public:
 
  GmAcResultsDataSrcBase()
    : _trackId(-1), _dim(-1), _history(0), _interpType(GM_DEFAULT_INTERPOLATOR),
      _nResLin(0), _nResCol(0), _interp(NULL), _subset(GmInterpolatorSubset::GM_SUBSET_ALL), _acceptDiscontinuitySet(false) {}
 
  virtual GmAcResultsDataSrcBase::~GmAcResultsDataSrcBase() { delete _interp; }
 
  // Comments on the base class
  virtual int monitorTrackId() const { return _trackId; }
 
  // Comments on the base class
  virtual void setMonitorTrackId(int id) { _trackId = id; }
 
  // Returns the accessor id
  virtual QString id() const = 0;
 
  // Comments on the base class
  virtual QString alias() const { return _alias; }
 
  // Comments on the base class
  virtual QString formatStr() const { return _formatStr; }
 
  virtual bool isScalar() const = 0;
 
  virtual int dimSize() const = 0;
 
  int history() const { return _history; }
 
  int dimFilter() const { return _dim; }
 
  GmInterpolator* interp() const { return _interp; }
 
  bool hasTransformationFunction() const { return _tFunc.isValid(); }
 
  GmInterpolatorSubset subsetType() const { return _subset; }
 
  void setBasicData(int dim, const QString& alias, int history,
                    GmInterpolatorType interpType, const QVariant& interpParam, GmInterpolatorSubset subset)
  {
    _dim         = dim;
    _alias       = alias;
    _history     = history;
    _interpType  = interpType;
    _interpParam = interpParam;
        _subset      = subset;
  }
 
  void setFormatStr(const QString& formatStr) { _formatStr = formatStr; }
 
  void setTransformationFunction(LuaFunction& tfunc, int nresLin, int nresCol)
  {
    _tFunc = tfunc;
    _tFunc.makeRef();  // Ensure that tFunc stores a function reference and not a stack index
    _nResLin = nresLin;
    _nResCol = nresCol;
  }
 
  void setInterpolator(GmInterpolator* interp) 
  { 
      delete _interp; _acceptDiscontinuitySet = false;
 
      _interp = interp;
      if (_interp) {
          int itype = _interp->interpolatorObject()->type();
          //DiscSet aware interpolation is not valid for shape interp
          _acceptDiscontinuitySet = (itype != GM_SHAPE_INTERPOLATOR && itype != GM_LSHAPE_INTERPOLATOR);
      }
  }
 
  bool interpAcceptDiscSet() const { return _acceptDiscontinuitySet; }
 
protected:
  friend class GmResultsDataSet; // Give full acces to the results data set class
 
  Q_DISABLE_COPY(GmAcResultsDataSrcBase);
 
  GmAcResultsDataSrcBase(const GmAcResultsDataSrcBase* ptr)
  {
    _interpType  = GM_DEFAULT_INTERPOLATOR;
    _interp      = NULL;
    _interpParam = QVariant();
    _acceptDiscontinuitySet = false;
 
    _trackId   = ptr->_trackId;
    _alias     = ptr->_alias;
    _dim       = ptr->_dim;
    _formatStr = ptr->_formatStr;
    _history   = ptr->_history;
    _tFunc     = ptr->_tFunc;   
    _nResLin   = ptr->_nResLin;
    _nResCol   = ptr->_nResCol;
    _subset    = ptr->_subset;
  }
 
  int                _trackId;     
  QString            _alias;       
  int                _dim;         
  QString            _formatStr;   
  int                _history;     
  GmInterpolatorType _interpType;  
  QVariant           _interpParam; 
  LuaFunction        _tFunc;       
  int                _nResLin;     
  int                _nResCol;     
  GmInterpolatorSubset _subset;    
private:
  GmInterpolator*    _interp;      
  bool _acceptDiscontinuitySet;    
};
 
template <class T>
class GMC_API_EXPORT GmAcResultsDataSrc : public GmAcResultsDataSrcBase
{
public:
  // The stored accessr type
  typedef T AcType;
 
  GmAcResultsDataSrc(T* ac) : GmAcResultsDataSrcBase() { assert(ac); _ac = ac; _ownership = true; }
 
  virtual ~GmAcResultsDataSrc() { if(_ownership) delete _ac; }
 
  // Comments on the base class
  virtual QString id() const { return _ac->info()->id(); }
 
  // Comments on the base class
  virtual QString description() const { return _ac->info()->description(); }
 
  // Comments on the base class
  virtual Unit unit() const { return _ac->unit(); }
 
  // Comments on the base class
  virtual bool isScalar() const { return _dim >= 0 || _ac->isScalar(); }
 
  // Comments on the base class
  virtual int dimSize() const { return _dim == -1 ? _ac->valueSize() : 1; }
 
  // Comments on the base class
  virtual int size() const { return _tFunc.isValid() ? _nResLin * _nResCol : dimSize(); }
 
  // Comments on the base class
  virtual int nlin() const { return _tFunc.isValid() ? _nResLin : (_dim == -1 ? _ac->info()->nlin() : 1); }
 
  // Comments on the base class
  virtual int ncol() const { return _tFunc.isValid() ? _nResCol : (_dim == -1 ? _ac->info()->ncol() : 1); }
 
  T* ac() const { return _ac; }
 
  void setAc(T* newAc) { if(_ownership) delete _ac; _ac = newAc; _ownership = true; }
 
protected:
  
  template <class Result>
  QVector<Result*> dimSplit() 
  { 
    assert(!interp());
    assert(dynamic_cast<Result*>(this)); // Result should realy be the same type as this!!!
 
    QVector<Result*> list;
    list.append(dynamic_cast<Result*>(this)); 
 
    if(!isScalar())
    {
      for(int i = 1, ndim = _ac->valueSize(); i < ndim; i++)
      {
        Result* r = new Result(this);
        r->_dim = i;
        r->_alias = r->_alias + QString("_%1").arg(i+1);
        list.append(r);
      }
      _dim = 0;
      _alias = _alias + QString("_%1").arg(1); // Can't be done before the loop or the copy would already include the dimension suffix
    }
    return list;
  }
 
  GmAcResultsDataSrc(const GmAcResultsDataSrc<T>* ptr)
    : GmAcResultsDataSrcBase(ptr)
  {
    _ac        = ptr->_ac;
    _ownership = false;
  }
 
  T*   _ac;        
  bool _ownership; 
};
 
class GMC_API_EXPORT GmNodeAcResultsDataSrc : public GmAcResultsDataSrc<GmValueAccessor>
{
public:
  GmNodeAcResultsDataSrc(GmValueAccessor* ac) : GmAcResultsDataSrc<GmValueAccessor>(ac) {}
 
  // Comments on the base class
  virtual GmResultsDataSrcType type() const { return GM_RR_DS_NODEDATA; }
 
  QVector<GmNodeAcResultsDataSrc*> dimensionSplit() { return dimSplit<GmNodeAcResultsDataSrc>(); }
 
  GmNodeAcResultsDataSrc* cloneSameAcNoInterp() const { return new GmNodeAcResultsDataSrc(this); }
 
private:
  friend QVector<GmNodeAcResultsDataSrc*> GmAcResultsDataSrc<GmValueAccessor>::dimSplit();
 
  GmNodeAcResultsDataSrc(const GmAcResultsDataSrc<GmValueAccessor>* base) : GmAcResultsDataSrc<GmValueAccessor>(base) {};
};
 
class GMC_API_EXPORT GmCellAcResultsDataSrc : public GmAcResultsDataSrc<GmCellAccessor>
{
public:
  GmCellAcResultsDataSrc(GmCellAccessor* ac) : GmAcResultsDataSrc<GmCellAccessor>(ac) {}
 
  virtual GmResultsDataSrcType type() const { return GM_RR_DS_CELLDATA; }
 
  // Comments on the base class
  QVector<GmCellAcResultsDataSrc*> dimensionSplit() { return dimSplit<GmCellAcResultsDataSrc>(); }
 
  GmCellAcResultsDataSrc* cloneSameAcNoInterp() const { return new GmCellAcResultsDataSrc(this); }
 
private:
  friend QVector<GmCellAcResultsDataSrc*> GmAcResultsDataSrc<GmCellAccessor>::dimSplit();
 
  GmCellAcResultsDataSrc(const GmAcResultsDataSrc<GmCellAccessor>* base) : GmAcResultsDataSrc<GmCellAccessor>(base) {};
};
 
class GMC_API_EXPORT GmGaussAcResultsDataSrc : public GmAcResultsDataSrc<GmGaussAccessor>
{
public:
  GmGaussAcResultsDataSrc(GmGaussAccessor* ac) : GmAcResultsDataSrc<GmGaussAccessor>(ac) {}
 
  // Comments on the base class
  virtual GmResultsDataSrcType type() const { return GM_RR_DS_GAUSSDATA; }
 
  QVector<GmGaussAcResultsDataSrc*> dimensionSplit() { return dimSplit<GmGaussAcResultsDataSrc>(); }
 
  GmGaussAcResultsDataSrc* cloneSameAcNoInterp() const { return new GmGaussAcResultsDataSrc(this); }
 
private:
  friend QVector<GmGaussAcResultsDataSrc*> GmAcResultsDataSrc<GmGaussAccessor>::dimSplit();
 
  GmGaussAcResultsDataSrc(const GmAcResultsDataSrc<GmGaussAccessor>* base) : GmAcResultsDataSrc<GmGaussAccessor>(base) {};
};
 
#endif