gmDiscontinuityAccessor.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_DISCONTINUITY_ACCESSOR_H_
#define _GEMA_DISCONTINUITY_ACCESSOR_H_
 
#include "gmAccessorProxy.h"
 
#include "gmDiscontinuity.h"
#include "gmSegmentCellIntersection.h"
#include "gmSurfaceCellIntersection.h"
#include <unitConverter.h>
#include "gmDiscontinuitySet.h"
 
#include <assert.h>
 
 
class GMC_API_EXPORT GmDiscontinuityAccessor : public GmAccessorProxy
{
public:
  GmDiscontinuityAccessor(GmValueAccessor* ac) : GmAccessorProxy(ac) {}
 
  // Wrapped functions.  For descriptions, see GmValueAccessor documentation
  const double* value(const GmDiscontinuity* d) const
  { 
    return _ac->value(queryIndex(d));
  }
  
  double scalarValue(const GmDiscontinuity* d) const
  { 
    return _ac->scalarValue(queryIndex(d));
  }
 
  void matrixValue(const GmDiscontinuity* d, GmCRMatrix& mat) const
  {
    _ac->matrixValue(queryIndex(d), mat);
  }
 
  void vectorValue(const GmDiscontinuity* d, GmCRVector& vec) const
  {
    _ac->vectorValue(queryIndex(d), vec);
  }
 
  bool setValue           (const GmDiscontinuity* d, const double* value)                   { return _ac->setValue(queryIndex(d), value); }
  bool setScalarValue     (const GmDiscontinuity* d, double value)                          { return _ac->setScalarValue(queryIndex(d), value); }
  bool setScalarValueAtDim(const GmDiscontinuity* d, int dim, double value)                 { return _ac->setScalarValueAtDim(queryIndex(d), dim, value); }
  bool setValueAsDef      (const GmDiscontinuity* d)                                        { return _ac->setValueAsDef(queryIndex(d)); }
  bool setFunctionValue   (const GmDiscontinuity* d, GmUserFunction* functionDef)           { Q_UNUSED(d); Q_UNUSED(functionDef);  return logUserFunctionError(); }
  bool setFunctionValue   (const GmDiscontinuity* d, GmUserFunctionEvaluator* functionEval) { Q_UNUSED(d); Q_UNUSED(functionEval); return logUserFunctionError(); }
 
  QString valueStr(const GmDiscontinuity* d, bool evalFunctions, bool printDefAsNil,
                   int fieldWidth = 0, char format = 'g', int precision = -1) const
  {
    return _ac->valueStr(queryIndex(d), evalFunctions, printDefAsNil, fieldWidth, format, precision, NULL);
  }
 
  bool setFunctionFromName(const GmDiscontinuity* d, QString userFunctionId, QString& err)
  {
    Q_UNUSED(d); Q_UNUSED(userFunctionId);
    err = QObject::tr("Discontinuity accessor does not accept function values.");
    return false;
  }
 
  bool setValueFromVariant(const GmDiscontinuity* d, const QVariant& v, bool acceptMissingDimension, QString& err)
  {
    return _ac->setValueFromVariant(queryIndex(d), v, acceptMissingDimension, err);
  }
 
  bool    isDefValue(const GmDiscontinuity* d) const { return _ac->isDefValue(queryIndex(d)); }
  bool    isFunction(const GmDiscontinuity* d) const { return _ac->isFunction(queryIndex(d)); }
  QString functionId(const GmDiscontinuity* d) const { return _ac->functionId(queryIndex(d)); }
 
protected:
  bool logUserFunctionError()
  {
    // We can only log a message if the accessor is a GmValueAccessorBase instance
    GmValueAccessorBase* bac = dynamic_cast<GmValueAccessorBase*>(_ac);
    if(bac)
      gmWarnMsg(bac->_logger, QObject::tr("Discontinuity accessor does not accept function values."));
    return false;
  }
 
  virtual int queryIndex(const GmDiscontinuity* d) const = 0;
};
 
class GMC_API_EXPORT GmAttributeDiscontinuityAccessor : public GmDiscontinuityAccessor
{
public:
  GmAttributeDiscontinuityAccessor(GmValueAccessor* ac) : GmDiscontinuityAccessor(ac) {}
 
protected:
  virtual int queryIndex(const GmDiscontinuity* d) const { assert(d); return d->index(); }
};
 
class GMC_API_EXPORT GmPropertyDiscontinuityAccessor : public GmDiscontinuityAccessor
{
public:
  GmPropertyDiscontinuityAccessor(GmValueAccessor* ac, int psetIndex) : GmDiscontinuityAccessor(ac), _pset(psetIndex) {}
 
protected:
  virtual int queryIndex(const GmDiscontinuity* d) const { assert(d); return d->propertyIndex(_pset); }
 
private:
  int _pset; 
};
 
 
class GMC_API_EXPORT GmSegmentCell2DIntersectionCoordAccessor
{
public:
  GmSegmentCell2DIntersectionCoordAccessor(int dim, UnitConverter* conv, QString desiredUnit)
    : _dim(dim), _unit(desiredUnit), _conv(conv), _convData(NULL)
  {
    if(conv)
      _convData = new GmTLBuffer<double, true>(dim);
  }
 
  ~GmSegmentCell2DIntersectionCoordAccessor()
  {
    delete _conv;
    delete _convData;
  }
 
  Unit unit() const { return Unit(_unit); }
 
  bool hasUnitConversion() const { return _conv; }
 
  int valueSize() const { return _dim; }
 
  const double* value(const GmCompact2DSegmentCellIntersection* ci, int i) const
  {
    const double* p = ci->rawCartCoord(i);
    return _conv ? _conv->convertArray(p, _dim, _convData->localBuffer()) : p;
  }
 
  void vectorValue(const GmCompact2DSegmentCellIntersection* ci, int i, GmCRVector& vec) const
  {
    vec.setMemory(value(ci, i), valueSize());
  }
 
private:
  int                               _dim;      
  QString                           _unit;     
  UnitConverter*                    _conv;     
  mutable GmTLBuffer<double, true>* _convData; 
};
 
 
class GMC_API_EXPORT GmCell3DIntersectionCoordAccessor
{
public:
    GmCell3DIntersectionCoordAccessor(const GmDiscontinuitySet* ds, int size, UnitConverter* conv, QString desiredUnit)
        : _ds(ds), _size(size), _unit(desiredUnit), _conv(conv), _convData(NULL)
    {
        assert(ds);
        assert(size > 0);
        if (conv)
            _convData = new GmTLBuffer<double, true>(_size);
    }
 
    ~GmCell3DIntersectionCoordAccessor()
    {
        delete _conv;
        delete _convData;
    }
 
    Unit unit() const { return Unit(_unit); }
 
    bool hasUnitConversion() const { return _conv; }
 
    int valueSize() const { return _size; }
 
    const double* value(const Gm3DSurfaceCellIntersection* ci, int i) const
    {
                const double* p = _ds->consolidated3DPoints()[ci->pointId[i]].memptr();
        return _conv ? _conv->convertArray(p, _size, _convData->localBuffer()) : p;
    }
 
    void vectorValue(const Gm3DSurfaceCellIntersection* ci, int i, GmCRVector& vec) const
    {
        vec.setMemory(value(ci, i), valueSize());
    }
 
private:
        const GmDiscontinuitySet*           _ds;       
    int                               _size;     
    QString                           _unit;     
    UnitConverter* _conv;                        
    mutable GmTLBuffer<double, true>* _convData; 
};
 
 
 
#endif