SubFieldLayout.h

//
// Class SubFieldLayout
// SubFieldLayout provides a layout for a sub-region of a larger field.
// It ensures that the sub-region is partitioned in the same way as the original FieldLayout,
// maintaining consistent parallel decomposition and neighbor relationships within the sub-region.
//
#ifndef IPPL_SUB_FIELD_LAYOUT_H
#define IPPL_SUB_FIELD_LAYOUT_H
 
#include <array>
#include <iostream>
#include <map>
#include <vector>
 
#include "Types/ViewTypes.h"
 
#include "Communicate/Communicator.h"
#include "FieldLayout/FieldLayout.h"
 
namespace ippl {
 
    template <unsigned Dim>
    class SubFieldLayout : public FieldLayout<Dim> {
    public:
        using NDIndex_t        = NDIndex<Dim>;
        using view_type        = typename detail::ViewType<NDIndex_t, 1>::view_type;
        using host_mirror_type = typename view_type::host_mirror_type;
 
        SubFieldLayout(const mpi::Communicator& = MPI_COMM_WORLD);
 
        SubFieldLayout(mpi::Communicator, const NDIndex<Dim>& domain, const NDIndex<Dim>& subDomain, std::array<bool, Dim> decomp,
                    bool isAllPeriodic = false);
 
        SubFieldLayout(mpi::Communicator, const NDIndex<Dim>& domain, std::array<bool, Dim> decomp,
                    bool isAllPeriodic = false);
 
        virtual ~SubFieldLayout() = default;
        
        void initialize(const NDIndex<Dim>& domain, const NDIndex<Dim>& subDomain, std::array<bool, Dim> decomp,
            bool isAllPeriodic = false);
            
        void initialize(const NDIndex<Dim>& domain, std::array<bool, Dim> decomp,
            bool isAllPeriodic = false);
 
        const NDIndex<Dim>& getOriginDomain() const { return originDomain_m; }
                
        template <unsigned Dim2>
        bool operator==(const SubFieldLayout<Dim2>& x) const {
            // Ensure the dimensions match
            if (Dim2 != Dim) {
                return false;
            }
 
            // Check if the original and global domains match
            if (originDomain_m != x.getOriginDomain() || this->gDomain_m != x.getDomain()) {
                return false;
            }
 
            // Ensure the local domains match
            for (unsigned int rank = 0; rank < this->comm.size(); ++rank) {
                if (this->hLocalDomains_m(rank) != x.getLocalNDIndex(rank)) {
                    return false;
                }
            }
 
            // If all checks passed, the SubFieldLayouts matche
            return true;
        }
 
        template <unsigned Dim2>
        bool operator==(const FieldLayout<Dim2>& x) const {
            // Ensure the dimensions match
            if (Dim2 != Dim) {
                return false;
            }
 
            // Check if the global domain matches the original domain and the FieldLayout's domain
            if (this->gDomain_m != originDomain_m || this->gDomain_m != x.getDomain()) {
                return false;
            }
 
            // Ensure the local domains match
            for (unsigned int rank = 0; rank < this->comm.size(); ++rank) {
                if (this->hLocalDomains_m(rank) != x.getLocalNDIndex(rank)) {
                    return false;
                }
            }
 
            // If all checks passed, the SubFieldLayout matches the FieldLayout
            return true;
        }
 
    private:
        NDIndex_t originDomain_m;
    };
}  // namespace ippl
 
#include "FieldLayout/SubFieldLayout.hpp"
 
#endif