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