hdf5Initializer.hpp

#ifndef ABLATELIBRARY_DOMAIN_HDF5INITIALIZER_HPP
#define ABLATELIBRARY_DOMAIN_HDF5INITIALIZER_HPP
 
#include <filesystem>
#include <memory>
#include <utility>
#include <vector>
#include "field.hpp"
#include "initializer.hpp"
#include "mathFunctions/fieldFunction.hpp"
 
namespace ablate::domain {
class Hdf5Initializer : public Initializer {
   protected:
    std::filesystem::path hdf5Path;
 
    const std::shared_ptr<ablate::domain::Region> region;
 
   public:
    explicit Hdf5Initializer(std::filesystem::path hdf5Path, std::shared_ptr<ablate::domain::Region> region = {});
 
    [[nodiscard]] std::vector<std::shared_ptr<mathFunctions::FieldFunction>> GetFieldFunctions(const std::vector<domain::Field>& fields) const override;
 
   protected:
    class Hdf5Mesh {
       private:
        // Pointer to the viewer that can be used to load the mesh or other vectors
        PetscViewer petscViewer = nullptr;
 
        // Pointer to the base dm
        DM dm = nullptr;
 
        // count the number of cells in this mesh
        PetscInt numberCells = -1;
 
       public:
        explicit Hdf5Mesh(const std::filesystem::path& hdf5Path);
 
        ~Hdf5Mesh();
 
        // Allow the Hdf5Initializer to access hdf5 mesh private variables
        friend class Hdf5Initializer;
    };
 
    class Hdf5MathFunction : public ablate::mathFunctions::MathFunction {
       protected:
        // the field used to represent this math function (useful for debugging)
        const std::string field;
 
        // The dm for this specific field/math function
        DM fieldDm = nullptr;
 
        // create an empty vec
        Vec fieldVec = nullptr;
 
        // Hold a reference to the base mesh,viewer
        std::shared_ptr<Hdf5Mesh> baseMesh;
 
        // The number of components in the field
        PetscInt components = -1;
 
        // The number of dimensions in the dm
        PetscInt dim = -1;
 
        // The result size, this is normally the number of components but can be overwritten by sub classes
        PetscInt resultSize = -1;
 
       public:
        Hdf5MathFunction(std::shared_ptr<Hdf5Mesh> baseMesh, std::string field);
 
        ~Hdf5MathFunction() override;
 
        virtual PetscErrorCode Eval(PetscInt dim, const PetscReal x[], PetscScalar* u) const;
 
       private:
        static PetscErrorCode Hdf5PetscFunction(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar* u, void* ctx);
 
       public:
        [[nodiscard]] double Eval(const double& x, const double& y, const double& z, const double& t) const override;
 
        [[nodiscard]] double Eval(const double* xyz, const int& ndims, const double& t) const override;
 
        void Eval(const double& x, const double& y, const double& z, const double& t, std::vector<double>& result) const override;
 
        void Eval(const double* xyz, const int& ndims, const double& t, std::vector<double>& result) const override;
 
        ablate::mathFunctions::PetscFunction GetPetscFunction() override { return Hdf5PetscFunction; }
 
        void* GetContext() override { return this; }
    };
};
 
}  // namespace ablate::domain
 
#endif  // ABLATELIBRARY_DOMAIN_HDF5INITIALIZER_HPP