gmpGemaCR.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_GEMA_CR_H_
#define _GEMA_PLUGIN_GEMA_CR_H_
 
#include <gmPCR.h>
#include <gmCellMesh.h>
 
#include "gmpGemaPCRConfig.h"
 
 
struct GmpColorData
{
  const GmCellGroupSet*    _srcGroup;        
  GmPCR::ColorState        _state;           
  GmCellGroupSet*          _seqSet;          
  GmCellGroupSet*          _seqHaloSet;      
  QVector<GmCellGroupSet*> _coloredSets;     
  QVector<GmCellGroupSet*> _coloredHaloSets; 
 
  GmpColorData(const GmCellGroupSet* gs) : _srcGroup(gs), _state(GmPCR::NOT_SET), _seqSet(NULL), _seqHaloSet(NULL) {}
  ~GmpColorData();
 
  size_t usedMemory() const;
};
 
class GmpColoringMethod
{
public:
 
  enum HaloColoring
  {
    HC_TOGETHER,        
    HC_TOGETHER_REMOTE, 
    HC_SPLIT,           
    HC_SPLIT_REMOTE,    
  };
 
  GmpColoringMethod(GmPCR::ColorType colorType, bool partition, HaloColoring haloOption, const QVariantMap& options)
    : _colorType(colorType), _partition(partition), _haloOption(haloOption), _options(options) {}
 
  virtual bool checkOptions(const GmLogCategory& logger) = 0;
 
  virtual void printParameters(const GmLogCategory& logger) const = 0;
 
  virtual void color(GmpColorData* colorData, const GmLogCategory& logger) const = 0;
 
protected:
  GmPCR::ColorType   _colorType;   
  bool               _partition;   
  HaloColoring       _haloOption;  
  const QVariantMap& _options;     
};
 
template <class IntVector>
class GmpNodeRenumberingMethod
{
public:
  GmpNodeRenumberingMethod(const QVariantMap& options) : _options(options) {}
 
  virtual bool checkOptions(const GmLogCategory& logger) = 0;
 
  virtual void printParameters(const GmLogCategory& logger) const = 0;
 
  virtual bool renumber(GmValueAccessor* ac, IntVector& sortedToOriginal, const GmLogCategory& logger) const = 0;
 
protected:
  const QVariantMap& _options;     
};
 
template <class IntVector>
class GmpCellRenumberingMethod
{
public:
  GmpCellRenumberingMethod(const QVariantMap& options) : _options(options) {}
 
  virtual bool checkOptions(const GmLogCategory& logger) = 0;
 
  virtual void printParameters(const GmLogCategory& logger) const = 0;
 
  virtual QStringList cellMappingRequiredGroups() const = 0;
 
  virtual bool renumber(GmPCR* pcr, IntVector& sortedToOriginal, const GmLogCategory& logger) const = 0;
 
  virtual bool usesSequentialColoring() const = 0;
 
protected:
  const QVariantMap& _options;     
};
 
// A macro to define th SR version of a "original to local" function
// The first parameter is the original function name. The second and third 
// should be either, nodeClass + REMOTE_NODE or cellClass + REMOTE_HALO_CELL,
// depending on the original function being a node or cell function.
#define MAKE_SR_FUNCTION(mainFunctionName, classFunction, classValue) \
  virtual int mainFunctionName##SR(int id) const                      \
  {                                                                   \
    if constexpr(Partition)                                           \
    {                                                                 \
      if(!_skipRemote)                                                \
        return mainFunctionName(id);                                  \
      int localId = mainFunctionName##Impl(id);                       \
      if(localId >= 0 && classFunction(localId) == classValue)        \
        return -1;                                                    \
      return localId;                                                 \
    }                                                                 \
    else                                                              \
      return mainFunctionName(id);                                    \
  }
 
template <template <class> class Vector, bool Partition>
class GMP_GEMA_PCR_API_EXPORT GmpGemaCRBase : public GmPCR
{
public:
 
