OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
 
Loading...
Searching...
No Matches
CartDecomposition_ext< dim, T, Memory, layout_base, Distribution > Class Template Reference

This class decompose a space into sub-sub-domains and distribute them across processors. More...

Detailed Description

template<unsigned int dim, typename T, typename Memory = HeapMemory, template< typename > class layout_base = memory_traits_lin, typename Distribution = ParMetisDistribution<dim, T>>
class CartDecomposition_ext< dim, T, Memory, layout_base, Distribution >

This class decompose a space into sub-sub-domains and distribute them across processors.

Template Parameters
dimis the dimensionality of the physical domain we are going to decompose.
Ttype of the space we decompose, Real, Integer, Complex ...
MemoryMemory factory used to allocate memory
Distributiontype of distribution, can be ParMetisDistribution or MetisDistribution

Most of the functionality is the same as CartDecomposition so refer to that class for more information

The additional functionality is the possibility to produce an extended decomposition, in figure is show what we mean with extended

See also
CartDecomposition

Create a Cartesian decomposition object on a Box space, distribute, calculate internal and external ghost boxes

Definition at line 42 of file CartDecomposition_ext.hpp.

#include <CartDecomposition_ext.hpp>

+ Inheritance diagram for CartDecomposition_ext< dim, T, Memory, layout_base, Distribution >:

Public Types

typedef CartDecomposition< dim, T, Memory, layout_base, Distribution > base_type
 The non-extended decomposition base class.
 
- Public Types inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
typedef T domain_type
 Type of the domain we are going to decompose.
 
typedef SpaceBox< dim, T > Box
 It simplify to access the SpaceBox element.
 
typedef CartDecomposition< dim, T, Memory, layout_base, Distribution > base_type
 This class is base of itself.
 
typedef CartDecomposition_ext< dim, T, Memory, layout_base, Distribution > extended_type
 This class admit a class defined on an extended domain.
 
typedef ie_loc_ghost< dim, T, layout_base, Memory > ie_loc_ghost_type
 
typedef nn_prcs< dim, T, layout_base, Memory > nn_prcs_type
 
typedef ie_ghost< dim, T, Memory, layout_base > ie_ghost_type
 
typedef T stype
 Space type.
 

Public Member Functions

 CartDecomposition_ext (Vcluster<> &v_cl)
 Cartesian decomposition constructor.
 
void setParameters (const CartDecomposition< dim, T, Memory, layout_base, Distribution > &dec, const Ghost< dim, T > &g, const ::Box< dim, T > &ext_domain)
 It create another object that contain the same decomposition information but with different ghost boxes and an extended domain.
 
- Public Member Functions inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
void initialize_fine_s (const ::Box< dim, T > &domain)
 
void construct_fine_s ()
 
void createSubdomains (Vcluster<> &v_cl, const size_t(&bc)[dim], size_t opt=0)
 Constructor, it decompose and distribute the sub-domains across the processors.
 
void Initialize_geo_cell_lists ()
 Initialize geo_cell lists.
 
void computeCommunicationAndMigrationCosts (size_t ts)
 Calculate communication and migration costs.
 
void CreateSubspaces ()
 Create the sub-domain that decompose your domain.
 
void calculateGhostBoxes ()
 It calculate the internal ghost boxes.
 
void incRef ()
 Increment the reference counter.
 
void decRef ()
 Decrement the reference counter.
 
long int ref ()
 Return the reference counter.
 
 CartDecomposition (Vcluster<> &v_cl)
 Cartesian decomposition constructor.
 
 CartDecomposition (const CartDecomposition< dim, T, Memory, layout_base, Distribution > &cart)
 Cartesian decomposition copy constructor.
 
 CartDecomposition (CartDecomposition< dim, T, Memory, layout_base, Distribution > &&cart)
 Cartesian decomposition copy constructor.
 
 ~CartDecomposition ()
 Cartesian decomposition destructor.
 
void applyPointBC (float(&pt)[dim]) const
 Apply boundary condition to the point.
 
void applyPointBC (Point< dim, T > &pt) const
 Apply boundary condition to the point.
 
template<typename Mem >
void applyPointBC (encapc< 1, Point< dim, T >, Mem > &&pt) const
 Apply boundary condition to the point.
 
CartDecomposition< dim, T, Memory, layout_base, Distribution > duplicate (const Ghost< dim, T > &g) const
 It create another object that contain the same decomposition information but with different ghost boxes.
 
CartDecomposition< dim, T, Memory, layout_base, Distribution > duplicate () const
 It create another object that contain the same information and act in the same way.
 
template<typename Memory2 , template< typename > class layout_base2>
CartDecomposition< dim, T, Memory2, layout_base2, Distribution > duplicate_convert () const
 It create another object that contain the same information and act in the same way.
 
CartDecomposition< dim, T, Memory, layout_base, Distribution > & operator= (const CartDecomposition &cart)
 Copy the element.
 
template<typename CartDecomposition2 >
CartDecomposition< dim, T, Memory, layout_base, Distribution > & operator= (const CartDecomposition2 &cart)
 Copy the element.
 
CartDecomposition< dim, T, Memory, layout_base, Distribution > & operator= (CartDecomposition &&cart)
 Copy the element, move semantic.
 
