gmDefaultPCR.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2015 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_DEFAULT_PCR_H_
#define _GEMA_DEFAULT_PCR_H_
 
#include "gmPCR.h"
#include "gmCellMesh.h"
 
class GMC_API_EXPORT GmDefaultPCR : public GmPCR
{
public:
  GmDefaultPCR(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : GmPCR(simulation, id, description, logger), _mesh(NULL) {}
 
  // Comments on the base class
  virtual const char* pluginCategory() const { return GM_PLUGIN_PCR; }
 
  // Comments on the base class
  virtual const char* pluginName() const { return "DummyGemaPCR"; }
 
  // Comments on the base class
  virtual const char* pluginType() const { return "pcr"; }
 
  virtual bool loadPrivateData(LuaTable& table) { Q_UNUSED(table); return false; }
 
  // Comments on the base class
  virtual bool hasCapability(QString capabilityName) const { Q_UNUSED(capabilityName);  return false; }
 
  virtual GmMesh* mesh() const { return _mesh; }
 
  virtual bool setMesh(GmMesh* mesh) { assert(mesh && !_mesh); _mesh = mesh; return true; }
 
  // Comments on the base class
  virtual size_t printMemoryStatistics(const GmLogCategory& logger, GmLogLevel level) const { Q_UNUSED(logger); Q_UNUSED(level); return 0; };
 
  // Comments on the base class
  virtual size_t usedMemory() const { return 0; }
 
  virtual ColorType coloringType() const { return NO_COLORING; }
 
  virtual int numPartitions()       const { return 1; }  
  virtual int partition()           const { return 0; }
  virtual int numGlobalNodes()      const { assert(_mesh); return _mesh->numNodes(); }
  virtual int numGlobalGhostNodes() const { assert(_mesh); return _mesh->numGhostNodes(); }
  virtual int numGlobalCells()      const { assert(_mesh); GmCellMesh* cmesh = dynamic_cast<GmCellMesh*>(_mesh); return cmesh ? cmesh->numCells() : 0; }
 
  virtual CellClass  cellClass      (int cellId) const          { Q_UNUSED(cellId);        return MY_CELL; }
  virtual int        cellClassData  (int cellId) const          { Q_UNUSED(cellId);        return 0; }
  virtual int        numCellsInClass(CellClass cellClass) const { Q_UNUSED(cellClass);     return 0; }
  virtual NodeClass  nodeClass      (int nodeId) const          { Q_UNUSED(nodeId);        return MY_NODE; }
  virtual int        nodeClassData  (int nodeId) const          { Q_UNUSED(nodeId);        return 0; }
  virtual int        numNodesInClass(NodeClass nodeClass, GmCellFillMode mode = GM_CELL_NODES) const { Q_UNUSED(nodeClass); Q_UNUSED(mode); return 0; }
  virtual int        numRemoteRanks (int templateIndex) const   { Q_UNUSED(templateIndex); return 0; }
  virtual const int* remoteRanks    (int templateIndex) const   { Q_UNUSED(templateIndex); return NULL; }
  virtual bool       skipRemote     ()                  const   { return false;}
  virtual bool       addPartitionInfoAsMeshAttributes     (QString cellAttrPrefix, QString nodeAttrPrefix) { Q_UNUSED(cellAttrPrefix); Q_UNUSED(nodeAttrPrefix); return false; }
  virtual bool       addDebugPartitionInfoAsMeshAttributes(QString cellAttrPrefix, QString nodeAttrPrefix) { Q_UNUSED(cellAttrPrefix); Q_UNUSED(nodeAttrPrefix); return false; }
  virtual void       printPartitionRankTemplateData       (const GmLogCategory& logger) const              { Q_UNUSED(logger); }
  virtual void       printPartitionClassStatistics        (const GmLogCategory& logger) const              { Q_UNUSED(logger); }
 
 
  virtual ColorState                      coloringState    (const GmCellGroupSet* gs) { Q_UNUSED(gs); return NOT_COLORED; }
  virtual const QVector<GmCellGroupSet*>& coloredSets      (const GmCellGroupSet* gs) { Q_UNUSED(gs); static QVector<GmCellGroupSet*> dummyEmptyVec; return dummyEmptyVec; }
  virtual const GmCellGroupSet*           sequentialSet    (const GmCellGroupSet* gs) { return gs; }
  virtual const QVector<GmCellGroupSet*>& coloredHaloSets  (const GmCellGroupSet* gs) { Q_UNUSED(gs); static QVector<GmCellGroupSet*> dummyEmptyVec; return dummyEmptyVec; }
  virtual const GmCellGroupSet*           sequentialHaloSet(const GmCellGroupSet* gs) { Q_UNUSED(gs); return NULL; }
 
  virtual bool addColoringAsMeshAttribute(const GmCellGroupSet* gs, QString attrName)                    { Q_UNUSED(gs);    Q_UNUSED(attrName); return false; }
  virtual bool addColoringAsMeshAttribute(const QVector<const GmCellGroupSet*>& gsets, QString attrName) { Q_UNUSED(gsets); Q_UNUSED(attrName); return false; }
  virtual void printColoringStatistics   (const GmLogCategory& logger) const                             { Q_UNUSED(logger); }
 
  virtual bool nodesRenumbered() const { return false; }
  virtual bool cellsRenumbered() const { return false; }
 
  virtual int originalToLocalOrderNode              (int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderGeomNode          (int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderGhostNodeHighSet  (int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderGhostNodeHighClear(int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderCell              (int originalCellId) const { return originalCellId; }
 
  virtual int originalToLocalOrderNodeSR              (int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderGeomNodeSR          (int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderGhostNodeHighSetSR  (int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderGhostNodeHighClearSR(int originalNodeId) const { return originalNodeId; }
  virtual int originalToLocalOrderCellSR              (int originalCellId) const { return originalCellId; }
 
  virtual int localOrderToOriginalNode              (int nodeId) const { return nodeId; }
  virtual int localOrderToOriginalGeomNode          (int nodeId) const { return nodeId; }
  virtual int localOrderToOriginalGhostNodeHighSet  (int nodeId) const { return nodeId; }
  virtual int localOrderToOriginalGhostNodeHighClear(int nodeId) const { return nodeId; }
  virtual int localOrderToOriginalCell              (int cellId) const { return cellId;}
 
  virtual int originalNodeTraversalOrder(int i) const { return i; }
  virtual int originalCellTraversalOrder(int i) const { return i; }
 
  virtual bool initPartitions(int numPartitions, int partition)
  {
    Q_UNUSED(numPartitions); Q_UNUSED(partition);
    return false;
  }
 
  virtual bool initNodeMapping(GmValueAccessor* ac, bool ghost, bool* renumbered,
                               QMap<int, int>& partOrigToLocOrder)
  { 
    Q_UNUSED(ac); Q_UNUSED(ghost); Q_UNUSED(partOrigToLocOrder);
    *renumbered = false; 
    return true; 
  }
 
  virtual bool initCellMapping(bool* renumbered, QMap<int, int>& partOrigToLocOrder,
                               QVector<int>& partLocToOrigOrder)
  { 
    Q_UNUSED(partOrigToLocOrder); Q_UNUSED(partLocToOrigOrder);
    *renumbered = false; return true; 
  }
 
  virtual QStringList cellMappingRequiredGroups() { return QStringList(); }
 
  virtual bool addNodes     (int numNodes)      { Q_UNUSED(numNodes);      return true; }
  virtual bool addGhostNodes(int numGhostNodes) { Q_UNUSED(numGhostNodes); return true; }
  virtual bool addCells     (int numCells)      { Q_UNUSED(numCells);      return true; }
 
  virtual void clear() {}
 
  virtual bool addStateGeometryData    (GmStateDump* state, int groupId)               { Q_UNUSED(state); Q_UNUSED(groupId); return true; }
  virtual bool fillDumpControlMapData  (QVariantMap* map, const GmLogCategory& logger) { Q_UNUSED(map);   Q_UNUSED(logger);  return true; }
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger) { Q_UNUSED(map);   Q_UNUSED(logger);  return true; }
 
private:
  GmMesh* _mesh; 
};
 
 
#endif // _GEMA_DEFAULT_PCR_H_