NekInterface.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 "CardinalEnums.h"
#include "MooseTypes.h"
#include "NekBoundaryCoupling.h"
#include "NekVolumeCoupling.h"
 
#include "inipp.hpp"
#include "nekrs.hpp"
#include "bcMap.hpp"
#include "udf.hpp"
#include "inipp.hpp"
#include "mesh.h"
 
#include "libmesh/point.h"
 
#include <string>
#include <vector>
 
namespace nekrs
{
 
static int build_only;
 
void initializeHostMeshParameters();
 
void updateHostMeshParameters();
 
dfloat * getSgeo();
dfloat * getVgeo();
 
void setAbsoluteTol(double tol);
 
void setRelativeTol(double tol);
 
void setNekSetupTime(const double & time);
 
double getNekSetupTime();
 
void setStartTime(const double & start);
 
bool isInitialized();
 
void write_usrwrk_field_file(const int & slot, const std::string & prefix, const dfloat & time, const int & step, const bool & write_coords);
 
void write_field_file(const std::string & prefix, const dfloat time, const int & step);
 
void buildOnly(int buildOnly);
 
int buildOnly();
 
void interpolateVolumeHex3D(const double * I, double * x, int N, double * Ix, int M);
 
bool hasCHT();
 
bool hasMovingMesh();
 
bool hasVariableDt();
 
bool hasBlendingSolver();
 
bool hasUserMeshSolver();
 
bool endControlElapsedTime();
 
bool endControlTime();
 
bool endControlNumSteps();
 
int scalarFieldOffset();
 
int velocityFieldOffset();
 
mesh_t * entireMesh();
 
mesh_t * flowMesh();
 
mesh_t * temperatureMesh();
 
mesh_t * getMesh(const nek_mesh::NekMeshEnum pp_mesh);
 
int commRank();
 
int commSize();
 
bool hasTemperatureVariable();
 
bool hasTemperatureSolve();
 
bool hasScalarVariable(int scalarId);
 
bool hasHeatSourceKernel();
 
bool scratchAvailable();
 
void initializeScratch(const unsigned int & n_slots);
 
void freeScratch();
 
double viscosity();
 
double Pr();
 
void copyDeformationToDevice();
 
template <typename T>
void allgatherv(const std::vector<int> & base_counts,
 const T * input,
 T * output,
 const int multiplier = 1);
 
void displacementAndCounts(const std::vector<int> & base_counts,
 int * counts,
 int * displacement,
 const int multiplier);
 
void interpolationMatrix(double * I, int starting_points, int ending_points);
 
void interpolateSurfaceFaceHex3D(
 double * scratch, const double * I, double * x, int N, double * Ix, int M);
 
Point centroidFace(int local_elem_id, int local_face_id);
 
Point centroid(int local_elem_id);
 
Point gllPoint(int local_elem_id, int local_node_id);
 
Point gllPointFace(int local_elem_id, int local_face_id, int local_node_id);
 
std::vector<double> usrwrkSideIntegral(const unsigned int & slot,
 const std::vector<int> & boundary,
 const nek_mesh::NekMeshEnum pp_mesh);
 
double usrwrkVolumeIntegral(const unsigned int & slot, const nek_mesh::NekMeshEnum pp_mesh);
 
void scaleUsrwrk(const unsigned int & slot, const dfloat & value);
 
bool normalizeFluxBySideset(const NekBoundaryCoupling & nek_boundary_coupling,
 const std::vector<int> & boundary,
 const std::vector<double> & moose_integral,
 std::vector<double> & nek_integral,
 double & normalized_nek_integral);
 
bool normalizeFlux(const NekBoundaryCoupling & nek_boundary_coupling,
 const std::vector<int> & boundary,
 const double moose_integral,
 double nek_integral,
 double & normalized_nek_integral);
 
double area(const std::vector<int> & boundary_id, const nek_mesh::NekMeshEnum pp_mesh);
 
double sideIntegral(const std::vector<int> & boundary_id, const field::NekFieldEnum & integrand,
 const nek_mesh::NekMeshEnum pp_mesh);
 
double volume(const nek_mesh::NekMeshEnum pp_mesh);
 
void dimensionalizeVolume(double & integral);
 
void dimensionalizeArea(double & integral);
 
void dimensionalizeVolumeIntegral(const field::NekFieldEnum & integrand,
 const Real & volume,
 double & integral);
 
void dimensionalizeSideIntegral(const field::NekFieldEnum & integrand,
 const Real & area,
 double & integral);
 
void dimensionalizeSideIntegral(const field::NekFieldEnum & integrand,
 const std::vector<int> & boundary_id,
 double & integral,
 const nek_mesh::NekMeshEnum pp_mesh);
 
double volumeIntegral(const field::NekFieldEnum & integrand,
 const double & volume,
 const nek_mesh::NekMeshEnum pp_mesh);
 
double massFlowrate(const std::vector<int> & boundary_id,
 const nek_mesh::NekMeshEnum pp_mesh);
 
double sideMassFluxWeightedIntegral(const std::vector<int> & boundary_id,
 const field::NekFieldEnum & integrand,
 const nek_mesh::NekMeshEnum pp_mesh);
 
double pressureSurfaceForce(const std::vector<int> & boundary_id, const Point & direction, const nek_mesh::NekMeshEnum pp_mesh);
 
double heatFluxIntegral(const std::vector<int> & boundary_id,
 const nek_mesh::NekMeshEnum pp_mesh);
 
void limitTemperature(const double * min_T, const double * max_T);
 
void gradient(const int offset, const double * f, double * grad_f,
 const nek_mesh::NekMeshEnum pp_mesh);
 
double volumeExtremeValue(const field::NekFieldEnum & field,
 const nek_mesh::NekMeshEnum pp_mesh,
 const bool max);
 
double sideExtremeValue(const std::vector<int> & boundary_id, const field::NekFieldEnum & field,
 const nek_mesh::NekMeshEnum pp_mesh, const bool max);
 
int Nfaces();
 
bool isHeatFluxBoundary(const int boundary);
 
bool isMovingMeshBoundary(const int boundary);
 
bool isTemperatureBoundary(const int boundary);
 
const std::string temperatureBoundaryType(const int boundary);
 
int polynomialOrder();
 
int Nelements();
 
int dim();
 
int NfaceVertices();
 
int NboundaryFaces();
 
int NboundaryID();
 
bool
validBoundaryIDs(const std::vector<int> & boundary_id, int & first_invalid_id, int & n_boundaries);
 
void storeBoundaryCoupling(const std::vector<int> & boundary_id, int & N);
 
struct usrwrkIndices
{
 int flux;
 