template<typename Mem >
size_t processorID (const encapc< 1, Point< dim, T >, Mem > &p) const
 Given a point return in which processor the particle should go.
 
size_t processorID (const Point< dim, T > &p) const
 Given a point return in which processor the particle should go.
 
size_t processorID (const T(&p)[dim]) const
 Given a point return in which processor the particle should go.
 
template<typename Mem >
size_t processorIDBC (encapc< 1, Point< dim, T >, Mem > p)
 Given a point return in which processor the point/particle should go.
 
size_t processorIDBC (const Point< dim, T > &p) const
 Given a point return in which processor the particle should go.
 
size_t processorIDBC (const T(&p)[dim]) const
 Given a point return in which processor the particle should go.
 
size_t periodicity (size_t i) const
 Get the periodicity on i dimension.
 
const size_t(& periodicity () const)[dim]
 Get the periodicity.
 
void calculate_magn (const grid_sm< dim, void > &gm)
 Calculate magnification.
 
void setGoodParameters (::Box< dim, T > &domain_, const size_t(&bc)[dim], const Ghost< dim, T > &ghost, size_t dec_gran, const grid_sm< dim, void > &sec_dist=grid_sm< dim, void >())
 Set the best parameters for the decomposition.
 
void getParameters (size_t(&div_)[dim])
 return the parameters of the decomposition
 
void setParameters (const size_t(&div_)[dim], ::Box< dim, T > &domain_, const size_t(&bc)[dim], const Ghost< dim, T > &ghost, const grid_sm< dim, void > &sec_dist=grid_sm< dim, void >())
 Set the parameter of the decomposition.
 
void reset ()
 Delete the decomposition and reset the data-structure.
 
void decompose (dec_options opt=dec_options::DEC_NONE)
 Start decomposition.
 
void refine (size_t ts)
 Refine the decomposition, available only for ParMetis distribution, for Metis it is a null call.
 
void redecompose (size_t ts)
 Refine the decomposition, available only for ParMetis distribution, for Metis it is a null call.
 
bool refine (DLB &dlb)
 Refine the decomposition, available only for ParMetis distribution, for Metis it is a null call.
 
float getUnbalance ()
 Get the current un-balance value.
 
size_t getProcessorLoad ()
 Compute the processor load counting the total weights of its vertices.
 
void getSubSubDomainPosition (size_t id, T(&pos)[dim])
 function that return the position of the cell in the space
 
size_t getNSubSubDomains ()
 Get the number of sub-sub-domains in this sub-graph.
 
void setSubSubDomainComputationCost (size_t id, size_t weight)
 Function that set the computational cost for a of a sub-sub domain.
 
size_t getSubSubDomainComputationCost (size_t id)
 function that return the computation cost of the sub-sub-domain id
 
size_t subSize ()
 Operator to access the size of the sub-graph.
 
size_t getNSubDomain ()
 Get the number of local sub-domains.
 
SpaceBox< dim, T > getSubDomain (size_t lc)
 Get the local sub-domain.
 
SpaceBox< dim, T > getSubDomainWithGhost (size_t lc)
 Get the local sub-domain enlarged with ghost extension.
 
const ::Box< dim, T > & getDomain () const
 Return the box of the physical domain.
 
const openfpm::vector< SpaceBox< dim, T >, Memory, layout_base > & getSubDomains () const
 
template<typename Mem >
bool isLocal (const encapc< 1, Point< dim, T >, Mem > p) const
 Check if the particle is local.
 
bool isLocal (const T(&pos)[dim]) const
 Check if the particle is local.
 
bool isLocal (const Point< dim, T > &pos) const
 Check if the particle is local.
 
template<typename Mem >
bool isLocalBC (const encapc< 1, Point< dim, T >, Mem > p, const size_t(&bc)[dim]) const
 Check if the particle is local considering boundary conditions.
 
bool isLocalBC (const Point< dim, T > &p, const size_t(&bc)[dim]) const
 Check if the particle is local considering boundary conditions.
 
openfpm::vector< size_t > & getDomainCells ()
 Get the domain Cells.
 
openfpm::vector< size_t > & getCRSDomainCells ()
 Get the CRS domain Cells with normal neighborhood.
 
void setNNParameters (grid_key_dx< dim > &shift, grid_sm< dim, void > &gs)
 set NN parameters to calculate cell-list neighborhood
 
openfpm::vector< subsub_lin< dim > > & getCRSAnomDomainCells ()
 Get the CRS anomalous cells.
 
bool isLocalBC (const T(&p)[dim], const size_t(&bc)[dim]) const
 Check if the particle is local considering boundary conditions.
 
::Box< dim, T > & getProcessorBounds ()
 Return the bounding box containing union of all the sub-domains for the local processor.
 
const Ghost< dim, T > & getGhost () const
 Return the ghost.
 
const grid_sm< dim, void > getGrid ()
 Decomposition grid.
 
const grid_sm< dim, void > getDistGrid ()
 Distribution grid.
 
bool write (std::string output) const
 Write the decomposition as VTK file.
 
VclustergetVC () const
 Get the Virtual Cluster machine.
 
void free_geo_cell ()
 Deallocate structures that identify a point to which internal ghost is located.
 
void free_fines ()
 Deallocate structures that identify a point to which internal ghost is located.
 
