domain.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoN authors
 
#pragma once
 
#include "NeoN/core/executor/executor.hpp"
#include "NeoN/fields/field.hpp"
#include "NeoN/core/vector.hpp"
#include "NeoN/mesh/unstructured/unstructuredMesh.hpp"
#include "NeoN/fields/boundaryData.hpp"
 
namespace NeoN::finiteVolume::cellCentred
{
 
template<typename ValueType>
class DomainMixin
{
public:
 
 
    typedef ValueType ElementType;
 
    DomainMixin(
        const Executor& exec,
        std::string fieldName,
        const UnstructuredMesh& mesh,
        const Field<ValueType>& field
    )
        : name(fieldName), exec_(exec), mesh_(mesh), field_(field)
    {}
 
    DomainMixin(
        const Executor& exec,
        std::string fieldName,
        const UnstructuredMesh& mesh,
        const Vector<ValueType>& internalVector,
        const BoundaryData<ValueType>& boundaryVectors
    )
        : name(fieldName), exec_(exec), mesh_(mesh), field_({exec, internalVector, boundaryVectors})
    {
        if (mesh.nCells() != internalVector.size())
        {
            NF_ERROR_EXIT("Inconsistent size of mesh and internal field detected");
        }
    }
 
    const Vector<ValueType>& internalVector() const { return field_.internalVector(); }
 
    Vector<ValueType>& internalVector() { return field_.internalVector(); }
 
    localIdx size() const { return field_.internalVector().size(); }
 
    const BoundaryData<ValueType>& boundaryData() const { return field_.boundaryData(); }
 
    BoundaryData<ValueType>& boundaryData() { return field_.boundaryData(); }
 
    const Executor& exec() const { return exec_; }
 
    const UnstructuredMesh& mesh() const { return mesh_; }
 
    std::string name; // The name of the field
 
protected:
 
    Executor exec_;                // The executor object
    const UnstructuredMesh& mesh_; // The unstructured mesh object
    Field<ValueType> field_;       // The domain field object
};
 
} // namespace NeoN