Began porting the mapping system

src/include/serif/mapping/compactification/compactification.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string_view>
+
+#include "serif/mapping/status.hpp"
+#include "serif/mapping/compactification/input_result.hpp"
+#include "serif/mapping/compactification/variation.hpp"
+
+
+namespace serif::mapping::compactification {
+    class ExteriorDomainMap {
+    public:
+        virtual ~ExteriorDomainMap() = default;
+
+        [[nodiscard]] virtual bool is_affine_in_displacement() const noexcept;
+
+        [[nodiscard]] virtual MappingStatus evaluate(
+            const ExteriorMapInput &input,
+            ExteriorMapResult &result
+        ) const = 0;
+
+        [[nodiscard]] virtual MappingStatus evaluate_variation(
+            const ExteriorMapInput &input,
+            const ExteriorMapResult &result,
+            const ExteriorMapDirection &direction,
+            ExteriorMapVariation &variation
+        ) const = 0;
+
+        [[nodiscard]] virtual std::string_view get_name() const noexcept = 0;
+
+    };
+}

src/include/serif/mapping/compactification/input_result.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "mfem/linalg/vector.hpp"
+#include "mfem/linalg/densemat.hpp"
+
+namespace serif::mapping::compactification {
+    struct ExteriorMapInput {
+        const mfem::Vector &reference_position;
+        const mfem::Vector &displaced_position;
+        const mfem::DenseMatrix &displacement_jacobian;
+        const mfem::Vector &compactification_coordinate_gradient;
+        double compactification_coordinate;
+    };
+
+    struct ExteriorMapResult {
+        mfem::Vector physical_position;
+        mfem::DenseMatrix mapping_jacobian;
+    };
+}

src/include/serif/mapping/compactification/kelvin.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include <string_view>
+
+#include "mfem/linalg/vector.hpp"
+
+#include "serif/mapping/status.hpp"
+#include "serif/mapping/compactification/compactification.hpp"
+#include "serif/utils/user_options/mapping/compactification/kelvin.hpp"
+
+namespace serif::mapping::compactification {
+    class KelvinCompactification final : public ExteriorDomainMap {
+    public:
+        explicit KelvinCompactification(const utils::user_options::KelvinCompactificationOptions& options);
+
+        [[nodiscard]] bool is_affine_in_displacement() const noexcept override;
+        [[nodiscard]] MappingStatus evaluate(
+            const ExteriorMapInput& input,
+            ExteriorMapResult& result
+        ) const override;
+
+        [[nodiscard]] MappingStatus evaluate_variation(
+            const ExteriorMapInput& input,
+            const ExteriorMapResult& result,
+            const ExteriorMapDirection& direction,
+            ExteriorMapVariation& variation
+        ) const override;
+
+        [[nodiscard]] std::string_view get_name() const noexcept override;
+
+        [[nodiscard]] double get_reference_stellar_radius() const noexcept;
+        [[nodiscard]] double get_reference_infinity_radius() const noexcept;
+        [[nodiscard]] double get_coordinate_tolerance() const noexcept;
+
+        [[nodiscard]] MappingStatus evaluate_jacobian_variation_factors(
+            double compactification_coordinate,
+            const mfem::Vector &coordinateGradient,
+            double &scale,
+            mfem::Vector &scaleGradient
+        ) const;
+
+    private:
+        struct RadialFactors {
+            double compactification_coordinate;
+            double computational_radius;
+            double scale;
+            double scale_derivative;
+        };
+
+    private:
+        [[nodiscard]] MappingStatus compute_radial_factors(
+            double compactification_coordinate,
+            RadialFactors &radial_factors
+        ) const;
+
+    private:
+        utils::user_options::KelvinCompactificationOptions m_options;
+        const std::string_view m_name = "KelvinCompactification";
+    };
+
+
+}

src/include/serif/mapping/compactification/variation.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "mfem/linalg/vector.hpp"
+#include "mfem/linalg/densemat.hpp"
+
+namespace serif::mapping::compactification {
+    struct ExteriorMapDirection {
+        const mfem::Vector &displaced_position_variation;
+        const mfem::DenseMatrix &displacement_jacobian_variation;
+    };
+
+    struct ExteriorMapVariation {
+        mfem::Vector physical_position_variation;
+        mfem::DenseMatrix mapping_jacobian_variation;
+    };
+}

