MeanField/libmeanfield/interface/deformation/surface_prescription.cppm

module;

#include <concepts>
#include <type_traits>

#include <mfem.hpp>

export module mean_field:deformation.surface_prescription;

export import :deformation.descriptors;

export namespace mean_field::deformation {
    template <typename Candidate>
    concept PreparedSurfaceDeformationPrescription = requires(
        const std::remove_cvref_t<Candidate> &preparedPrescription,
        const mfem::Vector &parameters,
        const mfem::Vector &parameterDirection,
        const mfem::Vector &surfaceDisplacementDual,
        mfem::Vector &surfaceDisplacement,
        mfem::Vector &parameterDual
    ) {
        { preparedPrescription.descriptor() } noexcept -> std::same_as<SurfaceDeformationDescriptor>;
        { preparedPrescription.parameterCount() } noexcept -> std::same_as<int>;
        { preparedPrescription.surfaceDisplacementSize() } noexcept -> std::same_as<int>;
        { preparedPrescription.buildSurfaceDisplacement(parameters, surfaceDisplacement) } -> std::same_as<void>;
        {
            preparedPrescription.applyJacobian(parameters, parameterDirection, surfaceDisplacement)
        } -> std::same_as<void>;
        {
            preparedPrescription.applyJacobianTranspose(parameters, surfaceDisplacementDual, parameterDual)
        } -> std::same_as<void>;
        {
            preparedPrescription.applyPullbackDerivative(
                parameters, parameterDirection, surfaceDisplacementDual, parameterDual
            )
        } -> std::same_as<void>;
    };

    template <typename Candidate>
    concept SurfaceDeformationPrescription = requires(const std::remove_cvref_t<Candidate> &prescription) {
        typename std::remove_cvref_t<Candidate>::PreparedType;
        requires PreparedSurfaceDeformationPrescription<typename std::remove_cvref_t<Candidate>::PreparedType>;
        { prescription.descriptor() } noexcept -> std::same_as<SurfaceDeformationDescriptor>;
        { prescription.validate() } -> std::same_as<void>;
    };

    template <typename Prescription, typename CompilationContext>
    concept SurfaceDeformationCompilable =
        SurfaceDeformationPrescription<Prescription> && requires(
                                                            const std::remove_cvref_t<Prescription> &prescription,
                                                            const std::remove_cvref_t<CompilationContext> &context
                                                        ) {
            {
                compileSurfaceDeformationPrescription(prescription, context)
            } -> std::same_as<typename std::remove_cvref_t<Prescription>::PreparedType>;
        };
} // namespace mean_field::deformation