surfaceField.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2024 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <vector>
#include "NeoN/core/database/database.hpp"
#include "NeoN/finiteVolume/cellCentred/fields/domain.hpp"
#include "NeoN/finiteVolume/cellCentred/boundary/surfaceBoundaryFactory.hpp"
#include "NeoN/core/database/fieldDatabase.hpp"
 
namespace NeoN::finiteVolume::cellCentred
{
 
template<typename ValueType>
class SurfaceField : public DomainMixin<ValueType>, public FieldDatabaseMixin
{
 
public:
 
    using VectorValueType = ValueType;
 
    SurfaceField(
        const Executor& exec,
        std::string fieldName,
        const UnstructuredMesh& mesh,
        const std::vector<SurfaceBoundary<ValueType>>& boundaryConditions
    )
        : DomainMixin<ValueType>(
            exec,
            fieldName,
            mesh,
            Field<ValueType>(exec, mesh.nInternalFaces(), mesh.boundaryMesh().offset())
        ),
          FieldDatabaseMixin(), boundaryConditions_(boundaryConditions)
    {}
 
    /* @brief Constructor for a surfaceVector with a given internal field
     *
     * @param exec The executor
     * @param mesh The underlying mesh
     * @param internalVector the underlying internal field
     * @param boundaryConditions a vector of boundary conditions
     */
    SurfaceField(
        const Executor& exec,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& domainVector,
        const std::vector<SurfaceBoundary<ValueType>>& boundaryConditions
    )
        : DomainMixin<ValueType>(exec, mesh, domainVector), FieldDatabaseMixin(),
          boundaryConditions_(boundaryConditions)
    {}
 
    /* @brief Constructor for a surfaceVector with a given internal field
     *
     * @param exec The executor
     * @param mesh The underlying mesh
     * @param internalVector the underlying internal field
     * @param boundaryVectors the underlying boundary data fields
     * @param boundaryConditions a vector of boundary conditions
     */
    SurfaceField(
        const Executor& exec,
        const UnstructuredMesh& mesh,
        const Vector<ValueType>& internalVector,
        const BoundaryData<ValueType>& boundaryVectors,
        const std::vector<SurfaceBoundary<ValueType>>& boundaryConditions
    )
        : DomainMixin<ValueType>(exec, mesh, {exec, mesh, internalVector, boundaryVectors}),
          FieldDatabaseMixin(), boundaryConditions_(boundaryConditions)
    {}
 
    /* @brief Constructor for a surface field with a given internal field and database registration.
     *
     * Mirrors the VolumeField db-registering constructor.
     *
     * @param exec The executor
     * @param fieldName The name of the field
     * @param mesh The underlying mesh
     * @param domainVector the underlying domain field (internal + boundary laid out as Field)
     * @param boundaryConditions a vector of boundary conditions
     * @param db The database to register with
     * @param dbKey The key of the field in the database
     * @param collectionName The name of the field collection in the database
     */
    SurfaceField(
        const Executor& exec,
        std::string fieldName,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& domainVector,
        const std::vector<SurfaceBoundary<ValueType>>& boundaryConditions,
        Database& db,
        std::string dbKey,
        std::string collectionName
    )
        : DomainMixin<ValueType>(exec, fieldName, mesh, domainVector),
          FieldDatabaseMixin(db, std::move(dbKey), std::move(collectionName)),
          boundaryConditions_(boundaryConditions)
    {}
 
    SurfaceField(const SurfaceField& other)
        : DomainMixin<ValueType>(other), FieldDatabaseMixin(other),
          boundaryConditions_(other.boundaryConditions_)
    {}
 
    void correctBoundaryConditions()
    {
        // One-time set() pass: initialise constant patch data once per field instance (e.g. the
        // processor BC's unused mixed-BC coefficients).
        if (!boundaryConditionsSet_)
        {
            for (auto& boundaryCondition : boundaryConditions_)
            {
                boundaryCondition.set(this->field_);
            }
            boundaryConditionsSet_ = true;
        }
        // Per-iteration update(): proc patches post their (already face-valued) data without
        // draining, so all are in flight before any completes.
        for (auto& boundaryCondition : boundaryConditions_)
        {
            boundaryCondition.update(this->field_);
        }
        // Drain any processor-halo exchange once, after all proc patches have posted. See
        // VolumeField::correctBoundaryConditions for the rationale (batched post-then-wait).
        this->field_.boundaryData().waitAll();
    }
 
    std::vector<SurfaceBoundary<ValueType>> boundaryConditions() const
    {
        return boundaryConditions_;
    }
 
private:
 
    std::vector<SurfaceBoundary<ValueType>>
        boundaryConditions_;      // The vector of boundary conditions
    std::optional<Database*> db_; // The optional pointer to the database
 
    // Whether the one-time boundary set() pass has run for this field instance. Default-init to
    // false so copies re-run set() on their first correctBoundaryConditions() call.
    bool boundaryConditionsSet_ {false};
};
 
inline SurfaceField<scalar>
operator*(const SurfaceField<scalar>& lhs, const SurfaceField<scalar>& rhs)
{
    SurfaceField<scalar> result(lhs);
    result.internalVector() *= rhs.internalVector();
    result.boundaryData().value() *= rhs.boundaryData().value();
    return result;
}
 
inline SurfaceField<scalar>
operator+(const SurfaceField<scalar>& lhs, const SurfaceField<scalar>& rhs)
{
    SurfaceField<scalar> result(lhs);
    result.internalVector() += rhs.internalVector();
    result.boundaryData().value() += rhs.boundaryData().value();
    return result;
}
 
inline SurfaceField<scalar>
operator-(const SurfaceField<scalar>& lhs, const SurfaceField<scalar>& rhs)
{
    SurfaceField<scalar> result(lhs);
    result.internalVector() -= rhs.internalVector();
    result.boundaryData().value() -= rhs.boundaryData().value();
    return result;
}
 
inline SurfaceField<scalar> operator*(scalar s, const SurfaceField<scalar>& fld)
{
    SurfaceField<scalar> result(fld);
    result.internalVector() *= s;
    result.boundaryData().value() *= s;
    return result;
}
 
} // namespace NeoN