Add crappy Kidder velocity boundary condition handling

src/language/modules/VariationalSchemeModule.cpp

@@ -7,6 +7,7 @@
 #include <language/utils/BuiltinFunctionEmbedder.hpp>
 #include <language/utils/TypeDescriptor.hpp>
 #include <scheme/DiscreteFunctionUtils.hpp>
+#include <scheme/KidderVelocityBoundaryConditionDescriptor.hpp>
 #include <scheme/P1P0AnalyticVariationalSolver.hpp>
 #include <scheme/P1P0VariationalSolver.hpp>
 #include <scheme/VariationalSolver.hpp>
@@ -250,6 +251,16 @@ VariationalSchemeModule::VariationalSchemeModule()
                                                             ReconstructionStrategy::developed_conservative);
                                                         }
 
+                                                        ));
+
+  this->_addBuiltinFunction("kidder_velocity",
+                            std::function(
+
+                              [](const double& time, std::shared_ptr<const IBoundaryDescriptor> boundary)
+                                -> std::shared_ptr<const IBoundaryConditionDescriptor> {
+                                return std::make_shared<KidderVelocityBoundaryConditionDescriptor>(time, boundary);
+                              }
+
                               ));
 }
 

src/scheme/IBoundaryConditionDescriptor.hpp

@@ -20,6 +20,7 @@ class IBoundaryConditionDescriptor
     free,
     inflow,
     inflow_list,
+    kidder_velocity,
     neumann,
     outflow,
     symmetry,

src/scheme/KidderVelocityBoundaryConditionDescriptor.hpp

+#ifndef KIDDER_VELOCITY_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+#define KIDDER_VELOCITY_BOUNDARY_CONDITION_DESCRIPTOR_HPP
+
+#include <language/utils/FunctionSymbolId.hpp>
+#include <mesh/IBoundaryDescriptor.hpp>
+#include <scheme/BoundaryConditionDescriptorBase.hpp>
+
+#include <memory>
+
+class KidderVelocityBoundaryConditionDescriptor : public BoundaryConditionDescriptorBase
+{
+ private:
+  std::ostream&
+  _write(std::ostream& os) const final
+  {
+    os << "kidder_velocity(t=" << m_time << ',' << *m_boundary_descriptor << ")";
+    return os;
+  }
+
+  const double m_time;
+
+ public:
+  PUGS_INLINE
+  const double&
+  time() const
+  {
+    return m_time;
+  }
+
+  Type
+  type() const final
+  {
+    return Type::kidder_velocity;
+  }
+
+  KidderVelocityBoundaryConditionDescriptor(const double& time,
+                                            const std::shared_ptr<const IBoundaryDescriptor>& boundary_descriptor)
+    : BoundaryConditionDescriptorBase{boundary_descriptor}, m_time{time}
+  {
+    ;
+  }
+
+  KidderVelocityBoundaryConditionDescriptor(const KidderVelocityBoundaryConditionDescriptor&) = delete;
+  KidderVelocityBoundaryConditionDescriptor(KidderVelocityBoundaryConditionDescriptor&&)      = delete;
+
+  ~KidderVelocityBoundaryConditionDescriptor() = default;
+};
+
+#endif   // KIDDER_VELOCITY_BOUNDARY_CONDITION_DESCRIPTOR_HPP