F/rayleigh damping

include/NaluParsing.h

@@ -70,6 +70,7 @@ struct WallUserData : public UserData {
 
   bool wallFunctionApproach_;
   bool ablWallFunctionApproach_;
+  YAML::Node ablWallFunctionNode_;
 
   bool isFsiInterface_;
 

include/Realm.h

@@ -92,6 +92,8 @@ class TensorProductQuadratureRule;
 class LagrangeBasis;
 class PromotedElementIO;
 
+class ComputeDistanceToSurface;
+
 /** Representation of a computational domain and physics equations solved on
  * this domain.
  *
@@ -135,6 +137,9 @@ class Realm {
   void enforce_bc_on_exposed_faces();
   void setup_initial_conditions();
   void setup_property();
+  void register_surface_distance_fields();
+  void setup_surface_distance_calculations();
+  void perform_surface_distance_calculations();
   void extract_universal_constant( 
     const std::string name, double &value, const bool useDefault);
   void augment_property_map(
@@ -646,6 +651,8 @@ class Realm {
   stk::mesh::PartVector allPeriodicInteractingParts_;
   stk::mesh::PartVector allNonConformalInteractingParts_;
 
+  std::vector<std::shared_ptr<ComputeDistanceToSurface>> surfDists_;
+
   bool isFinalOuterIter_{false};
 
   /** The starting index (global) of the HYPRE linear system in this MPI rank

include/SolutionOptions.h

@@ -14,6 +14,8 @@
 
 #include <Enums.h>
 
+#include <Kokkos_Core.hpp>
+
 // standard c++
 #include <string>
 #include <map>
@@ -47,6 +49,13 @@ enum ProjTScaleType {
   NUM_TSCALE_TYPES
 };
 
+struct RayleighDampingParameters
+{
+   double cmax{1};
+   double width{1};
+   Kokkos::Array<double, 3> uref{{1,0,0}};
+};
+
 class SolutionOptions
 {
 public:
@@ -100,6 +109,22 @@ class SolutionOptions
 
   bool has_set_boussinesq_time_scale();
 
+  RayleighDampingParameters get_rayleigh_damping_params(std::string name) const
+  {
+    return rdParams_.at(name);
+  }
+
+  std::map<std::string, RayleighDampingParameters> get_rayleigh_damping_params() const
+  {
+    return rdParams_;
+  }
+
+  bool has_rayleigh_damping_params() const
+  {
+    return !rdParams_.empty();
+  }
+
+
   double hybridDefault_;
   double alphaDefault_;
   double alphaUpwDefault_;
@@ -215,6 +240,8 @@ class SolutionOptions
   bool newHO_;
 
   bool resetTAMSAverages_;
+
+  std::map<std::string, RayleighDampingParameters> rdParams_;
 };
 
 } // namespace nalu

include/WallDistEquationSystem.h

@@ -26,7 +26,7 @@ class EquationSystems;
 class WallDistEquationSystem : public EquationSystem
 {
 public:
-  WallDistEquationSystem(EquationSystems&);
+  WallDistEquationSystem(EquationSystems&, std::string = "");
 
   virtual ~WallDistEquationSystem();
 
@@ -77,6 +77,28 @@ class WallDistEquationSystem : public EquationSystem
 
   void compute_wall_distance();
 
+  static std::string min_wall_distance_name(std::string wallName)
+  {
+    return "minimum_distance_to_" + wallName;
+  }
+  static std::string wall_distance_phi_name(std::string wallName)
+  {
+    return wallName + "_distance_phi";
+  }
+
+  static std::string wall_distance_phi_bc_name(std::string wallName)
+  {
+    return wallName + "_distance_phi_bc";
+  }
+
+  static std::string dphidx_name(std::string wallName)
+  {
+    return "grad_" + wall_distance_phi_name(wallName);
+  }
+
+  void register_nodal_grad_algorithm_on_part(stk::mesh::Part* part);
+  void register_disting_surface(stk::mesh::Part* part, bool = false);
+
 private:
   WallDistEquationSystem() = delete;
   WallDistEquationSystem(const WallDistEquationSystem&) = delete;
@@ -102,6 +124,35 @@ class WallDistEquationSystem : public EquationSystem
 
   //! User option to force recomputation of wall distance on restart
   bool forceInitOnRestart_{false};
+  std::string wallName_{""};
+};
+
+class ComputeDistanceToSurface
+{
+public:
+  ComputeDistanceToSurface(
+    Realm& realm, 
+    std::string surface_name,
+    stk::mesh::PartVector interior,
+    stk::mesh::PartVector bc)
+    : meta_(*realm.metaData_),
+      eqsys(realm.equationSystems_, surface_name),
+      surface_name_(surface_name),
+      interior_(interior),
+      bc_(bc)
+  {
+  }
+
+  void register_fields();
+  void create_algorithms();
+  const ScalarFieldType& compute();
+private:
+  stk::mesh::MetaData& meta_;
+  WallDistEquationSystem eqsys;
+  const std::string surface_name_;
+
+  stk::mesh::PartVector interior_;
+  stk::mesh::PartVector bc_;
 };
 
 }  // nalu

include/edge_kernels/MomentumABLWallShearStressEdgeKernel.h

@@ -0,0 +1,65 @@
+// Copyright 2017 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS), National Renewable Energy Laboratory, University of Texas Austin,
+// Northwest Research Associates. Under the terms of Contract DE-NA0003525
+// with NTESS, the U.S. Government retains certain rights in this software.
+//
+// This software is released under the BSD 3-clause license. See LICENSE file
+// for more details.
+//
+
+
+#ifndef MOMENTUMABLWALLSHEARSTRESSEDGEKERNEL_H
+#define MOMENTUMABLWALLSHEARSTRESSEDGEKERNEL_H
+
+#include "kernel/Kernel.h"
+#include "KokkosInterface.h"
+#include "FieldTypeDef.h"
+
+#include "stk_mesh/base/MetaData.hpp"
+#include "stk_mesh/base/Entity.hpp"
+
+namespace sierra {
+namespace nalu {
+
+
+/**
+ * This class applies the computed wall shear stress field to the boundary.
+ *
+ */
+template<typename BcAlgTraits>
+class MomentumABLWallShearStressEdgeKernel: public NGPKernel<MomentumABLWallShearStressEdgeKernel<BcAlgTraits>>
+{
+public:
+  MomentumABLWallShearStressEdgeKernel(
+    stk::mesh::MetaData&,
+    ElemDataRequests& faceDataPreReqs);
+
+  KOKKOS_FORCEINLINE_FUNCTION MomentumABLWallShearStressEdgeKernel() = default;
+
+  KOKKOS_FORCEINLINE_FUNCTION virtual ~MomentumABLWallShearStressEdgeKernel() = default;
+
+  using Kernel::execute;
+
+  KOKKOS_FUNCTION
+  virtual void execute(
+    SharedMemView<DoubleType**, DeviceShmem>&,
+    SharedMemView<DoubleType*, DeviceShmem>&,
+    ScratchViews<DoubleType, DeviceTeamHandleType, DeviceShmem>&);
+
+private:
+  unsigned velocityNp1_     {stk::mesh::InvalidOrdinal};
+  unsigned bcVelocity_      {stk::mesh::InvalidOrdinal};
+  unsigned density_         {stk::mesh::InvalidOrdinal};
+  unsigned exposedAreaVec_  {stk::mesh::InvalidOrdinal};
+  unsigned wallFricVel_     {stk::mesh::InvalidOrdinal};
+  unsigned wallShearStress_ {stk::mesh::InvalidOrdinal};
+  unsigned wallNormDist_    {stk::mesh::InvalidOrdinal};
+
+  MasterElement* meFC_{nullptr};
+};
+
+}  // nalu
+}  // sierra
+
+
+#endif /* MOMENTUMABLWALLFUNCEDGEKERNEL_H */

