NekRSProblemBase.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 "CardinalProblem.h"
#include "NekInterface.h"
#include "NekTimeStepper.h"
#include "NekScalarValue.h"
#include "NekRSMesh.h"
#include "Transient.h"
#include "TimeStepper.h"
 
#include <memory>
#include "inipp.hpp"
#include "nekrs.hpp"
 
class NekRSProblemBase : public CardinalProblem
{
public:
 NekRSProblemBase(const InputParameters & params);
 
 static InputParameters validParams();
 
 ~NekRSProblemBase();
 
 bool isDataTransferHappening(ExternalProblem::Direction direction);
 
 unsigned int minimumScratchSizeForCoupling() const { return _minimum_scratch_size_for_coupling; }
 
 unsigned int firstReservedUsrwrkSlot() const { return _first_reserved_usrwrk_slot; }
 
 void sendScalarValuesToNek();
 
 void getNekScalarValueUserObjects();
 
 void mapFaceDataToNekFace(const unsigned int & e, const unsigned int & var_num,
 const Real & multiplier, double ** outgoing_data);
 
 void mapVolumeDataToNekVolume(const unsigned int & e, const unsigned int & var_num,
 const Real & multiplier, double ** outgoing_data);
 
 void mapFaceDataToNekVolume(const unsigned int & e, const unsigned int & var_num,
 const Real & multiplier, double ** outgoing_data);
 
 void writeFieldFile(const Real & time, const int & step) const;
 
 virtual void adjustNekSolution() {}
 
 virtual bool isOutputStep() const;
 
 virtual void initialSetup() override;
 
 virtual void externalSolve() override;
 
 virtual bool converged(unsigned int) override { return true; }
 
 virtual void addExternalVariables() override;
 
 virtual void syncSolutions(ExternalProblem::Direction direction) override;
 
 virtual bool nondimensional() const { return _nondimensional; }
 
 virtual const bool hasMovingNekMesh() const { return false; }
 
 virtual bool synchronizeIn();
 
 virtual bool synchronizeOut();
 
 double L_ref() const { return _L_ref; }
 
 unsigned int nUsrWrkSlots() const { return _n_usrwrk_slots; }
 
protected:
 void copyScratchToDevice();
 
 void interpolateBoundarySolutionToNek(double * incoming_moose_value,
 double * outgoing_nek_value);
 
 void interpolateVolumeSolutionToNek(const int elem_id, double * incoming_moose_value,
 double * outgoing_nek_value);
 
 void writeVolumeSolution(const int elem_id,
 const field::NekWriteEnum & field,
 double * T,
 const std::vector<double> * add = nullptr);
 
 void writeBoundarySolution(const int elem_id, const field::NekWriteEnum & field, double * T);
 
 void volumeSolution(const field::NekFieldEnum & f, double * T);
 
 void boundarySolution(const field::NekFieldEnum & f, double * T);
 
 void initializeInterpolationMatrices();
 
 virtual void fillAuxVariable(const unsigned int var_number, const double * value);
 
 virtual void extractOutputs();
 
 virtual InputParameters getExternalVariableParameters();
 
 virtual void addTemperatureVariable();
 
 std::unique_ptr<NumericVector<Number>> _serialized_solution;
 
 std::string fieldFilePrefix(const int & number) const;
 
 const std::string & _casename;
 
 const bool & _nondimensional;
 
 const Real & _U_ref;
 
 const Real & _T_ref;
 
 const Real & _dT_ref;
 
 const Real & _L_ref;
 
 const Real & _rho_0;
 
 const Real & _Cp_0;
 
 const bool & _write_fld_files;
 
 const bool & _disable_fld_file_output;
 
 unsigned int _n_usrwrk_slots;
 
 const unsigned int & _constant_interval;
 
 const bool & _skip_final_field_file;
 
 const unsigned int & _first_reserved_usrwrk_slot;
 
 int _n_surface_elems;
 
 int _n_vertices_per_surface;
 
 int _n_volume_elems;
 
 int _n_vertices_per_volume;
 
 int _n_vertices_per_elem;
 
 const std::vector<int> * _boundary = nullptr;
 
 bool _volume;
 
 double _start_time;
 
 bool _is_output_step;
 
 NekRSMesh * _nek_mesh;
 
 NekTimeStepper * _timestepper = nullptr;
 
 Transient * _transient_executioner = nullptr;
 
 bool _needs_interpolation;
 
 const MultiMooseEnum * _outputs = nullptr;
 
 std::vector<std::string> _var_names;
 
 std::vector<unsigned int> _external_vars;
 
 std::string _var_string;
 
 double * _external_data = nullptr;
 
 int _n_points;
 
 const PostprocessorValue * _transfer_in = nullptr;
 
 double * _interpolation_outgoing = nullptr;
 
 double * _interpolation_incoming = nullptr;
 
 unsigned int _minimum_scratch_size_for_coupling;
 
 int _moose_Nq;
 
 const std::vector<unsigned int> * _usrwrk_output = nullptr;
 
 const std::vector<std::string> * _usrwrk_output_prefix = nullptr;
 
 double _elapsedStepSum;
 
 double _elapsedTime;
 
 double _tSolveStepMin;
 
 double _tSolveStepMax;
 
 synchronization::SynchronizationEnum _synchronization_interval;
 
 std::vector<std::string> _usrwrk_indices;
 
 std::vector<NekScalarValue *> _nek_uos;
 
 static bool _first;
 
 unsigned int _scratch_counter;
 
 unsigned int _n_uo_slots;
};