vtkIOSSUtilities.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkIOSSUtilities_h
#define vtkIOSSUtilities_h
 
#include "vtkDataArraySelection.h"
#include "vtkDoubleArray.h"
#include "vtkIOSSReader.h"
#include "vtkLogger.h"
#include "vtkObject.h"
#include "vtkSmartPointer.h"
#include "vtkTypeInt32Array.h"
#include "vtkTypeInt64Array.h"
#include "vtkTypeList.h" // Needed for ArrayList definition
 
// Ioss includes
#include <vtk_ioss.h>
// clang-format off
#include VTK_IOSS(Ioss_Region.h)
#include VTK_IOSS(Ioss_Transform.h)
#include VTK_IOSS(Ioss_StructuredBlock.h)
#include VTK_IOSS(Ioss_SideSet.h)
#include VTK_IOSS(Ioss_SideBlock.h)
// clang-format on
 
#include <cassert>
#include <set>
 
VTK_ABI_NAMESPACE_BEGIN
class vtkCellArray;
class vtkDataSet;
VTK_ABI_NAMESPACE_END
 
namespace vtkIOSSUtilities
{
VTK_ABI_NAMESPACE_BEGIN
 
enum DatabaseFormatType
{
  UNKNOWN,
  EXODUS,
  CGNS,
  CATALYST,
};
 
class Cache
{
public:
  Cache();
  ~Cache();
 
  void ResetAccessCounts();
 
  void ClearUnused();
 
  void Clear();
 
  vtkObject* Find(const Ioss::GroupingEntity* entity, const std::string& cachekey) const;
  void Insert(const Ioss::GroupingEntity* entity, const std::string& cachekey, vtkObject* array);
 
private:
  Cache(const Cache&) = delete;
  void operator=(const Cache&) = delete;
 
  class CacheInternals;
  CacheInternals* Internals;
};
 
class CaptureNonErrorMessages
{
public:
  CaptureNonErrorMessages();
  ~CaptureNonErrorMessages();
 
  std::string GetMessages() const;
 
private:
  std::ostringstream Stream;
  std::ostream* DebugStream;
  std::ostream* WarningStream;
};
 
using EntityNameType = std::pair<vtkTypeUInt64, std::string>;
 
using ArrayList = typename vtkTypeList::Unique<
  vtkTypeList::Create<vtkDoubleArray, vtkTypeInt32Array, vtkTypeInt64Array>>::Result;
 
std::vector<std::pair<int, double>> GetTime(const Ioss::Region* region);
 
std::string GetSanitizedBlockName(const Ioss::Region* region, const std::string& name);
 
template <typename EntityType>
void GetEntityAndFieldNames(const Ioss::Region* region, const std::vector<EntityType*>& entities,
  std::set<EntityNameType>& entity_names, std::set<std::string>& field_names)
{
  for (const auto& entity : entities)
  {
    const int64_t id = entity->property_exists("id") ? entity->get_property("id").get_int() : 0;
    auto name = vtkIOSSUtilities::GetSanitizedBlockName(region, entity->name());
    entity_names.insert(EntityNameType{ static_cast<vtkTypeUInt64>(id), name });
 
    Ioss::NameList attributeNames;
    entity->field_describe(Ioss::Field::TRANSIENT, &attributeNames);
    entity->field_describe(Ioss::Field::ATTRIBUTE, &attributeNames);
    std::copy(
      attributeNames.begin(), attributeNames.end(), std::inserter(field_names, field_names.end()));
  }
}
template <>
void GetEntityAndFieldNames<Ioss::SideSet>(const Ioss::Region* region,
  const std::vector<Ioss::SideSet*>& entities, std::set<EntityNameType>& entity_names,
  std::set<std::string>& field_names);
 
Ioss::EntityType GetIOSSEntityType(vtkIOSSReader::EntityType vtk_type);
 
vtkSmartPointer<vtkDataArray> CreateArray(const Ioss::Field& field);
 
vtkSmartPointer<vtkDataArray> GetData(const Ioss::GroupingEntity* entity,
  const std::string& fieldname, Ioss::Transform* transform = nullptr, Cache* cache = nullptr,
  const std::string& cachekey = std::string());
 
int GetCellType(const Ioss::ElementTopology* topology);
 
const Ioss::ElementTopology* GetElementTopology(int vtk_cell_type);
 
vtkSmartPointer<vtkCellArray> GetConnectivity(
  Ioss::GroupingEntity* group_entity, int& vtk_topology_type, Cache* cache = nullptr);
 
vtkSmartPointer<vtkPoints> GetMeshModelCoordinates(
  const Ioss::GroupingEntity* group_entity, Cache* cache = nullptr);
 
bool IsFieldTransient(Ioss::GroupingEntity* entity, const std::string& fieldname);
 
 
std::string GetDisplacementFieldName(Ioss::GroupingEntity* nodeblock);
std::string GetDisplacementFieldName(vtkDataSet* dataset);
 
void InitializeEnvironmentForIOSS();
 
DatabaseFormatType DetectType(const std::string& dbaseName);
 
DatabaseFormatType GetFormat(const Ioss::GroupingEntity* entity);
 
std::vector<Ioss::StructuredBlock*> GetMatchingStructuredBlocks(
  Ioss::Region* region, const std::string& blockname);
 
VTK_ABI_NAMESPACE_END
}
 
#endif
// VTK-HeaderTest-Exclude: vtkIOSSUtilities.h