 int heat_source;
 
 int mesh_velocity_x;
 
 int mesh_velocity_y;
 
 int mesh_velocity_z;
 
 int boundary_velocity;
 
 int boundary_temperature;
 
 int boundary_scalar01;
 
 int boundary_scalar02;
 
 int boundary_scalar03;
};
 
struct characteristicScales
{
 double U_ref;
 
 double T_ref;
 
 double dT_ref;
 
 double L_ref;
 
 double A_ref;
 
 double V_ref;
 
 double rho_ref;
 
 double Cp_ref;
 
 double flux_ref;
 
 double source_ref;
 
 bool nondimensional_T;
};
 
double (*solutionPointer(const field::NekFieldEnum & field))(int);
 
void (*solutionPointer(const field::NekWriteEnum & field))(int, dfloat);
 
double scalar01(const int id);
 
double scalar02(const int id);
 
double scalar03(const int id);
 
double temperature(const int id);
 
double pressure(const int id);
 
double unity(const int id);
 
double velocity_x(const int id);
 
double velocity_y(const int id);
 
double velocity_z(const int id);
 
double velocity(const int id);
 
void flux(const int id, const dfloat value);
 
void heat_source(const int id, const dfloat value);
 
void x_displacement(const int id, const dfloat value);
 
void y_displacement(const int id, const dfloat value);
 
void z_displacement(const int id, const dfloat value);
 
void initializeDimensionalScales(const double U_ref,
 const double T_ref,
 const double dT_ref,
 const double L_ref,
 const double rho_ref,
 const double Cp_ref);
 
void dimensionalize(const field::NekFieldEnum & field, double & value);
 
double referenceFlux();
 
double referenceSource();
 
double referenceLength();
 
double referenceArea();
 
double referenceVolume();
 
// useful concept from Stack Overflow for templating MPI calls
template <typename T>
MPI_Datatype resolveType();
 
template <typename T>
void
allgatherv(const std::vector<int> & base_counts, const T * input, T * output, const int multiplier)
{
 int * recvCounts = (int *)calloc(commSize(), sizeof(int));
 int * displacement = (int *)calloc(commSize(), sizeof(int));
 displacementAndCounts(base_counts, recvCounts, displacement, multiplier);
 
 MPI_Allgatherv(input,
 recvCounts[commRank()],
 resolveType<T>(),
 output,
 (const int *)recvCounts,
 (const int *)displacement,
 resolveType<T>(),
 platform->comm.mpiComm);
 
 free(recvCounts);
 free(displacement);
}
 
} // end namespace nekrs