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;
};
class NekRSMesh : public MooseMesh {…};