Geometry.hpp

Go to the documentation of this file.

/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   This file is part of CEPS.
 
   CEPS is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
   CEPS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with CEPS (see file LICENSE at root of project).
   If not, see <https://www.gnu.org/licenses/>.
 
 
   Copyright 2019-2024 Inria, Universite de Bordeaux
 
   Authors, in alphabetical order:
 
     Pierre-Elliott BECUE, Florian CARO, Yves COUDIERE(*), Andjela DAVIDOVIC, 
     Charlie DOUANLA-LONTSI, Marc FUENTES, Mehdi JUHOOR, Michael LEGUEBE(*), 
     Pauline MIGERDITICHAN, Valentin PANNETIER(*), Nejib ZEMZEMI.
     * : currently active authors
 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
#pragma once
 
#include "geometry/Mesh.hpp"
#include "geometry/base/GeomCellJunction.hpp"
#include "geometry/partitioning/PartitioningMethod.hpp"
 
// Forward declaration
class GeometryPartitioner;
 
class Geometry : public CepsObject
{
  
  // Geometry partitioner is responsible for setting many things in
  friend class GeometryPartitioner;
  friend class PtscotchPartitioner;
  
  public:
 
    Geometry();
  
    explicit Geometry(InputParameters *params);
  
    ~Geometry();
  
    void
    setupWithParameters(InputParameters* params);
  
    // Meshes
  
    void
    setMeshOfDim(CepsUInt dim, const CepsString& meshFileName);
  
    void
    set3dMesh(const CepsString& meshFileName);
  
    void
    set2dMesh(const CepsString& meshFileName);
  
    void
    set1dMesh(const CepsString& meshFileName);
  
    Mesh*
    getMeshOfDim(CepsUInt dim) const;
  
    Mesh*
    get3dMesh() const;
  
    Mesh*
    get2dMesh() const;
  
    Mesh*
    get1dMesh() const;
  
    CepsBool
    hasMeshOfDim(CepsUInt dim) const;
  
    CepsBool
    has3dMesh() const;
  
    CepsBool
    has2dMesh() const;
  
    CepsBool
    has1dMesh() const;
  
    // File names
  
    const CepsVector<CepsString>&
    getFileNamesForDim(CepsUInt dim) const;
  
    const CepsVector<CepsString>&
    getVolumicFileNames() const;
  
    const CepsVector<CepsString>&
    getSurfacicFileNames() const;
  
    const CepsVector<CepsString>&
    getCableFileNames() const;
  
    const CepsString&
    getCoupledNodesFileName() const;
  
    void
    setCoupledNodesFile(const CepsString& coupledNodesFile);
  
    // Partitioning
  
    void
    setPartitioningMethodFromString(const CepsString& s);
  
    void
    setPartitioningMethod(PartitioningMethod method);
  
    PartitioningMethod
    getPartitioningMethod() const;
 
    void
    setPartitionWeights(const CepsMap<CepsAttribute,CepsUInt>& weights);
 
    const CepsMap<CepsAttribute,CepsUInt>&
    getPartitionWeights() const;
 
    CepsUInt
    computePartition();
  
    // Number of nodes/cells
  
    CepsUInt
    getNbCells() const;
  
    CepsUInt
    getNbBoundaryCells() const;
  
    CepsUInt
    getNbNodes() const;
  
    CepsUInt
    getNbHaloNodes() const;
  
    CepsUInt
    getNbNodesLocal() const;
  
    CepsUInt
    getNbOwnedNodesLocal() const;
  
    CepsUInt
    getNbHaloNodesLocal() const;
  
    CepsUInt
    getNbCellsLocal() const;
  
    CepsUInt
    getNbBoundaryCellsLocal() const;
  
    CepsUInt
    getMaxNodeConnectivity() const;
 
    CepsReal
    getMaxCellDiameter() const;
  
    // Acces to cellary entities
  
    GeomNode*
    getNode(CepsNodeGlobalIndex globalID, CepsBool ownedOnly=false);
  
    GeomCell*
    getCell(CepsCellGlobalIndex globalID);
  
