grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > Class Template Reference

This is a distributed grid. More...

Detailed Description

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>
class grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >

This is a distributed grid.

Implementation of a distributed grid the decomposition is geometrical, grid is splitted across several processor

Parameters

dim	Dimensionality of the grid
St	Type of space where the grid is living
T	object the grid is storing
Decomposition	Class that decompose the grid for example CartDecomposition
Mem	Is the allocator
device	type of base structure is going to store the data

Create a distributed grid and access it

Synchronize the ghosts and check the information

        g_dist.template ghost_get<0>();

        // check that the communication is correctly completed

        auto domg = g_dist.getDomainGhostIterator();

        // check that the grid with the ghost part store the correct information
        while (domg.isNext())
        {
            auto key = domg.get();
            auto key_g = g_dist.getGKey(key);

            // In this case the boundary condition are non periodic
            if (g_dist.isInside(key_g))
            {
                match &= (g_dist.template get<0>(key) == info.LinId(key_g))?true:false;
                if (match == false)
                {std::cout << "ERROR IN: " << key_g.to_string() << "   " << info.LinId(key_g) << " != " << g_dist.template get<0>(key) << std::endl; break;}
            }

            ++domg;
        }

//      if (match == false)
//      {
            g_dist.write("Error_grid");

            g_dist.getDecomposition().write("Error_dec");
//      }

        BOOST_REQUIRE_EQUAL(match,true);

Create and access a distributed grid for complex structures

        // grid size
        size_t sz[2];
        sz[0] = k;
        sz[1] = k;

        float factor = pow(create_vcluster().getProcessingUnits()/2.0f,1.0f/2.0f);

        // Ghost
        Ghost<2,float> g(0.01 / factor);

        // Distributed grid with id decomposition
        grid_dist_id<2, float, Point_test<float>> g_dist(sz,domain,g);

        // check the consistency of the decomposition
        bool val = g_dist.getDecomposition().check_consistency();
        BOOST_REQUIRE_EQUAL(val,true);

        // Grid sm
        grid_sm<2,void> info(sz);

        // get the domain iterator
        size_t count = 0;

        auto dom = g_dist.getDomainIterator();

        while (dom.isNext())
        {
            auto key = dom.get();
            auto key_g = g_dist.getGKey(key);

            size_t k = info.LinId(key_g);

            g_dist.template get<p::x>(key) = 1 + k;
            g_dist.template get<p::y>(key) = 567 + k;
            g_dist.template get<p::z>(key) = 341 + k;
            g_dist.template get<p::s>(key) = 5670 + k;
            g_dist.template get<p::v>(key)[0] = 921 + k;
            g_dist.template get<p::v>(key)[1] = 5675 + k;
            g_dist.template get<p::v>(key)[2] = 117 + k;
            g_dist.template get<p::t>(key)[0][0] = 1921 + k;
            g_dist.template get<p::t>(key)[0][1] = 25675 + k;
            g_dist.template get<p::t>(key)[0][2] = 3117 + k;
            g_dist.template get<p::t>(key)[1][0] = 4921 + k;
            g_dist.template get<p::t>(key)[1][1] = 55675 + k;
            g_dist.template get<p::t>(key)[1][2] = 6117 + k;
            g_dist.template get<p::t>(key)[2][0] = 7921 + k;
            g_dist.template get<p::t>(key)[2][1] = 85675 + k;
            g_dist.template get<p::t>(key)[2][2] = 9117 + k;

            // Count the point
            count++;

            ++dom;
        }

Synchronize a distributed grid for complex structures

        g_dist.template ghost_get<p::x,p::y,p::z,p::s,p::v,p::t>();

        // check that the communication is correctly completed

        auto domg = g_dist.getDomainGhostIterator();

        // check that the grid with the ghost past store the correct information
        while (domg.isNext())
        {
            auto key = domg.get();
            auto key_g = g_dist.getGKey(key);

            // In this case the boundary condition are non periodic
            if (g_dist.isInside(key_g))
            {
                size_t k = info.LinId(key_g);

                match &= (g_dist.template get<p::x>(key) == 1 + k)?true:false;
                match &= (g_dist.template get<p::y>(key) == 567 + k)?true:false;
                match &= (g_dist.template get<p::z>(key) == 341 + k)?true:false;
                match &= (g_dist.template get<p::s>(key) == 5670 + k)?true:false;

                match &= (g_dist.template get<p::v>(key)[0] == 921 + k)?true:false;
                match &= (g_dist.template get<p::v>(key)[1] == 5675 + k)?true:false;
                match &= (g_dist.template get<p::v>(key)[2] == 117 + k)?true:false;

                match &= (g_dist.template get<p::t>(key)[0][0] == 1921 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[0][1] == 25675 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[0][2] == 3117 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[1][0] == 4921 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[1][1] == 55675 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[1][2] == 6117 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[2][0] == 7921 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[2][1] == 85675 + k)?true:false;
                match &= (g_dist.template get<p::t>(key)[2][2] == 9117 + k)?true:false;
            }

            ++domg;
        }

Usage of a grid dist iterator sub

        grid_key_dx<2> one(1,1);
        grid_key_dx<2> one_end(k-2,k-2);

        bool check = true;
        count = 0;

        // get the sub-domain iterator
        auto dom = g_dist.getSubDomainIterator(one,one_end);

        while (dom.isNext())
        {
            auto key = dom.get();
            auto key_g = g_dist.getGKey(key);

            // key_g should never be 1 or k-1
            check &= (key_g.get(0) == 0 || key_g.get(0) == k-1)?false:true;
            check &= (key_g.get(1) == 0 || key_g.get(1) == k-1)?false:true;

            g_dist.template get<0>(key) = info.LinId(key_g);

            // Count the point
            count++;

            ++dom;
        }

        BOOST_REQUIRE_EQUAL(check,true);

Construct two grid with the same decomposition

        // Distributed grid with id decomposition (It work also without the third template parameter)
        // Here is given to show that the 2 grid MUST have the same decomposition strategy
        grid_dist_id<3, float, Point_test<float>, CartDecomposition<3,float>> g_dist1(sz,domain,g);

        // another grid with the same decomposition
        grid_dist_id<3, float, Point_test<float>, CartDecomposition<3,float>> g_dist2(g_dist1.getDecomposition(),sz,g);

Definition at line 96 of file grid_dist_id.hpp.

#include <grid_dist_id.hpp>

Inheritance diagram for grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >:

Public Types
typedef device_grid	d_grid
	Which kind of grid the structure store.
typedef Decomposition	decomposition
	Decomposition used.
typedef T	value_type
	value_type
typedef St	stype
	Type of space.
typedef Memory	memory_type
	Type of Memory.
typedef device_grid	device_grid_type
	Type of device grid.

Public Member Functions
const Box< dim, St >	getDomain () const
	Get the domain where the grid is defined. More...
Point< dim, St >	getOffset (size_t i)
	Get the point where it start the origin of the grid of the sub-domain i. More...
St	spacing (size_t i) const
	Get the spacing of the grid in direction i. More...
size_t	size () const
	Return the total number of points in the grid. More...
void	setBackgroundValue (T &bv)
	set the background value More...
template<unsigned int p>
void	setBackgroundValue (const typename boost::mpl::at< typename T::type, boost::mpl::int_< p >>::type &bv)
	set the background value More...
size_t	size_local_inserted () const
	Return the local total number of points inserted in the grid. More...
size_t	size (size_t i) const
	Return the total number of points in the grid. More...
	grid_dist_id (const grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &g)
	Copy constructor. More...
template<typename H >
	grid_dist_id (const grid_dist_id< dim, St, H, typename Decomposition::base_type, Memory, grid_cpu< dim, H >> &g, const Ghost< dim, long int > &gh, Box< dim, size_t > ext)
	This constructor is special, it construct an expanded grid that perfectly overlap with the previous. More...
template<typename Decomposition2 >
	grid_dist_id (const Decomposition2 &dec, const size_t(&g_sz)[dim], const Ghost< dim, St > &ghost)
	grid_dist_id (Decomposition &&dec, const size_t(&g_sz)[dim], const Ghost< dim, St > &ghost)
	grid_dist_id (const Decomposition &dec, const size_t(&g_sz)[dim], const Ghost< dim, long int > &g)