bool check_consistency ()
 function to check the consistency of the information of the decomposition
 
void debugPrint ()
 Print subdomains, external and internal ghost boxes.
 
bool is_equal (CartDecomposition< dim, T, Memory > &cart)
 Check if the CartDecomposition contain the same information.
 
bool is_equal_ng (CartDecomposition< dim, T, Memory > &cart)
 Check if the CartDecomposition contain the same information with the exception of the ghost part It is anyway required that the ghost come from the same sub-domains decomposition.
 
Distribution & getDistribution ()
 Return the distribution object.
 
void addComputationCost (size_t gid, size_t i)
 Add computation cost i to the subsubdomain with global id gid.
 
size_t get_ndec ()
 Get the decomposition counter.
 
const CellDecomposer_sm< dim, T, shift< dim, T > > & getCellDecomposer ()
 Get the cell decomposer of the decomposition.
 
CartDecomposition_gpu< dim, T, Memory, layout_base > toKernel ()
 convert to a structure usable in a device kernel
 
openfpm::vector< SpaceBox< dim, T > > & private_get_sub_domains ()
 Return the internal data structure sub_domains.
 
const openfpm::vector< SpaceBox< dim, T > > & private_get_sub_domains () const
 Return the internal data structure sub_domains.
 
openfpm::vector< openfpm::vector< long unsigned int > > & private_get_box_nn_processor ()
 Return the internal data structure box_nn_processor.
 
const openfpm::vector< openfpm::vector< long unsigned int > > & private_get_box_nn_processor () const
 Return the internal data structure box_nn_processor.
 
CellList< dim, T, Mem_fast< Memory, int >, shift< dim, T > > & private_get_fine_s ()
 Return the internal data structure fine_s.
 
const CellList< dim, T, Mem_fast< Memory, int >, shift< dim, T > > & private_get_fine_s () const
 Return the internal data structure fine_s.
 
grid_sm< dim, void > & private_get_gr ()
 Return the internal data structure gr.
 
const grid_sm< dim, void > & private_get_gr () const
 Return the internal data structure gr.
 
grid_sm< dim, void > & private_get_gr_dist ()
 Return the internal data structure gr_dist.
 
const grid_sm< dim, void > & private_get_gr_dist () const
 Return the internal data structure gr_dist.
 
Distribution & private_get_dist ()
 Return the internal data structure dist.
 
const Distribution & private_get_dist () const
 Return the internal data structure dist.
 
bool & private_get_commCostSet ()
 Return the internal data structure commCostSet.
 
const bool & private_get_commCostSet () const
 Return the internal data structure commCostSet.
 
CellDecomposer_sm< dim, T, shift< dim, T > > & private_get_cd ()
 Return the internal data structure cd.
 
const CellDecomposer_sm< dim, T, shift< dim, T > > & private_get_cd () const
 Return the internal data structure cd.
 
::Box< dim, T > & private_get_domain ()
 Return the internal data structure domain.
 
const ::Box< dim, T > & private_get_domain () const
 Return the internal data structure domain.
 
openfpm::vector< Box_map< dim, T >, Memory, layout_base > & private_get_sub_domains_global ()
 Return the internal data structure sub_domains_global.
 
const openfpm::vector< Box_map< dim, T >, Memory, layout_base > & private_get_sub_domains_global () const
 Return the internal data structure sub_domains_global.
 
T & private_get_spacing (int i)
 Return the internal data structure spacing.
 
const T & private_get_spacing (int i) const
 Return the internal data structure spacing.
 
T & private_get_magn (int i)
 Return the internal data structure magn.
 
const T & private_get_magn (int i) const
 Return the internal data structure magn.
 
Ghost< dim, T > & private_get_ghost ()
 Return the internal data structure ghost.
 
const Ghost< dim, T > & private_get_ghost () const
 Return the internal data structure ghost.
 
::Box< dim, T > & private_get_bbox ()
 Return the internal data structure bbox.
 
const ::Box< dim, T > & private_get_bbox () const
 Return the internal data structure bbox.
 
size_t & private_get_bc (int i)
 Return the internal data structure bc.
 
const size_t & private_get_bc (int i) const
 Return the internal data structure bc.
 
- Public Member Functions inherited from ie_loc_ghost< dim, T, layout_base, Memory >
void create (openfpm::vector< SpaceBox< dim, T >, Memory, layout_base > &sub_domains, Box< dim, T > &domain, Ghost< dim, T > &ghost, const size_t(&bc)[dim])
 Create external and internal local ghosts.
 
 ie_loc_ghost ()
 Default constructor.
 
 ie_loc_ghost (const ie_loc_ghost< dim, T, layout_base, Memory > &ilg)
 Constructor from another ie_loc_ghost.
 
 ie_loc_ghost (ie_loc_ghost< dim, T, layout_base, Memory > &&ilg)
 Constructor from temporal ie_loc_ghost.
 
ie_loc_ghost< dim, T, layout_base, Memory > & operator= (const ie_loc_ghost< dim, T, layout_base, Memory > &ilg)
 copy the ie_loc_ghost
 
ie_loc_ghost< dim, T, layout_base, Memory > & operator= (ie_loc_ghost< dim, T, layout_base, Memory > &&ilg)
 copy the ie_loc_ghost
 
