boundaryData.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 NeoN authors
#pragma once
 
#include <Kokkos_Core.hpp>
 
 
#include "NeoN/core/primitives/label.hpp"
#include "NeoN/core/primitives/scalar.hpp"
#include "NeoN/core/executor/executor.hpp"
#include "NeoN/core/vector/vector.hpp"
 
#include <vector>
#include <utility>
 
namespace NeoN
{
 
 
template<typename T>
class BoundaryData
{
 
public:
 
    BoundaryData(const BoundaryData<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_)
    {}
 
 
    BoundaryData(const Executor& exec, const BoundaryData<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_(SerialExecutor {}, rhs.offset_),
          nBoundaries_(rhs.nBoundaries_), nBoundaryFaces_(rhs.nBoundaryFaces_)
    {}
 
 
    BoundaryData(const Executor& exec, localIdx nBoundaryFaces, localIdx nBoundaryTypes)
        : exec_(exec), value_(exec, nBoundaryFaces), refValue_(exec, nBoundaryFaces),
          valueFraction_(exec, nBoundaryFaces), refGrad_(exec, nBoundaryFaces),
          boundaryTypes_(exec, nBoundaryTypes), offset_(SerialExecutor {}, nBoundaryTypes + 1),
          nBoundaries_(nBoundaryTypes), nBoundaryFaces_(nBoundaryFaces)
    {}
 
    BoundaryData(const Executor& exec, const std::vector<localIdx>& offsets)
        : BoundaryData(exec, offsets.back(), static_cast<localIdx>(offsets.size() - 1))
    {
        offset_ = Vector(SerialExecutor {}, offsets);
    }
 
 
    const Vector<T>& value() const { return value_; }
 
    Vector<T>& value() { return value_; }
 
    const Vector<T>& refValue() const { return refValue_; }
 
    Vector<T>& refValue() { return refValue_; }
 
    const Vector<scalar>& valueFraction() const { return valueFraction_; }
 
    Vector<scalar>& valueFraction() { return valueFraction_; }
 
    const Vector<T>& refGrad() const { return refGrad_; }
 
    Vector<T>& refGrad() { return refGrad_; }
 
    const Vector<int>& boundaryTypes() const { return boundaryTypes_; }
 
    const Vector<localIdx>& offset() const { return offset_; }
 
    localIdx nBoundaries() const { return nBoundaries_; }
 
    localIdx nBoundaryFaces() const { return nBoundaryFaces_; }
 
    localIdx nBoundaryFaces(localIdx patchId) const
    {
        return offset_.data()[patchId + 1] - offset_.data()[patchId];
    }
 
    const Executor& exec() { return exec_; }
 
    BoundaryData<T>& operator=(const BoundaryData<T>& rhs)
    {
 
        // TODO maybe dont overwrite nBoundaries and nBoundaryFaces
        // but use them for a sanity check
        nBoundaries_ = rhs.nBoundaries_;
        nBoundaryFaces_ = rhs.nBoundaryFaces_;
 
        value_ = rhs.value_;
        refValue_ = rhs.refValue_;
        valueFraction_ = rhs.valueFraction_;
        refGrad_ = rhs.refGrad_;
        boundaryTypes_ = rhs.boundaryTypes_;
        offset_ = rhs.offset_;
        return *this;
    }
 
    BoundaryData<T>& operator=(const BoundaryData<T>&& rhs)
    {
 
        // TODO maybe dont overwrite nBoundaries and nBoundaryFaces
        // but use them for a sanity check
        nBoundaries_ = rhs.nBoundaries_;
        nBoundaryFaces_ = rhs.nBoundaryFaces_;
 
        value_ = std::move(rhs.value_);
        refValue_ = std::move(rhs.refValue_);
        valueFraction_ = std::move(rhs.valueFraction_);
        refGrad_ = std::move(rhs.refGrad_);
        boundaryTypes_ = std::move(rhs.boundaryTypes_);
        offset_ = std::move(rhs.offset_);
        return *this;
    }
 
    std::pair<localIdx, localIdx> range(localIdx patchId) const
    {
        return {offset_.data()[patchId], offset_.data()[patchId + 1]};
    }
 
private:
 
    Executor exec_;                
    Vector<T> value_;              
    Vector<T> refValue_;           
    Vector<scalar> valueFraction_; 
    Vector<T> refGrad_;            
    Vector<int> boundaryTypes_;    
    Vector<localIdx> offset_;      
    localIdx nBoundaries_;         
    localIdx nBoundaryFaces_;      
};
 
}