  GmpGemaCRBase(GmSimulationData* simulation, QString id, QString description, const GmLogCategory& logger)
    : GmPCR(simulation, id, description, logger), _mesh(NULL), 
      _coloringType(NO_COLORING), _nodeRenumberRequested(true), _cellRenumberRequested(true),
      _isNodeRenumbered(false), _isCellRenumbered(false), _skipRemote(false), _noColorData(NULL), _colorMethod(NULL),
      _nodeRenumberMethod(NULL), _cellRenumberMethod(NULL), _numGeomNodes(0), _numOriginalGeomNodes(0)
  {
    if constexpr(Partition)
    {
      _part._partitioned     = false; // Can't be initialized above since this field only exists if Partition is true
      _part._nodesRenumbered = false;
      _part._cellsRenumbered = false;
    }
  }
 
  virtual ~GmpGemaCRBase();
 
  // Comments on the base class
  virtual const char* pluginName() const { return "GemaPCR"; }
 
  // Comments on the base class
  virtual const char* pluginType() const { if constexpr(std::is_same<Vector<int>, GmSingleVector<int>>::value) return "cr"; else return "crd"; }
 
  virtual bool loadPrivateData(LuaTable& table);
 
  virtual void printParameters(const GmLogCategory& logger);
 
  // Comments on the base class
  virtual bool hasCapability(QString capabilityName) const { return capabilityName == "femColoring" || capabilityName == "fvmColoring" || capabilityName == "renumbering"; }
 
  // Comments on the base class
  virtual GmMesh* mesh() const { return _mesh; }
 
  virtual bool setMesh(GmMesh* mesh);
 
  virtual size_t printMemoryStatistics(const GmLogCategory& logger, GmLogLevel level) const;
 
  virtual size_t usedMemory() const { return nodeRenumberMemory() + cellRenumberMemory() + colorMemory() + partitionMemory(); }
 
  // --------------------------------------
  // -- Partition (identity) --------------
  // --------------------------------------
 
