fixing examples

example/Vector/4_complex_prop/Makefile

+include ../../example.mk
+
+CC=mpic++
+
+LDIR =
+
+OBJ = main.o
+
+%.o: %.cpp
+	$(CC) -O3 -c --std=c++11 -o $@ $< $(INCLUDE_PATH)
+
+vect: $(OBJ)
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS_PATH) $(LIBS)
+
+all: vect
+
+.PHONY: clean all
+
+clean:
+	rm -f *.o *~ core vect
+

example/Vector/4_complex_prop/main.cpp

+/*!
+ *
+ * \page Vector_4_complex_prop Vector 4 complex property
+ *
+ *
+ * [TOC]
+ *
+ *
+ * # Vector 4 complex property # {#vector_example_cp}
+ *
+ *
+ * This example show how we can use complex properties in a vector
+ *
+ */
+
+#include "Vector/vector_dist.hpp"
+
+int main(int argc, char* argv[])
+{
+	/*!
+	 *
+	 * \page Vector_4_complex_prop Vector 4 complex property
+	 *
+	 *
+	 * ## Initialization and vector creation ##
+	 *
+	 * After we initialize the library we can create a vector with complex properties
+	 * with the following line
+	 *
+	 * \snippet Vector/4_complex_prop/main.cpp vect create
+	 *
+	 * In This this particular case every particle carry a scalar,
+	 * a vector in form of float[3], a Point, a list
+	 * in form of vector of float and a list of custom structures
+	 *
+	 * \snippet Vector/4_complex_prop/main.cpp struct A
+	 *
+	 *
+	 */
+
+    // initialize the library
+	openfpm_init(&argc,&argv);
+
+	// Here we define our domain a 2D box with internals from 0 to 1.0 for x and y
+	Box<2,float> domain({0.0,0.0},{1.0,1.0});
+
+	// Here we define the boundary conditions of our problem
+    size_t bc[2]={PERIODIC,PERIODIC};
+
+	// extended boundary around the domain, and the processor domain
+	Ghost<2,float> g(0.01);
+	
+	//! \cond [struct A] \endcond
+
+	// The a custom structure
+	struct A
+	{
+		float p1;
+		int p2;
+
+		A() {};
+
+		A(float p1, int p2)
+		:p1(p1),p2(p2)
+		{}
+	};
+
+	//! \cond [struct A] \endcond
+
+	// the scalar is the element at position 0 in the aggregate
+	constexpr int scalar = 0;
+
+	// the vector is the element at position 1 in the aggregate
+	constexpr int vector = 1;
+
+	// the tensor is the element at position 2 in the aggregate
+	constexpr int point = 2;
+
+	// A list1
+	constexpr int list = 3;
+
+	// A listA
+	constexpr int listA = 4;
+
+	//! \cond [vect create] \endcond
+
+	vector_dist<2,float, aggregate<float,
+	                               float[3],
+								   Point<3,double>,
+								   openfpm::vector<float>,
+	                               openfpm::vector<A>>>
+	vd(4096,domain,bc,g);
+
+	//! \cond [vect create] \endcond
+
+	/*!
+	 *
+	 * \page Vector_4_complex_prop Vector 4 complex property
+	 *
+	 *
+	 * ## Assign values to properties ##
+	 *
+	 * Assign values to properties does not changes, from the simple case. Consider
+	 * now that each particle has a list, so when we can get the property listA for particle p
+	 * and resize such list with **vd.getProp<listA>(p).resize(...)**. We can add new elements at the
+	 * end with **vd.getProp<listA>(p).add(...)** and get some element with **vd.getProp<listA>(p).get(i)**.
+	 * More in general from vd.getProp<listA>(p) we can use the full openfpm::vector interface.
+	 *
+	 * \snippet Vector/4_complex_prop/main.cpp vect assign
+	 *
+	 */
+
+	//! \cond [vect assign] \endcond
+
+	auto it = vd.getDomainIterator();
+
+	while (it.isNext())
+	{
+		auto p = it.get();
+
+		// we define x, assign a random position between 0.0 and 1.0
+		vd.getPos(p)[0] = (float)rand() / RAND_MAX;
+
+		// we define y, assign a random position between 0.0 and 1.0
+		vd.getPos(p)[1] = (float)rand() / RAND_MAX;
+
+
+		vd.getProp<scalar>(p) = 1.0;
+
+		vd.getProp<vector>(p)[0] = 1.0;
+		vd.getProp<vector>(p)[1] = 1.0;
+		vd.getProp<vector>(p)[2] = 1.0;
+
+		vd.getProp<point>(p).get(0) = 1.0;
+		vd.getProp<point>(p).get(1) = 1.0;
+		vd.getProp<point>(p).get(2) = 1.0;
+
+		size_t n_cp = (float)10 * rand()/RAND_MAX;
+
+		vd.getProp<listA>(p).resize(n_cp);
+
+		for (size_t i = 0 ; i < n_cp ; i++)
+		{
+			vd.getProp<list>(p).add(i + 10);
+			vd.getProp<list>(p).add(i + 20);
+			vd.getProp<list>(p).add(i + 30);
+
+			vd.getProp<listA>(p).get(i) = A(i+10.0,i+20.0);
+			vd.getProp<listA>(p).get(i) = A(i+30.0,i+40.0);
+			vd.getProp<listA>(p).get(i) = A(i+50.0,i+60.0);
+		}
+
+		// next particle
+		++it;
+	}
+
+	//! \cond [vect assign] \endcond
+
+	/*!
+	 *
+	 * \page Vector_4_complex_prop Vector 4 complex property
+	 *
+	 *
+	 * ## Mapping and ghost_get ##
+	 *
+	 * Particles are redistributed across processors but only the scalar,vector and the point
+	 * are communicated (properties 0,1,2). A lot of time complex properties can be recomputed and
+	 * communicate them is not a good idea. The same concept also apply for ghost_get
+	 *
+	 * \note OpenFPM <= 0.5.0 cannot communicate complex properties like a vector or other structure
+	 *                        that are not POD object
+	 *
+	 * \note OpenFPM > 0.5.0 Does not have such limitation
+	 *
+	 *
+	 * \snippet Vector/4_complex_prop/main.cpp vect map ghost
+	 *
+	 */
+
+	//! \cond [vect map ghost] \endcond
+
+	// Particles are redistribued across the processors but only the scalar,vector, and point properties
+	// are transfert
+	vd.map_list<KillParticle,scalar,vector,point>();
+	
+	// Synchronize the ghost
+	vd.ghost_get<scalar,vector,point>();
+
+	//! \cond [vect map ghost] \endcond
+
+	/*!
+	 *
+	 * \page Vector_4_complex_prop Vector 4 complex property
+	 *
+	 *
+	 * ## Output and VTK visualization ##
+	 *
+	 * Vector with complex properties can be still be visualized, because unknown properties are
+	 * automatically excluded
+	 *
+	 * \snippet Vector/4_complex_prop/main.cpp vtk
+	 *
+	 */
+
+	//! \cond [vtk] \endcond
+
+	vd.write("particles");
+
+	//! \cond [vtk] \endcond
+
+	/*!
+	 * \page Vector_4_complex_prop Vector 4 complex property
+	 *
+	 * ## Finalize ## {#finalize}
+	 *
+	 *  At the very end of the program we have always to de-initialize the library
+	 *
+	 * \snippet Vector/4_complex_prop/main.cpp finalize
+	 *
+	 */
+
+	//! \cond [finalize] \endcond
+
+	openfpm_finalize();
+
+	//! \cond [finalize] \endcond
+
+	/*!
+	 * \page Vector_4_complex_prop Vector 4 complex property
+	 *
+	 * # Full code # {#code}
+	 *
+	 * \include Vector/4_complex_prop/main.cpp
+	 *
+	 */
+}