template<typename Decomposition2 >
	grid_dist_id (const Decomposition2 &dec, const size_t(&g_sz)[dim], const Ghost< dim, long int > &g)
	grid_dist_id (Decomposition &&dec, const size_t(&g_sz)[dim], const Ghost< dim, long int > &g)
	grid_dist_id (const size_t(&g_sz)[dim], const Box< dim, St > &domain, const Ghost< dim, St > &g, size_t opt=0)
	grid_dist_id (const size_t(&g_sz)[dim], const Box< dim, St > &domain, const Ghost< dim, long int > &g, size_t opt=0)
	grid_dist_id (const size_t(&g_sz)[dim], const Box< dim, St > &domain, const Ghost< dim, St > &g, const periodicity< dim > &p, size_t opt=0)
	grid_dist_id (const size_t(&g_sz)[dim], const Box< dim, St > &domain, const Ghost< dim, long int > &g, const periodicity< dim > &p, size_t opt=0, const grid_sm< dim, void > &g_dec=grid_sm< dim, void >())
	grid_dist_id (const size_t(&g_sz)[dim], const Box< dim, St > &domain, const Ghost< dim, long int > &g, const periodicity< dim > &p, openfpm::vector< Box< dim, long int >> &bx_def)
	It construct a grid on the full domain restricted to the set of boxes specified. More...
const grid_sm< dim, T > &	getGridInfo () const
	Get an object containing the grid informations. More...
const grid_sm< dim, void > &	getGridInfoVoid () const
	Get an object containing the grid informations without type. More...
Decomposition &	getDecomposition ()
	Get the object that store the information about the decomposition. More...
const Decomposition &	getDecomposition () const
	Get the object that store the information about the decomposition. More...
const CellDecomposer_sm< dim, St, shift< dim, St > > &	getCellDecomposer () const
	Return the cell decomposer. More...
bool	isInside (const grid_key_dx< dim > &gk) const
	Check that the global grid key is inside the grid domain. More...
size_t	getLocalDomainSize () const
	Get the total number of grid points for the calling processor. More...
size_t	getLocalDomainWithGhostSize () const
	Get the total number of grid points with ghost for the calling processor. More...
const openfpm::vector< GBoxes< device_grid::dims > > &	getLocalGridsInfo ()
	It return the informations about the local grids. More...
void	getGlobalGridsInfo (openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext_global) const
	It gathers the information about local grids for all of the processors. More...
grid_dist_iterator< dim, device_grid, decltype(device_grid::type_of_subiterator()), FREE >	getOldDomainIterator () const
	It return an iterator that span the full grid domain (each processor span its local domain) More...
grid_dist_id_iterator_dec< Decomposition >	getGridIterator (const grid_key_dx< dim > &start, const grid_key_dx< dim > &stop)
grid_dist_id_iterator_dec< Decomposition, true >	getGridGhostIterator (const grid_key_dx< dim > &start, const grid_key_dx< dim > &stop)
grid_dist_id_iterator_dec< Decomposition >	getGridIterator ()
grid_dist_iterator< dim, device_grid, decltype(device_grid::type_of_subiterator()), FREE >	getDomainIterator () const
	It return an iterator that span the full grid domain (each processor span its local domain) More...
template<unsigned int Np>
grid_dist_iterator< dim, device_grid, decltype(device_grid::template type_of_subiterator< stencil_offset_compute< dim, Np >>()), FREE, stencil_offset_compute< dim, Np > >	getDomainIteratorStencil (const grid_key_dx< dim >(&stencil_pnt)[Np]) const
	It return an iterator that span the full grid domain (each processor span its local domain) More...
grid_dist_iterator< dim, device_grid, decltype(device_grid::type_of_iterator()), FIXED >	getDomainGhostIterator () const
	It return an iterator that span the grid domain + ghost part. More...
grid_dist_iterator_sub< dim, device_grid >	getSubDomainIterator (const grid_key_dx< dim > &start, const grid_key_dx< dim > &stop) const
	It return an iterator that span the grid domain only in the specified part. More...
grid_dist_iterator_sub< dim, device_grid >	getSubDomainIterator (const long int(&start)[dim], const long int(&stop)[dim]) const
	It return an iterator that span the grid domain only in the specified part. More...
	~grid_dist_id ()
	Destructor.
Vcluster &	getVC ()
	Get the Virtual Cluster machine. More...
void	removeUnusedBuffers ()
	Eliminate many internal temporary buffer you can use this between flushes if you get some out of memory. More...
bool	is_staggered () const
	Indicate that this grid is not staggered. More...
template<typename bg_key >
void	remove (const grid_dist_key_dx< dim, bg_key > &v1)
	remove an element in the grid More...
template<typename bg_key >
void	remove_no_flush (const grid_dist_key_dx< dim, bg_key > &v1)
	remove an element in the grid More...
template<typename ... v_reduce>
void	flush (flush_type opt=flush_type::FLUSH_ON_HOST)
void	flush_remove ()
	remove an element in the grid More...
template<unsigned int p, typename bg_key >
auto	insert (const grid_dist_key_dx< dim, bg_key > &v1) -> decltype(loc_grid.get(v1.getSub()).template insert< p >(v1.getKey()))
	insert an element in the grid More...
template<unsigned int p, typename bg_key >
auto	insertFlush (const grid_dist_key_dx< dim, bg_key > &v1) -> decltype(loc_grid.get(v1.getSub()).template insertFlush< p >(v1.getKey()))
	insert an element in the grid More...
template<unsigned int p, typename bg_key >
auto	get (const grid_dist_key_dx< dim, bg_key > &v1) const -> typename std::add_lvalue_reference< decltype(loc_grid.get(v1.getSub()).template get< p >(v1.getKey()))>::type
	Get the reference of the selected element. More...
template<unsigned int p, typename bg_key >
auto	get (const grid_dist_key_dx< dim, bg_key > &v1) -> decltype(loc_grid.get(v1.getSub()).template get< p >(v1.getKey()))
	Get the reference of the selected element. More...
template<unsigned int p = 0>
auto	get (const grid_dist_g_dx< device_grid > &v1) const -> decltype(v1.getSub() ->template get< p >(v1.getKey()))
	Get the reference of the selected element. More...
template<unsigned int p = 0>
auto	get (const grid_dist_g_dx< device_grid > &v1) -> decltype(v1.getSub() ->template get< p >(v1.getKey()))
	Get the reference of the selected element. More...
template<unsigned int p = 0>
auto	get (const grid_dist_lin_dx &v1) const -> decltype(loc_grid.get(v1.getSub()).template get< p >(v1.getKey()))
	Get the reference of the selected element. More...
template<unsigned int p = 0>
auto	get (const grid_dist_lin_dx &v1) -> decltype(loc_grid.get(v1.getSub()).template get< p >(v1.getKey()))
	Get the reference of the selected element. More...
template<typename bg_key >
Point< dim, St >	getPos (const grid_dist_key_dx< dim, bg_key > &v1)
	Get the reference of the selected element. More...
template<typename bg_key >
bool	existPoint (const grid_dist_key_dx< dim, bg_key > &v1) const
	Check if the point exist. More...
template<unsigned int p = 0, typename bgkey >
auto	getProp (const grid_dist_key_dx< dim, bgkey > &v1) const -> decltype(this->template get< p >(v1))
	Get the reference of the selected element. More...
template<unsigned int p = 0, typename bgkey >
auto	getProp (const grid_dist_key_dx< dim, bgkey > &v1) -> decltype(this->template get< p >(v1))
	Get the reference of the selected element. More...
template<int... prp>
void	ghost_get (size_t opt=0)
	It synchronize the ghost parts. More...
template<template< typename, typename > class op, int... prp>
void	ghost_put ()
	It synchronize the ghost parts. More...
grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &	copy (grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &g, bool use_memcpy=true)
	Copy the give grid into this grid. More...
grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &	copy_sparse (grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &g, bool use_memcpy=true)
	Copy the give grid into this grid. More...
Point< dim, St >	getSpacing ()
	Get the spacing on each dimension. More...
grid_key_dx< dim >	getGKey (const grid_dist_key_dx< dim > &k) const
	Convert a g_dist_key_dx into a global key. More...
template<typename Model >
void	addComputationCosts (Model md=Model(), size_t ts=1)
	Add the computation cost on the decomposition using a resolution function. More...
template<unsigned int prop_src, unsigned int prop_dst, unsigned int stencil_size, unsigned int N, typename lambda_f , typename ... ArgsT>
void	conv (int(&stencil)[N][dim], grid_key_dx< 3 > start, grid_key_dx< 3 > stop, lambda_f func, ArgsT ... args)
	apply a convolution using the stencil N More...
template<unsigned int prop_src, unsigned int prop_dst, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>
void	conv_cross (grid_key_dx< 3 > start, grid_key_dx< 3 > stop, lambda_f func, ArgsT ... args)
	apply a convolution using the stencil N More...
template<unsigned int prop_src, unsigned int prop_dst, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>
void	conv_cross_b (grid_key_dx< 3 > start, grid_key_dx< 3 > stop, lambda_f func, ArgsT ... args)
	apply a convolution using the stencil N More...
