DistributedRectilinearMeshGenerator.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include "MeshGenerator.h"

#include "libmesh/face_quad4.h"
#include "libmesh/cell_hex8.h"
#include "libmesh/edge_edge2.h"

class DistributedRectilinearMeshGenerator : public MeshGenerator
{
public:
  static InputParameters validParams();

  DistributedRectilinearMeshGenerator(const InputParameters & parameters);

  std::unique_ptr<MeshBase> generate() override;

  template <typename T>
  void buildCube(UnstructuredMesh & /*mesh*/,
                 const unsigned int /*nx*/,
                 unsigned int /*ny*/,
                 unsigned int /*nz*/,
                 const Real /*xmin*/,
                 const Real /*xmax*/,
                 const Real /*ymin*/,
                 const Real /*ymax*/,
                 const Real /*zmin*/,
                 const Real /*zmax*/,
                 const ElemType /*type*/);

  template <typename T>
  dof_id_type elemId(const dof_id_type /*nx*/,
                     const dof_id_type /*ny*/,
                     const dof_id_type /*i*/,
                     const dof_id_type /*j*/,
                     const dof_id_type /*k*/)
  {
    mooseError(
        "elemId not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  dof_id_type numNeighbors(const dof_id_type /*nx*/,
                           const dof_id_type /*ny*/,
                           const dof_id_type /*nz*/,
                           const dof_id_type /*i*/,
                           const dof_id_type /*j*/,
                           const dof_id_type /*k*/)
  {
    mooseError("numNeighbors not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  void getNeighbors(const dof_id_type /*nx*/,
                    const dof_id_type /*ny*/,
                    const dof_id_type /*nz*/,
                    const dof_id_type /*i*/,
                    const dof_id_type /*j*/,
                    const dof_id_type /*k*/,
                    std::vector<dof_id_type> & /*neighbors*/,
                    const bool /*corner = false*/)
  {
    mooseError("getNeighbors not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  dof_id_type nodeId(const ElemType /*type*/,
                     const dof_id_type /*nx*/,
                     const dof_id_type /*ny*/,
                     const dof_id_type /*i*/,
                     const dof_id_type /*j*/,
                     const dof_id_type /*k*/)
  {
    mooseError(
        "nodeId not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  Node * addPoint(const dof_id_type /*nx*/,
                  const dof_id_type /*ny*/,
                  const dof_id_type /*nz*/,
                  const dof_id_type /*i*/,
                  const dof_id_type /*j*/,
                  const dof_id_type /*k*/,
                  const ElemType /*type*/,
                  MeshBase & /*mesh*/)
  {
    mooseError(
        "addPoint not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  void addElement(const dof_id_type /*nx*/,
                  const dof_id_type /*ny*/,
                  const dof_id_type /*nz*/,
                  const dof_id_type /*i*/,
                  const dof_id_type /*j*/,
                  const dof_id_type /*k*/,
                  const dof_id_type /*elem_id*/,
                  const processor_id_type /*pid*/,
                  const ElemType /*type*/,
                  MeshBase & /*mesh*/)
  {
    mooseError(
        "addElement not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  void paritionSquarely(const dof_id_type /*nx*/,
                        const dof_id_type /*ny*/,
                        const dof_id_type /*nz*/,
                        const processor_id_type /*num_procs*/,
                        std::vector<dof_id_type> & /*istarts*/,
                        std::vector<dof_id_type> & /*jstarts*/,
                        std::vector<dof_id_type> & /*kstarts*/)
  {
    mooseError("paritionSquarely not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  void getIndices(const dof_id_type /*nx*/,
                  const dof_id_type /*ny*/,
                  const dof_id_type /*elem_id*/,
                  dof_id_type & /*i*/,
                  dof_id_type & /*j*/,
                  dof_id_type & /*k*/)
  {
    mooseError(
        "getIndices not implemented for this element type in DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  void getGhostNeighbors(const dof_id_type /*nx*/,
                         const dof_id_type /*ny*/,
                         const dof_id_type /*nz*/,
                         const MeshBase & /*mesh*/,
                         const std::set<dof_id_type> & /*current_elems*/,
                         std::set<dof_id_type> & /*ghost_elems*/)
  {
    mooseError("getGhostNeighbors not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  void setBoundaryNames(BoundaryInfo & /*boundary_info*/)
  {
    mooseError("setBoundaryNames not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

  template <typename T>
  void scaleNodalPositions(dof_id_type /*nx*/,
                           dof_id_type /*ny*/,
                           dof_id_type /*nz*/,
                           Real /*xmin*/,
                           Real /*xmax*/,
                           Real /*ymin*/,
                           Real /*ymax*/,
                           Real /*zmin*/,
                           Real /*zmax*/,
                           MeshBase & /*mesh*/)
  {
    mooseError("scaleNodalPositions not implemented for this element type in "
               "DistributedRectilinearMeshGenerator");
  }

protected:
  MooseEnum _dim;

  dof_id_type &_nx, &_ny, &_nz;

  Real &_xmin, &_xmax, &_ymin, &_ymax, &_zmin, &_zmax;

  processor_id_type _num_cores_for_partition;

  ElemType _elem_type;

  Real _bias_x, _bias_y, _bias_z;

  std::string _part_package;

  processor_id_type _num_parts_per_compute_node;

  std::string _partition_method;

  unsigned _num_side_layers;
};

template <>
dof_id_type DistributedRectilinearMeshGenerator::elemId<Edge2>(const dof_id_type nx,
                                                               const dof_id_type ny,
                                                               const dof_id_type i,
                                                               const dof_id_type j,
                                                               const dof_id_type k);

template <>
dof_id_type DistributedRectilinearMeshGenerator::elemId<Quad4>(const dof_id_type nx,
                                                               const dof_id_type ny,
                                                               const dof_id_type i,
                                                               const dof_id_type j,
                                                               const dof_id_type k);

template <>
dof_id_type DistributedRectilinearMeshGenerator::elemId<Hex8>(const dof_id_type nx,
                                                              const dof_id_type ny,
                                                              const dof_id_type i,
                                                              const dof_id_type j,
                                                              const dof_id_type k);

template <>
dof_id_type DistributedRectilinearMeshGenerator::numNeighbors<Edge2>(const dof_id_type nx,
                                                                     const dof_id_type ny,
                                                                     const dof_id_type nz,
                                                                     const dof_id_type i,
                                                                     const dof_id_type j,
                                                                     const dof_id_type k);

template <>
dof_id_type DistributedRectilinearMeshGenerator::numNeighbors<Quad4>(const dof_id_type nx,
                                                                     const dof_id_type ny,
                                                                     const dof_id_type nz,
                                                                     const dof_id_type i,
                                                                     const dof_id_type j,
                                                                     const dof_id_type k);

template <>
dof_id_type DistributedRectilinearMeshGenerator::numNeighbors<Hex8>(const dof_id_type nx,
                                                                    const dof_id_type ny,
                                                                    const dof_id_type nz,
                                                                    const dof_id_type i,
                                                                    const dof_id_type j,
                                                                    const dof_id_type k);

template <>
void DistributedRectilinearMeshGenerator::getNeighbors<Edge2>(const dof_id_type nx,
                                                              const dof_id_type ny,
                                                              const dof_id_type nz,
                                                              const dof_id_type i,
                                                              const dof_id_type j,
                                                              const dof_id_type k,
                                                              std::vector<dof_id_type> & neighbors,
                                                              const bool corner);

template <>
void DistributedRectilinearMeshGenerator::getNeighbors<Quad4>(const dof_id_type nx,
                                                              const dof_id_type ny,
                                                              const dof_id_type nz,
                                                              const dof_id_type i,
                                                              const dof_id_type j,
                                                              const dof_id_type k,
                                                              std::vector<dof_id_type> & neighbors,
                                                              const bool corner);

template <>
void DistributedRectilinearMeshGenerator::getNeighbors<Hex8>(const dof_id_type nx,
                                                             const dof_id_type ny,
                                                             const dof_id_type nz,
                                                             const dof_id_type i,
                                                             const dof_id_type j,
                                                             const dof_id_type k,
                                                             std::vector<dof_id_type> & neighbors,
                                                             const bool corner);

template <>
dof_id_type DistributedRectilinearMeshGenerator::nodeId<Edge2>(const ElemType type,
                                                               const dof_id_type nx,
                                                               const dof_id_type ny,
                                                               const dof_id_type i,
                                                               const dof_id_type j,
                                                               const dof_id_type k);

template <>
dof_id_type DistributedRectilinearMeshGenerator::nodeId<Quad4>(const ElemType type,
                                                               const dof_id_type nx,
                                                               const dof_id_type ny,
                                                               const dof_id_type i,
                                                               const dof_id_type j,
                                                               const dof_id_type k);

template <>
dof_id_type DistributedRectilinearMeshGenerator::nodeId<Hex8>(const ElemType type,
                                                              const dof_id_type nx,
                                                              const dof_id_type ny,
                                                              const dof_id_type i,
                                                              const dof_id_type j,
                                                              const dof_id_type k);

template <>
Node * DistributedRectilinearMeshGenerator::addPoint<Edge2>(const dof_id_type nx,
                                                            const dof_id_type ny,
                                                            const dof_id_type nz,
                                                            const dof_id_type i,
                                                            const dof_id_type j,
                                                            const dof_id_type k,
                                                            const ElemType type,
                                                            MeshBase & mesh);

template <>
Node * DistributedRectilinearMeshGenerator::addPoint<Quad4>(const dof_id_type nx,
                                                            const dof_id_type ny,
                                                            const dof_id_type nz,
                                                            const dof_id_type i,
                                                            const dof_id_type j,
                                                            const dof_id_type k,
                                                            const ElemType type,
                                                            MeshBase & mesh);

template <>
Node * DistributedRectilinearMeshGenerator::addPoint<Hex8>(const dof_id_type nx,
                                                           const dof_id_type ny,
                                                           const dof_id_type nz,
                                                           const dof_id_type i,
                                                           const dof_id_type j,
                                                           const dof_id_type k,
                                                           const ElemType type,
                                                           MeshBase & mesh);

template <>
void DistributedRectilinearMeshGenerator::addElement<Edge2>(const dof_id_type nx,
                                                            const dof_id_type ny,
                                                            const dof_id_type nz,
                                                            const dof_id_type i,
                                                            const dof_id_type j,
                                                            const dof_id_type k,
                                                            const dof_id_type elem_id,
                                                            const processor_id_type pid,
                                                            const ElemType type,
                                                            MeshBase & mesh);

template <>
void DistributedRectilinearMeshGenerator::addElement<Quad4>(const dof_id_type nx,
                                                            const dof_id_type ny,
                                                            const dof_id_type nz,
                                                            const dof_id_type i,
                                                            const dof_id_type j,
                                                            const dof_id_type k,
                                                            const dof_id_type elem_id,
                                                            const processor_id_type pid,
                                                            const ElemType type,
                                                            MeshBase & mesh);

template <>
void DistributedRectilinearMeshGenerator::addElement<Hex8>(const dof_id_type nx,
                                                           const dof_id_type ny,
                                                           const dof_id_type nz,
                                                           const dof_id_type i,
                                                           const dof_id_type j,
                                                           const dof_id_type k,
                                                           const dof_id_type elem_id,
                                                           const processor_id_type pid,
                                                           const ElemType type,
                                                           MeshBase & mesh);

template <>
void DistributedRectilinearMeshGenerator::getIndices<Edge2>(const dof_id_type nx,
                                                            const dof_id_type ny,
                                                            const dof_id_type elem_id,
                                                            dof_id_type & i,
                                                            dof_id_type & j,
                                                            dof_id_type & k);

template <>
void DistributedRectilinearMeshGenerator::getIndices<Quad4>(const dof_id_type nx,
                                                            const dof_id_type ny,
                                                            const dof_id_type elem_id,
                                                            dof_id_type & i,
                                                            dof_id_type & j,
                                                            dof_id_type & k);

template <>
void DistributedRectilinearMeshGenerator::getIndices<Hex8>(const dof_id_type nx,
                                                           const dof_id_type ny,
                                                           const dof_id_type elem_id,
                                                           dof_id_type & i,
                                                           dof_id_type & j,
                                                           dof_id_type & k);

template <>
void DistributedRectilinearMeshGenerator::getGhostNeighbors<Edge2>(
    const dof_id_type nx,
    const dof_id_type ny,
    const dof_id_type nz,
    const MeshBase & mesh,
    const std::set<dof_id_type> & current_elems,
    std::set<dof_id_type> & ghost_elems);

template <>
void DistributedRectilinearMeshGenerator::getGhostNeighbors<Quad4>(
    const dof_id_type nx,
    const dof_id_type ny,
    const dof_id_type nz,
    const MeshBase & mesh,
    const std::set<dof_id_type> & current_elems,
    std::set<dof_id_type> & ghost_elems);

template <>
void DistributedRectilinearMeshGenerator::getGhostNeighbors<Hex8>(
    const dof_id_type nx,
    const dof_id_type ny,
    const dof_id_type nz,
    const MeshBase & mesh,
    const std::set<dof_id_type> & current_elems,
    std::set<dof_id_type> & ghost_elems);

template <>
void DistributedRectilinearMeshGenerator::scaleNodalPositions<Edge2>(dof_id_type nx,
                                                                     dof_id_type ny,
                                                                     dof_id_type nz,
                                                                     Real xmin,
                                                                     Real xmax,
                                                                     Real ymin,
                                                                     Real ymax,
                                                                     Real zmin,
                                                                     Real zmax,
                                                                     MeshBase & mesh);

template <>
void DistributedRectilinearMeshGenerator::scaleNodalPositions<Quad4>(dof_id_type nx,
                                                                     dof_id_type ny,
                                                                     dof_id_type nz,
                                                                     Real xmin,
                                                                     Real xmax,
                                                                     Real ymin,
                                                                     Real ymax,
                                                                     Real zmin,
                                                                     Real zmax,
                                                                     MeshBase & mesh);

template <>
void DistributedRectilinearMeshGenerator::scaleNodalPositions<Hex8>(dof_id_type nx,
                                                                    dof_id_type ny,
                                                                    dof_id_type nz,
                                                                    Real xmin,
                                                                    Real xmax,
                                                                    Real ymin,
                                                                    Real ymax,
                                                                    Real zmin,
                                                                    Real zmax,
                                                                    MeshBase & mesh);

template <>
void DistributedRectilinearMeshGenerator::setBoundaryNames<Edge2>(BoundaryInfo & boundary_info);

template <>
void DistributedRectilinearMeshGenerator::setBoundaryNames<Quad4>(BoundaryInfo & boundary_info);

template <>
void DistributedRectilinearMeshGenerator::setBoundaryNames<Hex8>(BoundaryInfo & boundary_info);

template <>
void DistributedRectilinearMeshGenerator::paritionSquarely<Edge2>(
    const dof_id_type /*nx*/,
    const dof_id_type /*ny*/,
    const dof_id_type /*nz*/,
    const processor_id_type /*num_procs*/,
    std::vector<dof_id_type> & /*istarts*/,
    std::vector<dof_id_type> & /*jstarts*/,
    std::vector<dof_id_type> & /*kstarts*/);

template <>
void DistributedRectilinearMeshGenerator::paritionSquarely<Quad4>(
    const dof_id_type /*nx*/,
    const dof_id_type /*ny*/,
    const dof_id_type /*nz*/,
    const processor_id_type /*num_procs*/,
    std::vector<dof_id_type> & /*istarts*/,
    std::vector<dof_id_type> & /*jstarts*/,
    std::vector<dof_id_type> & /*kstarts*/);

template <>
void
DistributedRectilinearMeshGenerator::paritionSquarely<Hex8>(const dof_id_type /*nx*/,
                                                            const dof_id_type /*ny*/,
                                                            const dof_id_type /*nz*/,
                                                            const processor_id_type /*num_procs*/,
                                                            std::vector<dof_id_type> & /*istarts*/,
                                                            std::vector<dof_id_type> & /*jstarts*/,
                                                            std::vector<dof_id_type> & /*kstarts*/);