volumeField.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoFOAM authors
 
#pragma once
 
#include <vector>
 
#include "NeoFOAM/core/database/database.hpp"
#include "NeoFOAM/finiteVolume/cellCentred/fields/geometricField.hpp"
#include "NeoFOAM/finiteVolume/cellCentred/boundary/volumeBoundaryFactory.hpp"
 
namespace NeoFOAM::finiteVolume::cellCentred
{
 
template<typename ValueType>
class VolumeField : public GeometricFieldMixin<ValueType>
{
 
public:
 
    using FieldValueType = ValueType;
 
 
    VolumeField(
        const Executor& exec,
        std::string name,
        const UnstructuredMesh& mesh,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions
    )
        : GeometricFieldMixin<ValueType>(
            exec,
            name,
            mesh,
            DomainField<ValueType>(exec, mesh.nCells(), mesh.nBoundaryFaces(), mesh.nBoundaries())
        ),
          key(""), fieldCollectionName(""), boundaryConditions_(boundaryConditions),
          db_(std::nullopt)
    {}
 
 
    VolumeField(
        const Executor& exec,
        std::string name,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& internalField,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions
    )
        : GeometricFieldMixin<ValueType>(
            exec,
            name,
            mesh,
            DomainField<ValueType>(exec, internalField, mesh.nBoundaryFaces(), mesh.nBoundaries())
        ),
          key(""), fieldCollectionName(""), boundaryConditions_(boundaryConditions),
          db_(std::nullopt)
    {}
 
    VolumeField(
        const Executor& exec,
        std::string name,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& internalField,
        const BoundaryFields<ValueType>& boundaryFields,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions
    )
        : GeometricFieldMixin<ValueType>(exec, name, mesh, internalField, boundaryFields), key(""),
          fieldCollectionName(""), boundaryConditions_(boundaryConditions), db_(std::nullopt)
    {}
 
    VolumeField(
        const Executor& exec,
        std::string fieldName,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& internalField,
        const std::vector<VolumeBoundary<ValueType>>& boundaryConditions,
        Database& db,
        std::string dbKey,
        std::string collectionName
    )
        : GeometricFieldMixin<ValueType>(
            exec,
            fieldName,
            mesh,
            DomainField<ValueType>(exec, internalField, mesh.nBoundaryFaces(), mesh.nBoundaries())
        ),
          key(dbKey), fieldCollectionName(collectionName), boundaryConditions_(boundaryConditions),
          db_(&db)
    {}
 
    VolumeField(const VolumeField& other)
        : GeometricFieldMixin<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 NeoFOAM