src/include/serif/mapping/context.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "mfem/linalg/densemat.hpp"
+#include "mfem/linalg/vector.hpp"
+
+namespace serif::mapping {
+    struct VolumeQuadratureContext {
+        mfem::DenseMatrix J_inv;
+        double detJ;
+        double weight;
+    };
+
+    struct FaceQuadratureContext {
+        mfem::Vector normal;
+        double ds;
+        double v_dot_n_scale;
+    };
+
+    struct MappingPointContext {
+        mfem::Vector reference_position;
+        mfem::Vector displaced_position;
+        mfem::Vector physical_position;
+        mfem::DenseMatrix displacement_jacobian;
+        mfem::DenseMatrix mapping_jacobian;
+        mfem::DenseMatrix inverse_mapping_jacobian;
+        double mapping_determinate{0.0};
+        bool compactified{false};
+    };
+
+    struct VolumeMappingContext {
+        MappingPointContext mapping;
+        VolumeQuadratureContext quadrature;
+    };
+
+    struct FaceMappingContext {
+        MappingPointContext mapping;
+        FaceQuadratureContext quadrature;
+        mfem::Vector reference_normal;
+        double reference_surface_weight{0.0};
+        double physical_surface_weight{0.0};
+    };
+}

src/include/serif/mapping/status.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <unordered_map>
+#include <cstdint>
+#include <utility>
+
+#include "serif/utils/error/codes.hpp"
+#include "serif/meta/enums.hpp"
+
+namespace serif::mapping
+{
+    enum class MappingStatus : uint16_t {
+        VALID,
+
+        // Start this at 400 so this is parallel to the mapping error codes. There must be a better way to
+        // do this but it is not worth the time to sort out now
+        INVALID_DIMENSION = 400,
+        NON_FINITE_MAPPING_INPUT,
+        INVALID_REFERENCE_RADIUS,
+        AT_COMPACTIFIED_INFINITY,
+        OUTSIDE_REFERENCE_DOMAIN,
+        NON_FINITE_MAPPING_RESULT,
+        NON_POSITIVE_DETERMINATE
+    };
+
+    static auto MappingStatus_enum_string_map = meta::enum_to_enum_string_map<MappingStatus>();
+    static auto MappingStatus_string_enum_map = meta::enum_to_string_enum_map<MappingStatus>();
+
+    inline std::unordered_map<MappingStatus, utils::errors::SERiFErrorCode> make_MappingStatus_SERiFErrorCode_map() {
+        std::unordered_map<MappingStatus, utils::errors::SERiFErrorCode> ret;
+        for (const auto& [MS, MS_name] : MappingStatus_enum_string_map) {
+            if (std::to_underlying(MS) < 400) {
+                continue; // Skip VALID since it is not in the error code set
+            }
+            ret.insert({MS, utils::errors::SERiFErrorCodeNameToTypeMap.at(MS_name)});
+        }
+        return ret;
+    }
+
+    inline std::unordered_map<utils::errors::SERiFErrorCode, MappingStatus> make_SERIFErrorCode_MappingStatus_map() {
+
+        std::unordered_map<utils::errors::SERiFErrorCode, MappingStatus> ret;
+        for (const auto& [MS, MS_name] : MappingStatus_enum_string_map) {
+            if (std::to_underlying(MS) < 400) {
+                continue; // Skip VALID since it is not in the error code set
+            }
+            ret.insert({utils::errors::SERiFErrorCodeNameToTypeMap.at(MS_name), MS});
+        }
+        return ret;
+    }
+
+    static auto MappingStatus_SERiFErrorCode_map = make_MappingStatus_SERiFErrorCode_map();
+    static auto SERiFErrorCode_MappingStatus_map = make_SERIFErrorCode_MappingStatus_map();
+}
+

src/include/serif/mapping/variation.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "mfem/linalg/densemat.hpp"
+#include "mfem/linalg/vector.hpp"
+
+namespace serif::mapping {
+    struct MappingPointVariation {
+        mfem::Vector displacement_variation;
+        mfem::Vector physical_position_variation;
+        mfem::DenseMatrix displacement_jacobian_variation;
+        mfem::DenseMatrix mapping_jacobian_variation;
+        mfem::DenseMatrix inverse_mapping_jacobian_variation;
+        double mapping_determinate_variation{0.0};
+    };
+
+    struct VolumeMappingVariation {
+        MappingPointVariation mapping;
+        mfem::DenseMatrix inverse_element_jacobian_variation;
+        double weight_variation{0.0};
+    };
+
+    struct FaceMappingVariation {
+        MappingPointVariation mapping;
+        mfem::Vector physical_normal_variation;
+
+        double physical_surface_weight_variation{0.0};
+        double normal_flux_scale_variation{0.0};
+    };
+}