NekRSMesh.h

Go to the documentation of this file.

/********************************************************************/
/*                  SOFTWARE COPYRIGHT NOTIFICATION                 */
/*                             Cardinal                             */
/*                                                                  */
/*                  (c) 2021 UChicago Argonne, LLC                  */
/*                        ALL RIGHTS RESERVED                       */
/*                                                                  */
/*                 Prepared by UChicago Argonne, LLC                */
/*               Under Contract No. DE-AC02-06CH11357               */
/*                With the U. S. Department of Energy               */
/*                                                                  */
/*             Prepared by Battelle Energy Alliance, LLC            */
/*               Under Contract No. DE-AC07-05ID14517               */
/*                With the U. S. Department of Energy               */
/*                                                                  */
/*                 See LICENSE for full restrictions                */
/********************************************************************/

#pragma once

#include "MooseMesh.h"
#include "MooseApp.h"
#include "CardinalEnums.h"
#include "NekBoundaryCoupling.h"
#include "NekVolumeCoupling.h"
#include "NekInterface.h"
#include "NekUtility.h"

class NekRSMesh : public MooseMesh
{
public:
  NekRSMesh(const InputParameters & parameters);
  static InputParameters validParams();

  NekRSMesh(const NekRSMesh & /* other_mesh */) = default;

  NekRSMesh & operator=(const NekRSMesh & other_mesh) = delete;
  virtual std::unique_ptr<MooseMesh> safeClone() const override;

  void saveInitialVolMesh();

  void initializePreviousDisplacements();

  int nekPolynomialOrder() const { return _nek_polynomial_order; }

  int nBuildPerVolumeElem() const { return _n_build_per_volume_elem; }

  int nBuildPerSurfaceElem() const { return _n_build_per_surface_elem; }

  const std::vector<double> & nek_initial_x() const { return _initial_x; }

  const std::vector<double> & nek_initial_y() const { return _initial_y; }

  const std::vector<double> & nek_initial_z() const { return _initial_z; }

  std::vector<double> & prev_disp_x() { return _prev_disp_x; }

  std::vector<double> & prev_disp_y() { return _prev_disp_y; }

  std::vector<double> & prev_disp_z() { return _prev_disp_z; }

  const NekBoundaryCoupling & boundaryCoupling() const { return _boundary_coupling; }

  const NekVolumeCoupling & volumeCoupling() const { return _volume_coupling; }

  virtual void addElems();

  const order::NekOrderEnum & order() const { return _order; }

  int numQuadraturePoints1D() const;

  int nekNumQuadraturePoints1D() const;

  const int & numElems() const { return _n_elems; }

  const int & numVerticesPerElem() const { return _n_vertices_per_elem; }

  int nodeIndex(const int gll_index) const { return (*_node_index)[gll_index]; }

  const int & numSurfaceElems() const { return _n_surface_elems; }

  const int & nekNumSurfaceElems() const { return _nek_n_surface_elems; }

  const int & numVerticesPerSurface() const { return _n_vertices_per_surface; }

  const int & numVolumeElems() const { return _n_volume_elems; }

  const int & nekNumVolumeElems() const { return _nek_n_volume_elems; }

  const int & numVerticesPerVolume() const { return _n_vertices_per_volume; }

  const std::vector<int> * boundary() const { return _boundary; }

  const bool & volume() const { return _volume; }

  Elem * boundaryElem() const;

  Elem * volumeElem() const;

  virtual void buildMesh() override;

  virtual void buildDummyMesh();

  virtual void extractSurfaceMesh();

  virtual void extractVolumeMesh();

  int boundaryNodeIndex(const int gll_index) const { return _bnd_node_index[gll_index]; }

  int volumeNodeIndex(const int gll_index) const { return _vol_node_index[gll_index]; }

  const Real & scaling() const { return _scaling; }

  virtual void printMeshInfo() const;

  int boundaryElemProcessorID(const int elem_id);

  int volumeElemProcessorID(const int elem_id);

  int facesOnBoundary(const int elem_id) const;

  bool exactMirror() const { return _exact; }

  std::vector<std::vector<int>> cornerIndices() const { return _corner_indices; }

  int nMoosePerNek() const { return _n_moose_per_nek; }

  void updateDisplacement(const int e, const double * src, const field::NekWriteEnum field);

protected:
  void storeVolumeCoupling();

  void storeBoundaryCoupling();

  int boundary_id(const int elem_id, const int face_id);

  void faceVertices();

  void volumeVertices();

  void initializeMeshParams();

  const bool & _volume;

  const std::vector<int> * _boundary;

  const order::NekOrderEnum _order;

  const bool & _exact;

  int _n_vertices_per_surface;

  int _n_vertices_per_volume;

  const Real & _scaling;

  const unsigned int & _fluid_block_id;

  const unsigned int & _solid_block_id;

  int _nek_polynomial_order;

  int _n_surface_elems;

  int _n_build_per_surface_elem;

  int _n_volume_elems;

  int _n_build_per_volume_elem;

  int _n_elems;

  int _n_moose_per_nek;

  int (NekRSMesh::*_elem_processor_id)(const int elem_id);

  int _n_vertices_per_elem;

  std::vector<int> * _node_index;

  int _nek_n_surface_elems;

  int _nek_n_volume_elems;

  std::vector<int> _phase;

  std::vector<double> _x;

  std::vector<double> _y;

  std::vector<double> _z;

  std::vector<double> _initial_x;

  std::vector<double> _initial_y;

  std::vector<double> _initial_z;


  std::vector<double> _prev_disp_x;
  std::vector<double> _prev_disp_y;
  std::vector<double> _prev_disp_z;

  std::vector<int> _bnd_node_index;

  std::vector<int> _vol_node_index;

  std::vector<int> _side_index;

  Elem * (NekRSMesh::*_new_elem)() const;

  NekBoundaryCoupling _boundary_coupling;

  NekVolumeCoupling _volume_coupling;

  mesh_t * _nek_internal_mesh = nullptr;

  std::vector<std::vector<int>> _corner_indices;
};