Commit acdb15b8 authored by incardon's avatar incardon

Added missing files

parent f0dbf3ce
/*
* CartDecomposition.cpp
*
* Created on: Aug 15, 2014
* Author: Pietro Incardona
*/
#include "CartDecomposition.hpp"
/*! \brief The the bulk part of the data set, or the data that does not depend
* from the ghosts layers
*
* The the bulk part of the data set, or the data that does not depend from the
* ghosts layers
*
*/
/*template<typename T> T CartDecomposition<T>::getBulk(T data)
{
// for each element in data
for (size_t i = 0; i < data.size() ; i++)
{
if (localSpace.isInside())
}
}
template<typename T> T CartDecomposition<T>::getInternal()
{
}*/
/*! \brief Check if is border or bulk
*
* \param neighboorhood define the neighboorhood of all the points
* \return true if border, false if bulk
*
*/
bool borderOrBulk(neighborhood & nb)
{
device::grid<1,size_t> nbr = nb.next();
// check the neighborhood
// get neighborhood iterator
grid_key_dx_iterator<dim> iterator_nbr = nbr.getIterator();
while (iterator_nbr.hasNext())
{
grid_key_dx key_nbr = iterator_nbr.next();
// check if the neighboorhood is internal
if(subspace.isBound(data.template get<Point::x>(key_nbr)) == false)
{
// it is border
return true;
ret.bord.push_back(key);
break;
}
}
return false;
}
/*! \brief This function divide the data set into bulk, border, external and internal part
*
* \tparam dim dimensionality of the structure storing your data
* (example if they are in 3D grid, has to be 3)
* \tparam T type of object we are dividing
* \tparam device type of layout selected
* \param data 1-dimensional grid of point
* \param nb define the neighborhood of all the points
* \return a structure with the set of objects divided
*
*/
template<unsigned int dim, typename T, template<typename> class layout, typename Memory, template<unsigned int, typename> class Domain, template<typename, typename, typename> class data_s>
dataDiv<T> CartDecomposition<dim,T,layout>::divide(device::grid<1,Point<dim,T>> & data, neighborhood & nb)
{
//! allocate the 3 subset
dataDiv<T> ret;
ret.bord = new boost::shared_ptr<T>(new T());
ret.inte = new boost::shared_ptr<T>(new T());
ret.ext = new boost::shared_ptr<T>(new T());
//! get grid iterator
grid_key_dx_iterator<dim> iterator = data.getIterator();
//! we iterate trough all the set of objects
while (iterator.hasNext())
{
grid_key_dx<dim> key = iterator.next();
//! Check if the object is inside the subspace
if (subspace.isBound(data.template get<Point<3,T>::x>(key)))
{
//! Check if the neighborhood is inside the subspace
if (borderOrBulk(nb) == true)
{
// It is border
ret.bord.push_back(key);
}
else
{
// It is bulk
ret.bulk.push_back(key);
}
}
else
{
//! it is external
ret.ext.push_back(key);
}
}
}
This diff is collapsed.
#ifndef CARTDECOMPOSITION_UNIT_TEST_HPP
#define CARTDECOMPOSITION_UNIT_TEST_HPP
#include "CartDecomposition.hpp"
#include "mathutil.hpp"
BOOST_AUTO_TEST_SUITE( CartDecomposition_test )
#define SUB_UNIT_FACTOR 64
BOOST_AUTO_TEST_CASE( CartDecomposition_test_use)
{
// Virtual cluster
Vcluster vcl(&boost::unit_test::framework::master_test_suite().argc,&boost::unit_test::framework::master_test_suite().argv);
CartDecomposition<3,float> dec(vcl);
// Physical domain
Box<3,float> box({0.0,0.0,0.0},{1.0,1.0,1.0});
size_t div[3];
// Get the number of processor and calculate the number of sub-domain
// for decomposition
size_t n_proc = vcl.getProcessingUnits();
size_t n_sub = n_proc * SUB_UNIT_FACTOR;
// Calculate the number of sub-domain on each dimension
for (int i = 0 ; i < 3 ; i++)
{div[i] = round_big_2(pow(n_sub,1.0/3));}
// Decompose
dec.setParameters(div,box);
}
BOOST_AUTO_TEST_SUITE_END()
#endif
#include "Space/SpaceBox.hpp"
#ifndef DECOMPOSITION_HPP_
#define DECOMPOSITION_HPP_
/**
*
* \brief class that store Internal part external and border part of a dataset
*
*/
template <typename T> class dataDiv
{
//! Border part of the data
boost::shared_ptr<T> bord;
//! internal part of your data
boost::shared_ptr<T> inte;
//! external part of your data
boost::shared_ptr<T> ext;
};
/*! \brief This class define the domain decomposition interface
*
* This class define the domain decomposition interface, its main functionality
* is to divide a domain in several subspaces
*
* \tparam T structure that store the dataset
* \tparam S type of space is decomposing Real integer complex ...
*
*/
template<typename T, typename S>
class Decomposition
{
/*! \brief The the internal part of the data set, or the data that
* does not depend from the ghosts layers
*
* \return The internal part of the dataset
*
*/
virtual T getInternal();
/*! Get the ghost part of the dataset
*
* \return The internal part of the dataset
*
*/
virtual T getBorder();
/*! Get the external part of the dataset (outside the ghost)
*
* \return The external part of the dataset
*
*/
virtual T getExternal();
//! divide the dataset from internal part and border
virtual dataDiv<T> divide();
//! Get the number of hyper-cube the space id is divided into
virtual size_t getNHyperCube(size_t id);
//! Get the hyper-cube margins
virtual std::vector<T> & getHyperCube(size_t id, size_t id_c);
//! destructor
virtual ~Decomposition(){}
};
#endif
#ifndef DIST_MODEL_HPP
#define DIST_MODEL_HPP
#include "metis.h"
/*! \brief This class do graph partitioning
*
* This class do graph partitioning, it use METIS internaly
*
*/
template<typename Graph, typename algorithm>
class GraphPartitioning
{
//! Structure that store the graph
Graph & grp;
/*! Constructor
*
* It load the graph to partition
*
* \param g Graph to store
*
*/
GraphPartitioning(Graph & g)
:grp(g)
{}
};
#endif
#ifndef COM_UNIT_HPP
#define COM_UNIT_HPP
#include <vector>
#include "Grid/map_grid.hpp"
#include "VCluster.hpp"
#include "Space/SpaceBox.hpp"
#include "mathutil.hpp"
#include "grid_dist_id_iterator.hpp"
#include "grid_dist_id_iterator_margin.hpp"
#include "grid_dist_key.hpp"
#define SUB_UNIT_FACTOR 64
/*! \brief This is a distributed grid
*
* Implementation of a distributed grid with id decomposition. A distributed grid is a grid distributed
* across processors. The decomposition is performed on the id of the elements
*
* [Examples]
*
* on 1D where the id is from 1 to N
* processor k take M contiguous elements
*
* on 3D where (for example)
* processor k take M id-connected elements
*
* \param dim Dimensionality of the grid
* \param T type of grid
* \param Decomposition Class that decompose the grid for example CartDecomposition
* \param Mem Is the allocator
* \param device type of base structure is going to store the data
*
*/
template<unsigned int dim, typename T, typename Decomposition,typename Memory=HeapMemory , typename device_grid=grid_cpu<dim,T> >
class grid_dist_id
{
// Ghost expansion
Box<dim,size_t> ghost;
//! Local grids
Vcluster_object_array<device_grid> loc_grid;
//! Space Decomposition
Decomposition dec;
//! Size of the grid on each dimension
size_t g_sz[dim];
//! Communicator class
Vcluster & v_cl;
/*! \brief Get the grid size
*
* Get the grid size, given a domain, the resolution on it and another spaceBox
* it give the size on all directions of the local grid
*
* \param sp SpaceBox enclosing the local grid
* \param domain Space box enclosing the physical domain or part of it
* \param v_size grid size on this physical domain
*
* \return An std::vector representing the local grid on each dimension
*
*/
std::vector<size_t> getGridSize(SpaceBox<dim,typename Decomposition::domain_type> & sp, Box<dim,typename Decomposition::domain_type> & domain, size_t (& v_size)[dim])
{
std::vector<size_t> tmp;
for (size_t d = 0 ; d < dim ; d++)
{
//! Get the grid size compared to the domain space and its resolution
typename Decomposition::domain_type dim_sz = (sp.getHigh(d) - sp.getLow(d)) / ((domain.getHigh(d) - domain.getLow(d)) / v_size[d]) + 0.5;
// push the size of the local grid
tmp.push_back(dim_sz);
}
return tmp;
}
/*! \brief Get the grid size
*
* Get the grid size, given a spaceBox
* it give the size on all directions of the local grid
*
* \param sp SpaceBox enclosing the local grid
* \param sz array to fill with the local grid size on each dimension
*
*/
void getGridSize(SpaceBox<dim,size_t> & sp, size_t (& v_size)[dim])
{
for (size_t d = 0 ; d < dim ; d++)
{
// push the size of the local grid
v_size[d] = sp.getHigh(d) - sp.getLow(d);
}
}
public:
//! constructor
grid_dist_id(Vcluster v_cl, Decomposition & dec, size_t (& g_sz)[dim], Box<dim,size_t> & ghost)
:ghost(ghost),loc_grid(NULL),v_cl(v_cl),dec(dec)
{
// fill the global size of the grid
for (int i = 0 ; i < dim ; i++) {this->g_sz[i] = g_sz[i];}
// Get the number of processor and calculate the number of sub-domain
// for decomposition
size_t n_proc = v_cl.getProcessingUnits();
size_t n_sub = n_proc * SUB_UNIT_FACTOR;
// Calculate the maximum number (before merging) of sub-domain on
// each dimension
size_t div[dim];
for (int i = 0 ; i < dim ; i++)
{div[i] = round_big_2(pow(n_sub,1.0/dim));}
// Create the sub-domains
dec.setParameters(div);
}
//! constructor
grid_dist_id(size_t (& g_sz)[dim])
:v_cl(*global_v_cluster),dec(Decomposition(v_cl))
{
// fill the global size of the grid
for (int i = 0 ; i < dim ; i++) {this->g_sz[i] = g_sz[i];}
// first compute a decomposition
Create();
}
/*! \brief Get the object that store the decomposition information
*
* \return the decomposition object
*
*/
Decomposition & getDecomposition()
{
return dec;
}
/*! \brief Create the grid on memory
*
*/
void Create()
{
// ! Create an hyper-cube approximation.
// ! In order to work on grid_dist the decomposition
// ! has to be a set of hyper-cube
dec.hyperCube();
// Get the number of local grid needed
size_t n_grid = dec.getNLocalHyperCube();
// create local grids for each hyper-cube
loc_grid = v_cl.allocate<device_grid>(n_grid);
// Size of the grid on each dimension
size_t l_res[dim];
// Allocate the grids
for (size_t i = 0 ; i < n_grid ; i++)
{
// Get the local hyper-cube
SpaceBox<dim,size_t> sp = dec.getLocalHyperCube(i);
// Calculate the local grid size
getGridSize(sp,l_res);
// Set the dimensions of the local grid
loc_grid.get(i).template resize<Memory>(l_res);
}
}
/*! \brief It return an iterator of the bulk part of the grid with a specified margin
*
* For margin we mean that every point is at least m points far from the border
*
* \param m margin
*
* \return An iterator to a grid with specified margins
*
*/
grid_dist_iterator_margin<dim,device_grid> getBulkIterator(size_t margin)
{
grid_dist_iterator_margin<dim,device_grid> it(loc_grid,margin);
return it;
}
//! Destructor
~grid_dist_id()
{
}
};
#endif
/*
* grid_dist_id_iterator.hpp
*
* Created on: Feb 4, 2015
* Author: Pietro Incardona
*/
#ifndef GRID_DIST_ID_ITERATOR_HPP_
#define GRID_DIST_ID_ITERATOR_HPP_
#include "grid_dist_key.hpp"
#include "Grid/grid.hpp"
/*! \brief Distributed grid iterator
*
* Iterator across the local element of the distributed grid
*
*/
template<unsigned int dim, typename l_grid>
class grid_dist_iterator
{
//! grid list counter
size_t g_c;
//! List of the grids we are going to iterate
std::vector<l_grid> & gList;
//! Actual iterator
grid_key_dx_iterator<dim> a_it;
public:
/*! \brief Constructor of the distributed grid
*
* \param gk std::vector of the local grid
*
*/
grid_dist_iterator(std::vector<l_grid> & gk)
:g_c(0),gList(gk)
{
// Initialize with the current iterator
// with the first grid
a_it = gList[0].getIterator();
}
// Destructor
~grid_dist_iterator()
{}
/*! \brief Get the next element
*
* \return the next grid_key
*
*/
grid_key_dx_iterator<dim> operator++()
{
a_it++;
// check if a_it is at the end
if (a_it.isEnd() == false)
return *this;
else
{
// switch to the new grid
g_c++;
// get the next grid iterator
a_it = a_it = gList[g_c].getIterator();
// increment to a valid point
a_it++;
}
return *this;
}
/*! \brief Check if there is the next element
*
* \return true if there is the next, false otherwise
*
*/
bool isEnd()
{
// If there are no other grid stop
if (g_c >= gList.size())
return true;
}
/*! \brief Get the actual key
*
* \return the actual key
*
*/
grid_dist_key_dx<dim> get()
{
return a_it;
}
};
#endif /* GRID_DIST_ID_ITERATOR_HPP_ */
/*
* grid_dist_id_iterator_sub.hpp
*
* Created on: Feb 4, 2015
* Author: Pietro Incardona
*/
#ifndef GRID_DIST_ID_ITERATOR_SUB_HPP_
#define GRID_DIST_ID_ITERATOR_SUB_HPP_
#include "VCluster.hpp"
/*! \brief Distributed grid iterator
*
* Iterator across the local element of the distributed grid
*
*/
template<unsigned int dim, typename device_grid>
class grid_dist_iterator_margin
{
//! grid list counter
size_t g_c;
//! List of the grids we are going to iterate
Vcluster_object_array<device_grid> & gList;
//! Actual iterator
grid_key_dx_iterator_sub<dim> * a_it;
//! margin of the grid iterator
size_t m;
public:
/*! \brief Constructor of the distributed grid
*
* \param gk std::vector of the local grid
*
*/
grid_dist_iterator_margin(Vcluster_object_array<device_grid> & gk, size_t m)
:g_c(0),gList(gk),m(m)
{
// Initialize the current iterator
// with the first grid
a_it = new grid_key_dx_iterator_sub<dim>(gList[0].getSubIterator(m));
}
// Destructor