feat(surface): major work on implementing surface constraints in a presciption agnostic manner

libmeanfield/interface/surface/compiled.cppm

@@ -0,0 +1,66 @@
+module;
+
+export module mean_field:surface.compiled;
+
+export import :eos.pressure_surface;
+export import :surface.constant;
+export import :surface.dependencies;
+
+export namespace mean_field::surface {
+    template <
+        eos::EquationOfStateModel EquationOfState,
+        SurfaceConstraintFormulationType Formulation,
+        eos::ThermodynamicRelationType SelectedRelation,
+        typename Dependencies>
+    class CompiledPressureSurfaceConstraint final {
+    public:
+        using PhysicalCondition   = ConstantPressureSurface;
+        using PhysicalQuantity    = eos::quantity::Pressure;
+        using CarrierQuantity     = typename Formulation::CarrierQuantity;
+        using CarrierField        = typename Formulation::CarrierField;
+        using Relation            = SelectedRelation;
+        using SurfaceDependencies = Dependencies;
+
+        CompiledPressureSurfaceConstraint(
+            const ConstantPressureSurface condition,
+            const EquationOfState &equationOfState
+        ) noexcept
+            : m_condition(condition),
+              m_resolvedRelation(
+                  equationOfState,
+                  condition.targetPressure()
+              ) {
+        }
+
+        [[nodiscard]] eos::PressureValue targetPressure() const noexcept {
+            return m_condition.targetPressure();
+        }
+
+        [[nodiscard]] PressureSurfaceDescriptor descriptor() const noexcept {
+            return m_condition.descriptor();
+        }
+
+        [[nodiscard]] static constexpr RuntimeSurfaceConstraintDependencies runtimeDependencies() noexcept {
+            return SurfaceDependencies::runtimeDescription();
+        }
+
+        template <typename SurfaceState> [[nodiscard]] double residual(const SurfaceState &state) const {
+            return state.value(CarrierQuantity{}).value() - m_resolvedRelation.requiredCarrierValue(state).value();
+        }
+
+        template <
+            typename SurfaceState,
+            typename SurfaceVariation>
+        [[nodiscard]] double jacobianAction(
+            const SurfaceState &state,
+            const SurfaceVariation &variation
+        ) const {
+            return variation.value(CarrierQuantity{}).value() -
+                   m_resolvedRelation.carrierCorrectionJacobianAction(state, variation);
+        }
+
+    private:
+        ConstantPressureSurface m_condition;
+        eos::ResolvedPressureSurfaceRelation<EquationOfState, Relation> m_resolvedRelation;
+    };
+} // namespace mean_field::surface