Compadre 1.5.5
Loading...
Searching...
No Matches
GMLS_Vector.cpp
Go to the documentation of this file.
1#include <iostream>
2#include <string>
3#include <vector>
4#include <map>
5#include <stdlib.h>
6#include <cstdio>
7#include <random>
8
9#include <Compadre_Config.h>
10#include <Compadre_GMLS.hpp>
13
14#include "GMLS_Tutorial.hpp"
16
17#ifdef COMPADRE_USE_MPI
18#include <mpi.h>
19#endif
20
21#include <Kokkos_Timer.hpp>
22#include <Kokkos_Core.hpp>
23
24using namespace Compadre;
25
26//! [Parse Command Line Arguments]
27
28// called from command line
29int main (int argc, char* args[]) {
30
31// initializes MPI (if available) with command line arguments given
32#ifdef COMPADRE_USE_MPI
33MPI_Init(&argc, &args);
34#endif
35
36// initializes Kokkos with command line arguments given
37Kokkos::initialize(argc, args);
38
39// becomes false if the computed solution not within the failure_threshold of the actual solution
40bool all_passed = true;
41
42// code block to reduce scope for all Kokkos View allocations
43// otherwise, Views may be deallocating when we call Kokkos::finalize() later
44{
45
46 CommandLineProcessor clp(argc, args);
47 auto order = clp.order;
48 auto dimension = clp.dimension;
49 auto number_target_coords = clp.number_target_coords;
50 auto constraint_name = clp.constraint_name;
51 auto solver_name = clp.solver_name;
52 auto problem_name = clp.problem_name;
53
54 // the functions we will be seeking to reconstruct are in the span of the basis
55 // of the reconstruction space we choose for GMLS, so the error should be very small
56 const double failure_tolerance = 1e-9;
57
58 // minimum neighbors for unisolvency is the same as the size of the polynomial basis
59 const int min_neighbors = Compadre::GMLS::getNP(order, dimension);
60
61 //! [Parse Command Line Arguments]
62 Kokkos::Timer timer;
63 Kokkos::Profiling::pushRegion("Setup Point Data");
64 //! [Setting Up The Point Cloud]
65
66 // approximate spacing of source sites
67 double h_spacing = 0.05;
68 int n_neg1_to_1 = 2*(1/h_spacing) + 1; // always odd
69
70 // number of source coordinate sites that will fill a box of [-1,1]x[-1,1]x[-1,1] with a spacing approximately h
71 const int number_source_coords = std::pow(n_neg1_to_1, dimension);
72
73 // Coordinates for source and target sites are allocated through memory managed views just
74 // to allocate space for the data and from which to provide a pointer to raw data on the device.
75 // An unmanaged view is then created and pointed at this raw pointer in order to test the GMLS class
76 // setSourceSites and setTargetSites interface.
77
78 // coordinates of source sites
79 // data allocated on device memory space
80 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> source_coords_data("source coordinates",
81 number_source_coords, 3);
82 // later accessed through unmanaged memory view
83 scratch_matrix_left_type source_coords_device(source_coords_data.data(),
84 number_source_coords, 3);
85 scratch_matrix_left_type::HostMirror source_coords = Kokkos::create_mirror_view(source_coords_device);
86
87 // coordinates of target sites
88 // data allocated on device memory space
89 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> target_coords_data("target coordinates",
90 number_target_coords, 3);
91 // later accessed through unmanaged memory view
92 scratch_matrix_right_type target_coords_device (target_coords_data.data(), number_target_coords, 3);
93 scratch_matrix_right_type::HostMirror target_coords = Kokkos::create_mirror_view(target_coords_device);
94
95
96 // fill source coordinates with a uniform grid
97 int source_index = 0;
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;
105 if (dimension==3) {
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];
109 source_index++;
110 }
111 }
112 if (dimension==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;
116 source_index++;
117 }
118 }
119 if (dimension==1) {
120 source_coords(source_index,0) = this_coord[0];
121 source_coords(source_index,1) = 0;
122 source_coords(source_index,2) = 0;
123 source_index++;
124 }
125 }
126
127 // fill target coords somewhere inside of [-0.5,0.5]x[-0.5,0.5]x[-0.5,0.5]
128 for(int i=0; i<number_target_coords; i++){
129
130 // first, we get a uniformly random distributed direction
131 double rand_dir[3] = {0,0,0};
132
133 for (int j=0; j<dimension; ++j) {
134 // rand_dir[j] is in [-0.5, 0.5]
135 rand_dir[j] = ((double)rand() / (double) RAND_MAX) - 0.5;
136 }
137
138 // then we get a uniformly random radius
139 for (int j=0; j<dimension; ++j) {
140 target_coords(i,j) = rand_dir[j];
141 }
142
143 }
144
145
146 //! [Setting Up The Point Cloud]
147
148 Kokkos::Profiling::popRegion();
149 Kokkos::Profiling::pushRegion("Creating Data");
150
151 //! [Creating The Data]
152
153
154 // source coordinates need copied to device before using to construct sampling data
155 Kokkos::deep_copy(source_coords_device, source_coords);
156
157 // target coordinates copied next, because it is a convenient time to send them to device
158 Kokkos::deep_copy(target_coords_device, target_coords);
159
160 // need Kokkos View storing true solution
161 Kokkos::View<double*, Kokkos::DefaultExecutionSpace> sampling_data_device("samples of true solution",
162 source_coords_device.extent(0));
163
164 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> gradient_sampling_data_device("samples of true gradient",
165 source_coords_device.extent(0), dimension);
166
167 Kokkos::View<double**, Kokkos::DefaultExecutionSpace> divergence_sampling_data_device
168 ("samples of true solution for divergence test", source_coords_device.extent(0), dimension);
169
170 Kokkos::parallel_for("Sampling Manufactured Solutions", Kokkos::RangePolicy<Kokkos::DefaultExecutionSpace>
171 (0,source_coords.extent(0)), KOKKOS_LAMBDA(const int i) {
172
173 // coordinates of source site 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;
177
178 // data for targets with scalar input
179 sampling_data_device(i) = trueSolution(xval, yval, zval, order, dimension);
180
181 // data for targets with vector input (divergence)
182 double true_grad[3] = {0,0,0};
183 trueGradient(true_grad, xval, yval,zval, order, dimension);
184
185 for (int j=0; j<dimension; ++j) {
186 gradient_sampling_data_device(i,j) = true_grad[j];
187
188 // data for target with vector input (curl)
189 divergence_sampling_data_device(i,j) = divergenceTestSamples(xval, yval, zval, j, dimension);
190 }
191
192 });
193
194
195 //! [Creating The Data]
196
197 Kokkos::Profiling::popRegion();
198 Kokkos::Profiling::pushRegion("Neighbor Search");
199
200 //! [Performing Neighbor Search]
201
202
203 // Point cloud construction for neighbor search
204 // CreatePointCloudSearch constructs an object of type PointCloudSearch, but deduces the templates for you
205 auto point_cloud_search(CreatePointCloudSearch(source_coords, dimension));
206
207 // each row is a neighbor list for a target site, with the first column of each row containing
208 // the number of neighbors for that rows corresponding target site
209 double epsilon_multiplier = 1.5;
210 int estimated_upper_bound_number_neighbors =
211 point_cloud_search.getEstimatedNumberNeighborsUpperBound(min_neighbors, dimension, epsilon_multiplier);
212
213 Kokkos::View<int**, Kokkos::DefaultExecutionSpace> neighbor_lists_device("neighbor lists",
214 number_target_coords, estimated_upper_bound_number_neighbors); // first column is # of neighbors
215 Kokkos::View<int**>::HostMirror neighbor_lists = Kokkos::create_mirror_view(neighbor_lists_device);
216
217 // each target site has a window size
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);
220
221 // query the point cloud to generate the neighbor lists using a kdtree to produce the n nearest neighbor
222 // to each target site, adding (epsilon_multiplier-1)*100% to whatever the distance away the further neighbor used is from
223 // each target to the view for epsilon
224 point_cloud_search.generate2DNeighborListsFromKNNSearch(false /*not dry run*/, target_coords, neighbor_lists,
225 epsilon, min_neighbors, epsilon_multiplier);
226
227
228 //! [Performing Neighbor Search]
229
230 Kokkos::Profiling::popRegion();
231 Kokkos::fence(); // let call to build neighbor lists complete before copying back to device
232 timer.reset();
233
234 //! [Setting Up The GMLS Object]
235
236
237 // Copy data back to device (they were filled on the host)
238 // We could have filled Kokkos Views with memory space on the host
239 // and used these instead, and then the copying of data to the device
240 // would be performed in the GMLS class
241 Kokkos::deep_copy(neighbor_lists_device, neighbor_lists);
242 Kokkos::deep_copy(epsilon_device, epsilon);
243
244 // initialize an instance of the GMLS class
246 order, dimension,
247 solver_name.c_str(), problem_name.c_str(), constraint_name.c_str(),
248 2 /*manifold order*/);
249
250 // pass in neighbor lists, source coordinates, target coordinates, and window sizes
251 //
252 // neighbor lists have the format:
253 // dimensions: (# number of target sites) X (# maximum number of neighbors for any given target + 1)
254 // the first column contains the number of neighbors for that rows corresponding target index
255 //
256 // source coordinates have the format:
257 // dimensions: (# number of source sites) X (dimension)
258 // entries in the neighbor lists (integers) correspond to rows of this 2D array
259 //
260 // target coordinates have the format:
261 // dimensions: (# number of target sites) X (dimension)
262 // # of target sites is same as # of rows of neighbor lists
263 //
264 my_GMLS.setProblemData(neighbor_lists_device, source_coords_device, target_coords_device, epsilon_device);
265
266 // create a vector of target operations
267 std::vector<TargetOperation> lro(5);
268 lro[0] = ScalarPointEvaluation;
271 lro[3] = VectorPointEvaluation;
273
274 // and then pass them to the GMLS class
275 my_GMLS.addTargets(lro);
276
277 // sets the weighting kernel function from WeightingFunctionType
278 my_GMLS.setWeightingType(WeightingFunctionType::Power);
279
280 // power to use in that weighting kernel function
281 my_GMLS.setWeightingParameter(2);
282
283 // generate the alphas that to be combined with data for each target operation requested in lro
284 my_GMLS.generateAlphas(1, true /* keep polynomial coefficients, only needed for a test later in this program */);
285
286
287 //! [Setting Up The GMLS Object]
288
289 double instantiation_time = timer.seconds();
290 std::cout << "Took " << instantiation_time << "s to complete alphas generation." << std::endl;
291 Kokkos::fence(); // let generateAlphas finish up before using alphas
292 Kokkos::Profiling::pushRegion("Apply Alphas to Data");
293
294 //! [Apply GMLS Alphas To Data]
295
296 // it is important to note that if you expect to use the data as a 1D view, then you should use double*
297 // however, if you know that the target operation will result in a 2D view (vector or matrix output),
298 // then you should template with double** as this is something that can not be infered from the input data
299 // or the target operator at compile time. Additionally, a template argument is required indicating either
300 // Kokkos::HostSpace or Kokkos::DefaultExecutionSpace::memory_space()
301
302 // The Evaluator class takes care of handling input data views as well as the output data views.
303 // It uses information from the GMLS class to determine how many components are in the input
304 // as well as output for any choice of target functionals and then performs the contactions
305 // on the data using the alpha coefficients generated by the GMLS class, all on the device.
306 Evaluator gmls_evaluator(&my_GMLS);
307
308 auto output_value = gmls_evaluator.applyAlphasToDataAllComponentsAllTargetSites<double*, Kokkos::HostSpace>
309 (sampling_data_device, ScalarPointEvaluation);
310
311 auto output_divergence = gmls_evaluator.applyAlphasToDataAllComponentsAllTargetSites<double*, Kokkos::HostSpace>
312 (gradient_sampling_data_device, DivergenceOfVectorPointEvaluation, VectorPointSample);
313
314 auto output_curl = gmls_evaluator.applyAlphasToDataAllComponentsAllTargetSites<double**, Kokkos::HostSpace>
315 (divergence_sampling_data_device, CurlOfVectorPointEvaluation);
316
317 auto output_gradient = gmls_evaluator.applyAlphasToDataAllComponentsAllTargetSites<double**, Kokkos::HostSpace>
318 (gradient_sampling_data_device, VectorPointEvaluation);
319
320 auto output_hessian = gmls_evaluator.applyAlphasToDataAllComponentsAllTargetSites<double**, Kokkos::HostSpace>
321 (gradient_sampling_data_device, GradientOfVectorPointEvaluation);
322
323 // retrieves polynomial coefficients instead of remapped field
324 auto scalar_coefficients = gmls_evaluator.applyFullPolynomialCoefficientsBasisToDataAllComponents<double**, Kokkos::HostSpace>
325 (sampling_data_device);
326
327 auto vector_coefficients = gmls_evaluator.applyFullPolynomialCoefficientsBasisToDataAllComponents<double**, Kokkos::HostSpace>
328 (gradient_sampling_data_device);
329
330 //! [Apply GMLS Alphas To Data]
331
332 Kokkos::fence(); // let application of alphas to data finish before using results
333 Kokkos::Profiling::popRegion();
334 // times the Comparison in Kokkos
335 Kokkos::Profiling::pushRegion("Comparison");
336
337 //! [Check That Solutions Are Correct]
338
339
340 // loop through the target sites
341 for (int i=0; i<number_target_coords; i++) {
342
343 // load value from output
344 double GMLS_value = output_value(i);
345
346 // load partial x from gradient
347 // this is a test that the scalar_coefficients 2d array returned hold valid entries
348 // scalar_coefficients(i,1)*1./epsilon(i) is equivalent to the target operation acting
349 // on the polynomials applied to the polynomial coefficients
350 double GMLS_GradX = scalar_coefficients(i,1)*1./epsilon(i);
351
352 // load partial y from gradient
353 double GMLS_GradY = (dimension>1) ? output_gradient(i,1) : 0;
354
355 // load partial z from gradient
356 double GMLS_GradZ = (dimension>2) ? output_gradient(i,2) : 0;
357
358 // load divergence from output
359 double GMLS_Divergence = output_divergence(i);
360
361 // load curl from output
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;
365
366 auto NP = min_neighbors; // size of basis is same as # needed for unisolvency
367 // load hessian
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;
372 // replace YY with with vector_coefficients as test that vector_coefficients hold valid entries
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;
376 // replace ZY with with vector_coefficients as test that vector_coefficients hold valid entries
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;
379
380 // target site i's coordinate
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;
384
385 // evaluation of various exact solutions
386 double actual_value = trueSolution(xval, yval, zval, order, dimension);
387
388 double actual_Gradient[3] = {0,0,0}; // initialized for 3, but only filled up to dimension
389 trueGradient(actual_Gradient, xval, yval, zval, order, dimension);
390
391 double actual_Divergence;
392 actual_Divergence = trueLaplacian(xval, yval, zval, order, dimension);
393
394 double actual_Hessian[9] = {0,0,0,0,0,0,0,0,0}; // initialized for 3, but only filled up to dimension
395 trueHessian(actual_Hessian, xval, yval, zval, order, dimension);
396
397 double actual_Curl[3] = {0,0,0}; // initialized for 3, but only filled up to dimension
398 // (and not at all for dimimension = 1)
399 if (dimension>1) {
400 actual_Curl[0] = curlTestSolution(xval, yval, zval, 0, dimension);
401 actual_Curl[1] = curlTestSolution(xval, yval, zval, 1, dimension);
402 if (dimension>2) {
403 actual_Curl[2] = curlTestSolution(xval, yval, zval, 2, dimension);
404 }
405 }
406
407 // check actual function value
408 if(GMLS_value!=GMLS_value || std::abs(actual_value - GMLS_value) > failure_tolerance) {
409 all_passed = false;
410 std::cout << i << " Failed Actual by: " << std::abs(actual_value - GMLS_value) << std::endl;
411 }
412
413 // check vector (which is the gradient)
414 if(std::abs(actual_Gradient[0] - GMLS_GradX) > failure_tolerance) {
415 all_passed = false;
416 std::cout << i << " Failed GradX by: " << std::abs(actual_Gradient[0] - GMLS_GradX) << std::endl;
417 }
418 if (dimension>1) {
419 if(std::abs(actual_Gradient[1] - GMLS_GradY) > failure_tolerance) {
420 all_passed = false;
421 std::cout << i << " Failed GradY by: " << std::abs(actual_Gradient[1] - GMLS_GradY) << std::endl;
422 }
423 }
424 if (dimension>2) {
425 if(std::abs(actual_Gradient[2] - GMLS_GradZ) > failure_tolerance) {
426 all_passed = false;
427 std::cout << i << " Failed GradZ by: " << std::abs(actual_Gradient[2] - GMLS_GradZ) << std::endl;
428 }
429 }
430
431 // check divergence
432 if(std::abs(actual_Divergence - GMLS_Divergence) > failure_tolerance) {
433 all_passed = false;
434 std::cout << i << " Failed Divergence by: " << std::abs(actual_Divergence - GMLS_Divergence) << std::endl;
435 }
436
437 // check matrix (which is the hessian)
438 if(std::abs(actual_Hessian[0] - GMLS_GradXX) > failure_tolerance) {
439 all_passed = false;
440 std::cout << i << " Failed GradXX by: " << std::abs(actual_Hessian[0] - GMLS_GradXX) << std::endl;
441 }
442 if (dimension>1) {
443 if(std::abs(actual_Hessian[1] - GMLS_GradXY) > failure_tolerance) {
444 all_passed = false;
445 std::cout << i << " Failed GradXY by: " << std::abs(actual_Hessian[1] - GMLS_GradXY) << std::endl;
446 }
447 if(std::abs(actual_Hessian[1*dimension+1] - GMLS_GradYY) > failure_tolerance) {
448 all_passed = false;
449 std::cout << i << " Failed GradYY by: " << std::abs(actual_Hessian[1*dimension+1] - GMLS_GradYY) << std::endl;
450 }
451 if(std::abs(actual_Hessian[1*dimension+0] - GMLS_GradYX) > failure_tolerance) {
452 all_passed = false;
453 std::cout << i << " Failed GradYX by: " << std::abs(actual_Hessian[1*dimension+0] - GMLS_GradYX) << std::endl;
454 }
455 }
456 if (dimension>2) {
457 if(std::abs(actual_Hessian[2] - GMLS_GradXZ) > failure_tolerance) {
458 all_passed = false;
459 std::cout << i << " Failed GradXZ by: " << std::abs(actual_Hessian[2] - GMLS_GradXZ) << std::endl;
460 }
461 if(std::abs(actual_Hessian[1*dimension+2] - GMLS_GradYZ) > failure_tolerance) {
462 all_passed = false;
463 std::cout << i << " Failed GradYZ by: " << std::abs(actual_Hessian[1*dimension+2] - GMLS_GradYZ) << std::endl;
464 }
465 if(std::abs(actual_Hessian[2*dimension+0] - GMLS_GradZX) > failure_tolerance) {
466 all_passed = false;
467 std::cout << i << " Failed GradZX by: " << std::abs(actual_Hessian[2*dimension+0] - GMLS_GradZX) << std::endl;
468 }
469 if(std::abs(actual_Hessian[2*dimension+1] - GMLS_GradZY) > failure_tolerance) {
470 all_passed = false;
471 std::cout << i << " Failed GradZY by: " << std::abs(actual_Hessian[2*dimension+1] - GMLS_GradZY) << std::endl;
472 }
473 if(std::abs(actual_Hessian[2*dimension+2] - GMLS_GradZZ) > failure_tolerance) {
474 all_passed = false;
475 std::cout << i << " Failed GradZZ by: " << std::abs(actual_Hessian[2*dimension+2] - GMLS_GradZZ) << std::endl;
476 }
477 }
478
479 // check curl
480 if (order > 2) { // reconstructed solution not in basis unless order greater than 2 used
481 double tmp_diff = 0;
482 if (dimension>1)
483 tmp_diff += std::abs(actual_Curl[0] - GMLS_CurlX) + std::abs(actual_Curl[1] - GMLS_CurlY);
484 if (dimension>2)
485 tmp_diff += std::abs(actual_Curl[2] - GMLS_CurlZ);
486 if(std::abs(tmp_diff) > failure_tolerance) {
487 all_passed = false;
488 std::cout << i << " Failed Curl by: " << std::abs(tmp_diff) << std::endl;
489 }
490 }
491 }
492
493
494 //! [Check That Solutions Are Correct]
495 // popRegion hidden from tutorial
496 // stop timing comparison loop
497 Kokkos::Profiling::popRegion();
498 //! [Finalize Program]
499
500
501} // end of code block to reduce scope, causing Kokkos View de-allocations
502// otherwise, Views may be deallocating when we call Kokkos::finalize() later
503
504// finalize Kokkos and MPI (if available)
505Kokkos::finalize();
506#ifdef COMPADRE_USE_MPI
507MPI_Finalize();
508#endif
509
510// output to user that test passed or failed
511if(all_passed) {
512 fprintf(stdout, "Passed test \n");
513 return 0;
514} else {
515 fprintf(stdout, "Failed test \n");
516 return -1;
517}
518
519} // main
520
521
522//! [Finalize Program]
Kokkos::View< double **, layout_left, Kokkos::MemoryTraits< Kokkos::Unmanaged > > scratch_matrix_left_type
Kokkos::View< double **, layout_right, Kokkos::MemoryTraits< Kokkos::Unmanaged > > scratch_matrix_right_type
KOKKOS_INLINE_FUNCTION double trueSolution(double x, double y, double z, int order, int dimension)
KOKKOS_INLINE_FUNCTION void trueGradient(double *ans, double x, double y, double z, int order, int dimension)
KOKKOS_INLINE_FUNCTION double divergenceTestSamples(double x, double y, double z, int component, int dimension)
KOKKOS_INLINE_FUNCTION double curlTestSolution(double x, double y, double z, int component, int dimension)
KOKKOS_INLINE_FUNCTION void trueHessian(double *ans, double x, double y, double z, int order, int dimension)
KOKKOS_INLINE_FUNCTION double trueLaplacian(double x, double y, double z, int order, int dimension)
int main(int argc, char *args[])
[Parse Command Line Arguments]
Definition: GMLS_Vector.cpp:29
Lightweight Evaluator Helper This class is a lightweight wrapper for extracting and applying all rele...
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)
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...
Generalized Moving Least Squares (GMLS)
void addTargets(TargetOperation lro)
Adds a target to the vector of target functional to be applied to the reconstruction.
void setWeightingParameter(int wp, int index=0)
Parameter for weighting kernel for GMLS problem index = 0 sets p paramater for weighting kernel index...
void generateAlphas(const int number_of_batches=1, const bool keep_coefficients=false, const bool clear_cache=true)
Meant to calculate target operations and apply the evaluations to the previously constructed polynomi...
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)
void setWeightingType(const std::string &wt)
Type for weighting kernel for GMLS problem.
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....
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...
@ CurlOfVectorPointEvaluation
Point evaluation of the curl of a vector (results in a vector)
@ GradientOfVectorPointEvaluation
Point evaluation of the gradient of a vector (results in a matrix, NOT CURRENTLY IMPLEMENTED)
@ DivergenceOfVectorPointEvaluation
Point evaluation of the divergence of a vector (results in a scalar)
@ VectorPointEvaluation
Point evaluation of a vector (reconstructs entire vector at once, requiring a ReconstructionSpace hav...
@ ScalarPointEvaluation
Point evaluation of a scalar.
constexpr SamplingFunctional VectorPointSample
Point evaluations of the entire vector source function.
@ VectorTaylorPolynomial
Vector polynomial basis having # of components _dimensions, or (_dimensions-1) in the case of manifol...