MeshGeneratorBase.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_MESH_GENERATORS_MESHGENERATORBASE_HPP
#define GEOS_MESH_GENERATORS_MESHGENERATORBASE_HPP
 
#include "mesh/mpiCommunications/SpatialPartition.hpp"
 
#include "dataRepository/Group.hpp"
#include "dataRepository/WrapperBase.hpp"
#include "codingUtilities/Utilities.hpp"
#include "common/DataTypes.hpp"
 
 
namespace geos
{
 
// Forward declarations
class CellBlockManager;
class NodeManager;
class EdgeManager;
class FaceManager;
class ElementRegionManager;
 
integer computeEulerCharacteristic( NodeManager const & nodeManager,
                                    EdgeManager const & edgeManager,
                                    FaceManager const & faceManager,
                                    ElementRegionManager const & elemManager );
 
class MeshGeneratorBase : public dataRepository::Group
{
public:
 
  explicit MeshGeneratorBase( string const & name,
                              Group * const parent );
 
  virtual void expandObjectCatalogs() override;
 
  using CatalogInterface = dataRepository::CatalogInterface< MeshGeneratorBase, string const &, Group * const >;
 
  virtual Group * createChild( string const & childKey, string const & childName ) override;
 
  static CatalogInterface::CatalogType & getCatalog();
 
  void generateMesh( Group & parent, SpatialPartition & partition );
 
  enum struct Block
  {
    VOLUMIC,
    SURFACIC,
    LINEIC
  };
 
  virtual void importFieldOnArray( Block block,
                                   string const & blockName,
                                   string const & meshFieldName,
                                   bool isMaterialField,
                                   dataRepository::WrapperBase & wrapper ) const = 0;
 
  virtual void freeResources() {}
 
  stdMap< string, string > const & getVolumicFieldsMapping() const { return m_volumicFields; }
 
  stdMap< string, string > const & getSurfacicFieldsMapping() const { return m_surfacicFields; }
 
  struct viewKeyStruct
  {
    constexpr static char const * checkEulerCharacteristicString() { return "checkEulerCharacteristic"; }
  };
 
  integer m_checkEulerCharacteristic = 0;
 
protected:
  stdMap< string, string > m_volumicFields;
 
  stdMap< string, string > m_surfacicFields;
 
private:
  virtual void fillCellBlockManager( CellBlockManager & cellBlockManager, SpatialPartition & partition )
  {
    GEOS_UNUSED_VAR( cellBlockManager );
    GEOS_UNUSED_VAR( partition );
    GEOS_ERROR( "Cell mesh generation not implemented for generator of this type" );
  }
 
  void attachWellInfo( CellBlockManager & cellBlockManager );
 
  virtual void fillParticleBlockManager( ParticleBlockManager & particleBlockManager, ParticleManager & particleManager, SpatialPartition const & partition )
  {
    GEOS_UNUSED_VAR( particleBlockManager );
    GEOS_UNUSED_VAR( particleManager );
    GEOS_UNUSED_VAR( partition );
    GEOS_ERROR( "Particle mesh generation not implemented for generator of this type" );
  }
 
};
}
 
#endif /* GEOS_MESH_GENERATORS_MESHGENERATORBASE_HPP */