OpenFPM_pdata  4.1.0
Project that contain the implementation of distributed structures
DCPSE_op.hpp
1 /*
2  * DCPSE_op.hpp
3  *
4  * Created on: Jan 7, 2020
5  * Author: Abhinav Singh, Pietro Incardona
6  */
7 
8 #ifndef DCPSE_OP_HPP_
9 #define DCPSE_OP_HPP_
10 #ifdef HAVE_EIGEN
11 
12 #include "Decomposition/CartDecomposition.hpp"
13 #include "DCPSE/Dcpse.hpp"
14 #include "Operators/Vector/vector_dist_operators.hpp"
15 
16 const double dcpse_oversampling_factor = 1.9;
17 const double rcut_verlet = 3.1;
18 
25 template<typename exp1, typename DCPSE_type>
26 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE> {
28  const exp1 o1;
29 
30  DCPSE_type &dcp;
31 
32 public:
33 
34  typedef std::false_type is_ker;
35 
36  typedef std::false_type NN_type;
37 
38  typedef std::false_type is_sort;
39 
40  typedef typename exp1::vtype vtype;
41 
43  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type &dcp)
44  : o1(o1), dcp(dcp) {}
45 
51  inline void init() const {
52  o1.init();
53  }
54 
62  template<typename r_type=typename std::remove_reference<decltype(o1.value(vect_dist_key_dx()))>::type>
63  inline r_type value(const vect_dist_key_dx &key) const {
64  return dcp.computeDifferentialOperator(key, o1);
65  }
66 
67  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
68  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
69  unsigned int comp) const {
70  // for all NN of key
71  for (int j = 0; j < dcp.getNumNN(key); j++) {
72  auto coeff_dc = dcp.getCoeffNN(key, j);
73  auto k = dcp.getIndexNN(key, j);
74 
75  auto k_coeff = coeff_dc * coeff * dcp.getEpsilonInvPrefactor(key);
76  o1.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
77 
78  auto kk_coeff = dcp.getSign() * coeff_dc * coeff * dcp.getEpsilonInvPrefactor(key);
79  o1.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
80  }
81  }
82 
90  vtype &getVector() {
91  return o1.getVector();
92  }
93 
101  const vtype &getVector() const {
102  return o1.getVector();
103  }
104 };
105 
106 template<typename exp1, typename DCPSE_type>
107 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE_V> {
109  const exp1 o1;
110 
111  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
112 
113  static const int dims = DCPSE_type::vtype::dims;
114  typedef typename DCPSE_type::vtype::stype stype;
115 
116 public:
117 
118  typedef std::false_type is_ker;
119 
120  typedef std::false_type NN_type;
121 
122  typedef std::false_type is_sort;
123 
124  typedef typename exp1::vtype vtype;
125 
127  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
128  : o1(o1), dcp(dcp) {}
129 
135  inline void init() const {
136  o1.init();
137  }
138 
146  template<typename r_type=VectorS<dims, stype> >
147  inline r_type value(const vect_dist_key_dx &key) const {
148  VectorS<dims, stype> v_grad;
149 
150  for (int i = 0; i < dims; i++) {
151  v_grad.get(i) = dcp[i].computeDifferentialOperator(key, o1);
152  }
153 
154  return v_grad;
155  }
156 
157  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
158  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
159  unsigned int comp) const {
160  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
161  // for all NN of key
162  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
163  auto coeff_dc = dcp[i].getCoeffNN(key, j);
164  auto k = dcp[i].getIndexNN(key, j);
165 
166  auto k_coeff = coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
167  o1.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
168 
169  auto kk_coeff = dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
170  o1.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
171 
172 
173  //cols[p_map. template getProp<0>(k)*Sys_eqs::nvar + comp] += coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
174 
175  //cols[p_map. template getProp<0>(key)*Sys_eqs::nvar + comp] += dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
176  }
177  }
178  }
179 
187  vtype &getVector() {
188  return o1.getVector();
189  }
190 
198  const vtype &getVector() const {
199  return o1.getVector();
200  }
201 
202 };
203 
204 
205 template<typename exp1, typename DCPSE_type>
206 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE_V_CURL2D> {
208  const exp1 o1;
209 
210  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
211 
212  static const int dims = DCPSE_type::vtype::dims;
213  typedef typename DCPSE_type::vtype::stype stype;
214 
215 public:
216 
217  typedef std::false_type is_ker;
218 
219  typedef std::false_type NN_type;
220 
221  typedef std::false_type is_sort;
222 
223  typedef typename exp1::vtype vtype;
224 
226  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
227  : o1(o1), dcp(dcp) {}
228 
234  inline void init() const {
235  o1.init();
236  }
237 
245  template<typename r_type=VectorS<dims, stype> >
246  inline r_type value(const vect_dist_key_dx &key) const {
247  VectorS<dims, stype> v_grad;
248  v_grad.get(0) = dcp[0].computeDifferentialOperator(key, o1);
249  v_grad.get(1) = -dcp[1].computeDifferentialOperator(key, o1);
250 
251  return v_grad;
252  }
253 
254  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
255  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
256  unsigned int comp) const {
257  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
258  // for all NN of key
259  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
260  auto coeff_dc = dcp[i].getCoeffNN(key, j);
261  auto k = dcp[i].getIndexNN(key, j);
262 
263  auto k_coeff = coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
264  o1.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
265 
266  auto kk_coeff = dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
267  o1.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
268 
269 
270  //cols[p_map. template getProp<0>(k)*Sys_eqs::nvar + comp] += coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
271 
272  //cols[p_map. template getProp<0>(key)*Sys_eqs::nvar + comp] += dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
273  }
274  }
275  }
276 
284  vtype &getVector() {
285  return o1.getVector();
286  }
287 
295  const vtype &getVector() const {
296  return o1.getVector();
297  }
298 
299 };
300 
301 
302 template<>
303 class vector_dist_expression_op<void, void, VECT_COPY_N_TO_N> {
304  mutable int i;
305 
307  openfpm::vector<aggregate<int>> &l1;
308  openfpm::vector<aggregate<int>> &l2;
309 
310 public:
311 
312  typedef std::false_type is_ker;
313 
314  typedef std::false_type NN_type;
315 
316  typedef std::false_type is_sort;
317 
318  inline vector_dist_expression_op(openfpm::vector<aggregate<int>> &l1, openfpm::vector<aggregate<int>> &l2)
319  : l1(l1), l2(l2) {}
320 
321  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
322  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
323  unsigned int comp) const {
324  if (l1.template get<0>(i) != key.getKey()) {
325  std::cout << "ERROR" << std::endl;
326  }
327 
328  cols[p_map.template getProp<0>(key) * Sys_eqs::nvar + comp] += coeff;
329  std::cout << "L2: " << l2.template get<0>(i) << std::endl;
330  cols[p_map.template getProp<0>(l2.template get<0>(i)) * Sys_eqs::nvar + comp] -= coeff;
331 
332  i++;
333  }
334 };
335 
336 
337 template<>
338 class vector_dist_expression_op<void, void, VECT_COPY_1_TO_N> {
339  mutable int i = 0;
340 
342  openfpm::vector<aggregate<int>> &l1;
343  int l2_key;
344 
345 public:
346 
347  typedef std::false_type is_ker;
348 
349  typedef std::false_type NN_type;
350 
351  typedef std::false_type is_sort;
352 
353  inline vector_dist_expression_op(openfpm::vector<aggregate<int>> &l1, int l2_key)
354  : l1(l1), l2_key(l2_key) {}
355 
356  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
357  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
358  unsigned int comp) const {
359  if (l1.template get<0>(i) != key.getKey()) {
360  std::cout << "ERROR" << std::endl;
361  }
362 
363  cols[p_map.template getProp<0>(key) * Sys_eqs::nvar + comp] += coeff;
364  cols[p_map.template getProp<0>(l2_key) * Sys_eqs::nvar + comp] -= coeff;
365  i++;
366  }
367 };
368 
369 
370 template<typename exp1, typename DCPSE_type>
371 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE_V_SUM> {
373  const exp1 o1;
374 
375  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
376 
377  static const int dims = DCPSE_type::vtype::dims;
378  typedef typename DCPSE_type::vtype::stype stype;
379 
380 public:
381 
382  typedef std::false_type is_ker;
383 
384  typedef std::false_type NN_type;
385 
386  typedef std::false_type is_sort;
387 
388  typedef typename exp1::vtype vtype;
389 
390  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
391  : o1(o1), dcp(dcp) {}
392 
393  inline void init() const {
394  o1.init();
395  }
396 
397  template<typename r_type= typename std::remove_reference<decltype(o1.value(vect_dist_key_dx(0)))>::type>
398  inline r_type value(const vect_dist_key_dx &key) const {
399  //typedef typename std::remove_reference<decltype(o1.value(key))>::type::blabla blabla;
400 
401  typename std::remove_reference<decltype(o1.value(key))>::type v_lap;
402  v_lap = 0.0;
403 
404 
405  for (int i = 0; i < dims; i++) {
406  v_lap += dcp[i].computeDifferentialOperator(key, o1);
407  }
408 
409  return v_lap;
410  }
411 
412  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
413  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
414  unsigned int comp) const {
415  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
416  // for all NN of key
417  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
418  auto coeff_dc = dcp[i].getCoeffNN(key, j);
419  auto k = dcp[i].getIndexNN(key, j);
420 
421  auto coeff_k = coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
422  o1.template value_nz<Sys_eqs>(p_map, k, cols, coeff_k, comp);
423 
424  auto coeff_kk = dcp[i].getSign() * coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
425  o1.template value_nz<Sys_eqs>(p_map, key, cols, coeff_kk, comp);
426  }
427  }
428  }
429 
437  vtype &getVector() {
438  return o1.getVector();
439  }
440 
448  const vtype &getVector() const {
449  return o1.getVector();
450  }
451 };
452 
453 
454 template<typename exp1, typename DCPSE_type>
455 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE_V_DIV> {
457  const exp1 o1;
458 
459  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
460 
461  static const int dims = DCPSE_type::vtype::dims;
462  typedef typename DCPSE_type::vtype::stype stype;
463 
464 public:
465 
466  typedef std::false_type is_ker;
467 
468  typedef std::false_type NN_type;
469 
470  typedef std::false_type is_sort;
471 
472  typedef typename exp1::vtype vtype;
473 
474  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
475  : o1(o1), dcp(dcp) {}
476 
477  inline void init() const {
478  o1.init();
479  }
480 
481  template<typename r_type= typename std::remove_reference<decltype(o1.value(vect_dist_key_dx(0)))>::type::coord_type>
482  inline r_type value(const vect_dist_key_dx &key) const {
483  //typedef typename std::remove_reference<decltype(o1.value(key))>::type::blabla blabla;
484 
485  typename std::remove_reference<decltype(o1.value(key))>::type::coord_type v_div;
486  v_div = 0.0;
487 
488  for (int i = 0; i < dims; i++) {
489  v_div += dcp[i].computeDifferentialOperator(key, o1, i);
490  }
491 
492  return v_div;
493  }
494 
495  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
496  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
497  unsigned int comp) const {
498  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
499  // for all NN of key
500  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
501  auto coeff_dc = dcp[i].getCoeffNN(key, j);
502  auto k = dcp[i].getIndexNN(key, j);
503 
504  auto k_coeff = coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
505  o1.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
506 
507  auto kk_coeff = dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
508  o1.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
509 
510 
511  //cols[p_map. template getProp<0>(k)*Sys_eqs::nvar + comp] += coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
512 
513  //cols[p_map. template getProp<0>(key)*Sys_eqs::nvar + comp] += dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
514  }
515  }
516  }
517 
525  vtype &getVector() {
526  return o1.getVector();
527  }
528 
536  const vtype &getVector() const {
537  return o1.getVector();
538  }
539 };
540 
541 template<typename exp1, typename exp2_pr>
542 class vector_dist_expression_op<exp1, exp2_pr, VECT_DCPSE_V_DOT> {
543  typedef typename std::tuple_element<1, exp2_pr>::type DCPSE_type;
544  typedef typename std::tuple_element<0, exp2_pr>::type exp2;
545 
547  const exp1 o1;
548  const exp2 o2;
549 
550  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
551 
552  static const int dims = DCPSE_type::vtype::dims;
553  typedef typename DCPSE_type::vtype::stype stype;
554 
555 public:
556 
557  typedef std::false_type is_ker;
558 
559  typedef std::false_type NN_type;
560 
561  typedef std::false_type is_sort;
562 
564  typedef typename first_or_second<has_vtype<exp1>::value, exp1, exp2>::vtype vtype;
565  //typedef typename exp2::vtype vtype;
566 
567 
568  inline vector_dist_expression_op(const exp1 &o1, const exp2 &o2, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
569  : o1(o1), o2(o2), dcp(dcp) {}
570 
571  inline void init() const {
572  o1.init();
573  o2.init();
574  }
575 
576  //template<typename r_type=VectorS<dims,stype> > inline r_type value(const vect_dist_key_dx & key) const
577  template<typename r_type= typename std::remove_reference<decltype(o2.value(vect_dist_key_dx(0)))>::type>
578  inline r_type value(const vect_dist_key_dx &key) const {
579  //typedef typename std::remove_reference<decltype(o1.value(key))>::type::blabla blabla;
580  typename std::remove_reference<decltype(o2.value(key))>::type adv;
581  adv = 0.0;
582  for (int i = 0; i < dims; i++) {
583  adv += o1.value(key)[i] * dcp[i].computeDifferentialOperator(key, o2);
584 
585  }
586  return adv;
587  }
588 
589 
590  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
591  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
592  unsigned int comp) const {
593  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
594  // for all NN of key
595  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
596  auto coeff_dc = dcp[i].getCoeffNN(key, j);
597  auto k = dcp[i].getIndexNN(key, j);
598 
599  auto k_coeff = o1.value(k) * coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
600  o2.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
601 
602  auto kk_coeff =
603  o1.value(key) * dcp[i].getSign() * coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
604  o2.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
605 
606  //cols[p_map. template getProp<0>(k)*Sys_eqs::nvar + comp] += o1.value(key)[i] * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
607  //cols[p_map. template getProp<0>(key)*Sys_eqs::nvar + comp] += o1.value(key)[i] * dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
608  }
609  }
610  }
611 
619  vtype &getVector() {
620  return first_or_second<has_vtype<exp1>::value, exp1, exp2>::getVector(o1, o2);
621  }
622 
630  const vtype &getVector() const {
631  return first_or_second<has_vtype<exp1>::value, exp1, exp2>::getVector(o1, o2);
632  }
633 
634 };
635 
636  /*
637  template<typename operand_type>
638  class Derivative_x_node
639  {
640  operand_type arg;
641 
642  public:
643  typedef int it_is_a_node;
644  Derivative_x_node(operand_type &arg)
645  :arg(arg)
646  {}
647  };
648  */
661 class Derivative_x {
662 
663  void *dcpse;
664 
665 public:
678  template<typename particles_type>
679  Derivative_x(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
680  double oversampling_factor = dcpse_oversampling_factor,
681  support_options opt = support_options::RADIUS) {
682  Point<particles_type::dims, unsigned int> p;
683  p.zero();
684  p.get(0) = 1;
685 
686  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
687 
688  }
689 
690  template<typename particles_type>
691  void deallocate(particles_type &parts) {
692  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
693  }
694 
695  template<typename operand_type>
696  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
697  operator()(operand_type arg) {
698  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
699 
700  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
701  }
702 
703  template<unsigned int prp, typename particles_type>
704  void DrawKernel(particles_type &particles, int k) {
705  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
706  dcpse_temp->template DrawKernel<prp>(particles, k);
707 
708  }
709 
710  template<unsigned int prp, typename particles_type>
711  void DrawKernelNN(particles_type &particles, int k) {
712  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
713  dcpse_temp->template DrawKernelNN<prp>(particles, k);
714 
715  }
716 
717  template<typename particles_type>
718  void checkMomenta(particles_type &particles) {
719  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
720  dcpse_temp->checkMomenta(particles);
721 
722  }
723 
729  template<typename particles_type>
730  void update(particles_type &particles) {
731  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
732  dcpse_temp->initializeUpdate(particles);
733 
734  }
735 
736 };
737 
750 class Derivative_y {
751 
752  void *dcpse;
753 
754 public:
755 
768  template<typename particles_type>
769  Derivative_y(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
770  double oversampling_factor = dcpse_oversampling_factor,
771  support_options opt = support_options::RADIUS) {
772  Point<particles_type::dims, unsigned int> p;
773  p.zero();
774  p.get(1) = 1;
775 
776  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
777 
778  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
779 
780  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
781  dcpse_ptr++;
782 
783  }
784 
785  template<typename particles_type>
786  void deallocate(particles_type &parts) {
787  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
788  }
789 
790  template<typename operand_type>
791 
792  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
793  operator()(operand_type arg) {
794  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
795 
796  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
797  }
798 
799  template<unsigned int prp, typename particles_type>
800  void DrawKernel(particles_type &particles, int k) {
801  auto dcpse2 = (Dcpse<particles_type::dims, particles_type> *) dcpse;
802  dcpse2->template DrawKernel<prp>(particles, k);
803 
804  }
805 
806  template<typename particles_type>
807  void checkMomenta(particles_type &particles) {
808  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
809  dcpse_temp->checkMomenta(particles);
810 
811  }
812 
818  template<typename particles_type>
819  void update(particles_type &particles) {
820  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
821  dcpse_temp->initializeUpdate(particles);
822 
823  }
824 };
825 
838 class Derivative_z {
839 
840  void *dcpse;
841 
842 public:
855  template<typename particles_type>
856  Derivative_z(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
857  double oversampling_factor = dcpse_oversampling_factor,
858  support_options opt = support_options::RADIUS) {
859  Point<particles_type::dims, unsigned int> p;
860  p.zero();
861  p.get(2) = 1;
862 
863  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
864  }
865 
866  template<typename particles_type>
867  void deallocate(particles_type &parts) {
868  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
869  }
870 
871  template<typename operand_type>
872  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
873  operator()(operand_type arg) {
874  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
875 
876  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
877  }
878 
884  template<typename particles_type>
885  void update(particles_type &particles) {
886  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
887  dcpse_temp->initializeUpdate(particles);
888 
889  }
890 
891  template<typename particles_type>
892  void checkMomenta(particles_type &particles) {
893  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
894  dcpse_temp->checkMomenta(particles);
895 
896  }
897 
898 };
899 
914 class Gradient {
915 
916  void *dcpse;
917 
918 public:
933  template<typename particles_type>
934  Gradient(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
935  double oversampling_factor = dcpse_oversampling_factor,
936  support_options opt = support_options::RADIUS) {
937  typedef Dcpse<particles_type::dims, particles_type> DCPSE_type;
938 
939  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
940 
941  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
942 
943  for (int i = 0; i < particles_type::dims; i++) {
944  Point<particles_type::dims, unsigned int> p;
945  p.zero();
946  p.get(i) = 1;
947  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
948  dcpse_ptr++;
949  }
950  }
951 
952  template<typename particles_type>
953  void deallocate(particles_type &parts) {
954  for (int i = 0; i < particles_type::dims; i++) {
955  delete &(((Dcpse<particles_type::dims, particles_type> *) dcpse)[i]);
956  }
957  }
958 
959  template<typename operand_type>
960  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE_V>
961  operator()(operand_type arg) {
962  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
963 
964  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V>(arg,
965  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
966  }
967 
968  template<unsigned int prp, typename particles_type>
969  void DrawKernel(particles_type &particles, int k) {
970  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
971 
972  for (int i = 0; i < particles_type::dims; i++) {
973  dcpse_ptr[i].template DrawKernel<prp>(particles, i, k);
974  }
975 
976  }
977 
983  template<typename particles_type>
984  void update(particles_type &particles) {
985  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
986  for (int i = 0; i < particles_type::dims; i++) {
987  dcpse_ptr[i].initializeUpdate(particles);
988  }
989 
990  }
991 
992 
993 };
1008 class Curl2D {
1009 
1010  void *dcpse;
1011 public:
1026  template<typename particles_type>
1027  Curl2D(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1028  double oversampling_factor = dcpse_oversampling_factor, support_options opt = support_options::RADIUS) {
1029  typedef Dcpse<particles_type::dims, particles_type> DCPSE_type;
1030 
1031  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1032 
1033  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1034  Point<particles_type::dims, unsigned int> p;
1035  p.zero();
1036  p.get(1) = 1;
1037  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1038  dcpse_ptr++;
1039  p.zero();
1040  p.get(0) = 1;
1041  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1042  dcpse_ptr++;
1043 
1044  }
1045 
1046  template<typename operand_type>
1047  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE_V_CURL2D>
1048  operator()(operand_type arg) {
1049  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1050 
1051  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V_CURL2D>(arg,
1052  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
1053  }
1054 };
1069 class Laplacian {
1070 
1071  void *dcpse;
1072 
1073 public:
1088  template<typename particles_type>
1089  Laplacian(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1090  double oversampling_factor = dcpse_oversampling_factor,
1091  support_options opt = support_options::RADIUS) {
1092  typedef Dcpse<particles_type::dims, particles_type> DCPSE_type;
1093 
1094  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1095 
1096  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1097 
1098  for (int i = 0; i < particles_type::dims; i++) {
1099  Point<particles_type::dims, unsigned int> p;
1100  p.zero();
1101  p.get(i) = 2;
1102  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1103  dcpse_ptr++;
1104  }
1105  }
1106 
1107  template<typename operand_type>
1108  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE_V_SUM>
1109  operator()(operand_type arg) {
1110  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1111 
1112  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V_SUM>(arg,
1113  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
1114  }
1115 
1116 
1117  template<typename particles_type>
1118  void checkMomenta(particles_type &particles) {
1119  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1120 
1121  for (int i = 0; i < particles_type::dims; i++) {
1122  dcpse_ptr[i].checkMomenta(particles);
1123  }
1124 
1125  }
1126 
1127  template<unsigned int prp, typename particles_type>
1128  void DrawKernel(particles_type &particles, int k) {
1129  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1130 
1131  for (int i = 0; i < particles_type::dims; i++) {
1132  dcpse_ptr[i].template DrawKernel<prp>(particles, k);
1133  }
1134 
1135  }
1136  template<typename particles_type>
1137  void deallocate(particles_type &parts) {
1138  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
1139  }
1145  template<typename particles_type>
1146  void update(particles_type &particles) {
1147  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1148  for (int i = 0; i < particles_type::dims; i++) {
1149  dcpse_ptr[i].initializeUpdate(particles);
1150  }
1151 
1152  }
1153 
1154 
1155 };
1156 
1171 class Divergence {
1172 
1173  void *dcpse;
1174 
1175 public:
1190  template<typename particles_type>
1191  Divergence(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1192  double oversampling_factor = dcpse_oversampling_factor,
1193  support_options opt = support_options::RADIUS) {
1194  typedef Dcpse<particles_type::dims, particles_type> DCPSE_type;
1195 
1196  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1197 
1198  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1199 
1200  for (int i = 0; i < particles_type::dims; i++) {
1201  Point<particles_type::dims, unsigned int> p;
1202  p.zero();
1203  p.get(i) = 1;
1204  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1205  dcpse_ptr++;
1206  }
1207  }
1208 
1209  template<typename operand_type>
1210  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE_V_DIV>
1211  operator()(operand_type arg) {
1212  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1213 
1214  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V_DIV>(arg,
1215  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
1216  }
1217 
1223  template<typename particles_type>
1224  void update(particles_type &particles) {
1225  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1226  for (int i = 0; i < particles_type::dims; i++) {
1227  dcpse_ptr[i].initializeUpdate(particles);
1228  }
1229 
1230  }
1231 
1232 };
1233 
1248 class Advection {
1249 
1250  void *dcpse;
1251 
1252 public:
1267  template<typename particles_type>
1268  Advection(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1269  double oversampling_factor = dcpse_oversampling_factor,
1270  support_options opt = support_options::RADIUS) {
1271  typedef Dcpse<particles_type::dims, particles_type> DCPSE_type;
1272 
1273  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1274 
1275  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1276 
1277  for (int i = 0; i < particles_type::dims; i++) {
1278  Point<particles_type::dims, unsigned int> p;
1279  p.zero();
1280  p.get(i) = 1;
1281  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1282  dcpse_ptr++;
1283  }
1284 
1285 
1286  }
1287 
1288  template<typename operand_type1, typename operand_type2>
1289  vector_dist_expression_op<operand_type1, std::pair<operand_type2, Dcpse<operand_type2::vtype::dims, typename operand_type2::vtype>>, VECT_DCPSE_V_DOT>
1290  operator()(operand_type1 arg, operand_type2 arg2) {
1291  typedef Dcpse<operand_type2::vtype::dims, typename operand_type2::vtype> dcpse_type;
1292 
1293  return vector_dist_expression_op<operand_type1, std::pair<operand_type2, dcpse_type>, VECT_DCPSE_V_DOT>(arg,
1294  arg2,
1295  *(dcpse_type(*)[operand_type2::vtype::dims]) dcpse);
1296  }
1297 
1298  template<typename particles_type>
1299  void checkMomenta(particles_type &particles) {
1300  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1301 
1302  for (int i = 0; i < particles_type::dims; i++) {
1303  dcpse_ptr[i].checkMomenta(particles);
1304  }
1305 
1306  }
1307 
1308  template<unsigned int prp, typename particles_type>
1309  void DrawKernel(particles_type &particles, int k) {
1310  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1311 
1312  for (int i = 0; i < particles_type::dims; i++) {
1313  dcpse_ptr[i].template DrawKernel<prp>(particles, i, k);
1314  }
1315 
1316  }
1317 
1323  template<typename particles_type>
1324  void update(particles_type &particles) {
1325  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1326  for (int i = 0; i < particles_type::dims; i++) {
1327  dcpse_ptr[i].initializeUpdate(particles);
1328  }
1329 
1330  }
1331 
1332 
1333 };
1334 
1347 class Derivative_xy {
1348 
1349  void *dcpse;
1350 
1351 public:
1364  template<typename particles_type>
1365  Derivative_xy(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1366  double oversampling_factor = dcpse_oversampling_factor,
1367  support_options opt = support_options::RADIUS) {
1368  Point<particles_type::dims, unsigned int> p;
1369  p.zero();
1370  p.get(0) = 1;
1371  p.get(1) = 1;
1372 
1373  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1374 
1375  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1376 
1377  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1378  dcpse_ptr++;
1379 
1380  }
1381 
1382  template<typename particles_type>
1383  void deallocate(particles_type &parts) {
1384  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
1385  }
1386 
1387  template<typename operand_type>
1388  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1389  operator()(operand_type arg) {
1390  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1391 
1392  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1393  }
1394 
1395  template<unsigned int prp, typename particles_type>
1396  void DrawKernel(particles_type &particles, int k) {
1397  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1398 
1399  dcpse_ptr[0].template DrawKernel<prp>(particles, k);
1400 
1401  }
1402 
1403  template<typename particles_type>
1404  void checkMomenta(particles_type &particles) {
1405  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1406  dcpse_temp->checkMomenta(particles);
1407 
1408  }
1409 
1415  template<typename particles_type>
1416  void update(particles_type &particles) {
1417  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1418  dcpse_temp->initializeUpdate(particles);
1419 
1420  }
1421 };
1434 class Derivative_yz {
1435 
1436  void *dcpse;
1437 
1438 public:
1451  template<typename particles_type>
1452  Derivative_yz(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1453  double oversampling_factor = dcpse_oversampling_factor,
1454  support_options opt = support_options::RADIUS) {
1455  Point<particles_type::dims, unsigned int> p;
1456  p.zero();
1457  p.get(1) = 1;
1458  p.get(2) = 1;
1459 
1460  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1461 
1462  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1463 
1464  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1465  dcpse_ptr++;
1466 
1467  }
1468 
1469  template<typename particles_type>
1470  void deallocate(particles_type &parts) {
1471  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
1472  }
1473 
1474  template<typename operand_type>
1475  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1476  operator()(operand_type arg) {
1477  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1478 
1479  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1480  }
1481 
1482  template<unsigned int prp, typename particles_type>
1483  void DrawKernel(particles_type &particles, int k) {
1484  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1485 
1486  dcpse_ptr[0].template DrawKernel<prp>(particles, k);
1487 
1488  }
1489 
1490  template<typename particles_type>
1491  void checkMomenta(particles_type &particles) {
1492  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1493  dcpse_temp->checkMomenta(particles);
1494 
1495  }
1496 
1502  template<typename particles_type>
1503  void update(particles_type &particles) {
1504  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1505  dcpse_temp->initializeUpdate(particles);
1506 
1507  }
1508 };
1521 class Derivative_xz {
1522 
1523  void *dcpse;
1524 
1525 public:
1538  template<typename particles_type>
1539  Derivative_xz(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1540  double oversampling_factor = dcpse_oversampling_factor,
1541  support_options opt = support_options::RADIUS) {
1542  Point<particles_type::dims, unsigned int> p;
1543  p.zero();
1544  p.get(0) = 1;
1545  p.get(2) = 1;
1546 
1547  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1548 
1549  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1550 
1551  new(dcpse_ptr) Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1552  dcpse_ptr++;
1553 
1554  }
1555 
1556  template<typename particles_type>
1557  void deallocate(particles_type &parts) {
1558  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
1559  }
1560 
1561  template<typename operand_type>
1562  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1563  operator()(operand_type arg) {
1564  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1565 
1566  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1567  }
1568 
1569  template<unsigned int prp, typename particles_type>
1570  void DrawKernel(particles_type &particles, int k) {
1571  Dcpse<particles_type::dims, particles_type> *dcpse_ptr = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1572 
1573  dcpse_ptr[0].template DrawKernel<prp>(particles, k);
1574 
1575  }
1576 
1577  template<typename particles_type>
1578  void checkMomenta(particles_type &particles) {
1579  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1580  dcpse_temp->checkMomenta(particles);
1581 
1582  }
1583 
1589  template<typename particles_type>
1590  void update(particles_type &particles) {
1591  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1592  dcpse_temp->initializeUpdate(particles);
1593 
1594  }
1595 };
1596 
1609 class Derivative_xx {
1610 
1611  void *dcpse;
1612 
1613 public:
1626  template<typename particles_type>
1627  Derivative_xx(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1628  double oversampling_factor = dcpse_oversampling_factor,
1629  support_options opt = support_options::RADIUS) {
1630  Point<particles_type::dims, unsigned int> p;
1631  p.zero();
1632  p.get(0) = 2;
1633  p.get(1) = 0;
1634 
1635  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1636  }
1637 
1638  template<typename particles_type>
1639  void deallocate(particles_type &parts) {
1640  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
1641  }
1642 
1643  template<typename operand_type>
1644  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1645  operator()(operand_type arg) {
1646  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1647 
1648  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1649  }
1650 
1651  template<typename particles_type>
1652  void checkMomenta(particles_type &particles) {
1653  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1654  dcpse_temp->checkMomenta(particles);
1655 
1656  }
1657 
1658  template<unsigned int prp, typename particles_type>
1659  void DrawKernel(particles_type &particles, int k) {
1660  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1661  dcpse_temp->template DrawKernel<prp>(particles, k);
1662 
1663  }
1664 
1670  template<typename particles_type>
1671  void update(particles_type &particles) {
1672  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1673  dcpse_temp->initializeUpdate(particles);
1674 
1675  }
1676 };
1677 
1690 class Derivative_yy {
1691 
1692  void *dcpse;
1693 
1694 public:
1707  template<typename particles_type>
1708  Derivative_yy(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1709  double oversampling_factor = dcpse_oversampling_factor,
1710  support_options opt = support_options::RADIUS) {
1711  Point<particles_type::dims, unsigned int> p;
1712  p.zero();
1713  p.get(0) = 0;
1714  p.get(1) = 2;
1715 
1716  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1717  }
1718 
1719  template<typename particles_type>
1720  void deallocate(particles_type &parts) {
1721  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
1722  }
1723 
1724  template<typename operand_type>
1725  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1726  operator()(operand_type arg) {
1727  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1728 
1729  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1730  }
1731 
1732  template<typename particles_type>
1733  void checkMomenta(particles_type &particles) {
1734  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1735  dcpse_temp->checkMomenta(particles);
1736 
1737  }
1738 
1739  template<unsigned int prp, typename particles_type>
1740  void DrawKernel(particles_type &particles, int k) {
1741  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1742  dcpse_temp->template DrawKernel<prp>(particles, k);
1743 
1744  }
1745 
1751  template<typename particles_type>
1752  void update(particles_type &particles) {
1753  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1754  dcpse_temp->initializeUpdate(particles);
1755 
1756  }
1757 };
1770 class Derivative_zz {
1771 
1772  void *dcpse;
1773 
1774 public:
1787  template<typename particles_type>
1788  Derivative_zz(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1789  double oversampling_factor = dcpse_oversampling_factor,
1790  support_options opt = support_options::RADIUS) {
1791  Point<particles_type::dims, unsigned int> p;
1792  p.zero();
1793  p.get(2) = 2;
1794 
1795  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1796  }
1797 
1798  template<typename particles_type>
1799  void deallocate(particles_type &parts) {
1800  delete (Dcpse<particles_type::dims, particles_type> *) dcpse;
1801  }
1802 
1803  template<typename operand_type>
1804  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1805  operator()(operand_type arg) {
1806  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1807 
1808  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1809  }
1810 
1811  template<typename particles_type>
1812  void checkMomenta(particles_type &particles) {
1813  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1814  dcpse_temp->checkMomenta(particles);
1815 
1816  }
1817 
1818  template<unsigned int prp, typename particles_type>
1819  void DrawKernel(particles_type &particles, int k) {
1820  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1821  dcpse_temp->template DrawKernel<prp>(particles, k);
1822 
1823  }
1824 
1830  template<typename particles_type>
1831  void update(particles_type &particles) {
1832  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1833  dcpse_temp->initializeUpdate(particles);
1834 
1835  }
1836 };
1837 
1838 
1839 class Derivative_xxx {
1840 
1841  void *dcpse;
1842 
1843 public:
1844 
1845  template<typename particles_type>
1846  Derivative_xxx(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1847  double oversampling_factor = dcpse_oversampling_factor,
1848  support_options opt = support_options::RADIUS) {
1849  Point<particles_type::dims, unsigned int> p;
1850  p.zero();
1851  p.get(0) = 3;
1852  p.get(1) = 0;
1853 
1854  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1855  }
1856 
1857  template<typename operand_type>
1858 
1859  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1860  operator()(operand_type arg) {
1861  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1862 
1863  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1864  }
1865 
1866  template<typename particles_type>
1867  void checkMomenta(particles_type &particles) {
1868  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1869  dcpse_temp->checkMomenta(particles);
1870 
1871  }
1872 
1873  template<unsigned int prp, typename particles_type>
1874  void DrawKernel(particles_type &particles, int k) {
1875  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1876  dcpse_temp->template DrawKernel<prp>(particles, k);
1877 
1878  }
1879 
1885  template<typename particles_type>
1886  void update(particles_type &particles) {
1887  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1888  dcpse_temp->initializeUpdate(particles);
1889 
1890  }
1891 };
1892 
1893 
1894 class Derivative_xxy {
1895 
1896  void *dcpse;
1897 
1898 public:
1899 
1900  template<typename particles_type>
1901  Derivative_xxy(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1902  double oversampling_factor = dcpse_oversampling_factor,
1903  support_options opt = support_options::RADIUS) {
1904  Point<particles_type::dims, unsigned int> p;
1905  p.zero();
1906  p.get(0) = 2;
1907  p.get(1) = 1;
1908 
1909  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1910  }
1911 
1912  template<typename operand_type>
1913 
1914  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1915  operator()(operand_type arg) {
1916  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1917 
1918  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1919  }
1920 
1921  template<typename particles_type>
1922  void checkMomenta(particles_type &particles) {
1923  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1924  dcpse_temp->checkMomenta(particles);
1925 
1926  }
1927 
1928  template<unsigned int prp, typename particles_type>
1929  void DrawKernel(particles_type &particles, int k) {
1930  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1931  dcpse_temp->template DrawKernel<prp>(particles, k);
1932 
1933  }
1934 
1940  template<typename particles_type>
1941  void update(particles_type &particles) {
1942  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1943  dcpse_temp->initializeUpdate(particles);
1944 
1945  }
1946 };
1947 
1948 
1949 class Derivative_yyx {
1950 
1951  void *dcpse;
1952 
1953 public:
1954 
1955  template<typename particles_type>
1956  Derivative_yyx(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
1957  double oversampling_factor = dcpse_oversampling_factor,
1958  support_options opt = support_options::RADIUS) {
1959  Point<particles_type::dims, unsigned int> p;
1960  p.zero();
1961  p.get(0) = 1;
1962  p.get(1) = 2;
1963 
1964  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
1965  }
1966 
1967  template<typename operand_type>
1968 
1969  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
1970  operator()(operand_type arg) {
1971  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
1972 
1973  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1974  }
1975 
1976  template<typename particles_type>
1977  void checkMomenta(particles_type &particles) {
1978  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1979  dcpse_temp->checkMomenta(particles);
1980 
1981  }
1982 
1983  template<unsigned int prp, typename particles_type>
1984  void DrawKernel(particles_type &particles, int k) {
1985  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1986  dcpse_temp->template DrawKernel<prp>(particles, k);
1987 
1988  }
1989 
1995  template<typename particles_type>
1996  void update(particles_type &particles) {
1997  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
1998  dcpse_temp->initializeUpdate(particles);
1999 
2000  }
2001 };
2002 
2003 
2004 class Derivative_yyy {
2005 
2006  void *dcpse;
2007 
2008 public:
2009 
2010  template<typename particles_type>
2011  Derivative_yyy(particles_type &parts, unsigned int ord, typename particles_type::stype rCut,
2012  double oversampling_factor = dcpse_oversampling_factor,
2013  support_options opt = support_options::RADIUS) {
2014  Point<particles_type::dims, unsigned int> p;
2015  p.zero();
2016  p.get(0) = 0;
2017  p.get(1) = 3;
2018 
2019  dcpse = new Dcpse<particles_type::dims, particles_type>(parts, p, ord, rCut, oversampling_factor, opt);
2020  }
2021 
2022  template<typename operand_type>
2023 
2024  vector_dist_expression_op<operand_type, Dcpse<operand_type::vtype::dims, typename operand_type::vtype>, VECT_DCPSE>
2025  operator()(operand_type arg) {
2026  typedef Dcpse<operand_type::vtype::dims, typename operand_type::vtype> dcpse_type;
2027 
2028  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2029  }
2030 
2031  template<typename particles_type>
2032  void checkMomenta(particles_type &particles) {
2033  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
2034  dcpse_temp->checkMomenta(particles);
2035 
2036  }
2037 
2038  template<unsigned int prp, typename particles_type>
2039  void DrawKernel(particles_type &particles, int k) {
2040  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
2041  dcpse_temp->template DrawKernel<prp>(particles, k);
2042 
2043  }
2044 
2050  template<typename particles_type>
2051  void update(particles_type &particles) {
2052  auto dcpse_temp = (Dcpse<particles_type::dims, particles_type> *) dcpse;
2053  dcpse_temp->initializeUpdate(particles);
2054 
2055  }
2056 };
2057 
2058 
2059 
2060 //template<typename operand_type1, typename operand_type2/*, typename sfinae=typename std::enable_if<
2061 // std::is_same<typename operand_type1::it_is_a_node,int>::value
2062 // >::type*/ >
2063 //plus<operand_type1,operand_type2> operator+(const operand_type1 & op1, const operand_type2 & op2)
2064 //{
2065 // return plus<operand_type1,operand_type2>(op1,op2);
2066 //}
2067 #endif /* Eigen */
2068 #endif /* DCPSE_OP_HPP_ */
first_or_second
Definition: vector_dist_operators.hpp:93
vector_dist::stype
St stype
space type
Definition: vector_dist.hpp:466
Point
This class implement the point shape in an N-dimensional space.
Definition: Point.hpp:27
vect_dist_key_dx
Grid key for a distributed grid.
Definition: vector_dist_key.hpp:19
vector_dist_expression_op
Unknown operation specialization.
Definition: vector_dist_operators.hpp:187
Point::get
__device__ __host__ const T & get(unsigned int i) const
Get coordinate.
Definition: Point.hpp:172
vector_dist::dims
static const unsigned int dims
dimensions of space
Definition: vector_dist.hpp:469
Point::zero
__device__ __host__ void zero()
Set to zero the point coordinate.
Definition: Point.hpp:284
vect_dist_key_dx::getKey
__device__ __host__ size_t getKey() const
Get the key.
Definition: vector_dist_key.hpp:42
vector_dist
Distributed vector.
Definition: vector_dist.hpp:297
aggregate
aggregate of properties, from a list of object if create a struct that follow the OPENFPM native stru...
Definition: aggregate.hpp:214
cub::init
OutputIteratorT OffsetT ReductionOpT OuputT init
< [in] The initial value of the reduction
Definition: dispatch_reduce.cuh:119
openfpm::vector
Implementation of 1-D std::vector like structure.
Definition: map_vector.hpp:202