template<template< typename > class layout_base2, typename Memory2 >
ie_loc_ghost< dim, T, layout_base, Memory > & operator= (const ie_loc_ghost< dim, T, layout_base2, Memory2 > &ilg)
 copy the ie_loc_ghost
 
template<template< typename > class layout_base2, typename Memory2 >
ie_loc_ghost< dim, T, layout_base, Memory > & operator= (ie_loc_ghost< dim, T, layout_base2, Memory2 > &&ilg)
 copy the ie_loc_ghost
 
openfpm::vector< lBox_dom< dim, T > > & private_get_loc_ghost_box ()
 Get the internal loc_ghost_box.
 
size_t getNLocalSub ()
 Get the number of local ghost boxes.
 
size_t getLocalNEGhost (size_t id)
 Get the number of external local ghost box for each sub-domain.
 
size_t getLocalNIGhost (size_t id)
 Get the number of internal local ghost box for each sub-domain.
 
size_t getLocalIGhostE (size_t i, size_t j)
 For the sub-domain i intersected with a surrounding sub-domain enlarged j. Produce a internal ghost box from the prospecive of i and an associated external ghost box from the prospective of j. In order to retrieve the information about the external ghost box we have to use getLocalEGhostBox(x,k). where k is the value returned by getLocalIGhostE(i,j) and x is the value returned by getLocalIGhostSub(i,j)
 
const ::Box< dim, T > & getLocalIGhostBox (size_t i, size_t j) const
 Get the j internal local ghost box for the i sub-domain.
 
const comb< dim > & getLocalIGhostPos (size_t i, size_t j) const
 Get the j internal local ghost box boundary position for the i sub-domain of the local processor.
 
const ::Box< dim, T > & getLocalEGhostBox (size_t i, size_t j) const
 Get the j external local ghost box for the local processor.
 
const comb< dim > & getLocalEGhostPos (size_t i, size_t j) const
 Get the j external local ghost box for the local processor.
 
size_t getLocalIGhostSub (size_t i, size_t k) const
 Considering that sub-domains has N internal local ghost box identified with the 0 <= k < N that come from the intersection of 2 sub-domains i and j where j is enlarged, given the sub-domain i and the id k of the internal box, it return the id j of the other sub-domain that produced the intersection.
 
size_t getLocalEGhostSub (size_t i, size_t k) const
 Considering that sub-domains has N external local ghost box identified with the 0 <= k < N that come from the intersection of 2 sub-domains i and j where i is enlarged, given the sub-domain i and the id k of the external box, it return the id of the other sub-domain j that produced the intersection.
 
bool write (std::string output, size_t p_id) const
 Write the decomposition as VTK file.
 
bool check_consistency (size_t n_sub)
 function to check the consistency of the information of the decomposition
 
bool is_equal (ie_loc_ghost< dim, T, layout_base, Memory > &ilg)
 Check if the ie_loc_ghosts contain the same information.
 
bool is_equal_ng (ie_loc_ghost< dim, T, layout_base, Memory > &ilg)
 Check if the ie_loc_ghosts contain the same information with the exception of the ghost part.
 
void reset ()
 Reset the ie_loc_ghost.
 
- Public Member Functions inherited from nn_prcs< dim, T, layout_base, Memory >
 nn_prcs (Vcluster<> &v_cl)
 Constructor require Vcluster.
 
 nn_prcs (const nn_prcs< dim, T, layout_base, Memory > &ilg)
 Constructor from another nn_prcs.
 
 nn_prcs (nn_prcs< dim, T, layout_base, Memory > &&ilg)
 Constructor from temporal ie_loc_ghost.
 
nn_prcs< dim, T, layout_base, Memory > & operator= (const nn_prcs< dim, T, layout_base, Memory > &nnp)
 Copy the object.
 
nn_prcs< dim, T, layout_base, Memory > & operator= (nn_prcs< dim, T, layout_base, Memory > &&nnp)
 Copy the object.
 
template<typename Memory2 , template< typename > class layout_base2>
nn_prcs< dim, T, layout_base, Memory > & operator= (const nn_prcs< dim, T, layout_base2, Memory2 > &nnp)
 Copy the object.
 
openfpm::vector< size_t > & private_get_nn_processors ()
 Return the internal nn_processor struct.
 
std::unordered_map< size_t, N_box< dim, T > > & private_get_nn_processor_subdomains ()
 Return the internal nn_processor_subdomains.
 
openfpm::vector< openfpm::vector< size_t > > & private_get_proc_adj_box ()
 Return the internal proc_adj_box.
 
openfpm::vector< openfpm::vector< ::SpaceBox< dim, T > > > & private_get_boxes ()
 Return the internal boxes structure.
 
template<typename Memory2 , template< typename > class layout_base2>
nn_prcs< dim, T, layout_base, Memory > & operator= (nn_prcs< dim, T, layout_base2, Memory2 > &&nnp)
 Copy the object.
 
void create (const openfpm::vector< openfpm::vector< long unsigned int > > &box_nn_processor, const openfpm::vector< SpaceBox< dim, T >, Memory, layout_base > &sub_domains)
 Create the list of adjacent processors and the list of adjacent sub-domains.
 
