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);
 
  std::pair<unsigned int, unsigned int> scratchSpaceReservedForCoupling() const;
 
  bool isUsrWrkSlotReservedForCoupling(const unsigned int & slot) const;
 
  void copyIndividualScratchSlot(const unsigned int & slot) const;
 
  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();
 
  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 & _write_fld_files;
 
  const bool & _disable_fld_file_output;
 
  bool _nondimensional;
 
  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;
};
class NekRSProblemBase : public CardinalProblem {…};