surfaceField.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoFOAM authors
 
#pragma once
 
#include <vector>
 
#include "NeoFOAM/finiteVolume/cellCentred/fields/geometricField.hpp"
#include "NeoFOAM/finiteVolume/cellCentred/boundary/surfaceBoundaryFactory.hpp"
 
namespace NeoFOAM::finiteVolume::cellCentred
{
 
template<typename ValueType>
class SurfaceField : public GeometricFieldMixin<ValueType>
{
 
public:
 
    SurfaceField(
        const Executor& exec,
        std::string fieldName,
        const UnstructuredMesh& mesh,
        const std::vector<SurfaceBoundary<ValueType>>& boundaryConditions
    )
        : GeometricFieldMixin<ValueType>(
            exec,
            fieldName,
            mesh,
            DomainField<ValueType>(
                exec,
                mesh.nInternalFaces() + mesh.nBoundaryFaces(),
                mesh.nBoundaryFaces(),
                mesh.nBoundaries()
            )
        ),
          boundaryConditions_(boundaryConditions)
    {}
 
    /* @brief Constructor for a surfaceField with a given internal field
     *
     * @param exec The executor
     * @param mesh The underlying mesh
     * @param internalField the underlying internal field
     * @param boundaryConditions a vector of boundary conditions
     */
    SurfaceField(
        const Executor& exec,
        const UnstructuredMesh& mesh,
        const DomainField<ValueType>& domainField,
        const std::vector<SurfaceBoundary<ValueType>>& boundaryConditions
    )
        : GeometricFieldMixin<ValueType>(exec, mesh, domainField),
          boundaryConditions_(boundaryConditions)
    {}
 
    /* @brief Constructor for a surfaceField with a given internal field
     *
     * @param exec The executor
     * @param mesh The underlying mesh
     * @param internalField the underlying internal field
     * @param boundaryConditions a vector of boundary conditions
     */
    SurfaceField(
        const Executor& exec,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& internalField,
        const BoundaryFields<ValueType>& boundaryFields,
        const std::vector<SurfaceBoundary<ValueType>>& boundaryConditions
    )
        : GeometricFieldMixin<ValueType>(exec, mesh, {exec, mesh, internalField, boundaryFields}),
          boundaryConditions_(boundaryConditions)
    {}
 
    SurfaceField(const SurfaceField& other)
        : GeometricFieldMixin<ValueType>(other), boundaryConditions_(other.boundaryConditions_)
    {}
 
    void correctBoundaryConditions()
    {
        for (auto& boundaryCondition : boundaryConditions_)
        {
            boundaryCondition.correctBoundaryCondition(this->field_);
        }
    }
 
 
private:
 
    std::vector<SurfaceBoundary<ValueType>>
        boundaryConditions_; // The vector of boundary conditions
};
 
 
} // namespace NeoFOAM