    void
    print(std::ostream& os = std::cout) const;
  
    friend std::ostream&
    operator<<(std::ostream& os, const Geometry& g);
  
    // Data distribution
  
    void
    printDataDistribution(CepsUInt*     nCells,
                          CepsUInt*     nBdCells,
                          CepsUInt*     nNodes,
                          CepsUInt*     nHaloNodes,
                          std::ostream& os = std::cout) const;
  
    void
    getLocalDistribution(CepsUInt* nCells, 
                         CepsUInt* nBdCells, 
                         CepsUInt* nNodes, 
                         CepsUInt* nHaloNodes) const;
  
    void
    getGlobalDistribution(CepsUInt* nCells,
                          CepsUInt* nBDCells,
                          CepsUInt* nNodes,
                          CepsUInt* nHaloNodes) const;
  
    // Indexing methods
  
    const CepsVector<CepsSet<CepsNodeGlobalIndex>>&
    getNodesToSend();
  
    const CepsVector<CepsSet<CepsNodeGlobalIndex>>&
    getNodesToReceive();
 
    const CepsVector<CepsNodeGlobalIndex>&
    getNodePartitionMap();
  
    const CepsVector<CepsCellGlobalIndex>&
    getCellPartitionMap();
  
    const CepsVector<CepsUInt>&
    getCellOffsetPerMesh();
  
    const CepsVector<CepsUInt>&
    getNodeOffsetPerMesh();
  
    const CepsMultiMap<CepsNodeGlobalIndex, CepsNodeGlobalIndex>&
    getCoupledNodes();
  
    void
    scale(CepsReal scaleFactor);
 
 
  protected:
 
    CepsUInt
    computeMaxNodeConnectivity();
  
    CepsReal
    computeMaxCellDiameter();
  
    void
    initialize();
  
    void
    setPartitionWeightsFromString(const CepsString& s);
 
    void
    updateMeshInfo(CepsUInt dim);
  
    void
    updateGeometryInfo();
 
  protected:
 
    InputParameters*   m_parameters;         
    PartitioningMethod m_partitioningMethod; 
  
    // GLOBAL DATA
    //---------------------------------------------------------------------------*
    // The following data is the same for every process
    //---------------------------------------------------------------------------*
    CepsArray3<CepsVector<CepsString>> m_meshFilenames;              
    CepsString                         m_coupledNodesFileName = "";  
  
    CepsArray3<CepsBool> m_hasMeshOfDim;     
    CepsBool             m_hasCoupledNodes;  
  
    CepsUInt m_nbCells;             
    CepsUInt m_nbBoundaryCells;     
    CepsUInt m_nbNodes;             
    CepsUInt m_nbHaloNodes;         
    CepsUInt m_maxNodeConnectivity; 
    CepsReal m_maxCellDiameter;     
  
    CepsVector<CepsUInt> m_cellOffsetPerMesh;  
    CepsVector<CepsUInt> m_nodeOffsetPerMesh;  
  
    // Unbalancing information
    CepsMap<CepsAttribute,CepsUInt> m_partitionWeights; 
 
    CepsVector<CepsNodeGlobalIndex> m_nodePartitionMap; 
    CepsVector<CepsCellGlobalIndex> m_cellPartitionMap;
 
    //---------------------------------------------------------------------------*
    // LOCAL DATA (specific to the process)
    //---------------------------------------------------------------------------*
    CepsArray3<Mesh*>             m_meshes;        
    CepsVector<GeomCellJunction*> m_junctionCells; 
  
    CepsVector<CepsSet<CepsNodeGlobalIndex>> m_nodesToSend;
  
    CepsVector<CepsSet<CepsNodeGlobalIndex>> m_nodesToReceive;
  
    CepsMultiMap<CepsNodeGlobalIndex,CepsNodeGlobalIndex> m_coupledNodes;
 
    CepsMap<CepsAttribute,CepsVector<CepsCellGlobalIndex>> m_connections; 
 
};
 
std::ostream& operator<< (std::ostream& os, const Geometry& g);