fieldCollection.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoFOAM authors
#pragma once
 
#include <limits>
#include <string>
#include <functional>
 
#include "NeoFOAM/core/demangle.hpp"
#include "NeoFOAM/core/error.hpp"
#include "NeoFOAM/core/database/database.hpp"
#include "NeoFOAM/core/database/collection.hpp"
#include "NeoFOAM/core/database/document.hpp"
 
namespace NeoFOAM::finiteVolume::cellCentred
{
bool validateFieldDoc(const Document& doc);
 
class FieldDocument
{
public:
 
    template<class FieldType>
    FieldDocument(
        const FieldType& 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}}
            ),
            validateFieldDoc
        )
    {}
 
    FieldDocument(const Document& doc);
 
    Document& doc();
 
    const Document& doc() const;
 
 
    std::string id() const;
 
    static std::string typeName();
 
    template<class FieldType>
    FieldType& field()
    {
        return doc_.get<FieldType&>("field");
    }
 
    template<class FieldType>
    const FieldType& field() const
    {
        return doc_.get<const FieldType&>("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<FieldDocument(NeoFOAM::Database& db)>;
 
class FieldCollection : public CollectionMixin<FieldDocument>
{
public:
 
    FieldCollection(NeoFOAM::Database& db, std::string name);
 
    FieldCollection(const FieldCollection&) = delete;
 
    FieldCollection& operator=(const FieldCollection&) = delete;
 
    FieldCollection(FieldCollection&&) = default;
 
    FieldCollection& operator=(FieldCollection&&) = delete;
 
    bool contains(const std::string& id) const;
 
    std::string insert(const FieldDocument& fd);
 
    FieldDocument& fieldDoc(const std::string& id);
 
    const FieldDocument& fieldDoc(const std::string& id) const;
 
    static FieldCollection& instance(NeoFOAM::Database& db, std::string name);
 
 
    static const FieldCollection& instance(const NeoFOAM::Database& db, std::string name);
 
    template<class FieldType>
    static FieldCollection& instance(FieldType& field)
    {
        validateRegistration(
            field, "attempting to retrieve FieldCollection from unregistered field"
        );
        return instance(field.db(), field.fieldCollectionName);
    }
 
    template<class FieldType>
    static const FieldCollection& instance(const FieldType& field)
    {
        validateRegistration(
            field, "attempting to retrieve FieldCollection from unregistered field"
        );
        const Database& db = field.db();
        const Collection& collection = db.at(field.fieldCollectionName);
        return collection.as<FieldCollection>();
        // return instance(field.db(), field.fieldCollectionName);
    }
 
    template<class FieldType>
    FieldType& registerField(CreateFunction createFunc)
    {
        FieldDocument doc = createFunc(db());
        if (!validateFieldDoc(doc.doc()))
        {
            throw std::runtime_error("Document is not valid");
        }
 
        std::string key = insert(doc);
        FieldDocument& fd = fieldDoc(key);
        FieldType& field = fd.field<FieldType>();
        field.key = key;
        field.fieldCollectionName = name();
        return field;
    }
};
 
 
template<typename FieldType>
class CreateFromExistingField
{
public:
 
    std::string name;
    const FieldType& 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();
 
    FieldDocument operator()(Database& db)
    {
        FieldType vf(
            field.exec(),
            name,
            field.mesh(),
            field.internalField(),
            field.boundaryConditions(),
            db,
            "",
            ""
        );
 
        if (field.registered())
        {
            const FieldCollection& fieldCollection = FieldCollection::instance(field);
            const FieldDocument& 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 NeoFOAM::Document(
            {{"name", vf.name},
             {"timeIndex", timeIndex},
             {"iterationIndex", iterationIndex},
             {"subCycleIndex", subCycleIndex},
             {"field", vf}},
            validateFieldDoc
        );
    }
};
 
 
} // namespace NeoFOAM