boundaryFields.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoFOAM authors
#pragma once
 
#include <Kokkos_Core.hpp>
 
#include <iostream>
 
#include "NeoFOAM/core/primitives/label.hpp"
#include "NeoFOAM/core/primitives/scalar.hpp"
#include "NeoFOAM/core/executor/executor.hpp"
#include "NeoFOAM/fields/field.hpp"
 
namespace NeoFOAM
{
 
 
template<typename T>
class BoundaryFields
{
 
public:
 
    BoundaryFields(const BoundaryFields<T>& rhs)
        : exec_(rhs.exec_), value_(rhs.value_), refValue_(rhs.refValue_),
          valueFraction_(rhs.valueFraction_), refGrad_(rhs.refGrad_),
          boundaryTypes_(rhs.boundaryTypes_), offset_(rhs.offset_), nBoundaries_(rhs.nBoundaries_),
          nBoundaryFaces_(rhs.nBoundaryFaces_)
    {}
 
 
    BoundaryFields(const Executor& exec, const BoundaryFields<T>& rhs)
        : exec_(rhs.exec_), value_(exec, rhs.value_), refValue_(exec, rhs.refValue_),
          valueFraction_(exec, rhs.valueFraction_), refGrad_(exec, rhs.refGrad_),
          boundaryTypes_(exec, rhs.boundaryTypes_), offset_(exec, rhs.offset_),
          nBoundaries_(rhs.nBoundaries_), nBoundaryFaces_(rhs.nBoundaryFaces_)
    {}
 
 
    BoundaryFields(const Executor& exec, size_t nBoundaryFaces, size_t nBoundaries)
        : exec_(exec), value_(exec, nBoundaryFaces), refValue_(exec, nBoundaryFaces),
          valueFraction_(exec, nBoundaryFaces), refGrad_(exec, nBoundaryFaces),
          boundaryTypes_(exec, nBoundaries), offset_(exec, nBoundaries + 1),
          nBoundaries_(nBoundaries), nBoundaryFaces_(nBoundaryFaces)
    {}
 
 
    const NeoFOAM::Field<T>& value() const { return value_; }
 
    NeoFOAM::Field<T>& value() { return value_; }
 
    const NeoFOAM::Field<T>& refValue() const { return refValue_; }
 
    NeoFOAM::Field<T>& refValue() { return refValue_; }
 
    const NeoFOAM::Field<scalar>& valueFraction() const { return valueFraction_; }
 
    NeoFOAM::Field<scalar>& valueFraction() { return refValue_; }
 
    const NeoFOAM::Field<T>& refGrad() const { return refGrad_; }
 
    NeoFOAM::Field<T>& refGrad() { return refGrad_; }
 
    const NeoFOAM::Field<int>& boundaryTypes() const { return boundaryTypes_; }
 
    const NeoFOAM::Field<localIdx>& offset() const { return offset_; }
 
    size_t nBoundaries() const { return nBoundaries_; }
 
    size_t nBoundaryFaces() const { return nBoundaryFaces_; }
 
    const Executor& exec() { return exec_; }
 
    std::pair<localIdx, localIdx> range(localIdx patchId) const
    {
        return {offset_.data()[patchId], offset_.data()[patchId + 1]};
    }
 
private:
 
    Executor exec_;                        
    NeoFOAM::Field<T> value_;              
    NeoFOAM::Field<T> refValue_;           
    NeoFOAM::Field<scalar> valueFraction_; 
    NeoFOAM::Field<T> refGrad_;            
    NeoFOAM::Field<int> boundaryTypes_;    
    NeoFOAM::Field<localIdx> offset_;      
    size_t nBoundaries_;                   
    size_t nBoundaryFaces_;                
};
 
}