meshIterationStrategies.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <cstddef>
#include <memory>
#include <string>
#include <utility>
 
#include "NeoN/core/segmentedVector.hpp"
 
#include "NeoN/linearAlgebra/csrSparsityPattern.hpp"
#include "NeoN/linearAlgebra/cooSparsityPattern.hpp"
#include "NeoN/linearAlgebra/faceToMatrixAddress.hpp"
#include "NeoN/finiteVolume/cellCentred/stencil/cellToFaceStencil.hpp"
 
namespace NeoN::la
{
 
class MeshIterationStrategy
{
 
protected:
public:
 
    virtual std::string name() const = 0;
 
    virtual size_t size() const = 0;
 
    virtual ~MeshIterationStrategy() {}
};
 
class MeshIteratorContext
{
 
    std::shared_ptr<MeshIterationStrategy> strategy {};
 
public:
 
    void setStrategy(std::shared_ptr<MeshIterationStrategy> strategy);
 
    std::shared_ptr<MeshIterationStrategy> get() const;
 
    std::string name() const;
};
 
 
class FaceBasedIterator : public MeshIterationStrategy
{
 
public:
 
    std::string name() const override { return "FaceBased"; }
 
    size_t size() const override { return 0; }
 
    ~FaceBasedIterator() override {}
};
 
 
class CellBasedIterator : public MeshIterationStrategy
{
 
 
public:
 
    CellBasedIterator();
 
    struct CellBasedData
    {
        CellBasedData() = delete;
 
        template<
            typename CellFaces,
            typename FaceNeighbour,
            typename FaceSign,
            typename MatrixColumnIdx>
        CellBasedData(
            localIdx sizeIn,
            CellFaces&& cellFacesIn,
            FaceNeighbour&& faceNeighbourIn,
            FaceSign&& faceSignIn,
            MatrixColumnIdx&& matrixColumnIdxIn
        )
            : size(sizeIn), cellFaces(std::forward<CellFaces>(cellFacesIn)),
              faceNeighbour(std::forward<FaceNeighbour>(faceNeighbourIn)),
              faceSign(std::forward<FaceSign>(faceSignIn)),
              matrixColumnIdx(std::forward<MatrixColumnIdx>(matrixColumnIdxIn))
        {}
 
        localIdx size; 
 
        SegmentedVector<localIdx, localIdx> cellFaces;
 
        Vector<localIdx> faceNeighbour;
 
        // TODO scalar is unreasonable large here
        Vector<scalar> faceSign;
 
        Vector<localIdx> matrixColumnIdx;
    };
 
    std::string name() const override;
 
    size_t size() const override;
 
    ~CellBasedIterator() override {}
 
    std::shared_ptr<CellBasedData> getCellBasedData();
 
    template<typename SparsityType>
    void setComputeCellBasedData(
        const UnstructuredMesh& mesh,
        std::shared_ptr<const SparsityType> sparsityPattern,
        std::shared_ptr<const la::FaceToMatrixAddress> faceToMatrixAddress
    );
 
    template<typename SparsityType>
    std::shared_ptr<CellBasedData> computeCellBasedData(
        const UnstructuredMesh& mesh,
        std::shared_ptr<const SparsityType> sparsityPattern,
        const std::shared_ptr<const la::FaceToMatrixAddress> faceToMatrixAddress
    );
 
    std::shared_ptr<CellBasedData> cellBasedIteratorData_;
};
 
}