gmpNodeMesh.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_PLUGIN_NODE_MESH_H_
#define _GEMA_PLUGIN_NODE_MESH_H_
 
#include <gmGhostNodeAccessor.h>
#include <gmLuaMesh.h>
#include <gmShapeOrthogonalPol.h>
#include <gmPCR.h>
#include <gmSimulationData.h>
#include <gmModelData.h>
 
#include "gmpNodeMeshData.h"
#include "gmpCellMeshData.h"
 
#include "gmpMeshLoader.h"
#include "gmpDataDump.h"
#include "gmpNodeDataDump.h"
 
#include <unitConverter.h>
#include <luaTable.h>
#include <luaStackBalancer.h>
 
#include <assert.h>
 
 
template <class Mesh, template <class> class Vector>
class GmpNodeMesh: public Mesh
{
public:
  GmpNodeMesh(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : Mesh(simulation, id, description, logger), _pcr(NULL), _ownPcr(false)
  {
  }
 
  virtual ~GmpNodeMesh()
  {
    clearNodeValueSets();
    if(_ownPcr)
    {
      assert(_pcr);
      simulationData()->modelData()->removePcrObject(_pcr->id(), true);
    }
  }
 
  // Comments on the base class
  virtual const char* pluginName() const { return "GemaMesh"; }
 
  // Comments on the base class
  virtual const char* pluginType() const { if constexpr(std::is_same<Vector<int>, GmSingleVector<int>>::value) return "nodes"; else return "nodesd"; }
 
  // Comments on the base class
  virtual bool hasCapability(QString capabilityName) const
  {
    // This implementation has a caveat: If this function is called before loadPrivateData() is called
    // on the mesh, it will return no support for ghost nodes, regardless of mesh configuration.  
    // This should not be a problem since it can not happen in a normal control flow.
    return (capabilityName == "addNodes"  || (capabilityName == "ghostNodes" && _nd._ghostEnabled) ||
            capabilityName == "clear"     || capabilityName == "stateDump");
  }
 
  // Comments on the base class
  virtual bool useDualVectors() const { if constexpr(std::is_same<Vector<int>, GmSingleVector<int>>::value) return false; else return true; }
 
  // Comments on the base class
  virtual void pushProxy(lua_State* L, const GmLogCategory& logger) { LuaProxy::pushObject(L, new GmLuaMesh(this, logger)); }
 
  virtual bool loadPrivateData(LuaTable& table)
  {
    // Check if the mesh should support ghost nodes or not.  This parameter is read here, and not
    // in the mesh loader, because this information is needed in the call to initCellData()
    bool ghostSupport = table.getField("useGhostNodes").toBool();
    bool ok;
 
    // Setup cell data for derived meshes. Might update ghostSupport.
    GmpCellMeshData<Vector>* cd = initCellData(table, &ghostSupport, &ok);
    if(!ok)
      return false;
 
    // Setup ghost support 
    _nd._ghostEnabled = ghostSupport;
    
    // Load mesh data. The call will fill _pcr and _ownPcr
    // We will take its ownership of the PCR object if it was created 
    // by the loader
    QScopedPointer<GmpMeshLoader<Vector>> loader(meshLoader());
    return loader->loadMeshData(table, this, &_nd, cd, &_pcr, &_ownPcr);
  }
 
  // Comments on the base class
  virtual GmValueInfo* nodeCoordInfo() const { return _nd._coordInfo; }
 
  // Comments on the base class
  virtual GmValueAccessor* nodeCoordAccessor(Unit desiredUnit, const GmLogCategory& logger) const
  {
    bool compatibleUnits;
    UnitConverter* conv = Unit::converter(_nd._coordInfo->unit(), desiredUnit, &compatibleUnits);
    if(!compatibleUnits) // Conv can be NULL with compatible units if no conversion is needed
    {
      gmInfoMsg(logger, QObject::tr("Could not create an accessor for mesh coordinates due to incompatible units.\n"
                                    "Data unit = '%1'.  Requested unit = '%2'.")
                                    .arg(_nd._coordInfo->unit().name(), desiredUnit.name()));
      return NULL;
    }
 
    if(_nd._ghostEnabled)
    {
      // Accessors own converters so no sharing is possible
      UnitConverter*   gconv = Unit::converter(_nd._coordInfo->unit(), desiredUnit, &compatibleUnits); 
      GmValueAccessor* ac    = const_cast<GmpNodeMeshData<Vector>&>(_nd).coordAc(logger, conv, desiredUnit.name());
      GmValueAccessor* gac   = const_cast<GmpNodeMeshData<Vector>&>(_nd).ghostAc(logger, gconv, desiredUnit.name());
      return new GmGhostNodeAccessor(ac, gac); 
    }
    else
      return const_cast<GmpNodeMeshData<Vector>&>(_nd).coordAc(logger, conv, desiredUnit.name());
  }
 
  // See comments on the base interface class
  virtual int numNodes() const { assert(_nd._numNodes >= 0);  return _nd._numNodes; }
 
  // See comments on the base interface class
  virtual int numGhostNodes() const { assert(_nd._numGhostNodes >= 0); return _nd._numGhostNodes; }
 
  // Comments on the base class
  virtual const QMap<QString, GmNodeSet*>& nodeSets() const { return _nd._nodeSets; }
 
  // See comments on the base interface class
  virtual int addNodes(int numNodes) { return _nd.addNodes(this, false, numNodes, true, _pcr); }
 
  // See comments on the base interface class
  virtual int addGhostNodes(int numNodes) { return _nd._ghostEnabled ? _nd.addNodes(this, true, numNodes, true, _pcr) : -1; }
 
  // See comments on the base interface class
  virtual void clear() { _nd.clear(this); _pcr->clear(); }
 
  // See comments on the base interface class
  virtual size_t nodeMemory() const { return _nd.nodeMemory(); }
 
  // See comments on the base interface class
  virtual size_t nodeSetsMemory() const { return _nd.nodeSetsMemory(); }
 
  // See comments on the base interface class
  virtual GmPCR* pcrObject() const { return _pcr; }
 
protected:
 
  virtual GmpCellMeshData<Vector>* initCellData(LuaTable& table, bool* ghostSupport, bool* ok) 
  {
    Q_UNUSED(table); Q_UNUSED(ghostSupport);  
    *ok = true;
    return NULL;
  }
 
  virtual GmpMeshLoader<Vector>* meshLoader() { return new GmpMeshLoader<Vector>(simulationData(), logger()); }
 
  //---------------------------------------
  // State dump control functions
  //---------------------------------------
 
  // See comments on the base class and on the enum definition
  virtual int controlMapStateItemType() { return GMP_GEMA_MESH_DUMP_ITEM; }
 
  // See comments on the base GmMesh class
  virtual bool addStateGeometryData(GmStateDump* state, int groupId) 
  { 
    return Mesh::addStateGeometryData(state, groupId) && 
           _nd._dumper->addStateGeometryData(state, groupId) &&
           _pcr->addStateGeometryData(state, groupId);
  }
 
  // See comments on the base GmMesh class
  virtual bool fillDumpControlMapData(QVariantMap* map, const GmLogCategory& logger) 
  { 
    return Mesh::fillDumpControlMapData(map, logger) && 
           _nd._dumper->fillDumpControlMapData(this, map, logger) &&
           _pcr->fillDumpControlMapData(map, logger);
  }
 
  // See comments on the base GmMesh class
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger) 
  { 
    return Mesh::dumpControlMapDataLoaded(map, logger) && 
           _nd._dumper->dumpControlMapDataLoaded(this, map, logger) &&
           _pcr->dumpControlMapDataLoaded(map, logger);
  }
 
  GmpNodeMeshData<Vector> _nd; 
 
  GmPCR* _pcr;    
  bool   _ownPcr; 
};
 
 
#endif