Cell.h

Go to the documentation of this file.

// Copyright(C) 2021, 2022 National Technology & Engineering Solutions
// of Sandia, LLC (NTESS).  Under the terms of Contract DE-NA0003525 with
// NTESS, the U.S. Government retains certain rights in this software.
//
// See packages/seacas/LICENSE for details
#pragma once
 
//
// `Cell`:
//  -- for each location:
//     -- i,j location (could be calculated, but easier if entry knows it...)
//     -- reference to unit_cell region
//     -- global node offset for node ids (over all ranks if parallel)
//     -- local node offset for node ids (for this rank only if parallel)
//     -- global element block offsets for element ids for each element block (over all ranks if
//     parallel)
//     -- local element block offsets for element ids for each element block (for this rank only
//     if parallel)
//     -- offX, offY -- coordinate offsets for nodes (can be calculated?)
//     -- rank (for parallel -- which rank does this entry exist on)
//
 
#include <array>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "UnitCell.h"
 
// Each entry in grid will have the following information:
enum class Axis { X, Y, Z };
enum class Mode { GLOBAL, PROCESSOR };
enum class Loc { C = 0, BL, B, BR, L, R, TL, T, TR };
 
class Cell
{
public:
  Cell()             = default;
  Cell(const Cell &) = default;
 
  std::pair<double, double> get_coordinate_range(enum Axis) const;
  void                      initialize(size_t i, size_t j, std::shared_ptr<UnitCell> unit_cell);
 
  std::shared_ptr<UnitCell> unit() const { return m_unitCell; }
 
  std::shared_ptr<Ioss::Region> region() const { return m_unitCell->m_region; }
 
  bool has_neighbor_i() const { return m_i > 0; }
 
  bool has_neighbor_j() const { return m_j > 0; }
 
  bool has_neighbor(enum Loc loc) const { return m_ranks[(int)loc] != -1; }
 
  bool processor_boundary(enum Loc loc) const
  {
    return m_ranks[(int)loc] >= 0 && (m_ranks[(int)Loc::C] != m_ranks[(int)loc]);
  }
 
  size_t added_node_count(enum Mode mode, bool equivalence_nodes) const;
 
  size_t processor_boundary_node_count() const;
 
  template <typename INT>
  void populate_node_communication_map(const std::vector<INT> &node_map, std::vector<INT> &nodes,
                                       std::vector<INT> &procs) const;
 
  std::array<int, 9> categorize_processor_boundary_nodes(int rank) const;
 
  int rank(enum Loc loc) const { return m_ranks[(int)loc]; }
 
  void set_rank(enum Loc loc, int my_rank) { m_ranks[(int)loc] = my_rank; }
 
  std::vector<int> categorize_nodes(enum Mode mode) const;
 
  template <typename INT>
  std::vector<INT> generate_node_map(Mode mode, bool equivalance_nodes, INT /*dummy*/) const;
 
  template <typename INT>
  void populate_neighbor(Loc location, const std::vector<INT> &map, const Cell &neighbor) const;
 
  mutable std::vector<int64_t> min_I_nodes;
 
  mutable std::vector<int64_t> min_J_nodes;
 
  size_t m_i{0};
  size_t m_j{0};
 
  int64_t m_globalNodeIdOffset{0};
  int64_t m_localNodeIdOffset{0};
 
  mutable size_t m_communicationNodeOffset{0};
 
  mutable size_t m_communicationNodeCount{0};
 
  std::map<std::string, size_t> m_globalElementIdOffset;
  std::map<std::string, size_t> m_localElementIdOffset;
 
  std::map<std::string, size_t> m_localSurfaceOffset;
 
  double m_offX{0.0};
 
  double m_offY{0.0};
 
private:
  std::shared_ptr<UnitCell> m_unitCell;
 
  std::array<int, 9> m_ranks{{0, -1, -1, -1, -1, -1, -1, -1, -1}};
};