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