  // See comments on the base class
  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 _skipRemote; }
  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); }
 
  // --------------------------------------
  // -- Coloring --------------------------
  // --------------------------------------
 
  // See comments on the base class
  virtual ColorType coloringType() const { return _coloringType; }
 
  // See comments on the base class
  virtual ColorState coloringState(const GmCellGroupSet* gs) { return colorData(gs)->_state; }
 
  // See comments on the base class
  virtual const QVector<GmCellGroupSet*>& coloredSets(const GmCellGroupSet* gs) { return colorData(gs)->_coloredSets; }
 
  // See comments on the base class
  virtual const GmCellGroupSet* sequentialSet(const GmCellGroupSet* gs)
  {
    const GmpColorData* cd = colorData(gs);
    return cd->_state == NOT_COLORED ? gs : cd->_seqSet;
  }
 
  // See comments on the base class
  virtual const QVector<GmCellGroupSet*>& coloredHaloSets(const GmCellGroupSet* gs) { return colorData(gs)->_coloredHaloSets; }
 
  // See comments on the base class
  virtual const GmCellGroupSet* sequentialHaloSet(const GmCellGroupSet* gs) { return colorData(gs)->_seqHaloSet; }
 
  // See comments on the base class
  virtual bool addColoringAsMeshAttribute(const GmCellGroupSet* gs, QString attrName) { return addColoringAsMeshAttribute(QVector{gs}, attrName); }
 
  virtual bool addColoringAsMeshAttribute(const QVector<const GmCellGroupSet*>& gsets, QString attrName);
 
  virtual void printColoringStatistics(const GmLogCategory& logger) const;
 
  // --------------------------------------
  // -- Renumbering -----------------------
  // --------------------------------------
 
  virtual bool nodesRenumbered() const { return _isNodeRenumbered; }
  virtual bool cellsRenumbered() const { return _isCellRenumbered; }
 
  virtual int originalToLocalOrderNode              (int originalNodeId) const { return _isNodeRenumbered ? originalToLocalOrderNodeImpl(originalNodeId) : originalNodeId; }
  virtual int originalToLocalOrderGeomNode          (int originalNodeId) const { return _isNodeRenumbered ? originalToLocalOrderGeomNodeImpl(originalNodeId) : originalNodeId; }
  virtual int originalToLocalOrderGhostNodeHighSet  (int originalNodeId) const { return _isNodeRenumbered ? originalToLocalOrderGhostNodeHighSetImpl(originalNodeId) : originalNodeId; }
  virtual int originalToLocalOrderGhostNodeHighClear(int originalNodeId) const { return _isNodeRenumbered ? originalToLocalOrderGhostNodeHighClearImpl(originalNodeId) : originalNodeId; }
 
  virtual int localOrderToOriginalNode              (int nodeId) const { return _isNodeRenumbered ? localOrderToOriginalNodeImpl(nodeId) : nodeId; }
  virtual int localOrderToOriginalGeomNode          (int nodeId) const { return _isNodeRenumbered ? localOrderToOriginalGeomNodeImpl(nodeId) : nodeId; }
  virtual int localOrderToOriginalGhostNodeHighSet  (int nodeId) const { return _isNodeRenumbered ? localOrderToOriginalGhostNodeHighSetImpl(nodeId) : nodeId; }
  virtual int localOrderToOriginalGhostNodeHighClear(int nodeId) const { return _isNodeRenumbered ? localOrderToOriginalGhostNodeHighClearImpl(nodeId) : nodeId; }
 
  virtual int originalToLocalOrderCell(int originalCellId) const  { return _isCellRenumbered ? originalToLocalOrderCellImpl(originalCellId) : originalCellId; }
  virtual int localOrderToOriginalCell(int cellId) const          { return _isCellRenumbered ? localOrderToOriginalCellImpl(cellId) : cellId; }
 
  // Automatically creates SR versions for the originalToLocal methods above. See the macro definition above
  MAKE_SR_FUNCTION(originalToLocalOrderNode,               nodeClass, REMOTE_NODE);
  MAKE_SR_FUNCTION(originalToLocalOrderGeomNode,           nodeClass, REMOTE_NODE);
  MAKE_SR_FUNCTION(originalToLocalOrderGhostNodeHighSet,   nodeClass, REMOTE_NODE);
  MAKE_SR_FUNCTION(originalToLocalOrderGhostNodeHighClear, nodeClass, REMOTE_NODE);
  MAKE_SR_FUNCTION(originalToLocalOrderCell,               cellClass, REMOTE_HALO_CELL);
 
  virtual int originalNodeTraversalOrder(int i) const { return _isNodeRenumbered ? originalNodeTraversalOrderImpl(i) : i; }
  virtual int originalCellTraversalOrder(int i) const { return _isCellRenumbered ? originalCellTraversalOrderImpl(i) : i; }
 
  // -------------------------------------------------
  // Initialization, control and dump API used by the mesh
  // -------------------------------------------------
  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);
  virtual bool initCellMapping(bool* renumbered, QMap<int, int>& partOrigToLocOrder,
                               QVector<int>& partLocToOrigOrder);
 
  // See comments on the base class
  virtual QStringList cellMappingRequiredGroups() { return _cellRenumberMethod ? _cellRenumberMethod->cellMappingRequiredGroups() : QStringList(); }
 
  virtual bool addNodes(int numNodes);
  virtual bool addGhostNodes(int numGhostNodes);
  virtual bool addCells(int numCells);
 
  virtual void clear();
 
  virtual bool addStateGeometryData(GmStateDump* state, int groupId);
  virtual bool fillDumpControlMapData(QVariantMap* map, const GmLogCategory& logger);
  virtual bool dumpControlMapDataLoaded(QVariantMap* map, const GmLogCategory& logger);
 
protected:
  using IntVector = Vector<int>;
 
  using IntVectorOrMap = std::conditional_t<Partition, QMap<int, int>, Vector<int>>;
 
  bool initMappingFromPartition(const IntVector& cells, const IntVector& geomNodes, const IntVector& ghostNodes);
 
  virtual size_t nodeRenumberMemory() const;
  virtual size_t cellRenumberMemory() const;
  virtual size_t colorMemory() const;
  virtual size_t partitionMemory() const { return 0; }
 
  GmValueAccessor* addNodeAttributeToMesh(QString name, QString description, GmStorageType type)
  {
    return addAttributeToMesh<GmValueAccessor, GM_NODE_ATTRIBUTE>(name, description, type);
  }
 
  GmCellAccessor* addCellAttributeToMesh(QString name, QString description, GmStorageType type)
  {
    return addAttributeToMesh<GmCellAccessor, GM_CELL_ATTRIBUTE>(name, description, type);
  }
 
