domain.hpp

#ifndef ABLATELIBRARY_DOMAIN_H
#define ABLATELIBRARY_DOMAIN_H
#include <petsc.h>
#include <algorithm>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "domain/fieldDescriptor.hpp"
#include "domain/modifiers/modifier.hpp"
#include "fieldDescription.hpp"
#include "initializer.hpp"
#include "io/serializable.hpp"
#include "mathFunctions/fieldFunction.hpp"
#include "region.hpp"
#include "utilities/loggable.hpp"
#include "utilities/nonCopyable.hpp"
 
namespace ablate::solver {
// forward declare the Solver
class Solver;
}  // namespace ablate::solver
 
namespace ablate::domain {
// forward declare the subDomain
class SubDomain;
 
class Domain : private utilities::Loggable<Domain>, private ablate::utilities::NonCopyable {
   public:
    const static inline std::string solution_vector_name = "solution";
 
    const static inline std::string aux_vector_name = "aux";
 
   protected:
    Domain(DM dm, std::string name, std::vector<std::shared_ptr<FieldDescriptor>>, std::vector<std::shared_ptr<modifiers::Modifier>> modifiers,
           const std::shared_ptr<parameters::Parameters>& options = {}, bool setFromOptions = true);
    virtual ~Domain();
 
    // The primary dm
    DM dm;
 
   private:
    // the name of the dm
    std::string name;
 
    // Hold a copy of the comm for this DM
    const MPI_Comm comm;
 
    // List of classes that are used to describe fields
    const std::vector<std::shared_ptr<FieldDescriptor>> fieldDescriptors;
 
    // Keep track of all solution fields
    std::vector<Field> fields;
 
    // This domain can be partitions into multiple subdomains
    std::vector<std::shared_ptr<SubDomain>> subDomains;
 
    Vec solGlobalField;
 
    void CreateStructures();
 
    // keep a list of functions that modify the dm
    std::vector<std::shared_ptr<modifiers::Modifier>> modifiers;
 
    PetscOptions petscOptions = nullptr;
 
   public:
    [[nodiscard]] const std::string& GetName() const { return name; }
 
    inline DM& GetDM() noexcept { return dm; }
 
    inline Vec GetSolutionVector() { return solGlobalField; }
 
    void RegisterField(const ablate::domain::FieldDescription& fieldDescription);
 
    [[nodiscard]] PetscInt GetDimensions() const noexcept;
 
    void InitializeSubDomains(const std::vector<std::shared_ptr<solver::Solver>>& solvers = {}, const std::shared_ptr<ablate::domain::Initializer>& initializations = {},
                              const std::vector<std::shared_ptr<mathFunctions::FieldFunction>>& = {});
 
    void ProjectFieldFunctions(const std::vector<std::shared_ptr<mathFunctions::FieldFunction>>& fieldFunctions, Vec globVec, PetscReal time = 0.0);
 
    std::shared_ptr<SubDomain> GetSubDomain(const std::shared_ptr<Region>& name) const;
 
    std::vector<std::weak_ptr<io::Serializable>> GetSerializableSubDomains();
 
    [[nodiscard]] inline const Field& GetField(int fieldId) const { return fields[fieldId]; }
 
    [[nodiscard]] inline const Field& GetField(const std::string_view& fieldName) const {
        auto field = std::find_if(fields.begin(), fields.end(), [&fieldName](auto field) { return field.name == fieldName; });
        if (field != fields.end()) {
            return *field;
        } else {
            throw std::invalid_argument("Cannot locate field with name " + std::string(fieldName) + " in domain " + name);
        }
    }
 
    [[nodiscard]] inline const std::vector<Field>& GetFields() const { return fields; }
 
    bool CheckFieldValues(Vec globSourceVector = nullptr);
};
}  // namespace ablate::domain
#endif  // ABLATELIBRARY_DOMAIN_H