include/kernel/ScalarFaceFluxBCElemKernel.h

@@ -0,0 +1,73 @@
+// Copyright 2017 National Technology & Engineering Solutions of Sandia, LLC
+// (NTESS), National Renewable Energy Laboratory, University of Texas Austin,
+// Northwest Research Associates. Under the terms of Contract DE-NA0003525
+// with NTESS, the U.S. Government retains certain rights in this software.
+//
+// This software is released under the BSD 3-clause license. See LICENSE file
+// for more details.
+//
+
+
+#ifndef SCALARFACEFLUXBCELEMKERNEL_H
+#define SCALARFACEFLUXBCELEMKERNEL_H
+
+#include "kernel/Kernel.h"
+#include "FieldTypeDef.h"
+
+#include "stk_mesh/base/MetaData.hpp"
+#include "stk_mesh/base/Entity.hpp"
+
+namespace sierra {
+namespace nalu {
+
+class ElemDataRequests;
+class MasterElement;
+
+/**
+ * This class applies the computed wall heat flux field to the boundary.
+ *
+ */
+template <typename BcAlgTraits>
+class ScalarFaceFluxBCElemKernel
+  : public NGPKernel<ScalarFaceFluxBCElemKernel<BcAlgTraits>>
+{
+public:
+  ScalarFaceFluxBCElemKernel(
+    const stk::mesh::BulkData&,
+    GenericFieldType*,
+    std::string,
+    const bool,
+    ElemDataRequests&);
+
+  KOKKOS_FORCEINLINE_FUNCTION
+  ScalarFaceFluxBCElemKernel() = default;
+
+  KOKKOS_FUNCTION
+  virtual ~ScalarFaceFluxBCElemKernel() = default;
+
+  /** Execute the kernel within a Kokkos loop and populate the LHS and RHS for
+   *  the linear solve
+   */
+  using Kernel::execute;
+
+  KOKKOS_FUNCTION
+  virtual void execute(
+    SharedMemView<DoubleType**, DeviceShmem>&,
+    SharedMemView<DoubleType*, DeviceShmem>&,
+    ScratchViews<DoubleType, DeviceTeamHandleType, DeviceShmem>&);
+
+private:
+  unsigned coordinates_{stk::mesh::InvalidOrdinal};
+  unsigned bcScalarQ_{stk::mesh::InvalidOrdinal};
+  unsigned exposedAreaVec_{stk::mesh::InvalidOrdinal};
+
+  const bool useShifted_{false};
+
+  MasterElement* meFC_{nullptr};
+};
+
+}  // nalu
+}  // sierra
+
+
+#endif /* SCALARFLUXBCELEMKERNEL_H */