Merge pull request #31027 from loganharbour/ray_periodic

Implement PeriodicRayBC, add multisystem support to periodic BCs

Author: loganharbour

framework/include/actions/AddPeriodicBCAction.h

@@ -10,6 +10,7 @@
 #pragma once
 
 #include "Action.h"
+#include "PeriodicBCHelper.h"
 
 class MooseMesh;
 namespace libMesh
@@ -22,7 +23,7 @@ class PeriodicBoundaryBase;
  * are not MooseObjects so you need not specify a type for these boundaries.  If you
  * do, it will currently be ignored by this Action.
  */
-class AddPeriodicBCAction : public Action
+class AddPeriodicBCAction : public Action, public Moose::PeriodicBCHelper
 {
 public:
   static InputParameters validParams();
@@ -32,15 +33,23 @@ class AddPeriodicBCAction : public Action
   virtual void act() override;
 
 protected:
+  using Action::paramError;
+
+  /**
+   * Overriden method from PeriodicBCHelper that is called on every periodic
+   * boundary, in which we will setup the algebraic ghosting via the DofMap
+   * and the MooseMesh context if possible.
+   */
+  virtual void onSetupPeriodicBoundary(libMesh::PeriodicBoundaryBase & p) override;
+
   /**
-   * This function will automatically add the correct translation vectors for
-   * each requested dimension when using GeneratedMesh
-   * @returns a boolean indicating whether or not these boundaries were automatically added
+   * Helper for getting the variables to which periodic boundary
+   * conditions will be applied
    */
-  bool autoTranslationBoundaries();
+  std::vector<const MooseVariableFieldBase *> getVariables() const;
 
-  void setPeriodicVars(libMesh::PeriodicBoundaryBase & p,
-                       const std::vector<VariableName> & var_names);
+  /// The variables to apply periodic boundary conditions to
+  std::vector<const MooseVariableFieldBase *> _vars;
 
   MooseMesh * _mesh;
 };

framework/include/bcs/FunctionPeriodicBoundary.h

@@ -11,33 +11,37 @@
 
 #include "Moose.h"
 
-// libMesh
 #include "libmesh/point.h"
 #include "libmesh/periodic_boundary_base.h"
 
+#include <array>
 #include <vector>
 
 class FEProblemBase;
 class Function;
 
 /**
- * Periodic boundary for calculation periodic BC on domains where the translation is given by
- * functions
+ * Periodic boundary for calculation periodic BC on domains where the
+ * translation is given by Function objects
  */
 class FunctionPeriodicBoundary : public libMesh::PeriodicBoundaryBase
 {
 public:
   /**
-   * Initialize the periodic boundary with three functions
+   * Initialize the periodic with the functions and inverse functions, one
+   * for each dimension needed
    */
-  FunctionPeriodicBoundary(FEProblemBase & subproblem, std::vector<std::string> fn_names);
+  FunctionPeriodicBoundary(FEProblemBase & subproblem,
+                           const std::vector<std::string> & fn_names,
+                           const std::vector<std::string> & inv_fn_names);
 
   /**
    * Copy constructor for creating the periodic boundary and inverse periodic boundary
    *
    * @param o - Periodic boundary being copied
+   * @param t - Transformation direction
    */
-  FunctionPeriodicBoundary(const FunctionPeriodicBoundary & o);
+  FunctionPeriodicBoundary(const FunctionPeriodicBoundary & o, TransformationType t = FORWARD);
 
   /**
    * Get the translation based on point 'pt'
@@ -46,26 +50,17 @@ class FunctionPeriodicBoundary : public libMesh::PeriodicBoundaryBase
    */
   virtual libMesh::Point get_corresponding_pos(const libMesh::Point & pt) const override;
 
-  /**
-   * Required interface, this class must be able to clone itself
-   */
   virtual std::unique_ptr<libMesh::PeriodicBoundaryBase> clone(TransformationType t) const override;
 
-protected:
-  //  /// The dimension of the problem (says which _tr_XYZ member variables are active)
-  unsigned int _dim;
-
-  /// Pointer to Function for x-component of the boundary
-  const Function * const _tr_x;
+private:
+  static std::array<const Function *, 3> getFunctions(FEProblemBase & problem,
+                                                      const std::vector<std::string> & names);
 
-  /// Pointer to Function for y-component of the boundary
-  const Function * const _tr_y;
+  /// The dimension of the problem (says which of _tr and _inv_tr are active)
+  const unsigned int _dim;
 
-  /// Pointer to Function for z-component of the boundary
-  const Function * const _tr_z;
-
-  /**
-   * An initialization method to make certain that initialSetup() of a function prior to value()
-   */
-  void init();
+  /// Pointers to translation functions in each dimension
+  const std::array<const Function *, 3> _tr;
+  /// Pointers to inverse translation functions in each dimension
+  const std::array<const Function *, 3> _inv_tr;
 };

framework/include/interfaces/Coupleable.h

@@ -1634,6 +1634,14 @@ class Coupleable
    */
   MooseVariableFieldBase * getFieldVar(const std::string & var_name, unsigned int comp);
 
+  /*
+   * Extract pointers to all components of a base coupled field variable.
+   * Could be either a finite volume or finite element variable
+   * @param var_name Name of variable desired
+   * @return Pointers to the desired variables
+   */
+  std::vector<const MooseVariableFieldBase *> getFieldVars(const std::string & var_name) const;
+
   /**
    * Helper that that be used to retrieve a variable of arbitrary type \p T
    */
@@ -1646,6 +1654,14 @@ class Coupleable
   template <typename T>
   T * getVarHelper(const std::string & var_name, unsigned int comp);
 
+  /**
+   * Helper that can be used to retrieve all the component variables of a variable
+   * of arbitrary type \p T
+   * @param var_name of the variable, can be a regular, vector or array variable
+   */
+  template <typename T>
+  std::vector<const T *> getVarsHelper(const std::string & var_name) const;
+
   /**
    * Extract pointer to a coupled variable
    * @param var_name Name of parameter desired
@@ -2003,3 +2019,14 @@ Coupleable::getVarHelper(const std::string & var_name, unsigned int comp) const
 {
   return const_cast<Coupleable *>(this)->getVarHelper<T>(var_name, comp);
 }
+
+template <typename T>
+std::vector<const T *>
+Coupleable::getVarsHelper(const std::string & var_name) const
+{
+  const auto components = coupledComponents(var_name);
+  std::vector<const T *> vars(components);
+  for (const auto i : make_range(components))
+    vars[i] = getVarHelper<T>(var_name, i);
+  return vars;
+}