diff --git a/src/Vector/performance/cl_comp_performance_graph.hpp b/src/Vector/performance/cl_comp_performance_graph.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..f9750488222656eb72bc17a0124514ff41b464bc
--- /dev/null
+++ b/src/Vector/performance/cl_comp_performance_graph.hpp
@@ -0,0 +1,281 @@
+/*
+ * performance_graph.hpp
+ *
+ * Created on: Dec 23, 2016
+ * Author: i-bird
+ */
+
+#ifndef SRC_VECTOR_PERFORMANCE_CL_COMP_PERFORMANCE_GRAPH_HPP_
+#define SRC_VECTOR_PERFORMANCE_CL_COMP_PERFORMANCE_GRAPH_HPP_
+
+#include "Plot/GoogleChart.hpp"
+
+/////////////////////////// COMPUTATIONAL HILBERT CURVE ORDERING ///////////////////////////////////////
+
+/*! \brief Time to calculate forces using random order or hilber curve compute ordering
+ *
+ * \tparam dim dimensionality of the test
+ *
+ * \param cg GoogleChart object
+ * \param cl_n_particles number of particles for each test
+ * \param cl_r_cutoff cell-list spacing used to construct a cell-list
+ * \param cl_time_hilb for each particle set, for each cut-off radius time to calculate the forces (Hilbert curve order)
+ * \param cl_time_rand for each particle set, for each cut-off radius, time to calculate the forces (no order)
+ *
+ */
+template<unsigned int dim> void cl_comp_normal_vs_hilbert_force_time(GoogleChart & cg,
+ openfpm::vector<size_t> & cl_n_particles,
+ openfpm::vector<float> & cl_r_cutoff,
+ openfpm::vector<openfpm::vector<double>> & cl_time_hilb_mean,
+ openfpm::vector<openfpm::vector<double>> & cl_time_rand_mean,
+ openfpm::vector<openfpm::vector<double>> & cl_time_hilb_dev,
+ openfpm::vector<openfpm::vector<double>> & cl_time_rand_dev,
+ double & warning_level,
+ double & norm)
+{
+ // Get the test dir
+ std::string file_mean(test_dir);
+ std::string file_var(test_dir);
+ file_mean += std::string("/openfpm_pdata/cl_comp_norm_hilbert_mean_" + std::to_string(dim) + std::string("_ref"));
+ file_var += std::string("/openfpm_pdata/cl_comp_norm_hilbert_dev_" + std::to_string(dim) + std::string("_ref"));
+
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_mean;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_dev;
+ y_ref_mean.load(file_mean);
+ y_ref_dev.load(file_var);
+
+ openfpm::vector<int> warning_vlevel;
+
+ // time graphs data
+
+ openfpm::vector<size_t> x;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_dev;
+
+ openfpm::vector<std::string> yn;
+
+ for (size_t i = 0; i < cl_n_particles.size() ; i++)
+ x.add(cl_n_particles.get(i));
+
+ yn.add("Random cell list");
+ yn.add("Hilbert cell list");
+
+ y.resize(cl_time_hilb_mean.size());
+ y_dev.resize(cl_time_hilb_mean.size());
+ for (size_t r = 0; r < cl_time_hilb_mean.size(); r++)
+ {
+ y.get(r).resize(cl_time_hilb_mean.get(r).size());
+ y_dev.get(r).resize(cl_time_hilb_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_hilb_mean.get(r).size(); k++)
+ {
+ // Time for construction hilbert and random
+ y.get(r).get(k).add(cl_time_rand_mean.get(r).get(k));
+ y.get(r).get(k).add(cl_time_hilb_mean.get(r).get(k));
+
+ y_dev.get(r).get(k).add(cl_time_rand_dev.get(r).get(k));
+ y_dev.get(r).get(k).add(cl_time_hilb_dev.get(r).get(k));
+ }
+ }
+
+ y.save("cl_comp_norm_hilbert_mean_" + std::to_string(dim) + std::to_string("_ref"));
+ y_dev.save("cl_comp_norm_hilbert_dev_" + std::to_string(dim) + std::to_string("_ref"));
+
+ if (y_ref_mean.size() != 0)
+ {
+ // We reconstruct y and yn
+
+ y.clear();
+ yn.clear();
+
+ yn.add("Random cell list");
+ yn.add("interval");
+ yn.add("interval");
+ yn.add("Hilbert cell list");
+ yn.add("interval");
+ yn.add("interval");
+ y.resize(cl_time_hilb_mean.size());
+ for (size_t r = 0; r < cl_time_hilb_mean.size(); r++)
+ {
+ int warning_level = -1;
+
+ y.get(r).resize(cl_time_hilb_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_hilb_mean.get(r).size(); k++)
+ {
+ // Time for construction hilbert and random
+ y.get(r).get(k).add(cl_time_rand_mean.get(r).get(k));
+
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(0) - 3.0*y_ref_dev.get(r).get(k).get(0));
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(0) + 3.0*y_ref_dev.get(r).get(k).get(0));
+ y.get(r).get(k).add(cl_time_hilb_mean.get(r).get(k));
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(1) - 3.0*y_ref_dev.get(r).get(k).get(1));
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(1) + 3.0*y_ref_dev.get(r).get(k).get(1));
+
+ warning_set(warning_level,cl_time_rand_mean.get(r).get(k),y_ref_mean.get(r).get(k).get(0),y_ref_dev.get(r).get(k).get(0));
+ warning_set(warning_level,cl_time_hilb_mean.get(r).get(k),y_ref_mean.get(r).get(k).get(1),y_ref_dev.get(r).get(k).get(1));
+ }
+
+ warning_vlevel.add(warning_level);
+ }
+ }
+
+ // Force time calculation
+
+ // Google charts options
+ GCoptions options;
+
+ options.yAxis = std::string("Time to calculate force");
+ options.xAxis = std::string("Number of particles");
+ options.lineWidth = 4;
+
+ std::string str("<h1>Cell-list " + std::to_string(dim) + "-D performance test: </h1>");
+ str += "<h2> 1) Time to calculate forces</h2>";
+ cg.addHTML(str);
+
+ for (size_t i = 0; i < cl_r_cutoff.size(); i++)
+ {
+ std::string chart_area;
+ if (warning_vlevel.size() != 0)
+ addchartarea(chart_area,warning_vlevel.get(i));
+ options.more = GC_Y_LOG + "," + GC_ZOOM + chart_area;
+
+ options.title = std::string("Cell-list performance, cut-off radius: " + std::to_string(cl_r_cutoff.get(i)));
+ cg.AddLinesGraph(x,y.get(i),yn,options);
+ }
+}
+
+/*! \brief Output the graph normal cell-list vs Hilbert cell-list (Total time)
+ *
+ * \tparam dim dimensionality of the test
+ *
+ * \param cg GoogleChart object
+ * \param cl_n_particles number of particles for each test
+ * \param cl_r_cutoff cell-list spacing used to construct a cell-list
+ * \param cl_time_force_hilb for each particle set, for each cut-off radius, for each order time to calculate the forces
+ * \param cl_time_force_rand for each particle set, for each cut-off radius, time to calculate the forces
+ *
+ */
+template<unsigned int dim> void cl_comp_normal_vs_hilbert_create_time(GoogleChart & cg,
+ openfpm::vector<size_t> & cl_n_particles,
+ openfpm::vector<float> & cl_r_cutoff,
+ openfpm::vector<openfpm::vector<double>> & cl_time_create_hilb_mean,
+ openfpm::vector<openfpm::vector<double>> & cl_time_create_rand_mean,
+ openfpm::vector<openfpm::vector<double>> & cl_time_create_hilb_dev,
+ openfpm::vector<openfpm::vector<double>> & cl_time_create_rand_dev,
+ double & warning_level,
+ double & norm)
+{
+ // Get the test dir
+ std::string file_mean(test_dir);
+ std::string file_var(test_dir);
+ file_mean += std::string("/openfpm_pdata/cl_comp_create_norm_hilbert_mean_" + std::to_string(dim) + std::string("_ref"));
+ file_var += std::string("/openfpm_pdata/cl_comp_create_norm_hilbert_dev_" + std::to_string(dim) + std::string("_ref"));
+
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_mean;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_dev;
+ y_ref_mean.load(file_mean);
+ y_ref_dev.load(file_var);
+
+ // warning level
+ openfpm::vector<int> warning_vlevel;
+
+ // Calculation time graphs data
+
+ openfpm::vector<size_t> x;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y2;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y2_dev;
+ openfpm::vector<std::string> yn2;
+
+ yn2.add("Random cell list");
+ yn2.add("Hilbert cell list");
+
+ for (size_t i = 0; i < cl_n_particles.size() ; i++)
+ x.add(cl_n_particles.get(i));
+
+ y2.resize(cl_time_create_hilb_mean.size());
+ y2_dev.resize(cl_time_create_hilb_mean.size());
+ for (size_t r = 0; r < cl_time_create_hilb_mean.size(); r++)
+ {
+ y2.get(r).resize(cl_time_create_hilb_mean.get(r).size());
+ y2_dev.get(r).resize(cl_time_create_hilb_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_create_hilb_mean.get(r).size(); k++)
+ {
+ // Put a total time
+ y2.get(r).get(k).add(cl_time_create_rand_mean.get(r).get(k));
+ y2.get(r).get(k).add(cl_time_create_hilb_mean.get(r).get(k));
+
+ y2_dev.get(r).get(k).add(cl_time_create_rand_dev.get(r).get(k));
+ y2_dev.get(r).get(k).add(cl_time_create_hilb_dev.get(r).get(k));
+ }
+ }
+
+ y2.save("cl_comp_create_norm_hilbert_mean_" + std::to_string(dim) + std::to_string("_ref"));
+ y2_dev.save("cl_comp_create_norm_hilbert_dev_" + std::to_string(dim) + std::to_string("_ref"));
+
+ if (y_ref_mean.size() != 0)
+ {
+ // We reconstruct y and yn
+
+ y2.clear();
+ yn2.clear();
+
+ yn2.add("Random cell list");
+ yn2.add("interval");
+ yn2.add("interval");
+ yn2.add("Hilbert cell list");
+ yn2.add("interval");
+ yn2.add("interval");
+
+ y2.resize(cl_time_create_hilb_mean.size());
+ for (size_t r = 0; r < cl_time_create_hilb_mean.size(); r++)
+ {
+ int warning_level = -1;
+
+ y2.get(r).resize(cl_time_create_hilb_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_create_hilb_mean.get(r).size(); k++)
+ {
+ // Time for construction hilbert and random
+ y2.get(r).get(k).add(cl_time_create_rand_mean.get(r).get(k));
+ y2.get(r).get(k).add(y_ref_mean.get(r).get(k).get(0) - 3.0*y_ref_dev.get(r).get(k).get(0));
+ y2.get(r).get(k).add(y_ref_mean.get(r).get(k).get(0) + 3.0*y_ref_dev.get(r).get(k).get(0));
+ y2.get(r).get(k).add(cl_time_create_hilb_mean.get(r).get(k));
+ y2.get(r).get(k).add(y_ref_mean.get(r).get(k).get(1) - 3.0*y_ref_dev.get(r).get(k).get(1));
+ y2.get(r).get(k).add(y_ref_mean.get(r).get(k).get(1) + 3.0*y_ref_dev.get(r).get(k).get(1));
+
+ warning_set(warning_level,cl_time_create_rand_mean.get(r).get(k),y_ref_mean.get(r).get(k).get(0),y_ref_dev.get(r).get(k).get(0));
+ warning_set(warning_level,cl_time_create_rand_mean.get(r).get(k),y_ref_mean.get(r).get(k).get(1),y_ref_dev.get(r).get(k).get(1));
+ }
+
+ warning_vlevel.add(warning_level);
+ }
+ }
+
+ // Calculation time graphs report
+
+ // Google charts options
+ GCoptions options2;
+
+ options2.yAxis = std::string("Time to create the cell-list");
+ options2.xAxis = std::string("Number of particles");
+ options2.lineWidth = 4;
+
+ std::string str2("<h2>2) Time to create the cell-list</h2>");
+ cg.addHTML(str2);
+
+ for (size_t i = 0; i < cl_r_cutoff.size(); i++)
+ {
+ std::string chart_area;
+ if (warning_vlevel.size() != 0)
+ addchartarea(chart_area,warning_vlevel.get(i));
+ options2.more = GC_Y_LOG + "," + GC_ZOOM + chart_area;
+
+ options2.title = std::string("Cell-list performance, cut-off radius: " + std::to_string(cl_r_cutoff.get(i)));
+ cg.AddLinesGraph(x,y2.get(i),yn2,options2);
+ }
+}
+
+
+///////////////////////////////// PARTICLE REORDERING //////////////////////////////////////////////////////
+
+
+
+#endif /* SRC_VECTOR_PERFORMANCE_CL_COMP_PERFORMANCE_GRAPH_HPP_ */
diff --git a/src/Vector/performance/cl_part_performance_graph.hpp b/src/Vector/performance/cl_part_performance_graph.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4d3346ac42c59dbd2d63bb6182cad7f7dd53dc7
--- /dev/null
+++ b/src/Vector/performance/cl_part_performance_graph.hpp
@@ -0,0 +1,268 @@
+/*
+ * cl_part_performance_graph.hpp
+ *
+ * Created on: Dec 23, 2016
+ * Author: i-bird
+ */
+
+#ifndef SRC_VECTOR_PERFORMANCE_CL_PART_PERFORMANCE_GRAPH_HPP_
+#define SRC_VECTOR_PERFORMANCE_CL_PART_PERFORMANCE_GRAPH_HPP_
+
+
+template<unsigned int dim> void cl_part_time(GoogleChart & cg,
+ openfpm::vector<size_t> & cl_n_particles,
+ openfpm::vector<float> & cl_r_cutoff,
+ openfpm::vector<size_t> &cl_orders,
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> cl_time_hilb_mean,
+ openfpm::vector<openfpm::vector<double>> cl_time_rand_mean,
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> cl_time_hilb_dev,
+ openfpm::vector<openfpm::vector<double>> cl_time_rand_dev)
+{
+ // Get the test dir
+ std::string file_mean(test_dir);
+ std::string file_var(test_dir);
+ file_mean += std::string("/openfpm_pdata/cl_part_norm_hilbert_mean_" + std::to_string(dim) + std::string("_ref"));
+ file_var += std::string("/openfpm_pdata/cl_part_norm_hilbert_dev_" + std::to_string(dim) + std::string("_ref"));
+
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_mean;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_dev;
+ y_ref_mean.load(file_mean);
+ y_ref_dev.load(file_var);
+
+ // warning level
+ openfpm::vector<int> warning_vlevel;
+
+ // Speedup graphs data
+
+ openfpm::vector<size_t> x;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_dev;
+ openfpm::vector<std::string> yn;
+
+ for (size_t i = 0; i < cl_n_particles.size() ; i++)
+ x.add(cl_n_particles.get(i));
+
+ for (size_t i = 0; i < cl_orders.size(); i++)
+ yn.add("Order of: " + std::to_string(cl_orders.get(i)));
+ yn.add("No-order");
+
+ // Add reorder time
+ y.resize(cl_time_hilb_mean.size());
+ y_dev.resize(cl_time_hilb_dev.size());
+ for (size_t r = 0; r < cl_time_hilb_mean.size(); r++)
+ {
+ y.get(r).resize(cl_time_hilb_mean.get(r).size());
+ y_dev.get(r).resize(cl_time_hilb_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_hilb_mean.get(r).size(); k++)
+ {
+ // reorder time
+ for (size_t m = 0; m < cl_time_hilb_mean.get(r).get(k).size(); m++)
+ {
+ // Put time
+ y.get(r).get(k).add(cl_time_hilb_mean.get(r).get(k).get(m));
+ y_dev.get(r).get(k).add(cl_time_hilb_dev.get(r).get(k).get(m));
+ }
+
+ // no reorder time
+ y.get(r).get(k).add(cl_time_rand_mean.get(r).get(k));
+ y_dev.get(r).get(k).add(cl_time_rand_dev.get(r).get(k));
+ }
+ }
+
+ // Save y
+ y.save("cl_part_norm_hilbert_mean_" + std::to_string(dim) + std::to_string("_ref"));
+ y_dev.save("cl_part_norm_hilbert_dev_" + std::to_string(dim) + std::to_string("_ref"));
+
+ if (y_ref_mean.size() != 0)
+ {
+ yn.clear();
+ y.clear();
+
+ for (size_t i = 0; i < cl_orders.size(); i++)
+ {
+ yn.add("Order of: " + std::to_string(cl_orders.get(i)));
+ yn.add("interval");
+ yn.add("interval");
+ }
+
+ yn.add("No-order");
+ yn.add("interval");
+ yn.add("interval");
+
+ // Add reorder time
+ y.resize(cl_time_hilb_mean.size());
+ for (size_t r = 0; r < cl_time_hilb_mean.size(); r++)
+ {
+ int warning_level = -1;
+
+ y.get(r).resize(cl_time_hilb_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_hilb_mean.get(r).size(); k++)
+ {
+ // reorder time
+ size_t m = 0;
+ for ( ; m < cl_time_hilb_mean.get(r).get(k).size(); m++)
+ {
+ // Put time
+ y.get(r).get(k).add(cl_time_hilb_mean.get(r).get(k).get(m));
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(m) - 3.0*y_ref_dev.get(r).get(k).get(m) );
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(m) + 3.0*y_ref_dev.get(r).get(k).get(m) );
+
+ warning_set(warning_level,cl_time_hilb_mean.get(r).get(k).get(m),y_ref_mean.get(r).get(k).get(m),y_ref_dev.get(r).get(k).get(m));
+ }
+
+ // no reorder time
+ y.get(r).get(k).add(cl_time_rand_mean.get(r).get(k));
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(m) - 3.0*y_ref_dev.get(r).get(k).get(m) );
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(m) + 3.0*y_ref_dev.get(r).get(k).get(m) );
+
+ warning_set(warning_level,cl_time_rand_mean.get(r).get(k),y_ref_mean.get(r).get(k).get(m),y_ref_dev.get(r).get(k).get(m));
+ }
+
+ warning_vlevel.add(warning_level);
+ }
+ }
+
+ // Speedup graphs report
+
+ // Google charts options
+ GCoptions options;
+
+ options.yAxis = std::string("Time (s)");
+ options.xAxis = std::string("Number of particles");
+ options.lineWidth = 2;
+ options.more = GC_Y_LOG + "," + GC_ZOOM;
+
+ //options.more = "hAxis: {logScale: true}";
+
+ std::string str("<h1>Cell-list " + std::to_string(dim) + "-D performance tests: </h1>");
+ str += "<h2> 1) Time to calculate forces in the case of particles randomly ordered in a vector of particles, and in the case of particles ordered along an hilbert curve of order N</h2>";
+
+ cg.addHTML(str);
+
+ for (size_t i = 0; i < cl_r_cutoff.size(); i++)
+ {
+ options.title = std::string("Cell-list performance, cut-off radius: " + std::to_string(cl_r_cutoff.get(i)));
+ cg.AddLinesGraph(x,y.get(i),yn,options);
+ }
+}
+
+template<unsigned int dim> void cl_part_reorder_time(GoogleChart & cg,
+ openfpm::vector<size_t> & cl_n_particles,
+ openfpm::vector<float> & cl_r_cutoff,
+ openfpm::vector<size_t> &cl_orders,
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> cl_time_reorder_mean,
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> cl_time_reorder_dev)
+{
+ // Get the test dir
+ std::string file_mean(test_dir);
+ std::string file_var(test_dir);
+ file_mean += std::string("/openfpm_pdata/cl_part_reorder_hilbert_mean_" + std::to_string(dim) + std::string("_ref"));
+ file_var += std::string("/openfpm_pdata/cl_part_reorder_hilbert_dev_" + std::to_string(dim) + std::string("_ref"));
+
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_mean;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_ref_dev;
+ y_ref_mean.load(file_mean);
+ y_ref_dev.load(file_var);
+
+ // warning level
+ openfpm::vector<int> warning_vlevel;
+
+ // graphs data
+ openfpm::vector<size_t> x;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y;
+ openfpm::vector<openfpm::vector<openfpm::vector<double>>> y_dev;
+ openfpm::vector<std::string> yn;
+
+ for (size_t i = 0; i < cl_n_particles.size() ; i++)
+ x.add(cl_n_particles.get(i));
+
+ for (size_t i = 0; i < cl_orders.size(); i++)
+ yn.add("Order of: " + std::to_string(cl_orders.get(i)));
+
+ // Add reorder time
+ y.resize(cl_time_reorder_mean.size());
+ y_dev.resize(cl_time_reorder_dev.size());
+ for (size_t r = 0; r < cl_time_reorder_mean.size(); r++)
+ {
+ y.get(r).resize(cl_time_reorder_mean.get(r).size());
+ y_dev.get(r).resize(cl_time_reorder_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_reorder_mean.get(r).size(); k++)
+ {
+ // reorder time
+ for (size_t m = 0; m < cl_time_reorder_mean.get(r).get(k).size(); m++)
+ {
+ // Put time
+ y.get(r).get(k).add(cl_time_reorder_mean.get(r).get(k).get(m));
+ y_dev.get(r).get(k).add(cl_time_reorder_dev.get(r).get(k).get(m));
+ }
+ }
+ }
+
+ // Save y
+ y.save("cl_part_reorder_hilbert_mean_" + std::to_string(dim) + std::to_string("_ref"));
+ y_dev.save("cl_part_reorder_hilbert_dev_" + std::to_string(dim) + std::to_string("_ref"));
+
+ if (y_ref_mean.size() != 0)
+ {
+ yn.clear();
+ y.clear();
+
+ size_t i = cl_orders.size()-1;
+ yn.add("Order of: " + std::to_string(cl_orders.get(i)));
+ yn.add("interval");
+ yn.add("interval");
+
+ // Add reorder time
+ y.resize(cl_time_reorder_mean.size());
+ for (size_t r = 0; r < cl_time_reorder_mean.size(); r++)
+ {
+ int warning_level = -1;
+
+ y.get(r).resize(cl_time_reorder_mean.get(r).size());
+ for (size_t k = 0; k < cl_time_reorder_mean.get(r).size(); k++)
+ {
+ // reorder time
+ size_t m = cl_orders.size()-1;
+
+ // Put time
+ y.get(r).get(k).add(cl_time_reorder_mean.get(r).get(k).get(m));
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(m) - 3.0*y_ref_dev.get(r).get(k).get(m) );
+ y.get(r).get(k).add(y_ref_mean.get(r).get(k).get(m) + 3.0*y_ref_dev.get(r).get(k).get(m) );
+
+ warning_set(warning_level,cl_time_reorder_mean.get(r).get(k).get(m),y_ref_mean.get(r).get(k).get(m),y_ref_dev.get(r).get(k).get(m));
+ }
+
+ warning_vlevel.add(warning_level);
+ }
+ }
+
+ // Speedup graphs report
+
+ // Google charts options
+ GCoptions options;
+
+ options.yAxis = std::string("Time (s)");
+ options.xAxis = std::string("Number of particles");
+ options.lineWidth = 2;
+ options.more = GC_ZOOM;
+
+ //options.more = "hAxis: {logScale: true}";
+
+ std::string str("<h1>Cell-list " + std::to_string(dim) + "-D performance tests: </h1>");
+ str += "<h2> 1) Time to reorder the distributed vector</h2>";
+
+ cg.addHTML(str);
+
+ for (size_t i = 0; i < cl_r_cutoff.size(); i++)
+ {
+ std::string chart_area;
+ if (warning_vlevel.size() != 0)
+ addchartarea(chart_area,warning_vlevel.get(i));
+ options.more = GC_Y_LOG + "," + GC_ZOOM + chart_area;
+
+ options.title = std::string("Cell-list performance, cut-off radius: " + std::to_string(cl_r_cutoff.get(i)));
+ cg.AddLinesGraph(x,y.get(i),yn,options);
+ }
+}
+
+#endif /* SRC_VECTOR_PERFORMANCE_CL_PART_PERFORMANCE_GRAPH_HPP_ */