xfemGaussAccessor.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_XFEM_GAUSS_ACCESSOR_H_
#define _GEMA_XFEM_GAUSS_ACCESSOR_H_
 
#include <gmGaussAccessor.h>
 
class XfemMGaussValueSet;
 
#include "xfemElement.h"
#include "xfemGaussValueSet.h"
 
class XfemGaussAccessor : public QObject, public GmGaussAccessor
{
  Q_OBJECT
 
public:
 
  XfemGaussAccessor(GmValueAccessor* ac, XfemGaussValueSet* gvs, int snum)
    : GmGaussAccessor(ac, gvs) 
  {
    assert(!ac->info()->canStoreFunctions()); // Functions are not supported in this particular implementation
    assert(snum >= 0 && snum < gvs->numSets());
    _snum = snum;
    _si   = gvs->stateIndex(snum);
  }
 
  virtual int numPoints(const GmCell* c) const 
  { 
    const XfemElement* e = dynamic_cast<const XfemElement*>(c);
    assert(e);
    if(!e->enriched())
      return GmGaussAccessor::numPoints(c);
    else
      return ((XfemGaussValueSet*)_gvs)->numEnrichedPoints(c->cellId());
  }
 
  // Wrapped functions.  For descriptions, see GmValueAccessor documentation
  virtual const double* valueAt(const GmCell* c, int ip, const GmVector* coord) const
  {
    const XfemElement* e = saveElemInContext(c, ip);
    if(!e->enriched())
      return _ac->valueAt(queryIndex(c, ip), coord);
    else
      return convertToAccessorUnit(((XfemGaussValueSet*)_gvs)->dataPointer(e, ip, _si));
  }
 
  virtual double scalarValueAt(const GmCell* c, int ip, const GmVector* coord) const
  {
    const XfemElement* e = saveElemInContext(c, ip);
    if(!e->enriched())
      return _ac->scalarValueAt(queryIndex(c, ip), coord);
    else
      return convertToAccessorUnit(*((XfemGaussValueSet*)_gvs)->dataPointer(e, ip, _si));
  }
 
  virtual void matrixValueAt(const GmCell* c, int ip, const GmVector* coord, GmCRMatrix& mat) const
  {
    mat.setMemory(valueAt(c, ip, coord), _ac->info()->nlin(), _ac->info()->ncol());
  }
 
  virtual void vectorValueAt(const GmCell* c, int ip, const GmVector* coord, GmCRVector& vec) const
  {
    vec.setMemory(valueAt(c, ip, coord), _ac->info()->size());
  }
 
  virtual bool setValue(const GmCell* c, int ip, const double* value) 
  { 
    const XfemElement* e = dynamic_cast<const XfemElement*>(c);
    assert(e);
    if(!e->enriched())
      return _ac->setValue(queryIndex(c, ip), value);
    else
      return convertFromAccessorUnit(value, ((XfemGaussValueSet*)_gvs)->dataPointer(e, ip, _si)), true;
  }
 
  virtual bool setScalarValue(const GmCell* c, int ip, double value) 
  { 
    const XfemElement* e = dynamic_cast<const XfemElement*>(c);
    assert(e);
    if(!e->enriched())
      return _ac->setScalarValue(queryIndex(c, ip), value);
    else
      return convertFromAccessorUnit(value, ((XfemGaussValueSet*)_gvs)->dataPointer(e, ip, _si)), true;
  }
 
  virtual bool setScalarValueAtDim(const GmCell* c, int ip, int dim, double value)
  {
    const XfemElement* e = dynamic_cast<const XfemElement*>(c);
    assert(e);
    if(!e->enriched())
      return _ac->setScalarValueAtDim(queryIndex(c, ip), dim, value);
    else
    {
      int n = valueSize();
      assert(dim >= 0 && dim < n);
      QVarLengthArray<double, 128> data(n); // If size < 128, allocated on the stack
      memcpy(data.data(), valueAt(c, ip, NULL), n * sizeof(double));
      data[dim] = value;
      return setValue(c, ip, data.data());
    }
  }
 
  virtual bool setValueAsDef(const GmCell* c, int ip)
  {
    const XfemElement* e = dynamic_cast<const XfemElement*>(c);
    assert(e);
    if(!e->enriched())
      return _ac->setValueAsDef(queryIndex(c, ip));
    else
      return memcpy(((XfemGaussValueSet*)_gvs)->dataPointer(e, ip, _si), info()->defValue(), info()->size() * sizeof(double)), true;
  }
 
  virtual bool setFunctionValue(const GmCell* c, int ip, GmUserFunction* functionDef)           { Q_UNUSED(c); Q_UNUSED(ip); Q_UNUSED(functionDef);  return false; }
  virtual bool setFunctionValue(const GmCell* c, int ip, GmUserFunctionEvaluator* functionEval) { Q_UNUSED(c); Q_UNUSED(ip); Q_UNUSED(functionEval); return false; }
 
  virtual QString valueStr(const GmCell* c, int ip, bool evalFunctions, bool printDefAsNil,
                           int fieldWidth = 0, char format = 'g', int precision = -1, const GmVector* coord = NULL) const;
 
  virtual bool setFunctionFromName(const GmCell* c, int ip, QString userFunctionId, QString& err)
  {
    Q_UNUSED(c); Q_UNUSED(ip); Q_UNUSED(userFunctionId);
    err = QObject::tr("Function values are currently unsuported by Xfem Gauss accessors.");
    return false;
  }
 
  virtual bool setValueFromVariant(const GmCell* c, int ip, const QVariant& v, bool acceptMissingDimension, QString& err);
 
  virtual bool isDefValue(const GmCell* c, int ip) const 
  { 
    const XfemElement* e = dynamic_cast<const XfemElement*>(c);
    assert(e);
    if(!e->enriched())
      return _ac->isDefValue(queryIndex(c, ip));
    else
      return !memcmp(((XfemGaussValueSet*)_gvs)->dataPointer(e, ip, _si), info()->defValue(), info()->size() * sizeof(double));
  }
  
  virtual bool    isFunction(const GmCell* c, int ip) const { Q_UNUSED(c); Q_UNUSED(ip); return false; }
  virtual QString functionId(const GmCell* c, int ip) const { Q_UNUSED(c); Q_UNUSED(ip); return ""; }
 
private slots :
  void setDataChanged(const GmValueSet* mvs) 
  { 
    const XfemGaussValueSet* gvs = dynamic_cast<const XfemGaussValueSet*>(mvs);
    assert(gvs);
    _si = gvs->stateIndex(_snum); 
  }
 
private:
  const XfemElement* saveElemInContext(const GmCell* c, int ip) const
  {
    const XfemElement* e = dynamic_cast<const XfemElement*>(c);
    assert(e);
    saveCellInContext(c, ip);
    return e;
  }
 
  int _snum; 
  int _si;   
};
 
#endif