doc/html/_g_m_l_s_01_tutorial-example.html

// called from command line

int main (int argc, char* args[]) {


// initializes MPI (if available) with command line arguments given

#ifdef COMPADRE_USE_MPI

MPI_Init(&argc, &args);

#endif


// initializes Kokkos with command line arguments given

auto kp = KokkosParser(argc, args, true);


// becomes false if the computed solution not within the failure_threshold of the actual solution

bool all_passed = true;


// code block to reduce scope for all Kokkos View allocations

// otherwise, Views may be deallocating when we call Kokkos finalize() later

{


    // check if 8 arguments are given from the command line, the first being the program name

    int number_of_batches = 1; // 1 batch by default

    if (argc >= 8) {

        int arg8toi = atoi(args[7]);

        if (arg8toi > 0) {

            number_of_batches = arg8toi;

        }

    }

    bool keep_coefficients = number_of_batches==1;


    // check if 7 arguments are given from the command line, the first being the program name

    //  constraint_type used in solving each GMLS problem:

    //      0 - No constraints used in solving each GMLS problem

    //      1 - Neumann Gradient Scalar used in solving each GMLS problem

    int constraint_type = 0; // No constraints by default

    if (argc >= 7) {

        int arg7toi = atoi(args[6]);

        if (arg7toi > 0) {

            constraint_type = arg7toi;

        }

    }


    // check if 6 arguments are given from the command line, the first being the program name

    // problem_type used in solving each GMLS problem:

    //      0 - Standard GMLS problem

    //      1 - Manifold GMLS problem

    int problem_type = 0; // Standard by default

    if (argc >= 6) {

        int arg6toi = atoi(args[5]);

        if (arg6toi > 0) {

            problem_type = arg6toi;

        }

    }


    // check if 5 arguments are given from the command line, the first being the program name

    //  solver_type used for factorization in solving each GMLS problem:

    //      0 - SVD used for factorization in solving each GMLS problem

    //      1 - QR  used for factorization in solving each GMLS problem

    //      2 - LU  used for factorization in solving each GMLS problem

    int solver_type = 1; // QR by default

    if (argc >= 5) {

        int arg5toi = atoi(args[4]);

        if (arg5toi >= 0) {

            solver_type = arg5toi;

        }

    }


    // check if 4 arguments are given from the command line

    //  dimension for the coordinates and the solution

    int dimension = 3; // dimension 3 by default

    if (argc >= 4) {

        int arg4toi = atoi(args[3]);

        if (arg4toi > 0) {

            dimension = arg4toi;

        }

    }


    // check if 3 arguments are given from the command line

    //  set the number of target sites where we will reconstruct the target functionals at

    int number_target_coords = 200; // 200 target sites by default

    if (argc >= 3) {

        int arg3toi = atoi(args[2]);

        if (arg3toi > 0) {

            number_target_coords = arg3toi;

        }

    }


    // check if 2 arguments are given from the command line

    //  set the number of target sites where we will reconstruct the target functionals at

    int order = 3; // 3rd degree polynomial basis by default

    if (argc >= 2) {

        int arg2toi = atoi(args[1]);

        if (arg2toi > 0) {

            order = arg2toi;

        }

    }


    // the functions we will be seeking to reconstruct are in the span of the basis

    // of the reconstruction space we choose for GMLS, so the error should be very small

    const double failure_tolerance = 1e-9;


    // Laplacian is a second order differential operator, which we expect to be slightly less accurate

    const double laplacian_failure_tolerance = 1e-9;


    // minimum neighbors for unisolvency is the same as the size of the polynomial basis

    const int min_neighbors = Compadre::GMLS::getNP(order, dimension);