nc_hyperslab.h

Go to the documentation of this file.

#pragma once
#include <vector>
#include <netcdf.h>
 
namespace dg{
namespace file{
struct NcHyperslab
{
    NcHyperslab( size_t start, size_t count = 1)
        : m_start( 1, start), m_count( 1, count)
    {
    }
 
    NcHyperslab(std::vector<size_t> start, std::vector<size_t> count)
        : m_start(start), m_count(count)
    {
        assert( start.size() == count.size());
    }
 
    template<class File>
    NcHyperslab( const File& file, std::string name)
    {
        auto dims = file.get_var_dims(name);
        m_count = std::vector<size_t>( get_dims_shape( dims));
        m_start = std::vector<size_t>( dims.size(), 0);
    }
 
    template<class ContainerType, std::enable_if_t< dg::is_vector_v<
        ContainerType, dg::SharedVectorTag>, bool> = true>
    NcHyperslab( const ContainerType& data)
    : NcHyperslab( 0, data.size())
    {
    }
    template<class Topology, std::enable_if_t<
        !dg::is_vector_v<Topology>, bool> = true>
    NcHyperslab( const Topology& grid)
    {
        auto ss = grid.start();
        auto cc = grid.count();
        m_start = std::vector<size_t>( ss.begin(), ss.end());
        m_count = std::vector<size_t>( cc.begin(), cc.end());
    }
 
    template<class T>
    NcHyperslab( size_t start0, const T& param)
          : NcHyperslab( start0, 1, param)
    {
    }
 
    template<class T>
    NcHyperslab( size_t start0, size_t count0, const T& param)
          : NcHyperslab( param)
    {
        m_start.insert( m_start.begin(), start0);
        m_count.insert( m_count.begin(), count0);
    }
 
    unsigned ndim() const { return m_start.size();}
 
    const std::vector<size_t>& start() const { return m_start;}
    const std::vector<size_t>& count() const { return m_count;}
    std::vector<size_t>& start() { return m_start;}
    std::vector<size_t>& count() { return m_count;}
    const size_t* startp() const { return &m_start[0];}
    const size_t* countp() const { return &m_count[0];}
    private:
    std::vector<size_t> m_start, m_count;
};
 
#ifdef MPI_VERSION
struct MPINcHyperslab
{
 
    MPINcHyperslab( size_t local_start, size_t local_count, MPI_Comm comm)
    : m_slab( local_start, local_count), m_comm(comm)
    {
    }
 
 
    MPINcHyperslab(std::vector<size_t> local_start,
        std::vector<size_t> local_count, MPI_Comm comm)
    : m_slab( local_start, local_count), m_comm(comm)
    {
    }
 
    template<class ContainerType, std::enable_if_t< dg::is_vector_v<
        ContainerType, dg::MPIVectorTag>, bool> = true>
    MPINcHyperslab( const ContainerType& data)
    : m_slab ( 0) // "default" construct
    {
        int count = data.size();
        MPI_Comm comm = data.communicator();
        int rank, size;
        MPI_Comm_rank( comm, &rank);
        MPI_Comm_size( comm, &size);
        std::vector<int> counts ( size);
        MPI_Allgather( &count, 1, MPI_INT, &counts[0], 1, MPI_INT, comm);
        size_t start = 0;
        for( int r=0; r<rank; r++)
            start += counts[r];
 
        *this = MPINcHyperslab{ start, (size_t)count, comm};
    }
 
    template<class MPITopology, std::enable_if_t<!dg::is_vector_v<MPITopology>,
    bool> = true>
    MPINcHyperslab( const MPITopology& grid)
    : m_slab( grid), m_comm(grid.communicator())
    {
    }
 
    template<class T>
    MPINcHyperslab( size_t start0, const T& param)
    : MPINcHyperslab( start0, 1, param)
    {
    }
    template<class T>
    MPINcHyperslab( size_t start0, size_t count0, const T& param)
    : MPINcHyperslab( param)
    {
        m_slab.start().insert( m_slab.start().begin(), start0);
        m_slab.count().insert( m_slab.count().begin(), count0);
    }
 
    unsigned ndim() const { return m_slab.ndim();}
 
    const std::vector<size_t>& start() const { return m_slab.start();}
    const std::vector<size_t>& count() const { return m_slab.count();}
    std::vector<size_t>& start() { return m_slab.start();}
    std::vector<size_t>& count() { return m_slab.count();}
    MPI_Comm communicator() const { return m_comm;}
    const size_t* startp() const { return m_slab.startp();}
    const size_t* countp() const { return m_slab.countp();}
    private:
    NcHyperslab m_slab;
    MPI_Comm m_comm;
};
 
namespace detail
{
inline int mpi_comm_global2local_rank( MPI_Comm comm, int global_rank = 0, MPI_Comm global_comm = MPI_COMM_WORLD )
{
    MPI_Group local_group, global_group;
    MPI_Comm_group(comm, &local_group);//local call
    MPI_Comm_group(MPI_COMM_WORLD, &global_group);//local call
    int local_root_rank;
    MPI_Group_translate_ranks(global_group, 1, &global_rank, local_group, &local_root_rank);
    return local_root_rank;
}
} // namespace detail
#endif
 
}//namespace file
}//namespace dg