template<unsigned int stencil_size, typename v_type , typename lambda_f , typename ... ArgsT>
void	conv_cross_ids (grid_key_dx< 3 > start, grid_key_dx< 3 > stop, lambda_f func, ArgsT ... args)
	apply a convolution using the stencil N More...
template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, unsigned int N, typename lambda_f , typename ... ArgsT>
void	conv2 (int(&stencil)[N][dim], grid_key_dx< dim > start, grid_key_dx< dim > stop, lambda_f func, ArgsT ... args)
	apply a convolution using the stencil N More...
template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>
void	conv2 (grid_key_dx< dim > start, grid_key_dx< dim > stop, lambda_f func, ArgsT ... args)
	apply a convolution on 2 property on GPU More...
template<unsigned int prop_src1, unsigned int prop_dst1, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>
void	conv (grid_key_dx< dim > start, grid_key_dx< dim > stop, lambda_f func, ArgsT ... args)
	apply a convolution on GPU More...
template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>
void	conv2_b (grid_key_dx< dim > start, grid_key_dx< dim > stop, lambda_f func, ArgsT ... args)
	apply a convolution on 2 property on GPU More...
template<typename NNtype >
void	findNeighbours ()
template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>
void	conv_cross2 (grid_key_dx< 3 > start, grid_key_dx< 3 > stop, lambda_f func, ArgsT ... args)
	apply a convolution using the stencil N More...
bool	write (std::string output, size_t opt=VTK_WRITER|FORMAT_BINARY)
	Write the distributed grid information. More...
bool	write_debug (std::string output)
	Write all grids indigually. More...
bool	write_frame (std::string output, size_t i, size_t opt=VTK_WRITER|FORMAT_ASCII)
	Write the distributed grid information. More...
device_grid &	get_loc_grid (size_t i)
	Get the i sub-domain grid. More...
grid_key_dx_iterator_sub< dim, no_stencil >	get_loc_grid_iterator (size_t i)
	Get the i sub-domain grid. More...
template<unsigned int Np>
grid_key_dx_iterator_sub< dim, stencil_offset_compute< dim, Np >, typename device_grid::linearizer_type >	get_loc_grid_iterator_stencil (size_t i, const grid_key_dx< dim >(&stencil_pnt)[Np])
	Get the i sub-domain grid. More...
size_t	getN_loc_grid ()
	Return the number of local grid. More...
long int	who ()
	It return the id of structure in the allocation list. More...
void	debugPrint ()
	It print the internal ghost boxes and external ghost boxes in global unit. More...
void	setPropNames (const openfpm::vector< std::string > &names)
	Set the properties names. More...
const openfpm::vector< std::string > &	getPropNames ()
	Set the properties names. More...
void	clear ()
	It delete all the points. More...
void	construct_link (self &grid_up, self &grid_dw)
	construct link between levels More...
void	construct_link_dw (self &grid_dw, openfpm::vector< offset_mv< dim >> &mvof)
	construct link between current and the level down More...
void	construct_link_up (self &grid_up, openfpm::vector< offset_mv< dim >> &mvof)
	construct link between current and the level up More...
template<typename stencil_type >
void	tagBoundaries ()
	construct link between current and the level up More...
void	map (size_t opt=0)
	It move all the grid parts that do not belong to the local processor to the respective processor. More...
void	save (const std::string &filename) const
	Save the grid state on HDF5. More...
void	load (const std::string &filename)
	Reload the grid from HDF5 file. More...
const openfpm::vector< i_lbox_grid< dim > > &	get_loc_ig_box ()
	Get the internal local ghost box. More...
const openfpm::vector< i_lbox_grid< dim > > &	get_ig_box ()
	Get the internal ghost box. More...
void	print_stats ()
void	clear_stats ()
Public Member Functions inherited from grid_dist_id_comm< dim, St, T, Decomposition, Memory, device_grid >
void	grids_reconstruct (openfpm::vector< openfpm::vector< aggregate< device_grid, SpaceBox< dim, long int >>>> &m_oGrid_recv, openfpm::vector< device_grid > &loc_grid, openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext, CellDecomposer_sm< dim, St, shift< dim, St >> &cd_sm)
	Reconstruct the local grids. More...
void	labelIntersectionGridsProcessor (Decomposition &dec, CellDecomposer_sm< dim, St, shift< dim, St >> &cd_sm, openfpm::vector< device_grid > &loc_grid_old, openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext, openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext_old, openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext_global, openfpm::vector< openfpm::vector< aggregate< device_grid, SpaceBox< dim, long int >>>> &lbl_b, openfpm::vector< size_t > &prc_sz)
	Label intersection grids for mappings. More...
void	map_ (Decomposition &dec, CellDecomposer_sm< dim, St, shift< dim, St >> &cd_sm, openfpm::vector< device_grid > &loc_grid, openfpm::vector< device_grid > &loc_grid_old, openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext, openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext_old, openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext_global)
	Moves all the grids that does not belong to the local processor to the respective processor. More...
template<int... prp>
void	ghost_get_ (const openfpm::vector< ip_box_grid< dim >> &ig_box, const openfpm::vector< ep_box_grid< dim >> &eg_box, const openfpm::vector< i_lbox_grid< dim >> &loc_ig_box, const openfpm::vector< e_lbox_grid< dim >> &loc_eg_box, const openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext, const openfpm::vector< e_box_multi< dim >> &eb_gid_list, bool use_bx_def, openfpm::vector< device_grid > &loc_grid, const grid_sm< dim, void > &ginfo, std::unordered_map< size_t, size_t > &g_id_to_external_ghost_box, size_t opt)
	It fill the ghost part of the grids. More...
template<template< typename, typename > class op, int... prp>
void	ghost_put_ (Decomposition &dec, const openfpm::vector< ip_box_grid< dim >> &ig_box, const openfpm::vector< ep_box_grid< dim >> &eg_box, const openfpm::vector< i_lbox_grid< dim >> &loc_ig_box, const openfpm::vector< e_lbox_grid< dim >> &loc_eg_box, const openfpm::vector< GBoxes< device_grid::dims >> &gdb_ext, openfpm::vector< device_grid > &loc_grid, openfpm::vector< std::unordered_map< size_t, size_t >> &g_id_to_internal_ghost_box)
	It merge the information in the ghost with the real information. More...
	grid_dist_id_comm ()
	Constructor. More...
	grid_dist_id_comm (const grid_dist_id_comm< dim, St, T, Decomposition, Memory, device_grid > &gc)
	Copy constructor. More...

Static Public Member Functions
template<typename stencil = no_stencil>
static grid_dist_iterator_sub< dim, device_grid >	type_of_subiterator ()
	This is a meta-function return which type of sub iterator a grid produce. More...

Static Public Attributes
static const unsigned int	dims = dim
	Number of dimensions.

Protected Member Functions
Box< dim, size_t >	getDomain (size_t i)
	Given a local sub-domain i with a local grid Domain + ghost return the part of the local grid that is domain. More...
void	setDecompositionGranularity (size_t n_sub)
	Set the minimum number of sub-domain per processor. More...
void	reset_ghost_structures ()

Static Protected Member Functions
static Ghost< dim, St >	convert_ghost (const Ghost< dim, long int > &gd, const CellDecomposer_sm< dim, St, shift< dim, St >> &cd_sm)
	Convert a ghost from grid point units into continus space. More...

Private Types
typedef grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >	self

Private Member Functions
void	set_for_adjustment (size_t sub_id, const Box< dim, St > &sub_domain_other, const comb< dim > &cmb, Box< dim, long int > &ib, Ghost< dim, long int > &g)
	this function is for optimization of the ghost size More...
void	create_ig_box ()
	Create per-processor internal ghost boxes list in grid units and g_id_to_external_ghost_box. More...
void	create_eg_box ()
	Create per-processor internal ghost box list in grid units. More...
void	create_local_ig_box ()
	Create local internal ghost box in grid units. More...
void	create_local_eg_box ()
	Create per-processor external ghost boxes list in grid units. More...
void	check_size (const size_t(&g_sz)[dim])
	Check the grid has a valid size. More...
void	check_domain (const Box< dim, St > &dom)
	Check the domain is valid. More...
void	Create (openfpm::vector< Box< dim, long int >> &bx_def, const Ghost< dim, long int > &g, bool use_bx_def)
	Create the grids on memory. More...
void	InitializeCellDecomposer (const CellDecomposer_sm< dim, St, shift< dim, St >> &cd_old, const Box< dim, size_t > &ext)
	Initialize the Cell decomposer of the grid enforcing perfect overlap of the cells. More...
void	InitializeCellDecomposer (const size_t(&g_sz)[dim], const size_t(&bc)[dim])
	Initialize the Cell decomposer of the grid. More...
