vtkCellGridSidesCache.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 vtkCellGridSidesCache_h
#define vtkCellGridSidesCache_h
 
#include "vtkObject.h"
 
#include "vtkCommonDataModelModule.h" // For export macro.
#include "vtkHashCombiner.h"          // For templated AddSide() method.
#include "vtkStringToken.h"           // For API.
 
#include <functional>
#include <map>
#include <set>
#include <unordered_map>
#include <vector>
 
VTK_ABI_NAMESPACE_BEGIN
 
class vtkIdTypeArray;

class VTKCOMMONDATAMODEL_EXPORT vtkCellGridSidesCache : public vtkObject
{
public:
  static vtkCellGridSidesCache* New();
  vtkTypeMacro(vtkCellGridSidesCache, vtkObject);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  struct Side
  {
    vtkStringToken CellType;
    vtkStringToken SideShape;
    vtkIdType DOF;
    int SideId;

    bool operator<(const Side& other) const
    {
      return (this->CellType < other.CellType) ||
        (this->CellType == other.CellType &&
          ((this->DOF < other.DOF) || (this->DOF == other.DOF && this->SideId < other.SideId)));
    }
  };

  struct Entry
  {
    std::set<Side> Sides;
  };

  std::unordered_map<std::size_t, Entry>& GetHashes() { return this->Hashes; }

  template <typename C, typename T = typename C::value_type>
  std::size_t HashSide(vtkStringToken shape, const C& conn, std::size_t pointArrayId = 0)
  {
    std::size_t ss = 0;
    std::size_t NN = conn.size();
    if (NN == 0)
    {
      return 0;
    }
 
    T smin = conn[0];
    for (std::size_t jj = 1; jj < NN; ++jj)
    {
      if (conn[jj] < smin)
      {
        smin = conn[jj];
        ss = jj;
      }
    }
    bool forward = conn[(ss + 1) % NN] > conn[(ss + NN - 1) % NN];
 
    std::size_t hashedValue = std::hash<std::size_t>{}(NN);
    vtkHashCombiner()(hashedValue, shape.GetId());
    // Include the identity of the coordinate array that the point IDs index into
    vtkHashCombiner()(hashedValue, pointArrayId);
    // std::cout << "Hash(" << (forward ? "F" : "R") << ")";
    if (forward)
    {
      for (std::size_t ii = 0; ii < NN; ++ii)
      {
        std::size_t hashedToken = std::hash<T>{}(conn[(ss + ii) % NN]);
        vtkHashCombiner()(hashedValue, hashedToken);
        // std::cout << " " << conn[(ss + ii) % NN];
      }
    }
    else // backward
    {
      for (std::size_t ii = 0; ii < NN; ++ii)
      {
        std::size_t hashedToken = std::hash<T>{}(conn[(ss + NN - ii) % NN]);
        // hashedValue = hashedValue ^ (hashedToken << (ii + 1));
        vtkHashCombiner()(hashedValue, hashedToken);
        // std::cout << " " << conn[(ss + NN - ii) % NN];
      }
    }
    // std::cout << " = " << std::hex << hashedValue << std::dec << "\n";
    return hashedValue;
  }

  //

  template <typename C, typename T = typename C::value_type>
  void AddSide(vtkStringToken cellType, vtkIdType cell, int side, vtkStringToken shape,
    const C& conn, std::size_t pointArrayId = 0)
  {
    auto hashedValue = this->HashSide(shape, conn, pointArrayId);
    this->Hashes[hashedValue].Sides.insert(Side{ cellType, shape, cell, side });
  }


  void Initialize();
 
protected:
  vtkCellGridSidesCache() = default;
  ~vtkCellGridSidesCache() override = default;
 
  std::unordered_map<std::size_t, Entry> Hashes;
 
private:
  vtkCellGridSidesCache(const vtkCellGridSidesCache&) = delete;
  void operator=(const vtkCellGridSidesCache&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkCellGridSidesCache_h