Grid.h

Go to the documentation of this file.

// Copyright(C) 2021, 2022, 2023 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
 
#include <vector>
 
#include "Cell.h"
#include "Ioss_ParallelUtils.h"
#include "Ioss_Region.h"
#include "UnitCell.h"
#include "ZE_SystemInterface.h"
 
 
class Grid
{
public:
  explicit Grid(SystemInterface &interFace);
 
  void set_extent(size_t extent_i, size_t extent_j, size_t /* unused */);
 
  UnitCellMap &unit_cells() { return m_unitCells; }
 
  Cell &get_cell(size_t i, size_t j)
  {
    size_t idx = i * m_gridJ + j;
    return m_grid[idx];
  }
 
  size_t II() const { return m_gridI; }
  size_t JJ() const { return m_gridJ; }
  size_t size() const { return m_gridI * m_gridJ; }
  int    parallel_size() const { return m_parallelSize; }
 
  void set_start_rank(int start_rank) { m_startRank = start_rank; }
 
  void handle_file_count();
 
  bool equivalence_nodes() const { return m_equivalenceNodes; }
 
  bool initialize(size_t i, size_t j, const std::string &key);
 
  void add_unit_cell(const std::string &key, const std::string &unit_filename, bool ints32bit);
 
  void set_coordinate_offsets();
 
  void generate_sidesets();
 
  template <typename INT> void process(SystemInterface &interFace, INT /* dummy */);
 
  void decompose(const std::string &method);
 
  const Ioss::ParallelUtils &util() const { return m_pu; }
 
  Ioss::Region *output_region(int rank = 0) { return m_outputRegions[rank].get(); }
 
  bool         minimize_open_files(Minimize type) { return (int)m_minimizeOpenFiles & int(type); }
  unsigned int get_generated_sidesets() { return m_generatedSideSets; }
 
  void set_sideset_names(const std::string &names);
 
  std::array<std::string, 6> generated_surface_names{
      {"min_i", "max_i", "min_j", "max_j", "min_k", "max_k"}};
 
private:
  template <typename INT> void output_model(INT /*dummy*/);
  void                         internal_process();
 
  void create_output_regions(SystemInterface &interFace);
  void categorize_processor_boundaries();
 
  void output_nodal_coordinates(const Cell &cell);
  template <typename INT>
  void output_block_connectivity(Cell &cell, const std::vector<INT> &node_map);
  template <typename INT>
  void output_nodal_communication_map(Cell &cell, const std::vector<INT> &node_map);
  template <typename INT> void output_element_map(Cell &cell, INT /*dummy*/);
  template <typename INT> void output_node_map(const Cell &cell, INT /*dummy*/);
 
  template <typename INT> void output_surfaces(Cell &cell, INT /*dummy*/);
  template <typename INT> void output_generated_surfaces(Cell &cell, INT /*dummy*/);
 
  UnitCellMap                                m_unitCells;
  std::vector<std::unique_ptr<Ioss::Region>> m_outputRegions;
  std::vector<Cell>                          m_grid{};
  Ioss::ParallelUtils                        m_pu{};
  size_t                                     m_gridI{0};
  size_t                                     m_gridJ{0};
  vector3d                                   m_offset{0.0, 0.0, 0.0};
  double                                     m_scaleFactor{1.0};
  int                                        m_parallelSize{1}; 
  int          m_rankCount{1}; 
  int          m_startRank{0}; 
  bool         m_equivalenceNodes{true};
  bool         m_useInternalSidesets{true};
  bool         m_subCycle{false};
  Minimize     m_minimizeOpenFiles{Minimize::NONE}; // 1: Unit, 2: output, 3: all
  unsigned int m_generatedSideSets{0};
};