void	InitializeDecomposition (const size_t(&g_sz)[dim], const size_t(&bc)[dim], const grid_sm< dim, void > &g_dist=grid_sm< dim, void >())
	Initialize the grid. More...
void	InitializeStructures (const size_t(&g_sz)[dim])
	Initialize the grid. More...
void	InitializeStructures (const size_t(&g_sz)[dim], openfpm::vector< Box< dim, long int >> &bx, const Ghost< dim, long int > &g, bool use_bx_def)
	Initialize the grid. More...

Static Private Member Functions
static void *	msg_alloc_external_box (size_t msg_i, size_t total_msg, size_t total_p, size_t i, size_t ri, void *ptr)
	Call-back to allocate buffer to receive incoming objects (external ghost boxes) More...

Private Attributes
Box< dim, St >	domain
	Domain.
Ghost< dim, St >	ghost
	Ghost expansion.
Ghost< dim, long int >	ghost_int
	Ghost expansion.
openfpm::vector< device_grid >	loc_grid
	Local grids.
openfpm::vector< device_grid >	loc_grid_old
	Old local grids.
Decomposition	dec
	Space Decomposition.
openfpm::vector< size_t >	gdb_ext_markers
openfpm::vector< GBoxes< device_grid::dims > >	gdb_ext
	Extension of each grid: Domain and ghost + domain.
openfpm::vector< GBoxes< device_grid::dims > >	gdb_ext_global
	Global gdb_ext.
openfpm::vector< GBoxes< device_grid::dims > >	gdb_ext_old
	Extension of each old grid (old): Domain and ghost + domain.
size_t	g_sz [dim]
	Size of the grid on each dimension.
CellDecomposer_sm< dim, St, shift< dim, St > >	cd_sm
	Structure that divide the space into cells.
size_t	gpu_n_insert_thread
	number of insert each GPU thread does
Vcluster &	v_cl
	Communicator class.
openfpm::vector< std::string >	prp_names
	properties names
std::unordered_map< size_t, size_t >	g_id_to_external_ghost_box
openfpm::vector< e_box_multi< dim > >	eb_gid_list
openfpm::vector< std::unordered_map< size_t, size_t > >	g_id_to_internal_ghost_box
openfpm::vector< size_t >	recv_sz
	Receiving size.
openfpm::vector< HeapMemory >	recv_mem_gg
	Receiving buffer for particles ghost get.
grid_sm< dim, T >	ginfo
	Grid informations object.
grid_sm< dim, void >	ginfo_v
	Grid informations object without type.
openfpm::vector< Box< dim, long int > >	bx_def
	Set of boxes that define where the grid is defined.
bool	use_bx_def = false
	Indicate if we have to use bx_def to define the grid.
bool	init_local_i_g_box = false
	Indicate if the local internal ghost box has been initialized.
bool	init_local_e_g_box = false
	Indicate if the local external ghost box has been initialized.
bool	init_e_g_box = false
	Flag that indicate if the external ghost box has been initialized.
bool	init_i_g_box = false
	Flag that indicate if the internal ghost box has been initialized.
bool	init_fix_ie_g_box = false
	Flag that indicate if the internal and external ghost box has been fixed.
openfpm::vector< ip_box_grid< dim > >	ig_box
	Internal ghost boxes in grid units.
openfpm::vector< ep_box_grid< dim > >	eg_box
	External ghost boxes in grid units.
openfpm::vector< i_lbox_grid< dim > >	loc_ig_box
	Local internal ghost boxes in grid units.
openfpm::vector< e_lbox_grid< dim > >	loc_eg_box
	Local external ghost boxes in grid units.
size_t	v_sub_unit_factor = 64
	Number of sub-sub-domain for each processor.
Ghost< dim, long int >	gint = Ghost<dim,long int>(0)

Constructor & Destructor Documentation

grid_dist_id() [1/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &  g )

inline

Copy constructor.

Parameters

g	grid to copy

Definition at line 1223 of file grid_dist_id.hpp.

grid_dist_id() [2/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename H >

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const grid_dist_id< dim, St, H, typename Decomposition::base_type, Memory, grid_cpu< dim, H >> &  g, const Ghost< dim, long int > &  gh, Box< dim, size_t >  ext  )

inline

This constructor is special, it construct an expanded grid that perfectly overlap with the previous.

The key-word here is "perfectly overlap". Using the default constructor you could create something similar, but because of rounding-off error it can happen that it is not perfectly overlapping

Parameters

g	previous grid
gh	Ghost part in grid units
ext	extension of the grid (must be positive on every direction)

Definition at line 1264 of file grid_dist_id.hpp.

grid_dist_id() [3/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename Decomposition2 >

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const Decomposition2 &  dec, const size_t(&)  g_sz[dim], const Ghost< dim, St > &  ghost  )

inline

It constructs a grid of a specified size, defined on a specified Box space, forcing to follow a specified decomposition and with a specified ghost size

Parameters

dec	Decomposition
g_sz	grid size on each dimension
ghost	Ghost part

Definition at line 1318 of file grid_dist_id.hpp.