size_t getNNProcessors () const
 Get the number of Near processors.
 
size_t IDtoProc (size_t id) const
 Return the processor id of the near processor list at place id.
 
const openfpm::vector< size_t > & getNearSubdomainsRealId (size_t p_id) const
 Get the real-id of the sub-domains of a near processor.
 
const openfpm::vector< ::Box< dim, T > > & getNearSubdomains (size_t p_id) const
 Get the sub-domains of a near processor.
 
size_t getNRealSubdomains (size_t p_id) const
 Get the number of real sub-domains of a near processor.
 
const openfpm::vector< comb< dim > > & getNearSubdomainsPos (size_t p_id) const
 Get the sub-domains sector position of a near processor.
 
size_t getNearProcessor (size_t p_id) const
 Get the near processor id.
 
const openfpm::vector< size_t > & getSentSubdomains (size_t p_id) const
 For each near processor it give a vector with the id of the local sub-domain sent to that processor.
 
size_t ProctoID (size_t p) const
 Convert the processor rank to the id in the list.
 
bool write (std::string output) const
 Write the decomposition as VTK file.
 
void applyBC (const Box< dim, T > &domain, const Ghost< dim, T > &ghost, const size_t(&bc)[dim])
 Apply boundary conditions.
 
bool is_equal (nn_prcs< dim, T, layout_base, Memory > &np)
 Check if the nn_prcs contain the same information.
 
void reset ()
 Reset the nn_prcs structure.
 
std::unordered_map< size_t, N_box< dim, T > > & get_nn_processor_subdomains ()
 Used for testing porpose do not use.
 
openfpm::vector< size_t > & get_nn_processors ()
 Used for testing porpose do not use.
 
- Public Member Functions inherited from ie_ghost< dim, T, Memory, layout_base >
 ie_ghost ()
 Default constructor.
 
 ie_ghost (const ie_ghost< dim, T, Memory, layout_base > &ie)
 Copy constructor.
 
 ie_ghost (ie_ghost< dim, T, Memory, layout_base > &&ie)
 Copy constructor.
 
ie_ghost< dim, T, Memory, layout_base > & operator= (ie_ghost< dim, T, Memory, layout_base > &&ie)
 Copy operator.
 
ie_ghost< dim, T, Memory, layout_base > & operator= (const ie_ghost< dim, T, Memory, layout_base > &ie)
 Copy operator.
 
template<typename Memory2 , template< typename > class layout_base2>
ie_ghost< dim, T, Memory, layout_base > & operator= (const ie_ghost< dim, T, Memory2, layout_base2 > &ie)
 Copy operator.
 
template<typename Memory2 , template< typename > class layout_base2>
ie_ghost< dim, T, Memory2, layout_base2 > duplicate ()
 duplicate this structure changing layout and Memory
 
const openfpm::vector< Point< dim, T >, Memory, layout_base > & getShiftVectors ()
 
size_t convertShift (const comb< dim > &cmb)
 
size_t getProcessorNIGhost (size_t id) const
 Get the number of Internal ghost boxes for one processor.
 
size_t getProcessorNEGhost (size_t id) const
 Get the number of External ghost boxes for one processor id.
 
const ::Box< dim, T > & getProcessorIGhostBox (size_t id, size_t j) const
 Get the j Internal ghost box for one processor.
 
const ::Box< dim, T > & getProcessorEGhostBox (size_t id, size_t j) const
 Get the j External ghost box.
 
const comb< dim > & getProcessorEGhostPos (size_t id, size_t j) const
 Get the j External ghost box sector.
 
const comb< dim > & getProcessorIGhostPos (size_t id, size_t j) const
 Get the ghost box sector of the external ghost box linked with the j internal ghost box.
 
size_t getProcessorIGhostId (size_t id, size_t j) const
 Get the j Internal ghost box id.
 
size_t getProcessorEGhostId (size_t id, size_t j) const
 Get the j External ghost box id.
 
size_t getProcessorIGhostSSub (size_t id, size_t j) const
 Get the sub-domain send-id at witch belong the internal ghost box.
 
size_t getProcessorIGhostSub (size_t id, size_t j) const
 Get the local sub-domain at witch belong the internal ghost box.
 
size_t getProcessorEGhostSub (size_t id, size_t j) const
 Get the local sub-domain at witch belong the external ghost box.
 
size_t getNIGhostBox () const
 Return the total number of the calculated internal ghost boxes.
 
inline ::Box< dim, T > getIGhostBox (size_t b_id) const
 Given the internal ghost box id, it return the internal ghost box.
 
size_t getIGhostBoxProcessor (size_t b_id) const
 Given the internal ghost box id, it return the near processor at witch belong or the near processor that produced this internal ghost box.
 
size_t getNEGhostBox () const
 Get the number of the calculated external ghost boxes.
 
inline ::Box< dim, T > getEGhostBox (size_t b_id) const
 Given the external ghost box id, it return the external ghost box.
 
size_t getEGhostBoxProcessor (size_t b_id) const
 Given the external ghost box id, it return the near processor at witch belong or the near processor that produced this external ghost box.
 
auto getInternalIDBoxes (Point< dim, T > &p) -> decltype(geo_cell.getCellIterator(geo_cell.getCell(p)))
 
