vtkCellGridSidesQuery.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 vtkCellGridSidesQuery_h
#define vtkCellGridSidesQuery_h
 
#include "vtkCellGridQuery.h"
 
#include "vtkStringToken.h" // For API.
 
#include <functional>
#include <map>
#include <set>
#include <unordered_map>
#include <vector>
 
VTK_ABI_NAMESPACE_BEGIN
 
class VTKCOMMONDATAMODEL_EXPORT vtkCellGridSidesQuery : public vtkCellGridQuery
{
public:
  static vtkCellGridSidesQuery* New();
  vtkTypeMacro(vtkCellGridSidesQuery, vtkCellGridQuery);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  void Initialize() override;
  void Finalize() override;
 
  std::map<vtkStringToken,
    std::unordered_map<vtkStringToken, std::unordered_map<vtkIdType, std::set<int>>>>&
  GetSides()
  {
    return this->Sides;
  }
  // std::map<vtkStringToken, std::unordered_map<vtkIdType, std::set<int>>>& GetSides() { return
  // this->Sides; }
 
 
  template <typename T, std::size_t NN>
  void AddSide(vtkStringToken cellType, vtkIdType cell, int side, vtkStringToken shape,
    const std::array<T, NN>& conn)
  {
    // Find where we should start hashing and in what direction.
    std::size_t ss = 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);
    vtkCellGridSidesQuery::HashCombiner()(hashedValue, shape.GetId());
    if (forward)
    {
      for (std::size_t ii = 0; ii < NN; ++ii)
      {
        std::size_t hashedToken = std::hash<T>{}(conn[(ss + ii) % NN]);
        vtkCellGridSidesQuery::HashCombiner()(hashedValue, hashedToken);
      }
    }
    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));
        vtkCellGridSidesQuery::HashCombiner()(hashedValue, hashedToken);
      }
    }
    this->Hashes[hashedValue].Sides.insert(Side{ cellType, shape, cell, side });
  }
 
  template <typename T>
  void AddSide(vtkStringToken cellType, vtkIdType cell, int side, vtkStringToken shape,
    const std::vector<T>& conn)
  {
    std::size_t ss = 0;
    std::size_t NN = conn.size();
    if (NN == 0)
    {
      return;
    }
 
    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);
    vtkCellGridSidesQuery::HashCombiner()(hashedValue, shape.GetId());
    // 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]);
        vtkCellGridSidesQuery::HashCombiner()(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));
        vtkCellGridSidesQuery::HashCombiner()(hashedValue, hashedToken);
        // std::cout << " " << conn[(ss + NN - ii) % NN];
      }
    }
    // std::cout << " = " << std::hex << hashedValue << std::dec << "\n";
    this->Hashes[hashedValue].Sides.insert(Side{ cellType, shape, cell, side });
  }
 
protected:
  vtkCellGridSidesQuery() = default;
  ~vtkCellGridSidesQuery() override = default;
 
  // Hash combiner adapted from boost::hash_combine
  class HashCombiner
  {
  public:
    template <typename T>
    void operator()(T& h, typename std::enable_if<sizeof(T) == 8, std::size_t>::type k)
    {
      constexpr T m = 0xc6a4a7935bd1e995ull;
      constexpr int r = 47;
 
      k *= m;
      k ^= k >> r;
      k *= m;
 
      h ^= k;
      h *= m;
 
      // Completely arbitrary number, to prevent 0's
      // from hashing to 0.
      h += 0xe6546b64;
    }
 
    template <typename T>
    void operator()(T& h, typename std::enable_if<sizeof(T) == 4, std::size_t>::type k)
    {
      constexpr std::uint32_t c1 = 0xcc9e2d51;
      constexpr std::uint32_t c2 = 0x1b873593;
      constexpr std::uint32_t r1 = 15;
      constexpr std::uint32_t r2 = 13;
 
      k *= c1;
      k = (k << r1) | (k >> (32 - r1));
      k *= c2;
 
      h ^= k;
      h = (h << r2) | (h >> (32 - r2));
      h = h * 5 + 0xe6546b64;
    }
  };
 
  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> Hashes;
  std::map<vtkStringToken,
    std::unordered_map<vtkStringToken, std::unordered_map<vtkIdType, std::set<int>>>>
    Sides;
 
private:
  vtkCellGridSidesQuery(const vtkCellGridSidesQuery&) = delete;
  void operator=(const vtkCellGridSidesQuery&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif // vtkCellGridSidesQuery_h