gmpMeshBase.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_MESH_BASE_H_
#define _GEMA_PLUGIN_MESH_BASE_H_

#include <gmGhostNodeAccessor.h>
#include <gmLuaMesh.h>
#include <gmShapeOrthogonalPol.h>

#include "gmpMeshLoader.h"

#include <unitConverter.h>
#include <luaTable.h>
#include <luaStackBalancer.h>

#include <assert.h>

#define GEMA_MESH_PLUGIN_DUMP_CODE 0x00AB0000

enum GmpGemaMeshStateDumpItemTypes
{
  GMP_GEMA_MESH_DUMP_ITEM  = GM_MESH_DUMP_ITEM | GEMA_MESH_PLUGIN_DUMP_CODE | 1, 
  GMP_GEMA_CMESH_DUMP_ITEM = GM_MESH_DUMP_ITEM | GEMA_MESH_PLUGIN_DUMP_CODE | 2, 
  GMP_GEMA_EMESH_DUMP_ITEM = GM_MESH_DUMP_ITEM | GEMA_MESH_PLUGIN_DUMP_CODE | 3, 
  GMP_GEMA_HMESH_DUMP_ITEM = GM_MESH_DUMP_ITEM | GEMA_MESH_PLUGIN_DUMP_CODE | 4, 
};

template <class Mesh, class CoordAcc, class CoordGhostAcc, 
          class Data, class CellData, template <class> class Vector>
class GmpMeshBase: public Mesh
{
public:
  GmpMeshBase(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : Mesh(simulation, id, description, logger), _nd(this)
  {
  }

  virtual ~GmpMeshBase()
  {
    clearNodeValueSets();
  }

  // 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 happend in a normal control flow.
    return (capabilityName == "addNodes"  || 
            capabilityName == "clear"     || 
            capabilityName == "stateDump" ||
            (capabilityName == "ghostNodes" && _nd._ghostEnabled));
  }

  // 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)
  {
#ifdef TRACK_MESHLOAD_TIME
    GmTimeMsg tmsg(logger(), QObject::tr("  *** Mesh load"));
#endif

    // Inform the mesh data object about the number of mesh coordinates
    // This is used by the surface mesh plugin to instance the correct mesh object
    // On the current implementation, MUST be called BEFORE the call to cellData()
    LuaStackBalancer bal(table.env());
    if(!_nd.setCoordinateDimension(table.getField("coordinateDim").toInt()))
    {
      gmErrorMsg(logger(), QObject::tr("Error loading mesh. Unsuported coordinate dimension."));
      return false;
    }

    // Check if the mesh should support ghost nodes or not.  This parameter is read here since
    // this information is needed in the call to cellAllocator()
    _nd.setGhostEnabled(table.getField("useGhostNodes").toBool());
    CellData* cd = cellData();
    if(cd)
      cd->setGhostEnabled(_nd.ghostEnabled());

    // We also need to check if the mesh contains hierarchical elements or not.  This is done by 
    // looking for the "hOrder" table and its contents, also before calling cellAllocator()
    if(cd && (pluginType() == QString("elem") || pluginType() == QString("elemd")))
    {
      LuaTable horderTable = table.getField("hOrder").value<LuaTable>();
      if(horderTable.isValid())
      {
        int p = horderTable.getField("P").toInt();   // Mesh script checks that if hOrder exists it contains fields P and Q
        int q = horderTable.getField("Q").toInt();

        if(p < 1 || p > GM_MAX_ORTHOGONAL_POL_ORDER || q < 1 || q > GM_MAX_ORTHOGONAL_POL_ORDER)
        {
          gmErrorMsg(logger(), QObject::tr("Error loading mesh hierarchical order. Invalid values for P and/or Q.\n"
                                           "Maximum supported polynomial order is %1").arg(GM_MAX_ORTHOGONAL_POL_ORDER));
          return false;
        }

        int pqIndex = CellData::hierarchicalOrderIndex(p, q);
        if(pqIndex == -1)
        {
          gmErrorMsg(logger(), QObject::tr("Error loading mesh hierarchical order.\n" 
                                           "A model can only have %1 different sets of hierarchical orders.")
                                           .arg(CellData::maxHTypes));
          return false;
        }
        cd->_hierarchicalIndex = pqIndex;
        _nd.setGhostEnabled(true);  // Using hierarchical elements implies in supporting ghost nodes
        cd->setGhostEnabled(true);
      }
    }
    
    // Load mesh data
    GmpMeshLoader<Vector>* loader = meshLoader();
    bool ret = loader->loadMeshData(table, this, (GmpMeshData<Vector>*)&_nd, (GmpCellMeshData<Vector>*)cd, cellAllocator(_nd._ghostEnabled, cd && cd->hierarchicalElements()));
    delete loader;
    return ret;
  }

  // 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)
    {
      UnitConverter* gconv = Unit::converter(_nd._coordInfo->unit(), desiredUnit, &compatibleUnits); // Accessors own converters so no sharing is possible

      GmValueAccessor* ac  = new CoordAcc     (const_cast<Data&>(_nd), logger, conv,  desiredUnit.name());
      GmValueAccessor* gac = new CoordGhostAcc(const_cast<Data&>(_nd), logger, gconv, desiredUnit.name());

      return new GmGhostNodeAccessor(ac, gac);
    }
    else
      return new CoordAcc(const_cast<Data&>(_nd), 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.addNewNodes(this, numNodes); }

  // See comments on the base interface class
  virtual int addGhostNodes(int numNodes) { return _nd.addNewGhostNodes(this, numNodes); }

  // See comments on the base interface class
  virtual void clear() { _nd.clear(this); }

  virtual CellData* cellData() { return NULL; }

  // 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(); }

protected:
  virtual GmpMeshLoaderCellAllocator cellAllocator(bool ghostSupport, bool hSupport) const { Q_UNUSED(ghostSupport); Q_UNUSED(hSupport); 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.addStateGeometryData(state, groupId); 
  }

  // See comments on the base GmMesh class
  virtual bool fillDumpControlMapData(QVariantMap* map, const GmLogCategory& logger) 
  { 
    return Mesh::fillDumpControlMapData(map, logger) && _nd.fillDumpControlMapData(this, map, logger);
  }

  // See comments on the base GmMesh class
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger) 
  { 
    return Mesh::dumpControlMapDataLoaded(map, logger) && _nd.dumpControlMapDataLoaded(this, map, logger);
  }

  Data _nd; 
};


#endif