auto labelPoint (Point< dim, T > &p) -> decltype(geo_cell.getCellIterator(geo_cell.getCell(p)))
 if the point fall into the ghost of some near processor it return the processors id's in which it fall
 
template<typename output_type >
void ghost_processor_ID (const Point< dim, T > &p, output_type &output, unsigned int base, unsigned int pi)
 Get the number of processor a particle must sent.
 
unsigned int ghost_processorID_N (const Point< dim, T > &p)
 Get the number of processor a particle must sent.
 
template<typename id1 , typename id2 >
const openfpm::vector< std::pair< size_t, size_t > > ghost_processorID_pair (Point< dim, T > &p, const int opt=MULTIPLE)
 Given a position it return if the position belong to any neighborhood processor ghost (Internal ghost)
 
template<typename id >
const openfpm::vector< size_t > ghost_processorID (const Point< dim, T > &p, const int opt=MULTIPLE)
 Given a position it return if the position belong to any neighborhood processor ghost (Internal ghost)
 
template<typename id1 , typename id2 , typename Mem >
const openfpm::vector< std::pair< size_t, size_t > > & ghost_processorID_pair (const encapc< 1, Point< dim, T >, Mem > &p, const int opt=MULTIPLE)
 Given a position it return if the position belong to any neighborhood processor ghost (Internal ghost)
 
template<typename id , typename Mem >
const openfpm::vector< size_t > & ghost_processorID (const encapc< 1, Point< dim, T >, Mem > &p, const int opt=MULTIPLE)
 Given a position it return if the position belong to any neighborhood processor ghost (Internal ghost)
 
bool write (std::string output, size_t p_id) const
 write the information about the ghost in vtk format
 
bool is_equal (ie_ghost< dim, T, Memory, layout_base > &ig)
 Check if the ie_ghosts contain the same information.
 
bool is_equal_ng (ie_ghost< dim, T, Memory, layout_base > &ig)
 Check if the ie_loc_ghosts contain the same information with the exception of the ghost part It is anyway required that the ghost come from the same sub-domains decomposition.
 
void reset ()
 Reset the nn_prcs structure.
 
const openfpm::vector< openfpm::vector< Box_proc< dim, T > > > & private_get_box_nn_processor_int () const
 Return the internal data structure box_nn_processor_int.
 
openfpm::vector< openfpm::vector< Box_proc< dim, T > > > & private_get_box_nn_processor_int ()
 Return the internal data structure box_nn_processor_int.
 
openfpm::vector< Box_dom< dim, T > > & private_get_proc_int_box ()
 Return the internal data structure proc_int_box.
 
const openfpm::vector< Box_dom< dim, T > > & private_get_proc_int_box () const
 Return the internal data structure proc_int_box.
 
openfpm::vector< p_box< dim, T > > & private_get_vb_ext ()
 Return the internal data structure vb_ext.
 
const openfpm::vector< p_box< dim, T > > & private_get_vb_ext () const
 Return the internal data structure vb_ext.
 
openfpm::vector< aggregate< unsigned int, unsigned int, unsigned int >, Memory, layout_base > & private_get_vb_int ()
 Return the internal data structure vb_int.
 
const openfpm::vector< aggregate< unsigned int, unsigned int, unsigned int >, Memory, layout_base > & private_get_vb_int () const
 Return the internal data structure vb_int.
 
openfpm::vector< Box< dim, T >, Memory, layout_base > & private_get_vb_int_box ()
 Return the internal data structure vb_int_box.
 
const openfpm::vector< Box< dim, T >, Memory, layout_base > & private_get_vb_int_box () const
 Return the internal data structure vb_int_box.
 
CellList< dim, T, Mem_fast< Memory, int >, shift< dim, T > > & private_geo_cell ()
 Return the internal data structure proc_int_box.
 
const CellList< dim, T, Mem_fast< Memory, int >, shift< dim, T > > & private_geo_cell () const
 Return the internal data structure proc_int_box.
 
openfpm::vector< Point< dim, T >, Memory, layout_base > & private_get_shifts ()
 Return the internal data structure shifts.
 
const openfpm::vector< Point< dim, T >, Memory, layout_base > & private_get_shifts () const
 Return the internal data structure shifts.
 
openfpm::vector< std::pair< size_t, size_t > > & private_get_ids_p ()
 Return the internal data structure ids_p.
 
const openfpm::vector< std::pair< size_t, size_t > > & private_get_ids_p () const
 Return the internal data structure ids_p.
 
openfpm::vector< size_t > & private_get_ids ()
 Return the internal data structure ids_p.
 
const openfpm::vector< size_t > & private_get_ids () const
 Return the internal data structure ids_p.
 
Box< dim, T > & private_get_domain ()
 Return the internal data structure domain.
 
const Box< dim, T > & private_get_domain () const
 Return the internal data structure domain.
 
size_t private_get_bc (int i) const
 
size_t(& private_get_bc ())[dim]
 Return the internal data structure domain.
 
ie_ghost_gpu< dim, T, Memory, layout_base > toKernel ()
 toKernel() Convert this data-structure into a kernel usable data-structure
 
void reset_host_dev_transfer ()
 Notify that the next toKernel() data-structures must be re-offloaded.
 
