OpenFPM  5.2.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 #if defined(__NVCC__)
16 #include "DCPSE/Dcpse.cuh"
17 #endif
18 
19 
20 const double dcpse_oversampling_factor = 1.9;
21 const double rcut_verlet = 3.1;
22 
29 template<typename exp1, typename DCPSE_type>
30 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE> {
32  const exp1 o1;
33 
34  DCPSE_type &dcp;
35 
36 public:
37 
38  typedef std::false_type is_ker;
39 
40  typedef std::false_type NN_type;
41 
42  typedef typename exp1::vtype vtype;
43 
45  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type &dcp)
46  : o1(o1), dcp(dcp) {}
47 
53  inline void init() const {
54  o1.init();
55  }
56 
64  template<typename r_type=typename std::remove_reference<decltype(o1.value(vect_dist_key_dx()))>::type>
65  inline r_type value(const vect_dist_key_dx &key) const {
66  return dcp.computeDifferentialOperator(key, o1);
67  }
68 
69  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
70  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
71  unsigned int comp) const {
72  // for all NN of key
73  for (int j = 0; j < dcp.getNumNN(key); j++) {
74  auto coeff_dc = dcp.getCoeffNN(key, j);
75  auto k = dcp.getIndexNN(key, j);
76 
77  auto k_coeff = coeff_dc * coeff * dcp.getEpsilonInvPrefactor(key);
78  o1.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
79 
80  auto kk_coeff = dcp.getSign() * coeff_dc * coeff * dcp.getEpsilonInvPrefactor(key);
81  o1.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
82  }
83  }
84 
92  vtype &getVector() {
93  return o1.getVector();
94  }
95 
103  const vtype &getVector() const {
104  return o1.getVector();
105  }
106 };
107 
108 template<typename exp1, typename DCPSE_type>
109 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE_V> {
111  const exp1 o1;
112 
113  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
114 
115  static const int dims = DCPSE_type::vtype::dims;
116  typedef typename DCPSE_type::vtype::stype stype;
117 
118 public:
119 
120  typedef std::false_type is_ker;
121 
122  typedef std::false_type NN_type;
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 typename exp1::vtype vtype;
222 
224  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
225  : o1(o1), dcp(dcp) {}
226 
232  inline void init() const {
233  o1.init();
234  }
235 
243  template<typename r_type=VectorS<dims, stype> >
244  inline r_type value(const vect_dist_key_dx &key) const {
245  VectorS<dims, stype> v_grad;
246  v_grad.get(0) = dcp[0].computeDifferentialOperator(key, o1);
247  v_grad.get(1) = -dcp[1].computeDifferentialOperator(key, o1);
248 
249  return v_grad;
250  }
251 
252  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
253  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
254  unsigned int comp) const {
255  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
256  // for all NN of key
257  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
258  auto coeff_dc = dcp[i].getCoeffNN(key, j);
259  auto k = dcp[i].getIndexNN(key, j);
260 
261  auto k_coeff = coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
262  o1.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
263 
264  auto kk_coeff = dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
265  o1.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
266 
267 
268  //cols[p_map. template getProp<0>(k)*Sys_eqs::nvar + comp] += coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
269 
270  //cols[p_map. template getProp<0>(key)*Sys_eqs::nvar + comp] += dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
271  }
272  }
273  }
274 
282  vtype &getVector() {
283  return o1.getVector();
284  }
285 
293  const vtype &getVector() const {
294  return o1.getVector();
295  }
296 
297 };
298 
299 
300 template<>
301 class vector_dist_expression_op<void, void, VECT_COPY_N_TO_N> {
302  mutable int i;
303 
305  openfpm::vector<aggregate<int>> &l1;
306  openfpm::vector<aggregate<int>> &l2;
307 
308 public:
309 
310  typedef std::false_type is_ker;
311 
312  typedef std::false_type NN_type;
313 
314  inline vector_dist_expression_op(openfpm::vector<aggregate<int>> &l1, openfpm::vector<aggregate<int>> &l2)
315  : l1(l1), l2(l2) {}
316 
317  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
318  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
319  unsigned int comp) const {
320  if (l1.template get<0>(i) != key.getKey()) {
321  std::cout << "ERROR" << std::endl;
322  }
323 
324  cols[p_map.template getProp<0>(key) * Sys_eqs::nvar + comp] += coeff;
325  std::cout << "L2: " << l2.template get<0>(i) << std::endl;
326  cols[p_map.template getProp<0>(l2.template get<0>(i)) * Sys_eqs::nvar + comp] -= coeff;
327 
328  i++;
329  }
330 };
331 
332 
333 template<>
334 class vector_dist_expression_op<void, void, VECT_COPY_1_TO_N> {
335  mutable int i = 0;
336 
338  openfpm::vector<aggregate<int>> &l1;
339  int l2_key;
340 
341 public:
342 
343  typedef std::false_type is_ker;
344 
345  typedef std::false_type NN_type;
346 
347  inline vector_dist_expression_op(openfpm::vector<aggregate<int>> &l1, int l2_key)
348  : l1(l1), l2_key(l2_key) {}
349 
350  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
351  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
352  unsigned int comp) const {
353  if (l1.template get<0>(i) != key.getKey()) {
354  std::cout << "ERROR" << std::endl;
355  }
356 
357  cols[p_map.template getProp<0>(key) * Sys_eqs::nvar + comp] += coeff;
358  cols[p_map.template getProp<0>(l2_key) * Sys_eqs::nvar + comp] -= coeff;
359  i++;
360  }
361 };
362 
363 
364 template<typename exp1, typename DCPSE_type>
365 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE_V_SUM> {
367  const exp1 o1;
368 
369  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
370 
371  static const int dims = DCPSE_type::vtype::dims;
372  typedef typename DCPSE_type::vtype::stype stype;
373 
374 public:
375 
376  typedef std::false_type is_ker;
377 
378  typedef std::false_type NN_type;
379 
380  typedef typename exp1::vtype vtype;
381 
382  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
383  : o1(o1), dcp(dcp) {}
384 
385  inline void init() const {
386  o1.init();
387  }
388 
389  template<typename r_type= typename std::remove_reference<decltype(o1.value(vect_dist_key_dx(0)))>::type>
390  inline r_type value(const vect_dist_key_dx &key) const {
391 
392  typename std::remove_reference<decltype(o1.value(key))>::type v_lap;
393  v_lap = 0.0;
394 
395 
396  for (int i = 0; i < dims; i++) {
397  v_lap += dcp[i].computeDifferentialOperator(key, o1);
398  }
399 
400  return v_lap;
401  }
402 
403  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
404  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
405  unsigned int comp) const {
406  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
407  // for all NN of key
408  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
409  auto coeff_dc = dcp[i].getCoeffNN(key, j);
410  auto k = dcp[i].getIndexNN(key, j);
411 
412  auto coeff_k = coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
413  o1.template value_nz<Sys_eqs>(p_map, k, cols, coeff_k, comp);
414 
415  auto coeff_kk = dcp[i].getSign() * coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
416  o1.template value_nz<Sys_eqs>(p_map, key, cols, coeff_kk, comp);
417  }
418  }
419  }
420 
428  vtype &getVector() {
429  return o1.getVector();
430  }
431 
439  const vtype &getVector() const {
440  return o1.getVector();
441  }
442 };
443 
444 
445 template<typename exp1, typename DCPSE_type>
446 class vector_dist_expression_op<exp1, DCPSE_type, VECT_DCPSE_V_DIV> {
448  const exp1 o1;
449 
450  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
451 
452  static const int dims = DCPSE_type::vtype::dims;
453  typedef typename DCPSE_type::vtype::stype stype;
454 
455 public:
456 
457  typedef std::false_type is_ker;
458 
459  typedef std::false_type NN_type;
460 
461  typedef typename exp1::vtype vtype;
462 
463  inline vector_dist_expression_op(const exp1 &o1, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
464  : o1(o1), dcp(dcp) {}
465 
466  inline void init() const {
467  o1.init();
468  }
469 
470  template<typename r_type= typename std::remove_reference<decltype(o1.value(vect_dist_key_dx(0)))>::type::coord_type>
471  inline r_type value(const vect_dist_key_dx &key) const {
472  //typedef typename std::remove_reference<decltype(o1.value(key))>::type::blabla blabla;
473 
474  typename std::remove_reference<decltype(o1.value(key))>::type::coord_type v_div;
475  v_div = 0.0;
476 
477  for (int i = 0; i < dims; i++) {
478  v_div += dcp[i].computeDifferentialOperator(key, o1, i);
479  }
480 
481  return v_div;
482  }
483 
484  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
485  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
486  unsigned int comp) const {
487  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
488  // for all NN of key
489  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
490  auto coeff_dc = dcp[i].getCoeffNN(key, j);
491  auto k = dcp[i].getIndexNN(key, j);
492 
493  auto k_coeff = coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
494  o1.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
495 
496  auto kk_coeff = dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
497  o1.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
498 
499 
500  //cols[p_map. template getProp<0>(k)*Sys_eqs::nvar + comp] += coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
501 
502  //cols[p_map. template getProp<0>(key)*Sys_eqs::nvar + comp] += dcp[i].getSign() * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
503  }
504  }
505  }
506 
514  vtype &getVector() {
515  return o1.getVector();
516  }
517 
525  const vtype &getVector() const {
526  return o1.getVector();
527  }
528 };
529 
530 template<typename exp1, typename exp2_pr>
531 class vector_dist_expression_op<exp1, exp2_pr, VECT_DCPSE_V_DOT> {
532  typedef typename std::tuple_element<1, exp2_pr>::type DCPSE_type;
533  typedef typename std::tuple_element<0, exp2_pr>::type exp2;
534 
536  const exp1 o1;
537  const exp2 o2;
538 
539  DCPSE_type (&dcp)[DCPSE_type::vtype::dims];
540 
541  static const int dims = DCPSE_type::vtype::dims;
542  typedef typename DCPSE_type::vtype::stype stype;
543 
544 public:
545 
546  typedef std::false_type is_ker;
547 
548  typedef std::false_type NN_type;
549 
551  typedef typename first_or_second<has_vtype<exp1>::value, exp1, exp2>::vtype vtype;
552  //typedef typename exp2::vtype vtype;
553 
554 
555  inline vector_dist_expression_op(const exp1 &o1, const exp2 &o2, DCPSE_type (&dcp)[DCPSE_type::vtype::dims])
556  : o1(o1), o2(o2), dcp(dcp) {}
557 
558  inline void init() const {
559  o1.init();
560  o2.init();
561  }
562 
563  //template<typename r_type=VectorS<dims,stype> > inline r_type value(const vect_dist_key_dx & key) const
564  template<typename r_type= typename std::remove_reference<decltype(o2.value(vect_dist_key_dx(0)))>::type>
565  inline r_type value(const vect_dist_key_dx &key) const {
566  //typedef typename std::remove_reference<decltype(o1.value(key))>::type::blabla blabla;
567  typename std::remove_reference<decltype(o2.value(key))>::type adv;
568  adv = 0.0;
569  for (int i = 0; i < dims; i++) {
570  adv += o1.value(key)[i] * dcp[i].computeDifferentialOperator(key, o2);
571 
572  }
573  return adv;
574  }
575 
576 
577  template<typename Sys_eqs, typename pmap_type, typename unordered_map_type, typename coeff_type>
578  inline void value_nz(pmap_type &p_map, const vect_dist_key_dx &key, unordered_map_type &cols, coeff_type &coeff,
579  unsigned int comp) const {
580  for (int i = 0; i < DCPSE_type::vtype::dims; i++) {
581  // for all NN of key
582  for (int j = 0; j < dcp[i].getNumNN(key); j++) {
583  auto coeff_dc = dcp[i].getCoeffNN(key, j);
584  auto k = dcp[i].getIndexNN(key, j);
585 
586  auto k_coeff = o1.value(k) * coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
587  o2.template value_nz<Sys_eqs>(p_map, k, cols, k_coeff, comp);
588 
589  auto kk_coeff =
590  o1.value(key) * dcp[i].getSign() * coeff_dc * coeff * dcp[i].getEpsilonInvPrefactor(key);
591  o2.template value_nz<Sys_eqs>(p_map, key, cols, kk_coeff, comp);
592 
593  //cols[p_map. template getProp<0>(k)*Sys_eqs::nvar + comp] += o1.value(key)[i] * coeff_dc * coeff / dcp[i].getEpsilonPrefactor(key);
594  //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);
595  }
596  }
597  }
598 
606  vtype &getVector() {
607  return first_or_second<has_vtype<exp1>::value, exp1, exp2>::getVector(o1, o2);
608  }
609 
617  const vtype &getVector() const {
618  return first_or_second<has_vtype<exp1>::value, exp1, exp2>::getVector(o1, o2);
619  }
620 
621 };
622 
623  /*
624  template<typename operand_type>
625  class Derivative_x_node
626  {
627  operand_type arg;
628 
629  public:
630  typedef int it_is_a_node;
631  Derivative_x_node(operand_type &arg)
632  :arg(arg)
633  {}
634  };
635  */
636 
637 
649 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
650 class Derivative_x_T {
651 
652  void *dcpse;
653 
654 public:
666  template<typename particles_type>
667  Derivative_x_T(
668  particles_type &parts,
669  VerletList_type& verletList,
670  unsigned int ord,
671  typename particles_type::stype rCut,
672  support_options opt = support_options::RADIUS
673  ) {
674  Point<particles_type::dims, unsigned int> p;
675  p.zero();
676  p.get(0) = 1;
677 
678  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
679  }
680 
693  template<
694  typename vector_type,
695  typename vector_type2,
696  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
697  Derivative_x_T(
698  vector_type &particlesSupport,
699  vector_type2 &particlesDomain,
700  VerletList_type& verletList,
701  unsigned int ord,
702  typename vector_type::stype rCut,
703  support_options opt = support_options::RADIUS
704  ) {
705  Point<vector_type::dims, unsigned int> p;
706  p.zero();
707  p.get(0) = 1;
708 
709  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
710  particlesSupport,
711  particlesDomain,
712  verletList,
713  p,
714  ord,
715  rCut,
716  opt
717  );
718  }
719 
720  template<typename particles_type>
721  void deallocate(particles_type &parts) {
722  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
723  }
724 
725  template<typename operand_type>
726  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
727  operator()(operand_type arg) {
728  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
729 
730  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
731  }
732 
733  template<unsigned int prp, typename particles_type>
734  void DrawKernel(particles_type &particles, int k) {
735  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
736  dcpse_temp->template DrawKernel<prp>(particles, k);
737 
738  }
739 
740  template<unsigned int prp, typename particles_type>
741  void DrawKernelNN(particles_type &particles, int k) {
742  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
743  dcpse_temp->template DrawKernelNN<prp>(particles, k);
744 
745  }
746 
747  template<typename particles_type>
748  void checkMomenta(particles_type &particles) {
749  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
750  dcpse_temp->checkMomenta(particles);
751 
752  }
753 
759  template<typename particles_type>
760  void save(particles_type &particles, const std::string &file) {
761  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
762  dcpse_temp->save(file);
763  }
769  template<typename particles_type>
770  void load(particles_type &particles, const std::string &file) {
771  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
772  dcpse_temp->load(file);
773  }
779  template<typename particles_type>
780  void update(particles_type &particles) {
781  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
782  dcpse_temp->initializeUpdate(particles);
783 
784  }
785 
786 };
787 
799 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
800 class Derivative_y_T {
801 
802  void *dcpse;
803 
804 public:
805 
817  template<typename particles_type>
818  Derivative_y_T(
819  particles_type &parts,
820  VerletList_type& verletList,
821  unsigned int ord,
822  typename particles_type::stype rCut,
823  support_options opt = support_options::RADIUS
824  ) {
825  Point<particles_type::dims, unsigned int> p;
826  p.zero();
827  p.get(1) = 1;
828 
829  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
830  }
831 
844  template<
845  typename vector_type,
846  typename vector_type2,
847  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
848  Derivative_y_T(
849  vector_type &particlesSupport,
850  vector_type2 &particlesDomain,
851  VerletList_type& verletList,
852  unsigned int ord,
853  typename vector_type::stype rCut,
854  support_options opt = support_options::RADIUS
855  ) {
856  Point<vector_type::dims, unsigned int> p;
857  p.zero();
858  p.get(1) = 1;
859 
860  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
861  particlesSupport,
862  particlesDomain,
863  verletList,
864  p,
865  ord,
866  rCut,
867  opt
868  );
869  }
870 
871  template<typename particles_type>
872  void deallocate(particles_type &parts) {
873  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
874  }
875 
876  template<typename operand_type>
877 
878  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
879  operator()(operand_type arg) {
880  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
881 
882  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
883  }
884 
885  template<unsigned int prp, typename particles_type>
886  void DrawKernel(particles_type &particles, int k) {
887  auto dcpse2 = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
888  dcpse2->template DrawKernel<prp>(particles, k);
889 
890  }
891 
892  template<typename particles_type>
893  void checkMomenta(particles_type &particles) {
894  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
895  dcpse_temp->checkMomenta(particles);
896 
897  }
898 
904  template<typename particles_type>
905  void save(particles_type &particles, const std::string &file) {
906  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
907  dcpse_temp->save(file);
908  }
914  template<typename particles_type>
915  void load(particles_type &particles, const std::string &file) {
916  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
917  dcpse_temp->load(file);
918  }
924  template<typename particles_type>
925  void update(particles_type &particles) {
926  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
927  dcpse_temp->initializeUpdate(particles);
928 
929  }
930 };
931 
943 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
944 class Derivative_z_T {
945 
946  void *dcpse;
947 
948 public:
960  template<typename particles_type>
961  Derivative_z_T(
962  particles_type &parts,
963  VerletList_type& verletList,
964  unsigned int ord,
965  typename particles_type::stype rCut,
966  support_options opt = support_options::RADIUS
967  ) {
968  Point<particles_type::dims, unsigned int> p;
969  p.zero();
970  p.get(2) = 1;
971 
972  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
973  }
974 
987  template<
988  typename vector_type,
989  typename vector_type2,
990  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
991  Derivative_z_T(
992  vector_type &particlesSupport,
993  vector_type2 &particlesDomain,
994  VerletList_type& verletList,
995  unsigned int ord,
996  typename vector_type::stype rCut,
997  support_options opt = support_options::RADIUS
998  ) {
999  Point<vector_type::dims, unsigned int> p;
1000  p.zero();
1001  p.get(2) = 1;
1002 
1003  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1004  particlesSupport,
1005  particlesDomain,
1006  verletList,
1007  p,
1008  ord,
1009  rCut,
1010  opt
1011  );
1012  }
1013 
1014  template<typename particles_type>
1015  void deallocate(particles_type &parts) {
1016  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1017  }
1018 
1019  template<typename operand_type>
1020  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
1021  operator()(operand_type arg) {
1022  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
1023 
1024  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1025  }
1026 
1032  template<typename particles_type>
1033  void save(particles_type &particles, const std::string &file) {
1034  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1035  dcpse_temp->save(file);
1036  }
1042  template<typename particles_type>
1043  void load(particles_type &particles, const std::string &file) {
1044  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1045  dcpse_temp->load(file);
1046  }
1052  template<typename particles_type>
1053  void update(particles_type &particles) {
1054  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1055  dcpse_temp->initializeUpdate(particles);
1056 
1057  }
1058 
1059  template<typename particles_type>
1060  void checkMomenta(particles_type &particles) {
1061  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1062  dcpse_temp->checkMomenta(particles);
1063 
1064  }
1065 
1066 };
1067 
1081 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
1082 class Gradient_T {
1083 
1084  void *dcpse;
1085 
1086 public:
1100  template<typename particles_type>
1101  Gradient_T(
1102  particles_type &parts,
1103  VerletList_type& verletList,
1104  unsigned int ord,
1105  typename particles_type::stype rCut,
1106  support_options opt = support_options::RADIUS
1107  ) {
1108  typedef Dcpse_type<particles_type::dims, VerletList_type, particles_type> DCPSE_type;
1109 
1110  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1111 
1112  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1113 
1114  for (int i = 0; i < particles_type::dims; i++) {
1115  Point<particles_type::dims, unsigned int> p;
1116  p.zero();
1117  p.get(i) = 1;
1118 
1119  new(&dcpse_ptr[i]) Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1120  }
1121  }
1122 
1136  template<
1137  typename vector_type,
1138  typename vector_type2,
1139  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
1140  Gradient_T(
1141  vector_type &particlesSupport,
1142  vector_type2 &particlesDomain,
1143  VerletList_type& verletList,
1144  unsigned int ord,
1145  typename vector_type::stype rCut,
1146  support_options opt = support_options::RADIUS
1147  ) {
1148  typedef Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> DCPSE_type;
1149 
1150  dcpse = new unsigned char[vector_type::dims * sizeof(DCPSE_type)];
1151 
1152  Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *dcpse_ptr = (Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *) dcpse;
1153 
1154  for (int i = 0; i < vector_type::dims; i++) {
1155  Point<vector_type::dims, unsigned int> p;
1156  p.zero();
1157  p.get(i) = 1;
1158 
1159  new(&dcpse_ptr[i]) Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1160  particlesSupport,
1161  particlesDomain,
1162  verletList,
1163  p,
1164  ord,
1165  rCut,
1166  opt
1167  );
1168  }
1169  }
1170 
1171  template<typename particles_type>
1172  void deallocate(particles_type &parts) {
1173  for (int i = 0; i < particles_type::dims; i++) {
1174  delete &(((Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse)[i]);
1175  }
1176  }
1177 
1178  template<typename operand_type>
1179  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE_V>
1180  operator()(operand_type arg) {
1181  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
1182 
1183  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V>(arg,
1184  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
1185  }
1186 
1187  template<unsigned int prp, typename particles_type>
1188  void DrawKernel(particles_type &particles, int k) {
1189  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1190 
1191  for (int i = 0; i < particles_type::dims; i++) {
1192  dcpse_ptr[i].template DrawKernel<prp>(particles, i, k);
1193  }
1194 
1195  }
1196 
1202  template<typename particles_type>
1203  void update(particles_type &particles) {
1204  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1205  for (int i = 0; i < particles_type::dims; i++) {
1206  dcpse_ptr[i].initializeUpdate(particles);
1207  }
1208 
1209  }
1210 
1211 
1212 };
1226 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
1227 class Curl2D_T {
1228 
1229  void *dcpse;
1230 public:
1244  template<typename particles_type>
1245  Curl2D_T(
1246  particles_type &parts,
1247  VerletList_type& verletList,
1248  unsigned int ord,
1249  typename particles_type::stype rCut,
1250  support_options opt = support_options::RADIUS
1251  ) {
1252  typedef Dcpse_type<particles_type::dims, VerletList_type, particles_type> DCPSE_type;
1253 
1254  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1255 
1256  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1257  Point<particles_type::dims, unsigned int> p;
1258 
1259  p.zero();
1260  p.get(1) = 1;
1261  new(dcpse_ptr) Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1262 
1263  p.zero();
1264  p.get(0) = 1;
1265  new(dcpse_ptr+1) Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1266 
1267  }
1268 
1283  template<
1284  typename vector_type,
1285  typename vector_type2,
1286  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
1287  Curl2D_T(
1288  vector_type &particlesSupport,
1289  vector_type2 &particlesDomain,
1290  VerletList_type& verletList,
1291  unsigned int ord,
1292  typename vector_type::stype rCut,
1293  support_options opt = support_options::RADIUS
1294  ) {
1295  typedef Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> DCPSE_type;
1296 
1297  dcpse = new unsigned char[vector_type::dims * sizeof(DCPSE_type)];
1298 
1299  Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *dcpse_ptr = (Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *) dcpse;
1300  Point<vector_type::dims, unsigned int> p;
1301 
1302  p.zero();
1303  p.get(1) = 1;
1304  new(dcpse_ptr) Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1305  particlesSupport,
1306  particlesDomain,
1307  verletList,
1308  p,
1309  ord,
1310  rCut,
1311  opt
1312  );
1313 
1314  p.zero();
1315  p.get(0) = 1;
1316  new(dcpse_ptr+1) Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1317  particlesSupport,
1318  particlesDomain,
1319  verletList,
1320  p,
1321  ord,
1322  rCut,
1323  opt
1324  );
1325 
1326  }
1327 
1328  template<typename operand_type>
1329  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE_V_CURL2D>
1330  operator()(operand_type arg) {
1331  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
1332 
1333  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V_CURL2D>(arg,
1334  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
1335  }
1336 };
1350 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
1351 class Laplacian_T {
1352 
1353  void *dcpse;
1354 
1355 public:
1369  template<typename particles_type>
1370  Laplacian_T(
1371  particles_type &parts,
1372  VerletList_type& verletList,
1373  unsigned int ord,
1374  typename particles_type::stype rCut,
1375  support_options opt = support_options::RADIUS
1376  ) {
1377  typedef Dcpse_type<particles_type::dims, VerletList_type, particles_type> DCPSE_type;
1378  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1379 
1380  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1381 
1382  for (int i = 0; i < particles_type::dims; i++) {
1383  Point<particles_type::dims, unsigned int> p;
1384  p.zero();
1385  p.get(i) = 2;
1386 
1387  new(&dcpse_ptr[i]) Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1388  }
1389  }
1390 
1405  template<
1406  typename vector_type,
1407  typename vector_type2,
1408  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
1409  Laplacian_T(
1410  vector_type &particlesSupport,
1411  vector_type2 &particlesDomain,
1412  VerletList_type& verletList,
1413  unsigned int ord,
1414  typename vector_type::stype rCut,
1415  support_options opt = support_options::RADIUS
1416  ) {
1417  typedef Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> DCPSE_type;
1418  dcpse = new unsigned char[vector_type::dims * sizeof(DCPSE_type)];
1419 
1420  Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *dcpse_ptr = (Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *) dcpse;
1421 
1422  for (int i = 0; i < vector_type::dims; i++) {
1423  Point<vector_type::dims, unsigned int> p;
1424  p.zero();
1425  p.get(i) = 2;
1426 
1427  new(&dcpse_ptr[i]) Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1428  particlesSupport,
1429  particlesDomain,
1430  verletList,
1431  p,
1432  ord,
1433  rCut,
1434  opt
1435  );
1436  }
1437  }
1438 
1439  template<typename operand_type>
1440  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE_V_SUM>
1441  operator()(operand_type arg) {
1442  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
1443 
1444  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V_SUM>(arg,
1445  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
1446  }
1447 
1448 
1449  template<typename particles_type>
1450  void checkMomenta(particles_type &particles) {
1451  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1452 
1453  for (int i = 0; i < particles_type::dims; i++) {
1454  dcpse_ptr[i].checkMomenta(particles);
1455  }
1456 
1457  }
1458 
1459  template<unsigned int prp, typename particles_type>
1460  void DrawKernel(particles_type &particles, int k) {
1461  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1462 
1463  for (int i = 0; i < particles_type::dims; i++) {
1464  dcpse_ptr[i].template DrawKernel<prp>(particles, k);
1465  }
1466 
1467  }
1468  template<typename particles_type>
1469  void deallocate(particles_type &parts) {
1470  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1471  }
1477  template<typename particles_type>
1478  void update(particles_type &particles) {
1479  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1480  for (int i = 0; i < particles_type::dims; i++) {
1481  dcpse_ptr[i].initializeUpdate(particles);
1482  }
1483 
1484  }
1485 
1486 
1487 };
1488 
1502 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
1503 class Divergence_T {
1504 
1505  void *dcpse;
1506 
1507 public:
1521  template<typename particles_type>
1522  Divergence_T(
1523  particles_type &parts,
1524  VerletList_type& verletList,
1525  unsigned int ord,
1526  typename particles_type::stype rCut,
1527  support_options opt = support_options::RADIUS
1528  ) {
1529  typedef Dcpse_type<particles_type::dims, VerletList_type, particles_type> DCPSE_type;
1530 
1531  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1532 
1533  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1534 
1535  for (int i = 0; i < particles_type::dims; i++) {
1536  Point<particles_type::dims, unsigned int> p;
1537  p.zero();
1538  p.get(i) = 1;
1539 
1540  new(&dcpse_ptr[i]) Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1541  }
1542  }
1543 
1558  template<
1559  typename vector_type,
1560  typename vector_type2,
1561  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
1562  Divergence_T(
1563  vector_type &particlesSupport,
1564  vector_type2 &particlesDomain,
1565  VerletList_type& verletList,
1566  unsigned int ord,
1567  typename vector_type::stype rCut,
1568  support_options opt = support_options::RADIUS
1569  ) {
1570  typedef Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> DCPSE_type;
1571 
1572  dcpse = new unsigned char[vector_type::dims * sizeof(DCPSE_type)];
1573 
1574  Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *dcpse_ptr = (Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *) dcpse;
1575 
1576  for (int i = 0; i < vector_type::dims; i++) {
1577  Point<vector_type::dims, unsigned int> p;
1578  p.zero();
1579  p.get(i) = 1;
1580 
1581  new(&dcpse_ptr[i]) Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1582  particlesSupport,
1583  particlesDomain,
1584  verletList,
1585  p,
1586  ord,
1587  rCut,
1588  opt
1589  );
1590  }
1591  }
1592 
1593  template<typename operand_type>
1594  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE_V_DIV>
1595  operator()(operand_type arg) {
1596  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
1597 
1598  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE_V_DIV>(arg,
1599  *(dcpse_type(*)[operand_type::vtype::dims]) dcpse);
1600  }
1601 
1607  template<typename particles_type>
1608  void update(particles_type &particles) {
1609  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1610  for (int i = 0; i < particles_type::dims; i++) {
1611  dcpse_ptr[i].initializeUpdate(particles);
1612  }
1613 
1614  }
1615 
1616 };
1617 
1631 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
1632 class Advection_T {
1633 
1634  void *dcpse;
1635 
1636 public:
1650  template<typename particles_type>
1651  Advection_T(
1652  particles_type &parts,
1653  VerletList_type& verletList,
1654  unsigned int ord,
1655  typename particles_type::stype rCut,
1656  support_options opt = support_options::RADIUS
1657  ) {
1658  typedef Dcpse_type<particles_type::dims, VerletList_type, particles_type> DCPSE_type;
1659 
1660  dcpse = new unsigned char[particles_type::dims * sizeof(DCPSE_type)];
1661 
1662  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1663 
1664  for (int i = 0; i < particles_type::dims; i++) {
1665  Point<particles_type::dims, unsigned int> p;
1666  p.zero();
1667  p.get(i) = 1;
1668 
1669  new(&dcpse_ptr[i]) Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1670  }
1671 
1672 
1673  }
1674 
1688  template<
1689  typename vector_type,
1690  typename vector_type2,
1691  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
1692  Advection_T(
1693  vector_type &particlesSupport,
1694  vector_type2 &particlesDomain,
1695  VerletList_type& verletList,
1696  unsigned int ord,
1697  typename vector_type::stype rCut,
1698  support_options opt = support_options::RADIUS
1699  ) {
1700  typedef Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> DCPSE_type;
1701 
1702  dcpse = new unsigned char[vector_type::dims * sizeof(DCPSE_type)];
1703 
1704  Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *dcpse_ptr = (Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2> *) dcpse;
1705 
1706  for (int i = 0; i < vector_type::dims; i++) {
1707  Point<vector_type::dims, unsigned int> p;
1708  p.zero();
1709  p.get(i) = 1;
1710 
1711  new(&dcpse_ptr[i]) Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1712  particlesSupport,
1713  particlesDomain,
1714  verletList,
1715  p,
1716  ord,
1717  rCut,
1718  opt
1719  );
1720  }
1721 
1722 
1723  }
1724 
1725  template<typename operand_type1, typename operand_type2>
1726  vector_dist_expression_op<operand_type1, std::pair<operand_type2, Dcpse_type<operand_type2::vtype::dims, VerletList_type, typename operand_type2::vtype>>, VECT_DCPSE_V_DOT>
1727  operator()(operand_type1 arg, operand_type2 arg2) {
1728  typedef Dcpse_type<operand_type2::vtype::dims, VerletList_type, typename operand_type2::vtype> dcpse_type;
1729 
1730  return vector_dist_expression_op<operand_type1, std::pair<operand_type2, dcpse_type>, VECT_DCPSE_V_DOT>(arg,
1731  arg2,
1732  *(dcpse_type(*)[operand_type2::vtype::dims]) dcpse);
1733  }
1734 
1735  template<typename particles_type>
1736  void checkMomenta(particles_type &particles) {
1737  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1738 
1739  for (int i = 0; i < particles_type::dims; i++) {
1740  dcpse_ptr[i].checkMomenta(particles);
1741  }
1742 
1743  }
1744 
1745  template<unsigned int prp, typename particles_type>
1746  void DrawKernel(particles_type &particles, int k) {
1747  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1748 
1749  for (int i = 0; i < particles_type::dims; i++) {
1750  dcpse_ptr[i].template DrawKernel<prp>(particles, i, k);
1751  }
1752 
1753  }
1754 
1760  template<typename particles_type>
1761  void update(particles_type &particles) {
1762  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1763  for (int i = 0; i < particles_type::dims; i++) {
1764  dcpse_ptr[i].initializeUpdate(particles);
1765  }
1766 
1767  }
1768 
1769 
1770 };
1771 
1783 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
1784 class Derivative_xy_T {
1785 
1786  void *dcpse;
1787 
1788 public:
1800  template<typename particles_type>
1801  Derivative_xy_T(
1802  particles_type &parts,
1803  VerletList_type& verletList,
1804  unsigned int ord,
1805  typename particles_type::stype rCut,
1806  support_options opt = support_options::RADIUS
1807  ) {
1808  Point<particles_type::dims, unsigned int> p;
1809  p.zero();
1810  p.get(0) = 1;
1811  p.get(1) = 1;
1812 
1813  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1814  }
1815 
1828  template<
1829  typename vector_type,
1830  typename vector_type2,
1831  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
1832  Derivative_xy_T(
1833  vector_type &particlesSupport,
1834  vector_type2 &particlesDomain,
1835  VerletList_type& verletList,
1836  unsigned int ord,
1837  typename vector_type::stype rCut,
1838  support_options opt = support_options::RADIUS
1839  ) {
1840  Point<vector_type::dims, unsigned int> p;
1841  p.zero();
1842  p.get(0) = 1;
1843  p.get(1) = 1;
1844 
1845  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1846  particlesSupport,
1847  particlesDomain,
1848  verletList,
1849  p,
1850  ord,
1851  rCut,
1852  opt
1853  );
1854  }
1855 
1856  template<typename particles_type>
1857  void deallocate(particles_type &parts) {
1858  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1859  }
1860 
1861  template<typename operand_type>
1862  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
1863  operator()(operand_type arg) {
1864  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
1865 
1866  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
1867  }
1868 
1869  template<unsigned int prp, typename particles_type>
1870  void DrawKernel(particles_type &particles, int k) {
1871  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1872 
1873  dcpse_ptr[0].template DrawKernel<prp>(particles, k);
1874 
1875  }
1876 
1877  template<typename particles_type>
1878  void checkMomenta(particles_type &particles) {
1879  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1880  dcpse_temp->checkMomenta(particles);
1881 
1882  }
1883 
1889  template<typename particles_type>
1890  void save(particles_type &particles, const std::string &file) {
1891  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1892  dcpse_temp->save(file);
1893  }
1899  template<typename particles_type>
1900  void load(particles_type &particles, const std::string &file) {
1901  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1902  dcpse_temp->load(file);
1903  }
1909  template<typename particles_type>
1910  void update(particles_type &particles) {
1911  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
1912  dcpse_temp->initializeUpdate(particles);
1913 
1914  }
1915 };
1927 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
1928 class Derivative_yz_T {
1929 
1930  void *dcpse;
1931 
1932 public:
1944  template<typename particles_type>
1945  Derivative_yz_T(
1946  particles_type &parts,
1947  VerletList_type& verletList,
1948  unsigned int ord,
1949  typename particles_type::stype rCut,
1950  support_options opt = support_options::RADIUS
1951  ) {
1952  Point<particles_type::dims, unsigned int> p;
1953  p.zero();
1954  p.get(1) = 1;
1955  p.get(2) = 1;
1956 
1957  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
1958  }
1959 
1972  template<
1973  typename vector_type,
1974  typename vector_type2,
1975  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
1976  Derivative_yz_T(
1977  vector_type &particlesSupport,
1978  vector_type2 &particlesDomain,
1979  VerletList_type& verletList,
1980  unsigned int ord,
1981  typename vector_type::stype rCut,
1982  support_options opt = support_options::RADIUS
1983  ) {
1984  Point<vector_type::dims, unsigned int> p;
1985  p.zero();
1986  p.get(1) = 1;
1987  p.get(2) = 1;
1988 
1989  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
1990  particlesSupport,
1991  particlesDomain,
1992  verletList,
1993  p,
1994  ord,
1995  rCut,
1996  opt
1997  );
1998  }
1999 
2000  template<typename particles_type>
2001  void deallocate(particles_type &parts) {
2002  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2003  }
2004 
2005  template<typename operand_type>
2006  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2007  operator()(operand_type arg) {
2008  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2009 
2010  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2011  }
2012 
2013  template<unsigned int prp, typename particles_type>
2014  void DrawKernel(particles_type &particles, int k) {
2015  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2016 
2017  dcpse_ptr[0].template DrawKernel<prp>(particles, k);
2018 
2019  }
2020 
2021  template<typename particles_type>
2022  void checkMomenta(particles_type &particles) {
2023  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2024  dcpse_temp->checkMomenta(particles);
2025 
2026  }
2027 
2033  template<typename particles_type>
2034  void save(particles_type &particles, const std::string &file) {
2035  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2036  dcpse_temp->save(file);
2037  }
2043  template<typename particles_type>
2044  void load(particles_type &particles, const std::string &file) {
2045  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2046  dcpse_temp->load(file);
2047  }
2053  template<typename particles_type>
2054  void update(particles_type &particles) {
2055  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2056  dcpse_temp->initializeUpdate(particles);
2057 
2058  }
2059 };
2071 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2072 class Derivative_xz_T {
2073 
2074  void *dcpse;
2075 
2076 public:
2088  template<typename particles_type>
2089  Derivative_xz_T(
2090  particles_type &parts,
2091  VerletList_type& verletList,
2092  unsigned int ord,
2093  typename particles_type::stype rCut,
2094  support_options opt = support_options::RADIUS
2095  ) {
2096  Point<particles_type::dims, unsigned int> p;
2097  p.zero();
2098  p.get(0) = 1;
2099  p.get(2) = 1;
2100 
2101  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2102  }
2103 
2116  template<
2117  typename vector_type,
2118  typename vector_type2,
2119  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2120  Derivative_xz_T(
2121  vector_type &particlesSupport,
2122  vector_type2 &particlesDomain,
2123  VerletList_type& verletList,
2124  unsigned int ord,
2125  typename vector_type::stype rCut,
2126  support_options opt = support_options::RADIUS
2127  ) {
2128  Point<vector_type::dims, unsigned int> p;
2129  p.zero();
2130  p.get(0) = 1;
2131  p.get(2) = 1;
2132 
2133  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2134  particlesSupport,
2135  particlesDomain,
2136  verletList,
2137  p,
2138  ord,
2139  rCut,
2140  opt
2141  );
2142  }
2143 
2144  template<typename particles_type>
2145  void deallocate(particles_type &parts) {
2146  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2147  }
2148 
2149  template<typename operand_type>
2150  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2151  operator()(operand_type arg) {
2152  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2153 
2154  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2155  }
2156 
2157  template<unsigned int prp, typename particles_type>
2158  void DrawKernel(particles_type &particles, int k) {
2159  Dcpse_type<particles_type::dims, VerletList_type, particles_type> *dcpse_ptr = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2160 
2161  dcpse_ptr[0].template DrawKernel<prp>(particles, k);
2162 
2163  }
2164 
2165  template<typename particles_type>
2166  void checkMomenta(particles_type &particles) {
2167  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2168  dcpse_temp->checkMomenta(particles);
2169 
2170  }
2171 
2177  template<typename particles_type>
2178  void save(particles_type &particles, const std::string &file) {
2179  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2180  dcpse_temp->save(file);
2181  }
2187  template<typename particles_type>
2188  void load(particles_type &particles, const std::string &file) {
2189  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2190  dcpse_temp->load(file);
2191  }
2197  template<typename particles_type>
2198  void update(particles_type &particles) {
2199  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2200  dcpse_temp->initializeUpdate(particles);
2201 
2202  }
2203 };
2204 
2216 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2217 class Derivative_xx_T {
2218 
2219  void *dcpse;
2220 
2221 public:
2233  template<typename particles_type>
2234  Derivative_xx_T(
2235  particles_type &parts,
2236  VerletList_type& verletList,
2237  unsigned int ord,
2238  typename particles_type::stype rCut,
2239  support_options opt = support_options::RADIUS
2240  ) {
2241  Point<particles_type::dims, unsigned int> p;
2242  p.zero();
2243  p.get(0) = 2;
2244  p.get(1) = 0;
2245 
2246  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2247  }
2248 
2261  template<
2262  typename vector_type,
2263  typename vector_type2,
2264  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2265  Derivative_xx_T(
2266  vector_type &particlesSupport,
2267  vector_type2 &particlesDomain,
2268  VerletList_type& verletList,
2269  unsigned int ord,
2270  typename vector_type::stype rCut,
2271  support_options opt = support_options::RADIUS
2272  ) {
2273  Point<vector_type::dims, unsigned int> p;
2274  p.zero();
2275  p.get(0) = 2;
2276  p.get(1) = 0;
2277 
2278  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2279  particlesSupport,
2280  particlesDomain,
2281  verletList,
2282  p,
2283  ord,
2284  rCut,
2285  opt
2286  );
2287  }
2288 
2289  template<typename particles_type>
2290  void deallocate(particles_type &parts) {
2291  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2292  }
2293 
2294  template<typename operand_type>
2295  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2296  operator()(operand_type arg) {
2297  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2298 
2299  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2300  }
2301 
2302  template<typename particles_type>
2303  void checkMomenta(particles_type &particles) {
2304  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2305  dcpse_temp->checkMomenta(particles);
2306 
2307  }
2308 
2309  template<unsigned int prp, typename particles_type>
2310  void DrawKernel(particles_type &particles, int k) {
2311  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2312  dcpse_temp->template DrawKernel<prp>(particles, k);
2313 
2314  }
2315 
2321  template<typename particles_type>
2322  void save(particles_type &particles, const std::string &file) {
2323  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2324  dcpse_temp->save(file);
2325  }
2331  template<typename particles_type>
2332  void load(particles_type &particles, const std::string &file) {
2333  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2334  dcpse_temp->load(file);
2335  }
2341  template<typename particles_type>
2342  void update(particles_type &particles) {
2343  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2344  dcpse_temp->initializeUpdate(particles);
2345 
2346  }
2347 };
2348 
2360 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2361 class Derivative_yy_T {
2362 
2363  void *dcpse;
2364 
2365 public:
2377  template<typename particles_type>
2378  Derivative_yy_T(
2379  particles_type &parts,
2380  VerletList_type& verletList,
2381  unsigned int ord,
2382  typename particles_type::stype rCut,
2383  support_options opt = support_options::RADIUS
2384  ) {
2385  Point<particles_type::dims, unsigned int> p;
2386  p.zero();
2387  p.get(0) = 0;
2388  p.get(1) = 2;
2389 
2390  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2391  }
2392 
2406  template<
2407  typename vector_type,
2408  typename vector_type2,
2409  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2410  Derivative_yy_T(
2411  vector_type &particlesSupport,
2412  vector_type2 &particlesDomain,
2413  VerletList_type& verletList,
2414  unsigned int ord,
2415  typename vector_type::stype rCut,
2416  support_options opt = support_options::RADIUS
2417  ) {
2418  Point<vector_type::dims, unsigned int> p;
2419  p.zero();
2420  p.get(0) = 0;
2421  p.get(1) = 2;
2422 
2423  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2424  particlesSupport,
2425  particlesDomain,
2426  verletList,
2427  p,
2428  ord,
2429  rCut,
2430  opt
2431  );
2432  }
2433 
2434  template<typename particles_type>
2435  void deallocate(particles_type &parts) {
2436  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2437  }
2438 
2439  template<typename operand_type>
2440  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2441  operator()(operand_type arg) {
2442  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2443 
2444  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2445  }
2446 
2447  template<typename particles_type>
2448  void checkMomenta(particles_type &particles) {
2449  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2450  dcpse_temp->checkMomenta(particles);
2451 
2452  }
2453 
2454  template<unsigned int prp, typename particles_type>
2455  void DrawKernel(particles_type &particles, int k) {
2456  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2457  dcpse_temp->template DrawKernel<prp>(particles, k);
2458 
2459  }
2460 
2466  template<typename particles_type>
2467  void save(particles_type &particles, const std::string &file) {
2468  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2469  dcpse_temp->save(file);
2470  }
2476  template<typename particles_type>
2477  void load(particles_type &particles, const std::string &file) {
2478  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2479  dcpse_temp->load(file);
2480  }
2486  template<typename particles_type>
2487  void update(particles_type &particles) {
2488  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2489  dcpse_temp->initializeUpdate(particles);
2490 
2491  }
2492 };
2504 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2505 class Derivative_zz_T {
2506 
2507  void *dcpse;
2508 
2509 public:
2521  template<typename particles_type>
2522  Derivative_zz_T(
2523  particles_type &parts,
2524  VerletList_type& verletList,
2525  unsigned int ord,
2526  typename particles_type::stype rCut,
2527  support_options opt = support_options::RADIUS
2528  ) {
2529  Point<particles_type::dims, unsigned int> p;
2530  p.zero();
2531  p.get(2) = 2;
2532 
2533  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2534  }
2535 
2549  template<
2550  typename vector_type,
2551  typename vector_type2,
2552  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2553  Derivative_zz_T(
2554  vector_type &particlesSupport,
2555  vector_type2 &particlesDomain,
2556  VerletList_type& verletList,
2557  unsigned int ord,
2558  typename vector_type::stype rCut,
2559  support_options opt = support_options::RADIUS
2560  ) {
2561  Point<vector_type::dims, unsigned int> p;
2562  p.zero();
2563  p.get(2) = 2;
2564 
2565  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2566  particlesSupport,
2567  particlesDomain,
2568  verletList,
2569  p,
2570  ord,
2571  rCut,
2572  opt
2573  );
2574  }
2575 
2576  template<typename particles_type>
2577  void deallocate(particles_type &parts) {
2578  delete (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2579  }
2580 
2581  template<typename operand_type>
2582  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2583  operator()(operand_type arg) {
2584  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2585 
2586  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2587  }
2588 
2589  template<typename particles_type>
2590  void checkMomenta(particles_type &particles) {
2591  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2592  dcpse_temp->checkMomenta(particles);
2593 
2594  }
2595 
2596  template<unsigned int prp, typename particles_type>
2597  void DrawKernel(particles_type &particles, int k) {
2598  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2599  dcpse_temp->template DrawKernel<prp>(particles, k);
2600 
2601  }
2602 
2608  template<typename particles_type>
2609  void save(particles_type &particles, const std::string &file) {
2610  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2611  dcpse_temp->save(file);
2612  }
2618  template<typename particles_type>
2619  void load(particles_type &particles, const std::string &file) {
2620  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2621  dcpse_temp->load(file);
2622  }
2628  template<typename particles_type>
2629  void update(particles_type &particles) {
2630  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2631  dcpse_temp->initializeUpdate(particles);
2632 
2633  }
2634 };
2635 
2636 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2637 class Derivative_xxx_T {
2638 
2639  void *dcpse;
2640 
2641 public:
2642 
2643  template<typename particles_type>
2644  Derivative_xxx_T(
2645  particles_type &parts,
2646  VerletList_type& verletList,
2647  unsigned int ord,
2648  typename particles_type::stype rCut,
2649  support_options opt = support_options::RADIUS
2650  ) {
2651  Point<particles_type::dims, unsigned int> p;
2652  p.zero();
2653  p.get(0) = 3;
2654  p.get(1) = 0;
2655 
2656  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2657  }
2658 
2659  template<
2660  typename vector_type,
2661  typename vector_type2,
2662  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2663  Derivative_xxx_T(
2664  vector_type &particlesSupport,
2665  vector_type2 &particlesDomain,
2666  VerletList_type& verletList,
2667  unsigned int ord,
2668  typename vector_type::stype rCut,
2669  support_options opt = support_options::RADIUS
2670  ) {
2671  Point<vector_type::dims, unsigned int> p;
2672  p.zero();
2673  p.get(0) = 3;
2674  p.get(1) = 0;
2675 
2676  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2677  particlesSupport,
2678  particlesDomain,
2679  verletList,
2680  p,
2681  ord,
2682  rCut,
2683  opt
2684  );
2685  }
2686 
2687  template<typename operand_type>
2688 
2689  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2690  operator()(operand_type arg) {
2691  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2692 
2693  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2694  }
2695 
2696  template<typename particles_type>
2697  void checkMomenta(particles_type &particles) {
2698  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2699  dcpse_temp->checkMomenta(particles);
2700 
2701  }
2702 
2703  template<unsigned int prp, typename particles_type>
2704  void DrawKernel(particles_type &particles, int k) {
2705  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2706  dcpse_temp->template DrawKernel<prp>(particles, k);
2707 
2708  }
2709 
2715  template<typename particles_type>
2716  void save(particles_type &particles, const std::string &file) {
2717  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2718  dcpse_temp->save(file);
2719  }
2725  template<typename particles_type>
2726  void load(particles_type &particles, const std::string &file) {
2727  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2728  dcpse_temp->load(file);
2729  }
2735  template<typename particles_type>
2736  void update(particles_type &particles) {
2737  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2738  dcpse_temp->initializeUpdate(particles);
2739 
2740  }
2741 };
2742 
2743 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2744 class Derivative_xxy_T {
2745 
2746  void *dcpse;
2747 
2748 public:
2749 
2750  template<typename particles_type>
2751  Derivative_xxy_T(
2752  particles_type &parts,
2753  VerletList_type& verletList,
2754  unsigned int ord,
2755  typename particles_type::stype rCut,
2756  support_options opt = support_options::RADIUS
2757  ) {
2758  Point<particles_type::dims, unsigned int> p;
2759  p.zero();
2760  p.get(0) = 2;
2761  p.get(1) = 1;
2762 
2763  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2764  }
2765 
2766  template<
2767  typename vector_type,
2768  typename vector_type2,
2769  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2770  Derivative_xxy_T(
2771  vector_type &particlesSupport,
2772  vector_type2 &particlesDomain,
2773  VerletList_type& verletList,
2774  unsigned int ord,
2775  typename vector_type::stype rCut,
2776  support_options opt = support_options::RADIUS
2777  ) {
2778  Point<vector_type::dims, unsigned int> p;
2779  p.zero();
2780  p.get(0) = 2;
2781  p.get(1) = 1;
2782 
2783  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2784  particlesSupport,
2785  particlesDomain,
2786  verletList,
2787  p,
2788  ord,
2789  rCut,
2790  opt
2791  );
2792  }
2793 
2794  template<typename operand_type>
2795 
2796  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2797  operator()(operand_type arg) {
2798  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2799 
2800  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2801  }
2802 
2803  template<typename particles_type>
2804  void checkMomenta(particles_type &particles) {
2805  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2806  dcpse_temp->checkMomenta(particles);
2807 
2808  }
2809 
2810  template<unsigned int prp, typename particles_type>
2811  void DrawKernel(particles_type &particles, int k) {
2812  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2813  dcpse_temp->template DrawKernel<prp>(particles, k);
2814 
2815  }
2816 
2822  template<typename particles_type>
2823  void save(particles_type &particles, const std::string &file) {
2824  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2825  dcpse_temp->save(file);
2826  }
2832  template<typename particles_type>
2833  void load(particles_type &particles, const std::string &file) {
2834  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2835  dcpse_temp->load(file);
2836  }
2842  template<typename particles_type>
2843  void update(particles_type &particles) {
2844  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2845  dcpse_temp->initializeUpdate(particles);
2846 
2847  }
2848 };
2849 
2850 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2851 class Derivative_yyx_T {
2852 
2853  void *dcpse;
2854 
2855 public:
2856 
2857  template<typename particles_type>
2858  Derivative_yyx_T(
2859  particles_type &parts,
2860  VerletList_type& verletList,
2861  unsigned int ord,
2862  typename particles_type::stype rCut,
2863  support_options opt = support_options::RADIUS
2864  ) {
2865  Point<particles_type::dims, unsigned int> p;
2866  p.zero();
2867  p.get(0) = 1;
2868  p.get(1) = 2;
2869 
2870  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2871  }
2872 
2873  template<
2874  typename vector_type,
2875  typename vector_type2,
2876  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2877  Derivative_yyx_T(
2878  vector_type &particlesSupport,
2879  vector_type2 &particlesDomain,
2880  VerletList_type& verletList,
2881  unsigned int ord,
2882  typename vector_type::stype rCut,
2883  support_options opt = support_options::RADIUS
2884  ) {
2885  Point<vector_type::dims, unsigned int> p;
2886  p.zero();
2887  p.get(0) = 1;
2888  p.get(1) = 2;
2889 
2890  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2891  particlesSupport,
2892  particlesDomain,
2893  verletList,
2894  p,
2895  ord,
2896  rCut,
2897  opt
2898  );
2899  }
2900 
2901  template<typename operand_type>
2902 
2903  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
2904  operator()(operand_type arg) {
2905  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
2906 
2907  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
2908  }
2909 
2910  template<typename particles_type>
2911  void checkMomenta(particles_type &particles) {
2912  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2913  dcpse_temp->checkMomenta(particles);
2914 
2915  }
2916 
2917  template<unsigned int prp, typename particles_type>
2918  void DrawKernel(particles_type &particles, int k) {
2919  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2920  dcpse_temp->template DrawKernel<prp>(particles, k);
2921 
2922  }
2923 
2929  template<typename particles_type>
2930  void save(particles_type &particles, const std::string &file) {
2931  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2932  dcpse_temp->save(file);
2933  }
2939  template<typename particles_type>
2940  void load(particles_type &particles, const std::string &file) {
2941  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2942  dcpse_temp->load(file);
2943  }
2949  template<typename particles_type>
2950  void update(particles_type &particles) {
2951  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
2952  dcpse_temp->initializeUpdate(particles);
2953 
2954  }
2955 };
2956 
2957 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
2958 class Derivative_yyy_T {
2959 
2960  void *dcpse;
2961 
2962 public:
2963 
2964  template<typename particles_type>
2965  Derivative_yyy_T(
2966  particles_type &parts,
2967  VerletList_type& verletList,
2968  unsigned int ord,
2969  typename particles_type::stype rCut,
2970  support_options opt = support_options::RADIUS
2971  ) {
2972  Point<particles_type::dims, unsigned int> p;
2973  p.zero();
2974  p.get(0) = 0;
2975  p.get(1) = 3;
2976 
2977  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
2978  }
2979 
2980  template<
2981  typename vector_type,
2982  typename vector_type2,
2983  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
2984  Derivative_yyy_T(
2985  vector_type &particlesSupport,
2986  vector_type2 &particlesDomain,
2987  VerletList_type& verletList,
2988  unsigned int ord,
2989  typename vector_type::stype rCut,
2990  support_options opt = support_options::RADIUS
2991  ) {
2992  Point<vector_type::dims, unsigned int> p;
2993  p.zero();
2994  p.get(0) = 0;
2995  p.get(1) = 3;
2996 
2997  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
2998  particlesSupport,
2999  particlesDomain,
3000  verletList,
3001  p,
3002  ord,
3003  rCut,
3004  opt
3005  );
3006  }
3007 
3008  template<typename operand_type>
3009 
3010  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
3011  operator()(operand_type arg) {
3012  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
3013 
3014  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
3015  }
3016 
3017  template<typename particles_type>
3018  void checkMomenta(particles_type &particles) {
3019  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3020  dcpse_temp->checkMomenta(particles);
3021 
3022  }
3023 
3024  template<unsigned int prp, typename particles_type>
3025  void DrawKernel(particles_type &particles, int k) {
3026  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3027  dcpse_temp->template DrawKernel<prp>(particles, k);
3028 
3029  }
3030 
3036  template<typename particles_type>
3037  void save(particles_type &particles, const std::string &file) {
3038  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3039  dcpse_temp->save(file);
3040  }
3046  template<typename particles_type>
3047  void load(particles_type &particles, const std::string &file) {
3048  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3049  dcpse_temp->load(file);
3050  }
3056  template<typename particles_type>
3057  void update(particles_type &particles) {
3058  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3059  dcpse_temp->initializeUpdate(particles);
3060 
3061  }
3062 };
3063 
3064 
3065 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
3066 class Derivative_xxxx_T {
3067 
3068  void *dcpse;
3069 
3070 public:
3071 
3072  template<typename particles_type>
3073  Derivative_xxxx_T(
3074  particles_type &parts,
3075  VerletList_type& verletList,
3076  unsigned int ord,
3077  typename particles_type::stype rCut,
3078  support_options opt = support_options::RADIUS
3079  ) {
3080  Point<particles_type::dims, unsigned int> p;
3081  p.zero();
3082  p.get(0) = 4;
3083  p.get(1) = 0;
3084 
3085  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
3086  }
3087 
3088  template<
3089  typename vector_type,
3090  typename vector_type2,
3091  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
3092  Derivative_xxxx_T(
3093  vector_type &particlesSupport,
3094  vector_type2 &particlesDomain,
3095  VerletList_type& verletList,
3096  unsigned int ord,
3097  typename vector_type::stype rCut,
3098  support_options opt = support_options::RADIUS
3099  ) {
3100  Point<vector_type::dims, unsigned int> p;
3101  p.zero();
3102  p.get(0) = 4;
3103  p.get(1) = 0;
3104 
3105  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
3106  particlesSupport,
3107  particlesDomain,
3108  verletList,
3109  p,
3110  ord,
3111  rCut,
3112  opt
3113  );
3114  }
3115 
3116  template<typename operand_type>
3117  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
3118  operator()(operand_type arg) {
3119  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
3120 
3121  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
3122  }
3123 
3124  template<typename particles_type>
3125  void checkMomenta(particles_type &particles) {
3126  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3127  dcpse_temp->checkMomenta(particles);
3128 
3129  }
3130 
3131  template<unsigned int prp, typename particles_type>
3132  void DrawKernel(particles_type &particles, int k) {
3133  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3134  dcpse_temp->template DrawKernel<prp>(particles, k);
3135 
3136  }
3137 
3143  template<typename particles_type>
3144  void save(particles_type &particles, const std::string &file) {
3145  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3146  dcpse_temp->save(file);
3147  }
3153  template<typename particles_type>
3154  void load(particles_type &particles, const std::string &file) {
3155  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3156  dcpse_temp->load(file);
3157  }
3163  template<typename particles_type>
3164  void update(particles_type &particles) {
3165  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3166  dcpse_temp->initializeUpdate(particles);
3167 
3168  }
3169 };
3170 
3171 
3172 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
3173 class Derivative_yyyy_T {
3174 
3175  void *dcpse;
3176 
3177 public:
3178 
3179  template<typename particles_type>
3180  Derivative_yyyy_T(
3181  particles_type &parts,
3182  VerletList_type& verletList,
3183  unsigned int ord,
3184  typename particles_type::stype rCut,
3185  support_options opt = support_options::RADIUS
3186  ) {
3187  Point<particles_type::dims, unsigned int> p;
3188  p.zero();
3189  p.get(0) = 0;
3190  p.get(1) = 4;
3191 
3192  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
3193  }
3194 
3195  template<
3196  typename vector_type,
3197  typename vector_type2,
3198  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
3199  Derivative_yyyy_T(
3200  vector_type &particlesSupport,
3201  vector_type2 &particlesDomain,
3202  VerletList_type& verletList,
3203  unsigned int ord,
3204  typename vector_type::stype rCut,
3205  support_options opt = support_options::RADIUS
3206  ) {
3207  Point<vector_type::dims, unsigned int> p;
3208  p.zero();
3209  p.get(0) = 0;
3210  p.get(1) = 4;
3211 
3212  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
3213  particlesSupport,
3214  particlesDomain,
3215  verletList,
3216  p,
3217  ord,
3218  rCut,
3219  opt
3220  );
3221  }
3222 
3223  template<typename operand_type>
3224  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
3225  operator()(operand_type arg) {
3226  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
3227 
3228  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
3229  }
3230 
3231  template<typename particles_type>
3232  void checkMomenta(particles_type &particles) {
3233  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3234  dcpse_temp->checkMomenta(particles);
3235 
3236  }
3237 
3238  template<unsigned int prp, typename particles_type>
3239  void DrawKernel(particles_type &particles, int k) {
3240  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3241  dcpse_temp->template DrawKernel<prp>(particles, k);
3242 
3243  }
3244 
3250  template<typename particles_type>
3251  void save(particles_type &particles, const std::string &file) {
3252  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3253  dcpse_temp->save(file);
3254  }
3260  template<typename particles_type>
3261  void load(particles_type &particles, const std::string &file) {
3262  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3263  dcpse_temp->load(file);
3264  }
3270  template<typename particles_type>
3271  void update(particles_type &particles) {
3272  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3273  dcpse_temp->initializeUpdate(particles);
3274 
3275  }
3276 };
3277 
3278 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
3279 class Derivative_xxyy_T {
3280 
3281  void *dcpse;
3282 
3283 public:
3284 
3285  template<typename particles_type>
3286  Derivative_xxyy_T(
3287  particles_type &parts,
3288  VerletList_type& verletList,
3289  unsigned int ord,
3290  typename particles_type::stype rCut,
3291  support_options opt = support_options::RADIUS
3292  ) {
3293  Point<particles_type::dims, unsigned int> p;
3294  p.zero();
3295  p.get(0) = 2;
3296  p.get(1) = 2;
3297 
3298  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
3299  }
3300 
3301  template<
3302  typename vector_type,
3303  typename vector_type2,
3304  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
3305  Derivative_xxyy_T(
3306  vector_type &particlesSupport,
3307  vector_type2 &particlesDomain,
3308  VerletList_type& verletList,
3309  unsigned int ord,
3310  typename vector_type::stype rCut,
3311  support_options opt = support_options::RADIUS
3312  ) {
3313  Point<vector_type::dims, unsigned int> p;
3314  p.zero();
3315  p.get(0) = 2;
3316  p.get(1) = 2;
3317 
3318  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
3319  particlesSupport,
3320  particlesDomain,
3321  verletList,
3322  p,
3323  ord,
3324  rCut,
3325  opt
3326  );
3327  }
3328 
3329  template<typename operand_type>
3330 
3331  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
3332  operator()(operand_type arg) {
3333  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
3334 
3335  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
3336  }
3337 
3338  template<typename particles_type>
3339  void checkMomenta(particles_type &particles) {
3340  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3341  dcpse_temp->checkMomenta(particles);
3342 
3343  }
3344 
3345  template<unsigned int prp, typename particles_type>
3346  void DrawKernel(particles_type &particles, int k) {
3347  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3348  dcpse_temp->template DrawKernel<prp>(particles, k);
3349 
3350  }
3351 
3357  template<typename particles_type>
3358  void save(particles_type &particles, const std::string &file) {
3359  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3360  dcpse_temp->save(file);
3361  }
3367  template<typename particles_type>
3368  void load(particles_type &particles, const std::string &file) {
3369  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3370  dcpse_temp->load(file);
3371  }
3377  template<typename particles_type>
3378  void update(particles_type &particles) {
3379  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3380  dcpse_temp->initializeUpdate(particles);
3381 
3382  }
3383 };
3384 
3385 
3386 template<typename VerletList_type, template<unsigned int, typename, typename...> class Dcpse_type = Dcpse>
3387 class Derivative_G_T {
3388 
3389  void *dcpse;
3390 
3391 public:
3392 
3393  template<typename particles_type>
3394  Derivative_G_T(
3395  particles_type &parts,
3396  VerletList_type& verletList,
3397  unsigned int ord,
3398  typename particles_type::stype rCut,
3399  const Point<particles_type::dims, unsigned int> &p,
3400  support_options opt = support_options::RADIUS
3401  ) {
3402  dcpse = new Dcpse_type<particles_type::dims, VerletList_type, particles_type>(parts, verletList, p, ord, rCut, opt);
3403  }
3404 
3405  template<
3406  typename vector_type,
3407  typename vector_type2,
3408  std::enable_if_t<std::is_same<int, typename vector_type2::yes_i_am_vector_subset>::value>* = nullptr>
3409  Derivative_G_T(
3410  vector_type &particlesSupport,
3411  vector_type2 &particlesDomain,
3412  VerletList_type& verletList,
3413  unsigned int ord,
3414  typename vector_type::stype rCut,
3415  const Point<vector_type::dims, unsigned int> &p,
3416  support_options opt = support_options::RADIUS
3417  ) {
3418  dcpse = new Dcpse_type<vector_type::dims, VerletList_type, vector_type, vector_type2>(
3419  particlesSupport,
3420  particlesDomain,
3421  verletList,
3422  p,
3423  ord,
3424  rCut,
3425  opt
3426  );
3427  }
3428 
3429  template<typename operand_type>
3430  vector_dist_expression_op<operand_type, Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype>, VECT_DCPSE>
3431  operator()(operand_type arg) {
3432  typedef Dcpse_type<operand_type::vtype::dims, VerletList_type, typename operand_type::vtype> dcpse_type;
3433 
3434  return vector_dist_expression_op<operand_type, dcpse_type, VECT_DCPSE>(arg, *(dcpse_type *) dcpse);
3435  }
3436 
3437  template<typename particles_type>
3438  void checkMomenta(particles_type &particles) {
3439  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3440  dcpse_temp->checkMomenta(particles);
3441 
3442  }
3443 
3444  template<unsigned int prp, typename particles_type>
3445  void DrawKernel(particles_type &particles, int k) {
3446  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3447  dcpse_temp->template DrawKernel<prp>(particles, k);
3448 
3449  }
3450 
3456  template<typename particles_type>
3457  void save(particles_type &particles, const std::string &file) {
3458  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3459  dcpse_temp->save(file);
3460  }
3466  template<typename particles_type>
3467  void load(particles_type &particles, const std::string &file) {
3468  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3469  dcpse_temp->load(file);
3470  }
3476  template<typename particles_type>
3477  void update(particles_type &particles) {
3478  auto dcpse_temp = (Dcpse_type<particles_type::dims, VerletList_type, particles_type> *) dcpse;
3479  dcpse_temp->initializeUpdate(particles);
3480 
3481  }
3482 };
3483 
3484 //typedef PPInterpolation_T<Dcpse> PPInterpolation;
3485 template <typename VerletList_type> using Derivative_x = Derivative_x_T<VerletList_type, Dcpse>;
3486 template <typename VerletList_type> using Derivative_x = Derivative_x_T<VerletList_type, Dcpse>;
3487 template <typename VerletList_type> using Derivative_y = Derivative_y_T<VerletList_type, Dcpse>;
3488 template <typename VerletList_type> using Derivative_z = Derivative_z_T<VerletList_type, Dcpse>;
3489 template <typename VerletList_type> using Gradient = Gradient_T<VerletList_type, Dcpse>;
3490 template <typename VerletList_type> using Curl2D = Curl2D_T<VerletList_type, Dcpse>;
3491 template <typename VerletList_type> using Laplacian = Laplacian_T<VerletList_type, Dcpse>;
3492 template <typename VerletList_type> using Divergence = Divergence_T<VerletList_type, Dcpse>;
3493 template <typename VerletList_type> using Advection = Advection_T<VerletList_type, Dcpse>;
3494 template <typename VerletList_type> using Derivative_xy = Derivative_xy_T<VerletList_type, Dcpse>;
3495 template <typename VerletList_type> using Derivative_yz = Derivative_yz_T<VerletList_type, Dcpse>;
3496 template <typename VerletList_type> using Derivative_xz = Derivative_xz_T<VerletList_type, Dcpse>;
3497 template <typename VerletList_type> using Derivative_xx = Derivative_xx_T<VerletList_type, Dcpse>;
3498 template <typename VerletList_type> using Derivative_yy = Derivative_yy_T<VerletList_type, Dcpse>;
3499 template <typename VerletList_type> using Derivative_zz = Derivative_zz_T<VerletList_type, Dcpse>;
3500 template <typename VerletList_type> using Derivative_xxx = Derivative_xxx_T<VerletList_type, Dcpse>;
3501 template <typename VerletList_type> using Derivative_xxy = Derivative_xxy_T<VerletList_type, Dcpse>;
3502 template <typename VerletList_type> using Derivative_yyx = Derivative_yyx_T<VerletList_type, Dcpse>;
3503 template <typename VerletList_type> using Derivative_yyy = Derivative_yyy_T<VerletList_type, Dcpse>;
3504 template <typename VerletList_type> using Derivative_xxxx = Derivative_xxxx_T<VerletList_type, Dcpse>;
3505 template <typename VerletList_type> using Derivative_yyyy = Derivative_yyyy_T<VerletList_type, Dcpse>;
3506 template <typename VerletList_type> using Derivative_xxyy = Derivative_xxyy_T<VerletList_type, Dcpse>;
3507 template <typename VerletList_type> using Derivative_G = Derivative_G_T<VerletList_type, Dcpse>;
3508 
3509 
3510 #if defined(__NVCC__)
3511 template <typename VerletList_type> using Derivative_x_gpu = Derivative_x_T<VerletList_type, Dcpse_gpu>;
3512 template <typename VerletList_type> using Derivative_y_gpu = Derivative_y_T<VerletList_type, Dcpse_gpu>;
3513 template <typename VerletList_type> using Derivative_z_gpu = Derivative_z_T<VerletList_type, Dcpse_gpu>;
3514 template <typename VerletList_type> using Gradient_gpu = Gradient_T<VerletList_type, Dcpse_gpu>;
3515 template <typename VerletList_type> using Curl2D_gpu = Curl2D_T<VerletList_type, Dcpse_gpu>;
3516 template <typename VerletList_type> using Laplacian_gpu = Laplacian_T<VerletList_type, Dcpse_gpu>;
3517 template <typename VerletList_type> using Divergence_gpu = Divergence_T<VerletList_type, Dcpse_gpu>;
3518 template <typename VerletList_type> using Advection_gpu = Advection_T<VerletList_type, Dcpse_gpu>;
3519 template <typename VerletList_type> using Derivative_xy_gpu = Derivative_xy_T<VerletList_type, Dcpse_gpu>;
3520 template <typename VerletList_type> using Derivative_yz_gpu = Derivative_yz_T<VerletList_type, Dcpse_gpu>;
3521 template <typename VerletList_type> using Derivative_xz_gpu = Derivative_xz_T<VerletList_type, Dcpse_gpu>;
3522 template <typename VerletList_type> using Derivative_xx_gpu = Derivative_xx_T<VerletList_type, Dcpse_gpu>;
3523 template <typename VerletList_type> using Derivative_yy_gpu = Derivative_yy_T<VerletList_type, Dcpse_gpu>;
3524 template <typename VerletList_type> using Derivative_zz_gpu = Derivative_zz_T<VerletList_type, Dcpse_gpu>;
3525 template <typename VerletList_type> using Derivative_xxx_gpu = Derivative_xxx_T<VerletList_type, Dcpse_gpu>;
3526 template <typename VerletList_type> using Derivative_xxy_gpu = Derivative_xxy_T<VerletList_type, Dcpse_gpu>;
3527 template <typename VerletList_type> using Derivative_yyx_gpu = Derivative_yyx_T<VerletList_type, Dcpse_gpu>;
3528 template <typename VerletList_type> using Derivative_yyy_gpu = Derivative_yyy_T<VerletList_type, Dcpse_gpu>;
3529 template <typename VerletList_type> using Derivative_G_gpu = Derivative_G_T<VerletList_type, Dcpse_gpu>;
3530 #endif
3531 
3532 #endif /*EIGEN */
3533 #endif /* DCPSE_OP_HPP_ */
Point
This class implement the point shape in an N-dimensional space.
Definition: Point.hpp:28
Point::get
__device__ __host__ const T & get(unsigned int i) const
Get coordinate.
Definition: Point.hpp:172
openfpm::vector
Implementation of 1-D std::vector like structure.
Definition: map_vector.hpp:204
vect_dist_key_dx
Grid key for a distributed grid.
Definition: vector_dist_key.hpp:20
vect_dist_key_dx::getKey
__device__ __host__ size_t getKey() const
Get the key.
Definition: vector_dist_key.hpp:42
vector_dist_expression_op
Unknown operation specialization.
Definition: vector_dist_operators.hpp:185
vector_dist_subset
Definition: vector_dist_subset.hpp:84
vector_dist
Distributed vector.
Definition: vector_dist.hpp:176
vector_dist::dims
static const unsigned int dims
template parameters typedefs
Definition: vector_dist.hpp:184
cub::int
KeyT const ValueT ValueT OffsetIteratorT OffsetIteratorT int
[in] The number of segments that comprise the sorting data
Definition: dispatch_radix_sort.cuh:336
cub::init
OutputIteratorT OffsetT ReductionOpT OuputT init
< [in] The initial value of the reduction
Definition: dispatch_reduce.cuh:119
aggregate
aggregate of properties, from a list of object if create a struct that follow the OPENFPM native stru...
Definition: aggregate.hpp:221
first_or_second
Definition: vector_dist_operators.hpp:91