volumeField.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoN authors
 
#pragma once
 
#include "NeoN/core/database/database.hpp"
#include "NeoN/finiteVolume/cellCentred/fields/domain.hpp"
#include "NeoN/finiteVolume/cellCentred/boundary/volumeBoundaryFactory.hpp"
 
#include <vector>
 
namespace NeoN::finiteVolume::cellCentred
{
 
template<typename ValueType>
class VolumeField : public DomainMixin<ValueType>
{
 
public:
 
    using VectorValueType = ValueType;
 
 
    VolumeField(
        const Executor& exec,
        std::string name,
        const UnstructuredMesh& mesh,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions
    )
        : DomainMixin<ValueType>(
            exec, name, mesh, Field<ValueType>(exec, mesh.nCells(), mesh.boundaryMesh().offset())
        ),
          key(""), fieldCollectionName(""), boundaryConditions_(boundaryConditions),
          db_(std::nullopt)
    {}
 
 
    VolumeField(
        const Executor& exec,
        std::string name,
        const UnstructuredMesh& mesh,
        const Vector<ValueType>& internalVector,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions
    )
        : DomainMixin<ValueType>(
            exec, name, mesh, Field<ValueType>(exec, internalVector, mesh.boundaryMesh().offset())
        ),
          key(""), fieldCollectionName(""), boundaryConditions_(boundaryConditions),
          db_(std::nullopt)
    {}
 
    VolumeField(
        const Executor& exec,
        std::string name,
        const UnstructuredMesh& mesh,
        const Vector<ValueType>& internalVector,
        const BoundaryData<ValueType>& boundaryVectors,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions
    )
        : DomainMixin<ValueType>(exec, name, mesh, internalVector, boundaryVectors), key(""),
          fieldCollectionName(""), boundaryConditions_(boundaryConditions), db_(std::nullopt)
    {}
 
    VolumeField(
        const Executor& exec,
        std::string fieldName,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& domainVector,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions,
        Database& db,
        std::string dbKey,
        std::string collectionName
    )
        : DomainMixin<ValueType>(exec, fieldName, mesh, domainVector), key(dbKey),
          fieldCollectionName(collectionName), boundaryConditions_(boundaryConditions), db_(&db)
    {}
 
    VolumeField(const VolumeField& other)
        : DomainMixin<ValueType>(other), key(other.key),
          fieldCollectionName(other.fieldCollectionName),
          boundaryConditions_(other.boundaryConditions_), db_(other.db_)
    {}
 
    void correctBoundaryConditions()
    {
        for (auto& boundaryCondition : boundaryConditions_)
        {
            boundaryCondition.correctBoundaryCondition(this->field_);
        }
    }
 
    bool hasDatabase() const { return db_.has_value(); }
 
    Database& db()
    {
        if (!db_.has_value())
        {
            throw std::runtime_error {
                "Database not set: make sure the field is registered in the database"
            };
        }
        return *db_.value();
    }
 
    const Database& db() const
    {
        if (!db_.has_value())
        {
            throw std::runtime_error(
                "Database not set: make sure the field is registered in the database"
            );
        }
        return *db_.value();
    }
 
    bool registered() const { return key != "" && fieldCollectionName != "" && db_.has_value(); }
 
    std::vector<VolumeBoundary<ValueType>> boundaryConditions() const
    {
        return boundaryConditions_;
    }
 
    std::string key;                 // The key of the field in the database
    std::string fieldCollectionName; // The name of the field collection in the database
 
private:
 
    std::vector<VolumeBoundary<ValueType>> boundaryConditions_; // The vector of boundary conditions
    std::optional<Database*> db_; // The optional pointer to the database
};
 
} // namespace NeoN