grid_dist_id() [4/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( Decomposition &&  dec, const size_t(&)  g_sz[dim], const Ghost< dim, St > &  ghost  )

inline

It constructs a grid of a specified size, defined on a specified Box space, forcing to follow a specified decomposition and with a specified ghost size

Parameters

dec	Decomposition
g_sz	grid size on each dimension
ghost	Ghost part

Definition at line 1342 of file grid_dist_id.hpp.

grid_dist_id() [5/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const Decomposition &  dec, const size_t(&)  g_sz[dim], const Ghost< dim, long int > &  g  )

inline

It constructs a grid of a specified size, defined on a specified Box space, forcing to follow a specified decomposition, and having a specified ghost size

Parameters

dec	Decomposition
g_sz	grid size on each dimension
g	Ghost part (given in grid units)

Warning

In very rare case the ghost part can be one point bigger than the one specified

Definition at line 1367 of file grid_dist_id.hpp.

grid_dist_id() [6/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename Decomposition2 >

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const Decomposition2 &  dec, const size_t(&)  g_sz[dim], const Ghost< dim, long int > &  g  )

inline

It constructs a grid of a specified size, defined on a specified Box space, forcing to follow a specified decomposition, and having a specified ghost size

Parameters

dec	Decomposition
g_sz	grid size on each dimension
g	Ghost part (given in grid units)

Warning

In very rare case the ghost part can be one point bigger than the one specified

Definition at line 1394 of file grid_dist_id.hpp.

grid_dist_id() [7/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( Decomposition &&  dec, const size_t(&)  g_sz[dim], const Ghost< dim, long int > &  g  )

inline

It construct a grid of a specified size, defined on a specified Box space, forcing to follow a specified decomposition, and having a specified ghost size

Parameters

dec	Decomposition
g_sz	grid size on each dimension
g	Ghost part (given in grid units)

Warning

In very rare case the ghost part can be one point bigger than the one specified

Definition at line 1420 of file grid_dist_id.hpp.

grid_dist_id() [8/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const size_t(&)  g_sz[dim], const Box< dim, St > &  domain, const Ghost< dim, St > &  g, size_t  opt = 0  )

inline

It construct a grid of a specified size, defined on a specified Box space, and having a specified ghost size

Parameters

g_sz	grid size on each dimension
domain	Box that contain the grid
g	Ghost part (given in grid units)

Warning

In very rare case the ghost part can be one point bigger than the one specified

Definition at line 1449 of file grid_dist_id.hpp.

grid_dist_id() [9/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const size_t(&)  g_sz[dim], const Box< dim, St > &  domain, const Ghost< dim, long int > &  g, size_t  opt = 0  )

inline

It construct a grid of a specified size, defined on a specified Box space, having a specified ghost size and periodicity

Parameters

g_sz	grid size on each dimension
domain	Box that contain the grid
g	Ghost part of the domain (given in grid units)

Warning

In very rare case the ghost part can be one point bigger than the one specified

Definition at line 1463 of file grid_dist_id.hpp.

grid_dist_id() [10/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const size_t(&)  g_sz[dim], const Box< dim, St > &  domain, const Ghost< dim, St > &  g, const periodicity< dim > &  p, size_t  opt = 0  )

inline

It construct a grid of a specified size, defined on a specified Box space, having a specified ghost size, and specified periodicity

Parameters

g_sz	grid size on each dimension
domain	Box that contain the grid
g	Ghost part (given in grid units)
p	Boundary conditions

Warning

In very rare case the ghost part can be one point bigger than the one specified

Definition at line 1478 of file grid_dist_id.hpp.

grid_dist_id() [11/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const size_t(&)  g_sz[dim], const Box< dim, St > &  domain, const Ghost< dim, long int > &  g, const periodicity< dim > &  p, size_t  opt = 0, const grid_sm< dim, void > &  g_dec = grid_sm<dim,void>()  )

inline

It construct a grid of a specified size, defined on a specified Box space, having a specified ghost size and periodicity

Parameters

g_sz	grid size on each dimension
domain	Box that contain the grid
g	Ghost part of the domain (given in grid units)
p	periodicity

Warning

In very rare case the ghost part can be one point bigger than the one specified

Definition at line 1505 of file grid_dist_id.hpp.

grid_dist_id() [12/12]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::grid_dist_id ( const size_t(&)  g_sz[dim], const Box< dim, St > &  domain, const Ghost< dim, long int > &  g, const periodicity< dim > &  p, openfpm::vector< Box< dim, long int >> &  bx_def  )

inline

It construct a grid on the full domain restricted to the set of boxes specified.

In particular the grid is defined in the space equal to the domain intersected the boxes defined by bx

Parameters

g_sz	grid size on each dimension
domain	where the grid is constructed
g	ghost size
p	periodicity of the grid
bx	set of boxes where the grid is defined

Definition at line 1544 of file grid_dist_id.hpp.

Member Function Documentation

addComputationCosts()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename Model >

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::addComputationCosts ( Model  md = Model(), size_t  ts = 1  )

inline

Add the computation cost on the decomposition using a resolution function.

Parameters

md	Model to use
ts	It is an optional parameter approximately should be the number of ghost get between two rebalancing at first decomposition this number can be ignored (default = 1) because not used

Definition at line 2582 of file grid_dist_id.hpp.

check_domain()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::check_domain ( const Box< dim, St > &  dom )

inlineprivate

Check the domain is valid.

Parameters

dom	domain is valid

Definition at line 876 of file grid_dist_id.hpp.

check_size()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::check_size ( const size_t(&)  g_sz[dim] )

inlineprivate

Check the grid has a valid size.

Parameters

g_sz	size of the grid

Definition at line 862 of file grid_dist_id.hpp.

clear()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::clear ( )

inline

It delete all the points.

This function on dense does nothing in case of dense grid but in case of sparse_grid it kills all the points

Definition at line 3112 of file grid_dist_id.hpp.

construct_link()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::construct_link ( self &  grid_up, self &  grid_dw  )

inline

construct link between levels

\praram grid_up grid level up

Parameters

grid_dw

grid level down

Definition at line 3124 of file grid_dist_id.hpp.

construct_link_dw()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::construct_link_dw ( self &  grid_dw, openfpm::vector< offset_mv< dim >> &  mvof  )

inline

construct link between current and the level down

Parameters

grid_dw

grid level down

Definition at line 3138 of file grid_dist_id.hpp.

construct_link_up()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::construct_link_up ( self &  grid_up, openfpm::vector< offset_mv< dim >> &  mvof  )

inline

construct link between current and the level up

Parameters

grid_dw

grid level down

Definition at line 3156 of file grid_dist_id.hpp.

conv() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src, unsigned int prop_dst, unsigned int stencil_size, unsigned int N, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv ( int(&)  stencil[N][dim], grid_key_dx< 3 >  start, grid_key_dx< 3 >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution using the stencil N

Definition at line 2610 of file grid_dist_id.hpp.

conv() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src1, unsigned int prop_dst1, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv ( grid_key_dx< dim >  start, grid_key_dx< dim >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution on GPU

Definition at line 2784 of file grid_dist_id.hpp.

conv2() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, unsigned int N, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv2 ( int(&)  stencil[N][dim], grid_key_dx< dim >  start, grid_key_dx< dim >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution using the stencil N

Definition at line 2726 of file grid_dist_id.hpp.

conv2() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv2 ( grid_key_dx< dim >  start, grid_key_dx< dim >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution on 2 property on GPU

Definition at line 2755 of file grid_dist_id.hpp.

conv2_b()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv2_b ( grid_key_dx< dim >  start, grid_key_dx< dim >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution on 2 property on GPU

Definition at line 2813 of file grid_dist_id.hpp.

conv_cross()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src, unsigned int prop_dst, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv_cross ( grid_key_dx< 3 >  start, grid_key_dx< 3 >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution using the stencil N

Definition at line 2639 of file grid_dist_id.hpp.

conv_cross2()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src1, unsigned int prop_src2, unsigned int prop_dst1, unsigned int prop_dst2, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv_cross2 ( grid_key_dx< 3 >  start, grid_key_dx< 3 >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution using the stencil N

Definition at line 2851 of file grid_dist_id.hpp.

conv_cross_b()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int prop_src, unsigned int prop_dst, unsigned int stencil_size, typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv_cross_b ( grid_key_dx< 3 >  start, grid_key_dx< 3 >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution using the stencil N

Definition at line 2668 of file grid_dist_id.hpp.

conv_cross_ids()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int stencil_size, typename v_type , typename lambda_f , typename ... ArgsT>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::conv_cross_ids ( grid_key_dx< 3 >  start, grid_key_dx< 3 >  stop, lambda_f  func, ArgsT ...  args  )

inline

apply a convolution using the stencil N

Definition at line 2697 of file grid_dist_id.hpp.

convert_ghost()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

static Ghost<dim,St> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::convert_ghost ( const Ghost< dim, long int > &  gd, const CellDecomposer_sm< dim, St, shift< dim, St >> &  cd_sm  )

inlinestaticprotected

Convert a ghost from grid point units into continus space.

Parameters

gd	Ghost in continuous space
cd_sm	CellDecomposer of the grid

Returns

the ghost in continuous unit

Definition at line 1049 of file grid_dist_id.hpp.

copy()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::copy ( grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &  g, bool  use_memcpy = true  )

inline

Copy the give grid into this grid.

It copy the first grid into the given grid (No ghost)

Warning

the Decomposition must be ensured to be the same, otherwise crashes can happen, if you want to copy the grid independently from the decomposition please use the operator equal

Parameters

g	Grid to copy
use_memcpy	use memcpy function if possible

Returns

itself

Definition at line 2465 of file grid_dist_id.hpp.

copy_sparse()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id<dim,St,T,Decomposition,Memory,device_grid>& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::copy_sparse ( grid_dist_id< dim, St, T, Decomposition, Memory, device_grid > &  g, bool  use_memcpy = true  )

inline

Copy the give grid into this grid.

It copy the first grid into the given grid (No ghost)

Warning

the Decomposition must be ensured to be the same, otherwise crashes can happen, if you want to copy the grid independently from the decomposition please use the operator equal

Parameters

g	Grid to copy
use_memcpy	use memcpy function if possible

Returns

itself

Definition at line 2523 of file grid_dist_id.hpp.

Create()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::Create ( openfpm::vector< Box< dim, long int >> &  bx_def, const Ghost< dim, long int > &  g, bool  use_bx_def  )

inlineprivate

Create the grids on memory.

Parameters

bx_def	Where the grid is defined
use_bx_def	use the array that define where the grid is defined

Definition at line 891 of file grid_dist_id.hpp.

create_eg_box()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::create_eg_box ( )

inlineprivate

Create per-processor internal ghost box list in grid units.

Definition at line 441 of file grid_dist_id.hpp.

create_ig_box()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::create_ig_box ( )

inlineprivate

Create per-processor internal ghost boxes list in grid units and g_id_to_external_ghost_box.

Definition at line 367 of file grid_dist_id.hpp.

create_local_eg_box()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::create_local_eg_box ( )

inlineprivate

Create per-processor external ghost boxes list in grid units.

Definition at line 773 of file grid_dist_id.hpp.

create_local_ig_box()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::create_local_ig_box ( )

inlineprivate

Create local internal ghost box in grid units.

Definition at line 649 of file grid_dist_id.hpp.

debugPrint()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::debugPrint ( )

inline

It print the internal ghost boxes and external ghost boxes in global unit.

Definition at line 3046 of file grid_dist_id.hpp.

existPoint()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename bg_key >

bool grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::existPoint ( const grid_dist_key_dx< dim, bg_key > &  v1 ) const

inline

Check if the point exist.

Parameters

v1	grid_key that identify the element in the grid

Returns

the true if the point exist

Definition at line 2350 of file grid_dist_id.hpp.

flush_remove()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::flush_remove ( )

inline

remove an element in the grid

In case of dense grid this function print a warning, in case of sparse grid this function remove a grid point.

Parameters

v1	grid_key that identify the element in the grid

Returns

a reference to the inserted element

Definition at line 2153 of file grid_dist_id.hpp.

get() [1/6]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p, typename bg_key >

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get ( const grid_dist_key_dx< dim, bg_key > &  v1 ) const -> typename std::add_lvalue_reference<decltype(loc_grid.get(v1.getSub()).template get<p>(v1.getKey()))>::type

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2221 of file grid_dist_id.hpp.

get() [2/6]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p, typename bg_key >

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get ( const grid_dist_key_dx< dim, bg_key > &  v1 ) -> decltype(loc_grid.get(v1.getSub()).template get<p>(v1.getKey()))

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2240 of file grid_dist_id.hpp.

get() [3/6]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p = 0>

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get ( const grid_dist_g_dx< device_grid > &  v1 ) const -> decltype(v1.getSub()->template get<p>(v1.getKey()))

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2258 of file grid_dist_id.hpp.

get() [4/6]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p = 0>

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get ( const grid_dist_g_dx< device_grid > &  v1 ) -> decltype(v1.getSub()->template get<p>(v1.getKey()))

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2276 of file grid_dist_id.hpp.

get() [5/6]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p = 0>

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get ( const grid_dist_lin_dx &  v1 ) const -> decltype(loc_grid.get(v1.getSub()).template get<p>(v1.getKey()))

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2293 of file grid_dist_id.hpp.

get() [6/6]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p = 0>

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get ( const grid_dist_lin_dx &  v1 ) -> decltype(loc_grid.get(v1.getSub()).template get<p>(v1.getKey()))

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2310 of file grid_dist_id.hpp.

get_ig_box()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const openfpm::vector<i_lbox_grid<dim> >& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get_ig_box ( )

inline

Get the internal ghost box.

Returns

the internal local ghost box

Definition at line 3309 of file grid_dist_id.hpp.

get_loc_grid()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

device_grid& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get_loc_grid ( size_t  i )

inline

Get the i sub-domain grid.

Parameters

i	sub-domain

Returns

local grid

Definition at line 2979 of file grid_dist_id.hpp.

get_loc_grid_iterator()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_key_dx_iterator_sub<dim,no_stencil> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get_loc_grid_iterator ( size_t  i )

inline

Get the i sub-domain grid.

Parameters

i	sub-domain

Returns

local grid

Definition at line 2991 of file grid_dist_id.hpp.

get_loc_grid_iterator_stencil()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int Np>

grid_key_dx_iterator_sub<dim,stencil_offset_compute<dim,Np>,typename device_grid::linearizer_type> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get_loc_grid_iterator_stencil ( size_t  i, const grid_key_dx< dim >(&)  stencil_pnt[Np]  )

inline

Get the i sub-domain grid.

Parameters

i	sub-domain

Returns

local grid

Definition at line 3007 of file grid_dist_id.hpp.

get_loc_ig_box()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const openfpm::vector<i_lbox_grid<dim> >& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::get_loc_ig_box ( )

inline

Get the internal local ghost box.

Returns

the internal local ghost box

Definition at line 3299 of file grid_dist_id.hpp.

getCellDecomposer()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const CellDecomposer_sm<dim,St,shift<dim,St> >& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getCellDecomposer ( ) const

inline

Return the cell decomposer.

Returns

the cell decomposer

Definition at line 1623 of file grid_dist_id.hpp.

getDecomposition() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

Decomposition& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getDecomposition ( )

inline

Get the object that store the information about the decomposition.

Returns

the decomposition object

Definition at line 1597 of file grid_dist_id.hpp.

getDecomposition() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const Decomposition& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getDecomposition ( ) const

inline

Get the object that store the information about the decomposition.

Returns

the decomposition object

Definition at line 1610 of file grid_dist_id.hpp.

getDomain() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

Box<dim,size_t> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getDomain ( size_t  i )

inlineprotected

Given a local sub-domain i with a local grid Domain + ghost return the part of the local grid that is domain.

Parameters

i	sub-domain

Returns

the Box defining the domain in the local grid

Definition at line 1036 of file grid_dist_id.hpp.

getDomain() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const Box<dim,St> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getDomain ( ) const

inline

Get the domain where the grid is defined.

Returns

the domain of the grid

Definition at line 1124 of file grid_dist_id.hpp.

getDomainGhostIterator()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_iterator<dim,device_grid, decltype(device_grid::type_of_iterator()), FIXED> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getDomainGhostIterator ( ) const

inline

It return an iterator that span the grid domain + ghost part.

Returns

the iterator

Definition at line 1994 of file grid_dist_id.hpp.

getDomainIterator()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_iterator<dim,device_grid, decltype(device_grid::type_of_subiterator()),FREE> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getDomainIterator ( ) const

inline

It return an iterator that span the full grid domain (each processor span its local domain)

Returns

the iterator

Definition at line 1937 of file grid_dist_id.hpp.

getDomainIteratorStencil()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int Np>

grid_dist_iterator<dim,device_grid, decltype(device_grid::template type_of_subiterator<stencil_offset_compute<dim,Np>>()), FREE, stencil_offset_compute<dim,Np> > grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getDomainIteratorStencil ( const grid_key_dx< dim >(&)  stencil_pnt[Np] ) const

inline

It return an iterator that span the full grid domain (each processor span its local domain)

Parameters

stencil_pnt

stencil points

Returns

the iterator

Definition at line 1967 of file grid_dist_id.hpp.

getGKey()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_key_dx<dim> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getGKey ( const grid_dist_key_dx< dim > &  k ) const

inline

Convert a g_dist_key_dx into a global key.

See also

grid_dist_key_dx

grid_dist_iterator

Parameters

k	grid_dist_key_dx point (in general returned by the iterators)

Returns

the global position in the grid

Definition at line 2558 of file grid_dist_id.hpp.

getGlobalGridsInfo()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getGlobalGridsInfo ( openfpm::vector< GBoxes< device_grid::dims >> &  gdb_ext_global ) const

inline

It gathers the information about local grids for all of the processors.

Parameters

gdb_ext_global

where to store the grid infos

Definition at line 1711 of file grid_dist_id.hpp.

getGridGhostIterator()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id_iterator_dec<Decomposition,true> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getGridGhostIterator ( const grid_key_dx< dim > &  start, const grid_key_dx< dim > &  stop  )

inline

/brief Get a grid Iterator running on domain and ghost area

In case of dense grid getGridIterator is equivalent to getDomainIterator in case if sparse distributed grid getDomainIterator go across all the inserted point get grid iterator run across all grid points independently that the point has been insert or not

Returns

a Grid iterator

Definition at line 1900 of file grid_dist_id.hpp.

getGridInfo()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const grid_sm<dim,T>& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getGridInfo ( ) const

inline

Get an object containing the grid informations.

Returns

an information object about this grid

Definition at line 1571 of file grid_dist_id.hpp.

getGridInfoVoid()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const grid_sm<dim,void>& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getGridInfoVoid ( ) const

inline

Get an object containing the grid informations without type.

Returns

an information object about this grid

Definition at line 1584 of file grid_dist_id.hpp.

getGridIterator() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id_iterator_dec<Decomposition> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getGridIterator ( const grid_key_dx< dim > &  start, const grid_key_dx< dim > &  stop  )

inline

/brief Get a grid Iterator

In case of dense grid getGridIterator is equivalent to getDomainIterator in case of sparse grid getDomainIterator go across all the inserted point get grid iterator run across all grid points independently that the point has been insert or not

Returns

a Grid iterator

Definition at line 1787 of file grid_dist_id.hpp.

getGridIterator() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_id_iterator_dec<Decomposition> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getGridIterator ( )

inline

/brief Get a grid Iterator

In case of dense grid getGridIterator is equivalent to getDomainIterator in case if sparse distributed grid getDomainIterator go across all the inserted point get grid iterator run across all grid points independently that the point has been insert or not

Returns

a Grid iterator

Definition at line 1916 of file grid_dist_id.hpp.

getLocalDomainSize()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

size_t grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getLocalDomainSize ( ) const

inline

Get the total number of grid points for the calling processor.

Returns

The number of grid points

Definition at line 1657 of file grid_dist_id.hpp.

getLocalDomainWithGhostSize()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

size_t grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getLocalDomainWithGhostSize ( ) const

inline

Get the total number of grid points with ghost for the calling processor.

Returns

The number of grid points

Definition at line 1677 of file grid_dist_id.hpp.

getLocalGridsInfo()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const openfpm::vector<GBoxes<device_grid::dims> >& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getLocalGridsInfo ( )

inline

It return the informations about the local grids.

Returns

The information about the local grids

Definition at line 1698 of file grid_dist_id.hpp.

getN_loc_grid()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

size_t grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getN_loc_grid ( )

inline

Return the number of local grid.

Returns

the number of local grid

Definition at line 3020 of file grid_dist_id.hpp.

getOffset()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

Point<dim,St> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getOffset ( size_t  i )

inline

Get the point where it start the origin of the grid of the sub-domain i.

Parameters

i	sub-domain

Returns

the point

Definition at line 1136 of file grid_dist_id.hpp.

getOldDomainIterator()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_iterator<dim,device_grid, decltype(device_grid::type_of_subiterator()), FREE> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getOldDomainIterator ( ) const

inline

It return an iterator that span the full grid domain (each processor span its local domain)

Returns

the iterator

Definition at line 1759 of file grid_dist_id.hpp.

getPos()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename bg_key >

Point<dim,St> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getPos ( const grid_dist_key_dx< dim, bg_key > &  v1 )

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2327 of file grid_dist_id.hpp.

getProp() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p = 0, typename bgkey >

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getProp ( const grid_dist_key_dx< dim, bgkey > &  v1 ) const -> decltype(this->template get<p>(v1))

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2364 of file grid_dist_id.hpp.

getProp() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p = 0, typename bgkey >

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getProp ( const grid_dist_key_dx< dim, bgkey > &  v1 ) -> decltype(this->template get<p>(v1))

inline

Get the reference of the selected element.

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

the selected element

Definition at line 2378 of file grid_dist_id.hpp.

getPropNames()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

const openfpm::vector<std::string>& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getPropNames ( )

inline

Set the properties names.

It is useful to specify name for the properties in vtk writers

Parameters

names

set of properties names

Definition at line 3101 of file grid_dist_id.hpp.

getSpacing()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

Point<dim,St> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getSpacing ( )

inline

Get the spacing on each dimension.

Returns

the spacing of the grid on each dimension as a point

Definition at line 2543 of file grid_dist_id.hpp.

getSubDomainIterator() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_iterator_sub<dim,device_grid> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getSubDomainIterator ( const grid_key_dx< dim > &  start, const grid_key_dx< dim > &  stop  ) const

inline

It return an iterator that span the grid domain only in the specified part.

The key spanned are the one inside the box spanned by the start point and the end point included

Parameters

start	point
stop	point

Returns

the sub-domain iterator

Definition at line 2023 of file grid_dist_id.hpp.

getSubDomainIterator() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

grid_dist_iterator_sub<dim,device_grid> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getSubDomainIterator ( const long int(&)  start[dim], const long int(&)  stop[dim]  ) const

inline

It return an iterator that span the grid domain only in the specified part.

The key spanned are the one inside the box spanned by the start point and the end point included

Parameters

start	point
stop	point

Returns

an iterator on the sub-part of the grid

Definition at line 2046 of file grid_dist_id.hpp.

getVC()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

Vcluster& grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::getVC ( )

inline

Get the Virtual Cluster machine.

Returns

the Virtual cluster machine

Definition at line 2067 of file grid_dist_id.hpp.

ghost_get()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<int... prp>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::ghost_get ( size_t  opt = 0 )

inline

It synchronize the ghost parts.

Template Parameters

prp...

Properties to synchronize

Definition at line 2388 of file grid_dist_id.hpp.

ghost_put()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<template< typename, typename > class op, int... prp>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::ghost_put ( )

inline

It synchronize the ghost parts.

Template Parameters

prp...

Properties to synchronize

Definition at line 2424 of file grid_dist_id.hpp.

InitializeCellDecomposer() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::InitializeCellDecomposer ( const CellDecomposer_sm< dim, St, shift< dim, St >> &  cd_old, const Box< dim, size_t > &  ext  )

inlineprivate

Initialize the Cell decomposer of the grid enforcing perfect overlap of the cells.

Parameters

cd_old	the CellDecomposer we are trying to mach
ext	extension of the domain

Definition at line 931 of file grid_dist_id.hpp.

InitializeCellDecomposer() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::InitializeCellDecomposer ( const size_t(&)  g_sz[dim], const size_t(&)  bc[dim]  )

inlineprivate

Initialize the Cell decomposer of the grid.

Parameters

g_sz	Size of the grid
bc	boundary conditions

Definition at line 943 of file grid_dist_id.hpp.

InitializeDecomposition()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::InitializeDecomposition ( const size_t(&)  g_sz[dim], const size_t(&)  bc[dim], const grid_sm< dim, void > &  g_dist = grid_sm<dim,void>()  )

inlineprivate

Initialize the grid.

Parameters

g_sz	Global size of the grid
bc	boundary conditions

Definition at line 962 of file grid_dist_id.hpp.

InitializeStructures() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::InitializeStructures ( const size_t(&)  g_sz[dim] )

inlineprivate

Initialize the grid.

Parameters

g_sz	Global size of the grid

Definition at line 994 of file grid_dist_id.hpp.

InitializeStructures() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::InitializeStructures ( const size_t(&)  g_sz[dim], openfpm::vector< Box< dim, long int >> &  bx, const Ghost< dim, long int > &  g, bool  use_bx_def  )

inlineprivate

Initialize the grid.

Parameters

g_sz	Global size of the grid
g	ghost extension of the grid in integer unit
bx	set of boxes that define where is defined the grid

Definition at line 1012 of file grid_dist_id.hpp.

insert()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p, typename bg_key >

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::insert ( const grid_dist_key_dx< dim, bg_key > &  v1 ) -> decltype(loc_grid.get(v1.getSub()).template insert<p>(v1.getKey()))

inline

insert an element in the grid

In case of dense grid this function is equivalent to get, in case of sparse grid this function insert a grid point. When the point already exist it return a reference to the already existing point. In case of massive insert Sparse grids it give a reference to the inserted element in the insert buffer

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

a reference to the inserted element

Definition at line 2175 of file grid_dist_id.hpp.

insertFlush()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p, typename bg_key >

auto grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::insertFlush ( const grid_dist_key_dx< dim, bg_key > &  v1 ) -> decltype(loc_grid.get(v1.getSub()).template insertFlush<p>(v1.getKey()))

inline

insert an element in the grid

In case of dense grid this function is equivalent to get, in case of sparse grid this function insert a grid point. When the point already exist it return a reference to the already existing point. In case of massive insert Sparse grids The point is inserted immediately and a reference to the inserted element is returned

Warning

This function is not fast an unlucky insert can potentially cost O(N) where N is the number of points (worst case)

Template Parameters

p	property to get (is an integer)

Parameters

v1	grid_key that identify the element in the grid

Returns

a reference to the inserted element

Definition at line 2202 of file grid_dist_id.hpp.

is_staggered()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

bool grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::is_staggered ( ) const

inline

Indicate that this grid is not staggered.

Returns

false

Definition at line 2092 of file grid_dist_id.hpp.

isInside()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

bool grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::isInside ( const grid_key_dx< dim > &  gk ) const

inline

Check that the global grid key is inside the grid domain.

Parameters

gk	point to check

Returns

true if is inside

Definition at line 1638 of file grid_dist_id.hpp.

load()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::load ( const std::string &  filename )

inline

Reload the grid from HDF5 file.

Parameters

filename

output filename

Definition at line 3241 of file grid_dist_id.hpp.

map()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::map ( size_t  opt = 0 )

inline

It move all the grid parts that do not belong to the local processor to the respective processor.

Definition at line 3191 of file grid_dist_id.hpp.

msg_alloc_external_box()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

static void* grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::msg_alloc_external_box ( size_t  msg_i, size_t  total_msg, size_t  total_p, size_t  i, size_t  ri, void *  ptr  )

inlinestaticprivate

Call-back to allocate buffer to receive incoming objects (external ghost boxes)

Parameters

msg_i	message size required to receive from i
total_msg	message size to receive from all the processors
total_p	the total number of processor want to communicate with you
i	processor id
ri	request id (it is an id that goes from 0 to total_p, and is unique every time message_alloc is called)
ptr	void pointer parameter for additional data to pass to the call-back

Definition at line 290 of file grid_dist_id.hpp.

remove()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename bg_key >

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::remove ( const grid_dist_key_dx< dim, bg_key > &  v1 )

inline

remove an element in the grid

In case of dense grid this function print a warning, in case of sparse grid this function remove a grid point.

Parameters

v1	grid_key that identify the element in the grid

Returns

a reference to the inserted element

Definition at line 2107 of file grid_dist_id.hpp.

remove_no_flush()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename bg_key >

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::remove_no_flush ( const grid_dist_key_dx< dim, bg_key > &  v1 )

inline

remove an element in the grid

In case of dense grid this function print a warning, in case of sparse grid this function remove a grid point.

Parameters

v1	grid_key that identify the element in the grid

Returns

a reference to the inserted element

Definition at line 2125 of file grid_dist_id.hpp.

removeUnusedBuffers()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::removeUnusedBuffers ( )

inline

Eliminate many internal temporary buffer you can use this between flushes if you get some out of memory.

Definition at line 2079 of file grid_dist_id.hpp.

save()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::save ( const std::string &  filename ) const

inline

Save the grid state on HDF5.

Parameters

filename

output filename

Definition at line 3229 of file grid_dist_id.hpp.

set_for_adjustment()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::set_for_adjustment ( size_t  sub_id, const Box< dim, St > &  sub_domain_other, const comb< dim > &  cmb, Box< dim, long int > &  ib, Ghost< dim, long int > &  g  )

inlineprivate

this function is for optimization of the ghost size

Because the decomposition work in continuum and discrete ghost is converted in continuum, in some case continuum ghost because of rounding-off error can produce ghost bigger than the discrete selected one. This function adjust for this round-off error

Parameters

sub_id	sub-domain id
sub_domain_other	the other sub-domain
ib	internal ghost box to adjust

Definition at line 319 of file grid_dist_id.hpp.

setBackgroundValue() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::setBackgroundValue ( T &  bv )

inline

set the background value

You can use this function make sense in case of sparse in case of dense it does nothing

Definition at line 1169 of file grid_dist_id.hpp.

setBackgroundValue() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<unsigned int p>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::setBackgroundValue ( const typename boost::mpl::at< typename T::type, boost::mpl::int_< p >>::type &  bv )

inline

set the background value

You can use this function make sense in case of sparse in case of dense it does nothing

Definition at line 1182 of file grid_dist_id.hpp.

setDecompositionGranularity()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::setDecompositionGranularity ( size_t  n_sub )

inlineprotected

Set the minimum number of sub-domain per processor.

Parameters

n_sub

Definition at line 1074 of file grid_dist_id.hpp.

setPropNames()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::setPropNames ( const openfpm::vector< std::string > &  names )

inline

Set the properties names.

It is useful to specify name for the properties in vtk writers

Parameters

names

set of properties names

Definition at line 3089 of file grid_dist_id.hpp.

size() [1/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

size_t grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::size ( ) const

inline

Return the total number of points in the grid.

Returns

number of points

Definition at line 1158 of file grid_dist_id.hpp.

size() [2/2]

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

size_t grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::size ( size_t  i ) const

inline

Return the total number of points in the grid.

Parameters

i

direction

Returns

number of points on direction i

Definition at line 1213 of file grid_dist_id.hpp.

size_local_inserted()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

size_t grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::size_local_inserted ( ) const

inline

Return the local total number of points inserted in the grid.

in case of dense grid it return the number of local points, in case of sparse it return the number of inserted points

Returns

number of points

Definition at line 1196 of file grid_dist_id.hpp.

spacing()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

St grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::spacing ( size_t  i ) const

inline

Get the spacing of the grid in direction i.

Parameters

i

dimension

Returns

the spacing

Definition at line 1148 of file grid_dist_id.hpp.

tagBoundaries()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename stencil_type >

void grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::tagBoundaries ( )

inline

construct link between current and the level up

Parameters

grid_dw

grid level down

Definition at line 3175 of file grid_dist_id.hpp.

type_of_subiterator()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

template<typename stencil = no_stencil>

static grid_dist_iterator_sub<dim,device_grid> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::type_of_subiterator ( )

inlinestatic

This is a meta-function return which type of sub iterator a grid produce.

Returns

the type of the sub-grid iterator

Definition at line 3289 of file grid_dist_id.hpp.

who()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

long int grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::who ( )

inline

It return the id of structure in the allocation list.

See also

print_alloc and SE_CLASS2

Returns

the id

Definition at line 3033 of file grid_dist_id.hpp.

write()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

bool grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::write ( std::string  output, size_t  opt = VTK_WRITER | FORMAT_BINARY  )

inline

Write the distributed grid information.

• grid_X.vtk Output each local grids for each local processor X
• internal_ghost_X.vtk Internal ghost boxes in grid units for the local processor X

Parameters

output	directory where to put the files + prefix
opt	options

Returns

true if the write operation succeed

Definition at line 2886 of file grid_dist_id.hpp.

write_debug()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

bool grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::write_debug ( std::string  output )

inline

Write all grids indigually.

Parameters

output

files

Definition at line 2918 of file grid_dist_id.hpp.

write_frame()

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

bool grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::write_frame ( std::string  output, size_t  i, size_t  opt = VTK_WRITER | FORMAT_ASCII  )

inline

Write the distributed grid information.

• grid_X.vtk Output each local grids for each local processor X
• internal_ghost_X.vtk Internal ghost boxes in grid units for the local processor X

Parameters

output	directory where to put the files + prefix
i	frame number
opt	options

Returns

true id the write succeed

Definition at line 2948 of file grid_dist_id.hpp.

Field Documentation

eb_gid_list

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

openfpm::vector<e_box_multi<dim> > grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::eb_gid_list

private

Link a received external ghost box to the linked eg_box. When the grid is defined everywhere for each received external ghost box exists one eg_box linked to it that contain the information on how to transfer the information to the associated sub-domain grid. Unfortunately when we specify where the grid is defined, a received external ghost box can be linked to multiple sub-domain grids (one sub-domain can have multiple sub grids). So in standard situation (grid defined everywhere) a received external ghost box is linked to a single eg_box entry and eb_gid_list play mainly no role. (play no role but must be filled ghost_get expect this structure to be filled consistently, it will be clear later how to do it in this case). When the grid is not defined everywhere a received ghost box can be linked to multiple external ghost boxes. (Like in figure)

  +--------------------------------------------+------
  |        Sub-domain                          | Another sub-domain
  |          +------+           +---------+    |
  |          |      |           |         |    |
  |          |      |           |         |    |
  |          |      |           |         |    |
  |          |  3   |           |    4    |    |
  |   empty  |      |    empty  |         |    |
  |          |      |           |         |    |
  |          |      |           |         |    |
  |          |      |           |         |    |                         1
  |          |      |           |         |    |
+-+-----+----+------+-----------+---------+----+-----+-----   Processor bound
        |***##########*********#############****|****|
        |                                            |                   0
        |                                            |
        |                                            |
        |                  9                         |
        |                                            |
        |                                            |
        |                                            |
        +--------------------------------------------+

     * 

As we can see here the grid number 9 on processo 0 has an internal ghost box The internal ghost-box is sent to processor 1 and is a received external ghost box. This external ghost box is partially shared in two separated grids. It is important to note that 3 and 4 are grid defined externally and are not defined by the sub-domain border. It is important also to note that the sub-domain granularity in processor 1 define the granularity of the internal ghost box in processor 0 and consequently every external ghost box in processor 1 is linked uniquely with one internal ghost box in processor 0. On the other hand if we have a secondary granularity define by external boxes like 3 and 4 this is not anymore true and one internal ghost box in 0 can be linked with multiple grids. The granularity of the space division is different from the granularity of where the grid is defined. Space decomposition exist independently from the data-structure and can be shared across multiple data-structure this mean that cannot be redefined based on where is the grid definitions. The internal ghost box could be redefined in order to respect the granularity. We do not do this for 3 main reason.

1) The definition box must be communicated across processors. 2) An interprocessor global-id link must be established with lower sub-domain granularty 3) Despite the points * are not linked, but must be anyway sent to processor 1, this mean that make not too much sense to increase the granularity in advance on processor 0, but it is better receive the information an than solve the lower granularity locally on processor 1

Definition at line 225 of file grid_dist_id.hpp.

g_id_to_external_ghost_box

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

std::unordered_map<size_t,size_t> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::g_id_to_external_ghost_box

private

It map a global ghost id (g_id) to the external ghost box information It is unique across all the near processor

Definition at line 155 of file grid_dist_id.hpp.

g_id_to_internal_ghost_box

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

openfpm::vector<std::unordered_map<size_t,size_t> > grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::g_id_to_internal_ghost_box

private

It map a global ghost id (g_id) to the internal ghost box information (is unique for processor), it is not unique across all the near processor

Definition at line 229 of file grid_dist_id.hpp.

gdb_ext_markers

template<unsigned int dim, typename St, typename T, typename Decomposition = CartDecomposition<dim,St>, typename Memory = HeapMemory, typename device_grid = grid_cpu<dim,T>>

openfpm::vector<size_t> grid_dist_id< dim, St, T, Decomposition, Memory, device_grid >::gdb_ext_markers

private

gdb_ext markers In the case where the grid is defined everywhere gdb_ext_marker is useless and so is empty in the case we have a grid defined on a smaller set of boxes gbd_ext_markers indicate the division across subdomains. For example Sub-domain 0 produce 2 grid Sub-domain 1 produce 3 grid Sub-domain 2 produce 2 grid Sub-domain 3 produce 1 grid gdb_ext_markers contain 0,2,5,7,8

Definition at line 127 of file grid_dist_id.hpp.

---

The documentation for this class was generated from the following file:

• src/Grid/grid_dist_id.hpp