gmMeshUtils.h

/************************************************************************
**
** 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_MESH_UTILS_H_
#define _GEMA_MESH_UTILS_H_
 
#include "gmPCR.h"
#include "gmCellMesh.h"
 
#include <assert.h>
 
namespace GmMeshUtils
{
  enum TranslationSemantics
  {
    API,     
    REPORT,  
    IO,      
  };
 
  inline int geomNodeToModel(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    return pcr->localOrderToOriginalGeomNode(nodeId) + 1; // If unknow, returned -1 value will be converted to 0, as expected!!
  }
 
  inline int nodeToModel(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    return pcr->localOrderToOriginalNode(nodeId) + 1;  // If unknow, returned -1 value will be converted to 0, as expected!!
  }
 
  inline int nodeToModel_Ghs_Gn(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  { 
    Q_UNUSED(semantic);
    if(GmMesh::isGhostNode(nodeId))
      return -(pcr->localOrderToOriginalGhostNodeHighClear(GmMesh::clearGhostFlag(nodeId)) + 1);
    else
      return pcr->localOrderToOriginalGeomNode(nodeId) + 1;  // If unknow, returned -1 value will be converted to 0, as expected!!
  }
 
  inline int nodeToModel_Gl_Gn(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    if(nodeId >= pcr->mesh()->numNodes())
      return -(pcr->localOrderToOriginalGhostNodeHighClear(nodeId - pcr->mesh()->numNodes()) + 1);
    else
      return pcr->localOrderToOriginalGeomNode(nodeId) + 1; // If unknow, returned -1 value will be converted to 0, as expected!!
  }
 
  inline int nodeToModel_Ghs_Ghs(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    return pcr->localOrderToOriginalNode(nodeId) + 1; // If unknow, returned -1 value will be converted to 0, as expected!!
  }
 
  inline int cellToModel(int cellId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    return pcr->localOrderToOriginalCell(cellId) + 1;  // If unknow, returned -1 value will be converted to 0, as expected!!
  }
 
  inline int cellToModel(const GmCell* c, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    return cellToModel(c->cellId(), c->mesh()->pcrObject(), semantic);
  }
 
  inline int checkedNodeFromModel(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    if(nodeId >= 0)  // Common node or linear ghost node. Using >= ensures that a 0 (invalid) value will be flagged correctly
    {
      nodeId--;  // -1 to adjust from 1-based to 0-based
      if(nodeId < 0 || nodeId >= pcr->mesh()->totalNumGlobalNodes())
        return -2;
      return pcr->originalToLocalOrderNode(nodeId); // Returns -1 if out of the partition
    }
    else // Ghost node represented with the high bit set (and so, a negative number)
    {
      nodeId = GmMesh::clearGhostFlag(nodeId) - 1;
      if(nodeId >= pcr->mesh()->numGlobalGhostNodes())
        return -2;
      return GmMesh::setGhostFlag(pcr->originalToLocalOrderGhostNodeHighClear(nodeId)); // Returns -1 if out of the partition
    }
  }
 
  inline int checkedGeomNodeFromModel(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    nodeId--;  // -1 to adjust from 1-based to 0-based
    if(nodeId < 0 || nodeId >= pcr->mesh()->numGlobalNodes())
      return -2;
    return pcr->originalToLocalOrderGeomNode(nodeId); // Returns -1 if out of the partition
  }
 
  // The SR version for checkedGeomNodeFromModel(). See comments on the namespace definition
  inline int checkedGeomNodeFromModelSR(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    nodeId--;  // -1 to adjust from 1-based to 0-based
    if(nodeId < 0 || nodeId >= pcr->mesh()->numGlobalNodes())
      return -2;
    return pcr->originalToLocalOrderGeomNodeSR(nodeId); // Returns -1 if out of the partition
  }
 
  inline int checkedNodeFromModel_Gn_Ghs(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    if(nodeId >= 0)  // Common node. Using >= ensures that a 0 (invalid) value will be flagged correctly
      return checkedGeomNodeFromModel(nodeId, pcr, semantic);
    else // Ghost node represented by a negative number 
    {
      nodeId = (-nodeId) - 1;
      if(nodeId >= pcr->mesh()->numGlobalGhostNodes())
        return -2;
      return GmMesh::setGhostFlag(pcr->originalToLocalOrderGhostNodeHighClear(nodeId)); // Returns -1 if out of the partition
    }
  }
 
  // The SR version for checkedNodeFromModel_Gn_Ghs(). See comments on the namespace definition
  inline int checkedNodeFromModel_Gn_GhsSR(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    if(nodeId >= 0)  // Common node. Using >= ensures that a 0 (invalid) value will be flagged correctly
      return checkedGeomNodeFromModelSR(nodeId, pcr, semantic);
    else // Ghost node represented by a negative number 
    {
      nodeId = (-nodeId) - 1;
      if(nodeId >= pcr->mesh()->numGlobalGhostNodes())
        return -2;
      return GmMesh::setGhostFlag(pcr->originalToLocalOrderGhostNodeHighClearSR(nodeId)); // Returns -1 if out of the partition
    }
  }
 
  inline int checkedNodeFromModel_Gn_Gl(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    if(nodeId >= 0)  // Common node. Using >= ensures that a 0 (invalid) value will be flagged correctly
      return checkedGeomNodeFromModel(nodeId, pcr, semantic);
    else // Ghost node represented by a negative number 
    {
      nodeId = (-nodeId) - 1;
      if(nodeId >= pcr->mesh()->numGlobalGhostNodes())
        return -2;
      int tnode = pcr->originalToLocalOrderGhostNodeHighClear(nodeId);
      return  tnode == -1 ? -1 : tnode + pcr->mesh()->numNodes(); 
    }
  }
 
  inline int checkedNodeFromModel_Ghs_Ghs(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    if(nodeId >= 0)  // Common node. Using >= ensures that a 0 (invalid) value will be flagged correctly
      return checkedGeomNodeFromModel(nodeId, pcr, semantic);
    else // Ghost node represented with the high bit set (and so, a negative number)
    {
      nodeId = GmMesh::clearGhostFlag(nodeId) - 1;
      if(nodeId >= pcr->mesh()->numGlobalGhostNodes())
        return -2;
      return GmMesh::setGhostFlag(pcr->originalToLocalOrderGhostNodeHighClear(nodeId)); // Returns -1 if out of the partition
    }
  }
 
  inline int checkedGhostNodeFromModel_Ghc_Ghc(int nodeId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    nodeId--;  // -1 to adjust from 1-based to 0-based
    if(nodeId < 0 || nodeId >= pcr->mesh()->numGlobalGhostNodes())
      return -2;
    return pcr->originalToLocalOrderGhostNodeHighClear(nodeId); // Returns -1 if out of the partition
  }
 
  inline int checkedCellFromModel(int cellId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    assert(dynamic_cast<GmCellMesh*>(pcr->mesh()));
    cellId--;  // -1 to adjust from 1-based to 0-based
    if(cellId < 0 || cellId >= ((GmCellMesh*)pcr->mesh())->numGlobalCells())
      return -2;
    return pcr->originalToLocalOrderCell(cellId);  // Returns -1 if out of the partition
  }
 
  // The SR version for checkedCellFromModel(). See comments on the namespace definition
  inline int checkedCellFromModelSR(int cellId, const GmPCR* pcr, TranslationSemantics semantic)
  {
    Q_UNUSED(semantic);
    assert(dynamic_cast<GmCellMesh*>(pcr->mesh()));
    cellId--;  // -1 to adjust from 1-based to 0-based
    if(cellId < 0 || cellId >= ((GmCellMesh*)pcr->mesh())->numGlobalCells())
      return -2;
    return pcr->originalToLocalOrderCellSR(cellId); // Returns -1 if out of the partition / remote halo cell
  }
}
 
#endif