- Public Member Functions inherited from domain_nn_calculator_cart< dim >
void setParameters (const Box< dim, long int > &proc_box)
 Set parameters to calculate the cell neighborhood.
 
void setNNParameters (openfpm::vector<::Box< dim, size_t > > &loc_box, const grid_key_dx< dim > &shift, const grid_sm< dim, void > &gs)
 Set parameters to calculate the cell neighborhood.
 
openfpm::vector< size_t > & getDomainCells ()
 Get the domain Cells.
 
openfpm::vector< size_t > & getCRSDomainCells ()
 Get the domain Cells.
 
openfpm::vector< subsub_lin< dim > > & getCRSAnomDomainCells ()
 Get the domain anomalous cells.
 
void reset ()
 In case you have to recompute the indexes.
 
- Public Member Functions inherited from domain_icell_calculator< dim, T, layout_base, Memory >
template<typename VCluster_type >
void CalculateInternalCells (VCluster_type &v_cl, openfpm::vector< Box< dim, T >, Memory, layout_base > &ig_box, openfpm::vector< SpaceBox< dim, T >, Memory, layout_base > &domain, Box< dim, T > &pbox, T r_cut, const Ghost< dim, T > &enlarge)
 Calculate the subdomain that are in the skin part of the domain.
 
openfpm::vector< aggregate< ids_type >, Memory, layout_base > & getIcells ()
 Return the list of the internal cells.
 
openfpm::vector< aggregate< ids_type >, Memory, layout_base > & getDcells ()
 Return the list of the internal cells.
 
Box< dim, T > getBoxCell (unsigned int ci)
 Given a cell index return the cell box.
 
const grid_sm< dim, void > & getGrid ()
 Get the grid base information about this cell decomposition.
 

Private Member Functions

void extend_subdomains (const CartDecomposition< dim, T, Memory, layout_base, Distribution > &dec, const ::Box< dim, T > &ext_dom)
 It copy the sub-domains into another CartesianDecomposition object extending them.
 
void reconstruct_fine_s_from_extended_domain (const ::Box< dim, T > &ext_domain)
 Extend the fines for the new Cartesian decomposition.
 

Additional Inherited Members

- Static Public Member Functions inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
static size_t getDefaultGrid (size_t n_sub)
 The default grid size.
 
- Static Public Member Functions inherited from nn_prcs< dim, T, layout_base, Memory >
static bool check_valid (comb< dim > cmb, const size_t(&bc)[dim])
 
- Data Fields inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
friend extended_type
 friend classes
 
- Static Public Attributes inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
static constexpr int dims = dim
 Space dimensions.
 
- Protected Types inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
typedef openfpm::vector< SpaceBox< dim, T >, Memory, memory_traits_lin, openfpm::vector_grow_policy_default, openfpm::vect_isel< SpaceBox< dim, T > >::value >::access_key acc_key
 
- Protected Member Functions inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
template<typename Memory_bx >
SpaceBox< dim, T > convertDecBoxIntoSubDomain (encapc< 1,::Box< dim, size_t >, Memory_bx > loc_box)
 It convert the box from the domain decomposition into sub-domain.
 
void collect_all_sub_domains (openfpm::vector< Box_map< dim, T >, Memory, layout_base > &sub_domains_global)
 
- Protected Member Functions inherited from ie_ghost< dim, T, Memory, layout_base >
void generateShiftVectors (const Box< dim, T > &domain, size_t(&bc)[dim])
 Here we generare the shift vectors.
 
void Initialize_geo_cell (const Box< dim, T > &domain, const size_t(&div)[dim])
 Initialize the geo cell list structure.
 
void free_geo_cell ()
 Deallocate structures that identify a point to which internal ghost is located.
 
void create_box_nn_processor_ext (Vcluster<> &v_cl, Ghost< dim, T > &ghost, openfpm::vector< SpaceBox< dim, T >, Memory, layout_base > &sub_domains, const openfpm::vector< openfpm::vector< long unsigned int > > &box_nn_processor, const nn_prcs< dim, T, layout_base, Memory > &nn_p)
 Create the box_nn_processor_int (bx part) structure.
 
void create_box_nn_processor_int (Vcluster<> &v_cl, Ghost< dim, T > &ghost, openfpm::vector< SpaceBox< dim, T >, Memory, layout_base > &sub_domains, const openfpm::vector< openfpm::vector< long unsigned int > > &box_nn_processor, const nn_prcs< dim, T, layout_base, Memory > &nn_p)
 Create the box_nn_processor_int (nbx part) structure, the geo_cell list and proc_int_box.
 
void reorder_geo_cell ()
 in this function we reorder the list in each cells by processor id
 
- Protected Attributes inherited from CartDecomposition< dim, T, Memory, layout_base, Distribution >
bool host_dev_transfer = false
 bool that indicate whenever the buffer has been already transfer to device
 
bool commCostSet = false
 Indicate the communication weight has been set.
 
openfpm::vector< SpaceBox< dim, T >, Memory, layout_base > sub_domains
 the set of all local sub-domain as vector
 
openfpm::vector< Box_map< dim, T >, Memory, layout_base > sub_domains_global
 the remote set of all sub-domains as vector of 'sub_domains' vectors
 
