VTKUtilities.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_VTKUTILITIES_HPP
#define GEOS_MESH_GENERATORS_VTKUTILITIES_HPP
 
#include "common/DataTypes.hpp"
#include "common/MpiWrapper.hpp"
#include "mesh/generators/CellBlockManager.hpp"
 
#include <vtkDataSet.h>
#include <vtkMultiProcessController.h>
#include <vtkSmartPointer.h>
 
#include <numeric>
#include <unordered_set>
 
namespace geos
{
namespace vtk
{
class CollocatedNodes;
 
enum class PartitionMethod : integer
{
  parmetis, 
  ptscotch, 
};
 
ENUM_STRINGS( PartitionMethod,
              "parmetis",
              "ptscotch" );
 
using CellMapType = stdMap< ElementType, stdUnorderedMap< int, stdVector< vtkIdType > > >;
 
vtkSmartPointer< vtkMultiProcessController > getController();
 
class AllMeshes
{
public:
  AllMeshes() = default;
 
  AllMeshes( vtkSmartPointer< vtkDataSet > const & main,
             stdMap< string, vtkSmartPointer< vtkDataSet > > const & faceBlocks )
    : m_main( main ),
    m_faceBlocks( faceBlocks )
  { }
 
  vtkSmartPointer< vtkDataSet > getMainMesh()
  {
    return m_main;
  }
 
  stdMap< string, vtkSmartPointer< vtkDataSet > > & getFaceBlocks()
  {
    return m_faceBlocks;
  }
 
  void setMainMesh( vtkSmartPointer< vtkDataSet > main )
  {
    m_main = main;
  }
 
  void setFaceBlocks( stdMap< string, vtkSmartPointer< vtkDataSet > > const & faceBlocks )
  {
    m_faceBlocks = faceBlocks;
  }
 
private:
  vtkSmartPointer< vtkDataSet > m_main;
 
  stdMap< string, vtkSmartPointer< vtkDataSet > > m_faceBlocks;
};
 
AllMeshes loadAllMeshes( Path const & filePath,
                         string const & mainBlockName,
                         string_array const & faceBlockNames );
 
stdVector< int >
findNeighborRanks( stdVector< vtkBoundingBox > boundingBoxes );
 
AllMeshes
redistributeMeshes( integer const logLevel,
                    vtkSmartPointer< vtkDataSet > loadedMesh,
                    stdMap< string, vtkSmartPointer< vtkDataSet > > & namesToFractures,
                    MPI_Comm const comm,
                    PartitionMethod const method,
                    int const partitionRefinement,
                    int const partitionFractureWeight,
                    int const useGlobalIds,
                    string const & structuredIndexAttributeName,
                    int const numPartZ );
 
CellMapType buildCellMap( vtkDataSet & mesh,
                          string const & attributeName );
 
void printMeshStatistics( vtkDataSet & mesh,
                          CellMapType const & cellMap,
                          MPI_Comm const comm );
 
vtkDataArray * findArrayForImport( vtkDataSet & mesh, string const & sourceName );
 
bool hasArray( vtkDataSet & mesh, string const & sourceName );
 
string buildCellBlockName( ElementType const type, int const regionId );
 
void importMaterialField( stdVector< vtkIdType > const & cellIds,
                          vtkDataArray * vtkArray,
                          dataRepository::WrapperBase & wrapper );
 
void importRegularField( stdVector< vtkIdType > const & cellIds,
                         vtkDataArray * vtkArray,
                         dataRepository::WrapperBase & wrapper );
 
void importRegularField( vtkDataArray * vtkArray,
                         dataRepository::WrapperBase & wrapper );
 
stdVector< vtkIdType > findMatchingCellsForFractureElement(
  vtkIdList * fractureNodeIds,
  CollocatedNodes const & collocatedNodes,
  stdMap< vtkIdType, std::set< vtkIdType > > const & nodesToCells );
 
 
} // namespace vtk
 
void writeNodes( integer const logLevel,
                 vtkDataSet & mesh,
                 string_array & nodesetNames,
                 CellBlockManager & cellBlockManager,
                 const geos::R1Tensor & translate,
                 const geos::R1Tensor & scale );
 
void writeCells( integer const logLevel,
                 vtkDataSet & mesh,
                 vtk::CellMapType const & cellMap,
                 string const & structuredIndexAttributeName,
                 CellBlockManager & cellBlockManager );
 
void writeSurfaces( integer const logLevel,
                    vtkDataSet & mesh,
                    const geos::vtk::CellMapType & cellMap,
                    CellBlockManager & cellBlockManager );
 
std::pair< real64, real64 > getGlobalLengthAndOffset( vtkDataSet & mesh );
 
} // namespace geos
 
#endif /* GEOS_MESH_GENERATORS_VTKUTILITIES_HPP */