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;
};