gmGhostNodeAccessor.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_GHOSTNODE_ACCESSOR_H_
#define _GEMA_GHOSTNODE_ACCESSOR_H_

#include "gmMesh.h"
#include "gmValueAccessor.h"
#include "gmValueSetEvalContext.h"

class GmGhostNodeAccessor : public GmValueAccessor
{
public:
  GmGhostNodeAccessor(GmValueAccessor* commonAc, GmValueAccessor* ghostAc)
  {
    assert(ghostAc);
    _cAc = commonAc;
    _gAc = ghostAc;

    // Mark in the evaluation context that this is an accessor to the ghost part of the data
    if(_gAc->evalContext())
      _gAc->evalContext()->setGhostData(true);
  }

  virtual ~GmGhostNodeAccessor() 
  {
    delete _cAc;
    delete _gAc;
  }

  // See comments on the base class
  virtual int size() const { return _gAc->size() + (_cAc ? _cAc->size() : 0); }

  int nodeSize() const { return _cAc ? _cAc->size() : 0; }

  int ghostSize() const { return _gAc->size(); }

  // See comments on the base class
  virtual int adjustLinearIndex(int index, const GmMesh* m)
  { 
    if(!_cAc)
      index = m->toLocalGhostIndex(index);
    return (index >= 0 && index < size()) ? index : -1; 
  }

  // See comments on the base class
  virtual int adjustLinearIndex(int index, int firstGhostIndex)
  {
    if(!_cAc)
      index -= firstGhostIndex;
    return (index >= 0 && index < size()) ? index : -1;
  }

  // See comments on the base class
  virtual GmValueInfo* info() const { return _gAc->info(); }

  // See comments on the base class
  virtual bool isDefValue(int index) const { return t(&index)->isDefValue(index); }

  // See comments on the base class
  virtual Unit unit() const { return _gAc->unit(); }

  // See comments on the base class
  virtual bool hasUnitConversion() const { return _gAc->hasUnitConversion(); }

  // See comments on the base class
  virtual const double* valueAt(int index, const GmVector* coord) const { return t(&index)->valueAt(index, coord); }

  // See comments on the base class
  virtual double scalarValueAt(int index, const GmVector* coord) const { return t(&index)->scalarValueAt(index, coord); }

  // See comments on the base class
  virtual bool setValue(int index, const double* value) { return t(&index)->setValue(index, value); }

  // See comments on the base class
  virtual bool setScalarValue(int index, double value) { return t(&index)->setScalarValue(index, value); }

  // See comments on the base class
  virtual bool setValueAsDef(int index) { return t(&index)->setValueAsDef(index); }

  // See comments on the base class
  virtual bool setFunctionValue(int index, GmUserFunction* functionDef) { return t(&index)->setFunctionValue(index, functionDef); }

  // See comments on the base class
  virtual bool setFunctionValue(int index, GmUserFunctionEvaluator* functionEval) { return t(&index)->setFunctionValue(index, functionEval); }

  // See comments on the base class
  virtual QString valueStr(int index, bool evalFunctions, bool printDefAsNil,
                           int fieldWidth = 0, char format = 'g', int precision = -1,
                           const GmVector* coord = NULL) const 
  {
    return t(&index)->valueStr(index, evalFunctions, printDefAsNil, fieldWidth, format, precision, coord);
  }

  // See comments on the base class
  virtual bool setFunctionFromName(int index, QString userFunctionId, QString& err) { return t(&index)->setFunctionFromName(index, userFunctionId, err); }

  // See comments on the base class
  virtual bool setValueFromVariant(int index, const QVariant& v, bool acceptMissingDimension, QString& err) { return t(&index)->setValueFromVariant(index, v, acceptMissingDimension, err); }

  // See comments on the base class
  virtual bool isFunction(int index) const { return t(&index)->isFunction(index); }

  // See comments on the base class
  virtual QString functionId(int index) const { return t(&index)->functionId(index); }

  // See comments on the base class
  virtual void setEvalContext(GmValueSetEvalContext* context, bool ownsContext) 
  { 
    // From the current accessor work flow, this function should be never called
    // for a ghost accessor (it is called for the base accessors stored on _cAc and _gAc).
    // If this changes in the future, the implementation must be sure to add different
    // contexts to the _cAC and _gAc accessors since the ghost offset should be 
    // different from zero in _gAc only. To do this, we will probably need to change
    // the function signature to include a mesh parameter (?!? - unchecked)
    assert(0); Q_UNUSED(context); Q_UNUSED(ownsContext);

    //if(_cAc)
    //  _cAc->setEvalContext(context, false);
    //_gAc->setEvalContext(context, ownsContext);
  }

  // See comments on the base class
  virtual GmValueSetEvalContext* evalContext() const 
  { 
    // Which context should we return? When _cAc exists, its context is different 
    // from _gAc context. In the current workflow, this function is never called
    // for a ghost accessor. If this ever changes we must decide what to do!
    // See also the coments on the setEvalContext() implementation.
    assert(0);  
    return NULL;
    //return _gAc->evalContext(); 
  }

protected:

  // See comments on the base class
  virtual double convertToAccessorUnit(double val) const { return _gAc->convertToAccessorUnit(val); }

  // See comments on the base class
  virtual const double* convertToAccessorUnit(const double* p) const { return _gAc->convertToAccessorUnit(p); }

  // See comments on the base class
  virtual void convertFromAccessorUnit(double val, double* dst) const { return _gAc->convertFromAccessorUnit(val, dst); }

  // See comments on the base class
  virtual void convertFromAccessorUnit(const double* val, double* dst) const { return _gAc->convertFromAccessorUnit(val, dst); }

private:
  const GmValueAccessor* t(int* index) const
  {
    if(!_cAc || GmMesh::isGhostNode(*index))
    {
      *index = GmMesh::clearGhostFlag(*index);
      return _gAc;
    }
    return (*index < _cAc->size()) ? _cAc : (*index -= _cAc->size(), _gAc);
  }

  GmValueAccessor* t(int* index)
  {
    if(!_cAc || GmMesh::isGhostNode(*index))
    {
      *index = GmMesh::clearGhostFlag(*index);
      return _gAc;
    }
    return (*index < _cAc->size()) ? _cAc : (*index -= _cAc->size(), _gAc);
  }

  friend class GmStateDump; // State dump interface needs to get the base value accessor

  GmValueAccessor* _cAc;  
  GmValueAccessor* _gAc;  
};




#endif