fieldCollection.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoN authors
#pragma once
 
#include <limits>
#include <string>
#include <functional>
 
#include "NeoN/core/demangle.hpp"
#include "NeoN/core/error.hpp"
#include "NeoN/core/vector.hpp"
#include "NeoN/fields/field.hpp"
#include "NeoN/core/database/database.hpp"
#include "NeoN/core/database/collection.hpp"
#include "NeoN/core/database/document.hpp"
 
namespace NeoN::finiteVolume::cellCentred
{
bool validateVectorDoc(const Document& doc);
 
class VectorDocument
{
public:
 
    template<class VectorType>
    VectorDocument(
        const VectorType& field,
        std::int64_t timeIndex,
        std::int64_t iterationIndex,
        std::int64_t subCycleIndex
    )
        : doc_(
            Document(
                {{"name", field.name},
                 {"timeIndex", timeIndex},
                 {"iterationIndex", iterationIndex},
                 {"subCycleIndex", subCycleIndex},
                 {"field", field}}
            ),
            validateVectorDoc
        )
    {}
 
    VectorDocument(const Document& doc);
 
    Document& doc();
 
    const Document& doc() const;
 
 
    std::string id() const;
 
    static std::string typeName();
 
    template<class VectorType>
    VectorType& field()
    {
        return doc_.get<VectorType&>("field");
    }
 
    template<class VectorType>
    const VectorType& field() const
    {
        return doc_.get<const VectorType&>("field");
    }
 
    std::string name() const;
 
    std::string& name();
 
    std::int64_t timeIndex() const;
 
    std::int64_t& timeIndex();
 
    std::int64_t iterationIndex() const;
 
    std::int64_t& iterationIndex();
 
    std::int64_t subCycleIndex() const;
 
    std::int64_t& subCycleIndex();
 
private:
 
    Document doc_; 
};
 
using CreateFunction = std::function<VectorDocument(NeoN::Database& db)>;
 
class VectorCollection : public CollectionMixin<VectorDocument>
{
public:
 
    VectorCollection(NeoN::Database& db, std::string name);
 
    VectorCollection(const VectorCollection&) = delete;
 
    VectorCollection& operator=(const VectorCollection&) = delete;
 
    VectorCollection(VectorCollection&&) = default;
 
    VectorCollection& operator=(VectorCollection&&) = delete;
 
    bool contains(const std::string& id) const;
 
    std::string insert(const VectorDocument& fd);
 
    VectorDocument& fieldDoc(const std::string& id);
 
    const VectorDocument& fieldDoc(const std::string& id) const;
 
    static VectorCollection& instance(NeoN::Database& db, std::string name);
 
 
    static const VectorCollection& instance(const NeoN::Database& db, std::string name);
 
    template<class VectorType>
    static VectorCollection& instance(VectorType& field)
    {
        validateRegistration(
            field, "attempting to retrieve VectorCollection from unregistered field"
        );
        return instance(field.db(), field.fieldCollectionName);
    }
 
    template<class VectorType>
    static const VectorCollection& instance(const VectorType& field)
    {
        validateRegistration(
            field, "attempting to retrieve VectorCollection from unregistered field"
        );
        const Database& db = field.db();
        const Collection& collection = db.at(field.fieldCollectionName);
        return collection.as<VectorCollection>();
        // return instance(field.db(), field.fieldCollectionName);
    }
 
    template<class VectorType>
    VectorType& registerVector(CreateFunction createFunc)
    {
        VectorDocument doc = createFunc(db());
        if (!validateVectorDoc(doc.doc()))
        {
            throw std::runtime_error {"Document is not valid"};
        }
 
        std::string key = insert(doc);
        VectorDocument& fd = fieldDoc(key);
        VectorType& field = fd.field<VectorType>();
        field.key = key;
        field.fieldCollectionName = name();
        return field;
    }
};
 
 
template<typename VectorType>
class CreateFromExistingVector
{
public:
 
    std::string name;
    const VectorType& field;
    std::int64_t timeIndex = std::numeric_limits<std::int64_t>::max();
    std::int64_t iterationIndex = std::numeric_limits<std::int64_t>::max();
    std::int64_t subCycleIndex = std::numeric_limits<std::int64_t>::max();
 
    VectorDocument operator()(Database& db)
    {
        Field<typename VectorType::VectorValueType> domainVector(
            field.mesh().exec(), field.internalVector(), field.boundaryData()
        );
 
        VectorType vf(
            field.exec(), name, field.mesh(), domainVector, field.boundaryConditions(), db, "", ""
        );
 
        if (field.registered())
        {
            const VectorCollection& fieldCollection = VectorCollection::instance(field);
            const VectorDocument& fieldDoc = fieldCollection.fieldDoc(field.key);
            if (timeIndex == std::numeric_limits<std::int64_t>::max())
            {
                timeIndex = fieldDoc.timeIndex();
            }
            if (iterationIndex == std::numeric_limits<std::int64_t>::max())
            {
                iterationIndex = fieldDoc.iterationIndex();
            }
            if (subCycleIndex == std::numeric_limits<std::int64_t>::max())
            {
                subCycleIndex = fieldDoc.subCycleIndex();
            }
        }
        return NeoN::Document(
            {{"name", vf.name},
             {"timeIndex", timeIndex},
             {"iterationIndex", iterationIndex},
             {"subCycleIndex", subCycleIndex},
             {"field", vf}},
            validateVectorDoc
        );
    }
};
 
 
} // namespace NeoN