main.cpp

/*
 * ### WIKI 1 ###
 *
 * ## Simple example
 *
 * In this example we show 1D PSE derivative function approximation
 * convergence plot
 *
 * ### WIKI END ###
 *
 */

#include "config/config.h"

// Some compiler like clang does not have libquadmath this example
// require libquadmath. So is active only if in openfpm installation
// such library has been detected

#ifdef HAVE_LIBQUADMATH

#include "VCluster.hpp"
#include "PSE/Kernels_test_util.hpp"
#include "Plot/GoogleChart.hpp"
#include <boost/multiprecision/float128.hpp>

/*
 *
 * ### WIKI 2 ###
 *
 * In this header we encapsulate the example 0_Derivative_approx_1D.
 * In particular instead of printing the l2 and l_infinity norm, it
 * expose a function PSE_test that given a number of particles it
 * return the calculated l2 and l_inf error for the second order Laplacian
 * approximation of the function x*e^{-x^2} in the interval 0.0 and 4.0
 *
 */

/*
 *
 * ### WIKI END ###
 *
 */

int main(int argc, char* argv[])
{
    //
    // ### WIKI 2 ###
    //
    // Here we Initialize the library and we define Ghost size
    // and non-periodic boundary conditions
    //
    openfpm_init(&argc,&argv);
    Vcluster & v_cl = create_vcluster();

    // This test is not made to run in parallel
    if (v_cl.getProcessingUnits() > 1)
    {
        std::cerr << "Error: only one processor is allowed" << "\n";
        return 1;
    }

    openfpm::vector<size_t> x;
    openfpm::vector<openfpm::vector<double>> y;

    openfpm::vector<std::string> yn;
    yn.add("(order 2) float128 overlap=2");
    yn.add("(order 2) float128 overlap=4");
    yn.add("(order 2) overlap 2 double ");
    yn.add("(order 2) overlap 4 double (order 2)");
    yn.add("(order 2) overlap 2 float (order 2)");
    yn.add("(order 2) overlap 4 float (order 2)");

    yn.add("(order 4) float128 overlap=2");
    yn.add("(order 4) float128 overlap=4");

    yn.add("(order 6) float128 overlap=2");
    yn.add("(order 6) float128 overlap=4");

    yn.add("(order 8) float128 overlap=2");
    yn.add("(order 8) float128 overlap=4");

    // Every time increase the number of particles by 2
    for (size_t i = 125 ; i <= 2097152000 ; i*=2)
    {
        x.add(i);
        y.add();

        PSEError err;


        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,2>>(i,2,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,2>>(i,4,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<double,Lap_PSE<1,double,2>>(i,2,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<double,Lap_PSE<1,double,2>>(i,4,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<float,Lap_PSE<1,float,2>>(i,2,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<float,Lap_PSE<1,float,2>>(i,4,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);


        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,4>>(i,2,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,4>>(i,4,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);



        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,6>>(i,2,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,6>>(i,4,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);


        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,8>>(i,8,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);

        PSE_test<boost::multiprecision::float128,Lap_PSE<1,boost::multiprecision::float128,8>>(i,16,err);
        std::cout << "Particles: " << i << " error: " << err.linf_error << std::endl;
        y.last().add(err.linf_error);
    }

    // Google charts options
    GCoptions options;

    options.title = std::string("PSE Laplacian convergence");
    options.yAxis = std::string("Y Axis");
    options.xAxis = std::string("X Axis");
    options.more = std::string("hAxis:{logScale: true},vAxis:{logScale: true,format: 'scientific'}");
    options.lineWidth = 1.0;

    GoogleChart cg;
    cg.AddLinesGraph(x,y,yn,options);
    cg.write("PSE_plot.html");

    //
    // ### WIKI 8 ###
    //
    // Deinitialize the library
    //
    openfpm_finalize();
}

#else

int main()
{

}

#endif