9 #include <Compadre_Config.h>
17 #ifdef COMPADRE_USE_MPI
21 #include <Kokkos_Timer.hpp>
22 #include <Kokkos_Core.hpp>
24 using namespace Compadre;
29 int main (
int argc,
char* args[]) {
32 #ifdef COMPADRE_USE_MPI
33 MPI_Init(&argc, &args);
37 Kokkos::initialize(argc, args);
40 bool all_passed =
true;
47 auto order = clp.
order;
56 const double failure_tolerance = 1e-9;
63 Kokkos::Profiling::pushRegion(
"Setup Point Data");
67 double h_spacing = 0.05;
68 int n_neg1_to_1 = 2*(1/h_spacing) + 1;
71 const int number_source_coords = std::pow(n_neg1_to_1, dimension);
80 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> source_coords_data(
"source coordinates",
81 number_source_coords, 3);
84 number_source_coords, 3);
85 scratch_matrix_left_type::HostMirror source_coords = Kokkos::create_mirror_view(source_coords_device);
89 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> target_coords_data(
"target coordinates",
90 number_target_coords, 3);
93 scratch_matrix_right_type::HostMirror target_coords = Kokkos::create_mirror_view(target_coords_device);
98 double this_coord[3] = {0,0,0};
99 for (
int i=-n_neg1_to_1/2; i<n_neg1_to_1/2+1; ++i) {
100 this_coord[0] = i*h_spacing;
101 for (
int j=-n_neg1_to_1/2; j<n_neg1_to_1/2+1; ++j) {
102 this_coord[1] = j*h_spacing;
103 for (
int k=-n_neg1_to_1/2; k<n_neg1_to_1/2+1; ++k) {
104 this_coord[2] = k*h_spacing;
106 source_coords(source_index,0) = this_coord[0];
107 source_coords(source_index,1) = this_coord[1];
108 source_coords(source_index,2) = this_coord[2];
113 source_coords(source_index,0) = this_coord[0];
114 source_coords(source_index,1) = this_coord[1];
115 source_coords(source_index,2) = 0;
120 source_coords(source_index,0) = this_coord[0];
121 source_coords(source_index,1) = 0;
122 source_coords(source_index,2) = 0;
128 for(
int i=0; i<number_target_coords; i++){
131 double rand_dir[3] = {0,0,0};
133 for (
int j=0; j<dimension; ++j) {
135 rand_dir[j] = ((double)rand() / (double) RAND_MAX) - 0.5;
139 for (
int j=0; j<dimension; ++j) {
140 target_coords(i,j) = rand_dir[j];
148 Kokkos::Profiling::popRegion();
149 Kokkos::Profiling::pushRegion(
"Creating Data");
155 Kokkos::deep_copy(source_coords_device, source_coords);
158 Kokkos::deep_copy(target_coords_device, target_coords);
161 Kokkos::View<double*, Kokkos::DefaultExecutionSpace> sampling_data_device(
"samples of true solution",
162 source_coords_device.extent(0));
164 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> gradient_sampling_data_device(
"samples of true gradient",
165 source_coords_device.extent(0), dimension);
167 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> divergence_sampling_data_device
168 (
"samples of true solution for divergence test", source_coords_device.extent(0), dimension);
170 Kokkos::parallel_for(
"Sampling Manufactured Solutions", Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace>
171 (0,source_coords.extent(0)), KOKKOS_LAMBDA(
const int i) {
174 double xval = source_coords_device(i,0);
175 double yval = (dimension>1) ? source_coords_device(i,1) : 0;
176 double zval = (dimension>2) ? source_coords_device(i,2) : 0;
179 sampling_data_device(i) =
trueSolution(xval, yval, zval, order, dimension);
182 double true_grad[3] = {0,0,0};
183 trueGradient(true_grad, xval, yval,zval, order, dimension);
185 for (
int j=0; j<dimension; ++j) {
186 gradient_sampling_data_device(i,j) = true_grad[j];
197 Kokkos::Profiling::popRegion();
198 Kokkos::Profiling::pushRegion(
"Neighbor Search");
209 double epsilon_multiplier = 1.5;
210 int estimated_upper_bound_number_neighbors =
211 point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
213 Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device(
"neighbor lists",
214 number_target_coords, estimated_upper_bound_number_neighbors);
215 Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
218 Kokkos::View<double*, Kokkos::DefaultExecutionSpace> epsilon_device(
"h supports", number_target_coords);
219 Kokkos::View<double*>::HostMirror epsilon = Kokkos::create_mirror_view(epsilon_device);
224 point_cloud_search.generate2DNeighborListsFromKNNSearch(
false , target_coords, neighbor_lists,
225 epsilon, min_neighbors, epsilon_multiplier);
230 Kokkos::Profiling::popRegion();
241 Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
242 Kokkos::deep_copy(epsilon_device, epsilon);
247 solver_name.c_str(), problem_name.c_str(), constraint_name.c_str(),
264 my_GMLS.
setProblemData(neighbor_lists_device, source_coords_device, target_coords_device, epsilon_device);
267 std::vector<TargetOperation> lro(5);
275 my_GMLS.addTargets(lro);
281 my_GMLS.setWeightingParameter(2);
284 my_GMLS.generateAlphas(1,
true );
289 double instantiation_time = timer.seconds();
290 std::cout <<
"Took " << instantiation_time <<
"s to complete alphas generation." << std::endl;
292 Kokkos::Profiling::pushRegion(
"Apply Alphas to Data");
325 (sampling_data_device);
328 (gradient_sampling_data_device);
333 Kokkos::Profiling::popRegion();
335 Kokkos::Profiling::pushRegion(
"Comparison");
341 for (
int i=0; i<number_target_coords; i++) {
344 double GMLS_value = output_value(i);
350 double GMLS_GradX = scalar_coefficients(i,1)*1./epsilon(i);
353 double GMLS_GradY = (dimension>1) ? output_gradient(i,1) : 0;
356 double GMLS_GradZ = (dimension>2) ? output_gradient(i,2) : 0;
359 double GMLS_Divergence = output_divergence(i);
362 double GMLS_CurlX = (dimension>1) ? output_curl(i,0) : 0;
363 double GMLS_CurlY = (dimension>1) ? output_curl(i,1) : 0;
364 double GMLS_CurlZ = (dimension>2) ? output_curl(i,2) : 0;
366 auto NP = min_neighbors;
368 double GMLS_GradXX = output_hessian(i,0*dimension+0);
369 double GMLS_GradXY = (dimension>1) ? output_hessian(i,0*dimension+1) : 0;
370 double GMLS_GradXZ = (dimension>2) ? output_hessian(i,0*dimension+2) : 0;
371 double GMLS_GradYX = (dimension>1) ? output_hessian(i,1*dimension+0) : 0;
373 double GMLS_GradYY = (dimension>1) ? vector_coefficients(i,1*NP+2)*1./epsilon(i) : 0;
374 double GMLS_GradYZ = (dimension>2) ? output_hessian(i,1*dimension+2) : 0;
375 double GMLS_GradZX = (dimension>2) ? output_hessian(i,2*dimension+0) : 0;
377 double GMLS_GradZY = (dimension>2) ? vector_coefficients(i,2*NP+2)*1./epsilon(i) : 0;
378 double GMLS_GradZZ = (dimension>2) ? output_hessian(i,2*dimension+2) : 0;
381 double xval = target_coords(i,0);
382 double yval = (dimension>1) ? target_coords(i,1) : 0;
383 double zval = (dimension>2) ? target_coords(i,2) : 0;
386 double actual_value =
trueSolution(xval, yval, zval, order, dimension);
388 double actual_Gradient[3] = {0,0,0};
389 trueGradient(actual_Gradient, xval, yval, zval, order, dimension);
391 double actual_Divergence;
392 actual_Divergence =
trueLaplacian(xval, yval, zval, order, dimension);
394 double actual_Hessian[9] = {0,0,0,0,0,0,0,0,0};
395 trueHessian(actual_Hessian, xval, yval, zval, order, dimension);
397 double actual_Curl[3] = {0,0,0};
408 if(GMLS_value!=GMLS_value || std::abs(actual_value - GMLS_value) > failure_tolerance) {
410 std::cout << i <<
" Failed Actual by: " << std::abs(actual_value - GMLS_value) << std::endl;
414 if(std::abs(actual_Gradient[0] - GMLS_GradX) > failure_tolerance) {
416 std::cout << i <<
" Failed GradX by: " << std::abs(actual_Gradient[0] - GMLS_GradX) << std::endl;
419 if(std::abs(actual_Gradient[1] - GMLS_GradY) > failure_tolerance) {
421 std::cout << i <<
" Failed GradY by: " << std::abs(actual_Gradient[1] - GMLS_GradY) << std::endl;
425 if(std::abs(actual_Gradient[2] - GMLS_GradZ) > failure_tolerance) {
427 std::cout << i <<
" Failed GradZ by: " << std::abs(actual_Gradient[2] - GMLS_GradZ) << std::endl;
432 if(std::abs(actual_Divergence - GMLS_Divergence) > failure_tolerance) {
434 std::cout << i <<
" Failed Divergence by: " << std::abs(actual_Divergence - GMLS_Divergence) << std::endl;
438 if(std::abs(actual_Hessian[0] - GMLS_GradXX) > failure_tolerance) {
440 std::cout << i <<
" Failed GradXX by: " << std::abs(actual_Hessian[0] - GMLS_GradXX) << std::endl;
443 if(std::abs(actual_Hessian[1] - GMLS_GradXY) > failure_tolerance) {
445 std::cout << i <<
" Failed GradXY by: " << std::abs(actual_Hessian[1] - GMLS_GradXY) << std::endl;
447 if(std::abs(actual_Hessian[1*dimension+1] - GMLS_GradYY) > failure_tolerance) {
449 std::cout << i <<
" Failed GradYY by: " << std::abs(actual_Hessian[1*dimension+1] - GMLS_GradYY) << std::endl;
451 if(std::abs(actual_Hessian[1*dimension+0] - GMLS_GradYX) > failure_tolerance) {
453 std::cout << i <<
" Failed GradYX by: " << std::abs(actual_Hessian[1*dimension+0] - GMLS_GradYX) << std::endl;
457 if(std::abs(actual_Hessian[2] - GMLS_GradXZ) > failure_tolerance) {
459 std::cout << i <<
" Failed GradXZ by: " << std::abs(actual_Hessian[2] - GMLS_GradXZ) << std::endl;
461 if(std::abs(actual_Hessian[1*dimension+2] - GMLS_GradYZ) > failure_tolerance) {
463 std::cout << i <<
" Failed GradYZ by: " << std::abs(actual_Hessian[1*dimension+2] - GMLS_GradYZ) << std::endl;
465 if(std::abs(actual_Hessian[2*dimension+0] - GMLS_GradZX) > failure_tolerance) {
467 std::cout << i <<
" Failed GradZX by: " << std::abs(actual_Hessian[2*dimension+0] - GMLS_GradZX) << std::endl;
469 if(std::abs(actual_Hessian[2*dimension+1] - GMLS_GradZY) > failure_tolerance) {
471 std::cout << i <<
" Failed GradZY by: " << std::abs(actual_Hessian[2*dimension+1] - GMLS_GradZY) << std::endl;
473 if(std::abs(actual_Hessian[2*dimension+2] - GMLS_GradZZ) > failure_tolerance) {
475 std::cout << i <<
" Failed GradZZ by: " << std::abs(actual_Hessian[2*dimension+2] - GMLS_GradZZ) << std::endl;
483 tmp_diff += std::abs(actual_Curl[0] - GMLS_CurlX) + std::abs(actual_Curl[1] - GMLS_CurlY);
485 tmp_diff += std::abs(actual_Curl[2] - GMLS_CurlZ);
486 if(std::abs(tmp_diff) > failure_tolerance) {
488 std::cout << i <<
" Failed Curl by: " << std::abs(tmp_diff) << std::endl;
497 Kokkos::Profiling::popRegion();
506 #ifdef COMPADRE_USE_MPI
512 fprintf(stdout,
"Passed test \n");
515 fprintf(stdout,
"Failed test \n");
Point evaluation of a scalar.
Lightweight Evaluator Helper This class is a lightweight wrapper for extracting and applying all rele...
KOKKOS_INLINE_FUNCTION void trueHessian(double *ans, double x, double y, double z, int order, int dimension)
PointCloudSearch< view_type > CreatePointCloudSearch(view_type src_view, const local_index_type dimensions=-1, const local_index_type max_leaf=-1)
CreatePointCloudSearch allows for the construction of an object of type PointCloudSearch with templat...
int main(int argc, char **argv)
Point evaluation of the curl of a vector (results in a vector)
Vector polynomial basis having # of components _dimensions, or (_dimensions-1) in the case of manifol...
Kokkos::View< output_data_type, output_array_layout, output_memory_space > applyFullPolynomialCoefficientsBasisToDataAllComponents(view_type_input_data sampling_data, bool scalar_as_vector_if_needed=true) const
Generation of polynomial reconstruction coefficients by applying to data in GMLS (allocates memory fo...
static KOKKOS_INLINE_FUNCTION int getNP(const int m, const int dimension=3, const ReconstructionSpace r_space=ReconstructionSpace::ScalarTaylorPolynomial)
Returns size of the basis for a given polynomial order and dimension General to dimension 1...
KOKKOS_INLINE_FUNCTION void trueGradient(double *ans, double x, double y, double z, int order, int dimension)
Kokkos::View< double **, layout_right, Kokkos::MemoryTraits< Kokkos::Unmanaged > > scratch_matrix_right_type
Point evaluation of the divergence of a vector (results in a scalar)
Kokkos::View< double **, layout_left, Kokkos::MemoryTraits< Kokkos::Unmanaged > > scratch_matrix_left_type
KOKKOS_INLINE_FUNCTION double trueLaplacian(double x, double y, double z, int order, int dimension)
Generalized Moving Least Squares (GMLS)
KOKKOS_INLINE_FUNCTION double curlTestSolution(double x, double y, double z, int component, int dimension)
KOKKOS_INLINE_FUNCTION double divergenceTestSamples(double x, double y, double z, int component, int dimension)
Kokkos::View< output_data_type, output_array_layout, output_memory_space > applyAlphasToDataAllComponentsAllTargetSites(view_type_input_data sampling_data, TargetOperation lro, const SamplingFunctional sro_in=PointSample, bool scalar_as_vector_if_needed=true, const int evaluation_site_local_index=0) const
Transformation of data under GMLS (allocates memory for output)
void setProblemData(view_type_1 neighbor_lists, view_type_2 source_coordinates, view_type_3 target_coordinates, view_type_4 epsilons)
Sets basic problem data (neighbor lists, source coordinates, and target coordinates) ...
std::string constraint_name
KOKKOS_INLINE_FUNCTION double trueSolution(double x, double y, double z, int order, int dimension)
constexpr SamplingFunctional VectorPointSample
Point evaluations of the entire vector source function.
Point evaluation of the gradient of a vector (results in a matrix, NOT CURRENTLY IMPLEMENTED) ...
Point evaluation of a vector (reconstructs entire vector at once, requiring a ReconstructionSpace hav...