openfpm::vector< openfpm::vector< long unsigned int > > box_nn_processor
 for each sub-domain, contain the list of the neighborhood processors
 
CellList< dim, T, Mem_fast< Memory, int >, shift< dim, T > > fine_s
 
grid_sm< dim, void > gr
 Structure that store the cartesian grid information.
 
grid_sm< dim, void > gr_dist
 Structure that store the cartesian grid information.
 
CellDecomposer_sm< dim, T, shift< dim, T > > cd
 
::Box< dim, T > domain
 rectangular domain to decompose
 
spacing [dim]
 Box Spacing.
 
size_t magn [dim]
 
Vclusterv_cl
 Runtime virtual cluster machine.
 
Distribution dist
 Create distribution.
 
::Box< dim, T > bbox
 Processor bounding box.
 
long int ref_cnt
 reference counter of the object in case is shared between object
 
Ghost< dim, T > ghost
 ghost info
 
size_t bc [dim]
 Boundary condition info.
 
::Box< dim, size_t > proc_box
 Processor domain bounding box.
 
openfpm::vector<::Box< dim, size_t > > loc_box
 set of Boxes produced by the decomposition optimizer
 

Member Typedef Documentation

◆ base_type

template<unsigned int dim, typename T , typename Memory = HeapMemory, template< typename > class layout_base = memory_traits_lin, typename Distribution = ParMetisDistribution<dim, T>>
typedef CartDecomposition<dim,T,Memory,layout_base,Distribution> CartDecomposition_ext< dim, T, Memory, layout_base, Distribution >::base_type

The non-extended decomposition base class.

Definition at line 176 of file CartDecomposition_ext.hpp.

Constructor & Destructor Documentation

◆ CartDecomposition_ext()

template<unsigned int dim, typename T , typename Memory = HeapMemory, template< typename > class layout_base = memory_traits_lin, typename Distribution = ParMetisDistribution<dim, T>>
CartDecomposition_ext< dim, T, Memory, layout_base, Distribution >::CartDecomposition_ext ( Vcluster<> &  v_cl)
inline

Cartesian decomposition constructor.

Parameters
v_clVCluster

Definition at line 170 of file CartDecomposition_ext.hpp.

Member Function Documentation

◆ extend_subdomains()

template<unsigned int dim, typename T , typename Memory = HeapMemory, template< typename > class layout_base = memory_traits_lin, typename Distribution = ParMetisDistribution<dim, T>>
void CartDecomposition_ext< dim, T, Memory, layout_base, Distribution >::extend_subdomains ( const CartDecomposition< dim, T, Memory, layout_base, Distribution > &  dec,
const ::Box< dim, T > &  ext_dom 
)
inlineprivate

It copy the sub-domains into another CartesianDecomposition object extending them.

See also
duplicate (in case of extended domain)
Parameters
decCartesian decomposition object
ext_domExtended domain

Definition at line 54 of file CartDecomposition_ext.hpp.

◆ reconstruct_fine_s_from_extended_domain()

template<unsigned int dim, typename T , typename Memory = HeapMemory, template< typename > class layout_base = memory_traits_lin, typename Distribution = ParMetisDistribution<dim, T>>
void CartDecomposition_ext< dim, T, Memory, layout_base, Distribution >::reconstruct_fine_s_from_extended_domain ( const ::Box< dim, T > &  ext_domain)
inlineprivate

Extend the fines for the new Cartesian decomposition.

Parameters
decNon-extended decomposition

Definition at line 157 of file CartDecomposition_ext.hpp.

◆ setParameters()

template<unsigned int dim, typename T , typename Memory = HeapMemory, template< typename > class layout_base = memory_traits_lin, typename Distribution = ParMetisDistribution<dim, T>>
void CartDecomposition_ext< dim, T, Memory, layout_base, Distribution >::setParameters ( const CartDecomposition< dim, T, Memory, layout_base, Distribution > &  dec,
const Ghost< dim, T > &  g,
const ::Box< dim, T > &  ext_domain 
)
inline

It create another object that contain the same decomposition information but with different ghost boxes and an extended domain.

The domain extension is produced extending the boxes at the border like in figure

 *
+--------------^--------^----------^----------+
|              |        |          |          |
|        A     |    E   |     F    |    N     |
|    +-----------------------------------+---->
|    |         |        |          |     |    |
|  A |   A     |        |     F    |     |    |
|    |         |        |          |     |    |
|    |         |    E   +----------+  N  |  N |
<--------------+        |          |     |    |
|    |         |        |          |     |    |
|    |         |        |     G    |     |    |
|    |         |        |          +---------->
|  B |   B     |        +----------+     |    |
|    |         +--------+          |  M  |  M |
|    |         |        |     H    |     |    |
|    |         |        +-----+----+---------->
<--------------+    D   |     |          |    |
|    |         |        |  I  |     L    |  L |
|  C |   C     |        |     |          |    |
|    |         |        |     |          |    |
|    +-----------------------------------+    |
|              |        |     |               |
|        C     |    D   |  I  |     L         |
+--------------v--------v-----v---------------+

 *
 * 
Parameters
decDecomposition
gghost
ext_domainextended domain (MUST be extended)
Returns
a duplicated decomposition with different ghost boxes and an extended domain

Definition at line 219 of file CartDecomposition_ext.hpp.


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