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(const 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