example/Vector/4_multiphase_celllist/Makefile

+include ../../example.mk
+
+CC=mpic++
+
+LDIR =
+
+OBJ = main.o
+
+%.o: %.cpp
+	$(CC) -O3 -c --std=c++11 -o $@ $< $(INCLUDE_PATH)
+
+cell: $(OBJ)
+	$(CC) -o $@ $^ $(CFLAGS) $(LIBS_PATH) $(LIBS)
+
+all: cell
+
+.PHONY: clean all
+
+clean:
+	rm -f *.o *~ core cell
+

example/Vector/4_multiphase_celllist/main.cpp

+
+#include "Vector/vector_dist.hpp"
+#include "Decomposition/CartDecomposition.hpp"
+#include "data_type/aggregate.hpp"
+#include "NN/CellList/CellListM.hpp"
+
+/*!
+ * \page Vector_4_mp_cl Vector 4 Multi Phase cell-list
+ *
+ * [TOC]
+ *
+ *
+ * # Vector Multi Phase cell-list # {#e4_ph_cl}
+ *
+ * This example show multi-phase cell lists for the distributed vector
+ *
+ * \warning BETA version
+ *
+ */
+
+int main(int argc, char* argv[])
+{
+	/*!
+	 * \page Vector_4_mp_cl Vector 4 Multi Phase cell-list
+	 *
+	 * ## Initialization ##
+	 *
+	 * Here we Initialize the library, and we create a set of distributed vectors all forced to have the same
+	 * decomposition. Each vector identify one phase
+	 *
+	 * \snippet Vector/1_celllist/main.cpp Initialization and parameters
+	 *
+	 */
+
+	//! \cond [Initialization and parameters] \endcond
+
+	openfpm_init(&argc,&argv);
+	Vcluster & v_cl = create_vcluster();
+
+	// we will place the particles on a grid like way with 128 particles on each direction
+	size_t sz[3] = {128,128,128};
+
+	// The domain
+	Box<3,float> box({0.0,0.0,0.0},{1.0,1.0,1.0});
+
+	// Boundary conditions
+	size_t bc[3]={PERIODIC,PERIODIC,PERIODIC};
+
+	// ghost, big enough to contain the interaction radius
+	Ghost<3,float> ghost(1.0/(128-2));
+
+	//! \cond [Initialization and parameters] \endcond
+
+	/*!
+	 * \page Vector_1_celllist Vector 1 Cell-list
+	 *
+	 * ## %Vector create ##
+	 *
+	 * Here we define a distributed vector in 3D, containing 3 properties, a
+	 * scalar double, a vector double[3], and a tensor or rank 2 double[3][3].
+	 * In this case the vector contain 0 particles initially
+	 *
+	 * \see \ref vector_inst
+	 *
+	 * \snippet Vector/1_celllist/main.cpp vector inst
+	 *
+	 */
+
+	//! \cond [vector inst] \endcond
+
+	openfpm::vector< vector_dist<3,float, aggregate<double,double>> > phases;
+
+	// first phase
+	phases.add( vector_dist<3,float, aggregate<double,double>>(4096,box,bc,ghost) );
+
+	// The other 3 phases
+	phases.add( vector_dist<3,float, aggregate<double,double>>(phases.get(1).getDecomposition(),4096) );
+	phases.add( vector_dist<3,float, aggregate<double,double>>(phases.get(2).getDecomposition(),4096) );
+	phases.add( vector_dist<3,float, aggregate<double,double>>(phases.get(3).getDecomposition(),4096) );
+
+	//! \cond [grid like part] \endcond
+
+	auto it = phases.get(0).getDomainIterator();
+
+	// For all the particles
+	while (it.isNext())
+	{
+		// for all phases
+		for (size_t i = 0 ; i < phases.size() ; i++)
+		{
+			auto key = it.get();
+
+			phases.get(i).getPos(key)[0] = (float)rand() / RAND_MAX;
+			phases.get(i).getPos(key)[1] = (float)rand() / RAND_MAX;
+			phases.get(i).getPos(key)[2] = (float)rand() / RAND_MAX;
+		}
+		// next point
+		++it;
+	}
+
+	// Redistribute all the phases in the mean while also take the iterators of all the phases
+
+	typedef decltype(phases.get(0).getIterator()) iterator;
+	openfpm::vector<iterator> phase_it;
+
+	for (size_t i = 0 ; i < phases.size() ; i++)
+	{
+		phases.get(i).map();
+		phase_it.add(phases.get(i).getDomainIterator());
+	}
+
+	// Construct one single Multi-phase cell list to use in the computation
+
+	CellListM<3,float,2> NN;
+
+	while (it.isNext())
+	{
+		for (size_t i = 0; i < phases.size() ; i++)
+		{
+			auto key = it.get();
+
+			NN.add(phases.get(i).getPos(key), key.getKey(), i);
+
+			++it;
+		}
+	}
+
+	vector_dist<3,float, aggregate<double,double> > & current_phase = phases.get(0);
+
+	// Get the iterator of the particles of phase 0
+	auto it2 = current_phase.getIterator();
+
+	// For each particle ...
+	while (it2.isNext())
+	{
+		// ... p
+		auto p = it2.get();
+
+		// Get the position of the particle p
+		Point<3,float> xp = current_phase.getPos(p);
+
+		// Get an iterator of all the particles neighborhood of p
+		auto Np = NN.getNNIterator(NN.getCell(current_phase.getPos(p)));
+
+		// For each particle near p
+		while (Np.isNext())
+		{
+			// Get the particle q near to p
+			auto q = Np.getP();
+
+			// Get from which phase it come from
+			auto ph_q = Np.getV();
+
+			Point<3,float> xq = phases.get(ph_q).getPos(q);
+
+			// we accumulate all the distances
+			current_phase.getProp<0>(p) = norm(xp - xq);
+
+			++Np;
+		}
+
+		// Next particle p
+		++it2;
+	}
+
+	//! \cond [verletlist] \endcond
+
+	/*!
+	 * \page Vector_1_celllist Vector 1 Cell-list
+	 *
+	 * ## Finalize ## {#finalize}
+	 *
+	 *  At the very end of the program we have always to de-initialize the library
+	 *
+	 * \snippet Vector/1_celllist/main.cpp finalize
+	 *
+	 */
+
+	//! \cond [finalize] \endcond
+
+	openfpm_finalize();
+
+	//! \cond [finalize] \endcond
+
+	/*!
+	 * \page Vector_1_celllist Vector 1 Cell-list
+	 *
+	 * # Full code # {#code}
+	 *
+	 * \include Vector/1_celllist/main.cpp
+	 *
+	 */
+}
+
+
+
+