private:
  const GmpColorData* colorData(const GmCellGroupSet* gs);
  void renumberColoredGroupSets(const QVector<int>& partLocToOrigOrder);
 
  inline int originalToLocalOrderNodeImpl              (int originalNodeId) const;
  inline int originalToLocalOrderGeomNodeImpl          (int originalNodeId) const;
  inline int originalToLocalOrderGhostNodeHighSetImpl  (int originalNodeId) const;
  inline int originalToLocalOrderGhostNodeHighClearImpl(int originalNodeId) const;
  inline int originalToLocalOrderCellImpl              (int originalCellId) const;
 
  inline int localOrderToOriginalNodeImpl              (int nodeId) const;
  inline int localOrderToOriginalGeomNodeImpl          (int nodeId) const;
  inline int localOrderToOriginalGhostNodeHighSetImpl  (int nodeId) const;
  inline int localOrderToOriginalGhostNodeHighClearImpl(int nodeId) const;
  inline int localOrderToOriginalCellImpl              (int cellId) const;
 
  inline int originalNodeTraversalOrderImpl(int i) const;
  inline int originalCellTraversalOrderImpl(int i) const;
 
  bool initGeomNodeMapping (GmValueAccessor* ac, bool* renumbered);
  bool initGhostNodeMapping(GmValueAccessor* ac, bool* renumbered);
 
  void initReverseMapping(const IntVector& localToOriginal, IntVectorOrMap& originalToLocal);
  void initOrdering      (const IntVectorOrMap& originalToLocal, IntVector& orderVec);
 
  bool addVectors       (size_t numAddedEntries, IntVector* localToOriginal, IntVectorOrMap* originalToLocal, IntVector* orderVec);
  bool addAndInitVectors(size_t numAddedEntries, IntVector* localToOriginal, IntVectorOrMap* originalToLocal, IntVector* orderVec,
                         int localToOriginalInit, int originalToLocalInit, int orderVecInit);
 
  template <class Ac, GmValueSetKind SetKind>
  Ac* addAttributeToMesh(QString name, QString description, GmStorageType type);
 
protected:
  QVariantMap                                _options;               
  GmMesh*                                    _mesh;                  
  ColorType                                  _coloringType;          
  bool                                       _nodeRenumberRequested; 
  bool                                       _cellRenumberRequested; 
  bool                                       _isNodeRenumbered;      
  bool                                       _isCellRenumbered;      
  bool                                       _skipRemote;            
  QMap<const GmCellGroupSet*, GmpColorData*> _gsColorMap;            
  GmpColorData*                              _noColorData;           
  GmpColoringMethod*                         _colorMethod;           
  GmpNodeRenumberingMethod<IntVector>*       _nodeRenumberMethod;    
  GmpCellRenumberingMethod<IntVector>*       _cellRenumberMethod;    
 
  int _numGeomNodes;  
 
  int _numOriginalGeomNodes;
 
  IntVector _localToOriginalGeomNode;
 
  IntVectorOrMap _originalToLocalGeomNode;  
 
  IntVector _localToOriginalCell;
 
  IntVectorOrMap _originalToLocalCell;
 
 
  struct PartitionFalse { };
 
  struct PartitionTrue
  { 
    bool _partitioned; 
 
    bool _nodesRenumbered; 
    bool _cellsRenumbered; 
 
    IntVector _localToOriginalGhostNode;
 
    IntVectorOrMap _originalToLocalGhostNode;
 
    IntVector _originalNodeTraversalOrder;
 
    IntVector _originalCellTraversalOrder;
  };
 
  using PartitionT = std::conditional_t<Partition, PartitionTrue, PartitionFalse>;
 
  PartitionT _part;
};
 
typedef GmpGemaCRBase<GmSingleVector, false> GmpGemaCR;
 
typedef GmpGemaCRBase<GmDualVector, false> GmpGemaCRD;
 
 
#endif