← Back to branch summary

~ubuntu-branches/debian/sid/lammps/sid

« back to all changes in this revision

Viewing changes to src/KOKKOS/atom_vec_full_kokkos.cpp

  • Committer: Package Import Robot
  • Author(s): Anton Gladky
  • Date: 2015-04-29 23:44:49 UTC
  • mfrom: (5.1.3 experimental)
  • Revision ID: package-import@ubuntu.com-20150429234449-mbhy9utku6hp6oq8
Tags: 0~20150313.gitfa668e1-1
Upload into unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/KOKKOS/atom_vec_full_kokkos.cpp
 
1
/* ----------------------------------------------------------------------
 
2
   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
 
3
   http://lammps.sandia.gov, Sandia National Laboratories
 
4
   Steve Plimpton, sjplimp@sandia.gov
 
5
 
 
6
   Copyright (2003) Sandia Corporation.  Under the terms of Contract
 
7
   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
 
8
   certain rights in this software.  This software is distributed under
 
9
   the GNU General Public License.
 
10
 
 
11
   See the README file in the top-level LAMMPS directory.
 
12
------------------------------------------------------------------------- */
 
13
 
 
14
#include "stdlib.h"
 
15
#include "atom_vec_full_kokkos.h"
 
16
#include "atom_kokkos.h"
 
17
#include "comm_kokkos.h"
 
18
#include "domain.h"
 
19
#include "modify.h"
 
20
#include "fix.h"
 
21
#include "atom_masks.h"
 
22
#include "memory.h"
 
23
#include "error.h"
 
24
 
 
25
using namespace LAMMPS_NS;
 
26
 
 
27
#define DELTA 10000
 
28
 
 
29
/* ---------------------------------------------------------------------- */
 
30
 
 
31
AtomVecFullKokkos::AtomVecFullKokkos(LAMMPS *lmp) : AtomVecKokkos(lmp)
 
32
{
 
33
  molecular = 1;
 
34
  bonds_allow = angles_allow = dihedrals_allow = impropers_allow = 1;
 
35
  mass_type = 1;
 
36
 
 
37
  comm_x_only = comm_f_only = 1;
 
38
  size_forward = 3;
 
39
  size_reverse = 3;
 
40
  size_border = 8;
 
41
  size_velocity = 3;
 
42
  size_data_atom = 7;
 
43
  size_data_vel = 4;
 
44
  xcol_data = 5;
 
45
 
 
46
  atom->molecule_flag = atom->q_flag = 1;
 
47
 
 
48
  k_count = DAT::tdual_int_1d("atom::k_count",1);
 
49
  atomKK = (AtomKokkos *) atom;
 
50
  commKK = (CommKokkos *) comm;
 
51
}
 
52
 
 
53
/* ----------------------------------------------------------------------
 
54
   grow atom arrays
 
55
   n = 0 grows arrays by DELTA
 
56
   n > 0 allocates arrays to size n
 
57
------------------------------------------------------------------------- */
 
58
 
 
59
void AtomVecFullKokkos::grow(int n)
 
60
{
 
61
  if (n == 0) nmax += DELTA;
 
62
  else nmax = n;
 
63
  atomKK->nmax = nmax;
 
64
  if (nmax < 0 || nmax > MAXSMALLINT)
 
65
    error->one(FLERR,"Per-processor system is too big");
 
66
 
 
67
  sync(Device,ALL_MASK);
 
68
  modified(Device,ALL_MASK);
 
69
 
 
70
  memory->grow_kokkos(atomKK->k_tag,atomKK->tag,nmax,"atom:tag");
 
71
  memory->grow_kokkos(atomKK->k_type,atomKK->type,nmax,"atom:type");
 
72
  memory->grow_kokkos(atomKK->k_mask,atomKK->mask,nmax,"atom:mask");
 
73
  memory->grow_kokkos(atomKK->k_image,atomKK->image,nmax,"atom:image");
 
74
 
 
75
  memory->grow_kokkos(atomKK->k_x,atomKK->x,nmax,3,"atom:x");
 
76
  memory->grow_kokkos(atomKK->k_v,atomKK->v,nmax,3,"atom:v");
 
77
  memory->grow_kokkos(atomKK->k_f,atomKK->f,nmax,3,"atom:f");
 
78
 
 
79
  memory->grow_kokkos(atomKK->k_q,atomKK->q,nmax,"atom:q");
 
80
  memory->grow_kokkos(atomKK->k_molecule,atomKK->molecule,nmax,"atom:molecule");
 
81
 
 
82
  memory->grow_kokkos(atomKK->k_nspecial,atomKK->nspecial,nmax,3,"atom:nspecial");
 
83
  memory->grow_kokkos(atomKK->k_special,atomKK->special,nmax,atomKK->maxspecial,
 
84
                      "atom:special");
 
85
  memory->grow_kokkos(atomKK->k_num_bond,atomKK->num_bond,nmax,"atom:num_bond");
 
86
  memory->grow_kokkos(atomKK->k_bond_type,atomKK->bond_type,nmax,atomKK->bond_per_atom,
 
87
                      "atom:bond_type");
 
88
  memory->grow_kokkos(atomKK->k_bond_atom,atomKK->bond_atom,nmax,atomKK->bond_per_atom,
 
89
                      "atom:bond_atom");
 
90
 
 
91
  memory->grow_kokkos(atomKK->k_num_angle,atomKK->num_angle,nmax,"atom:num_angle");
 
92
  memory->grow_kokkos(atomKK->k_angle_type,atomKK->angle_type,nmax,atomKK->angle_per_atom,
 
93
                      "atom:angle_type");
 
94
  memory->grow_kokkos(atomKK->k_angle_atom1,atomKK->angle_atom1,nmax,atomKK->angle_per_atom,
 
95
                      "atom:angle_atom1");
 
96
  memory->grow_kokkos(atomKK->k_angle_atom2,atomKK->angle_atom2,nmax,atomKK->angle_per_atom,
 
97
                      "atom:angle_atom2");
 
98
  memory->grow_kokkos(atomKK->k_angle_atom3,atomKK->angle_atom3,nmax,atomKK->angle_per_atom,
 
99
                      "atom:angle_atom3");
 
100
 
 
101
  memory->grow_kokkos(atomKK->k_num_dihedral,atomKK->num_dihedral,nmax,"atom:num_dihedral");
 
102
  memory->grow_kokkos(atomKK->k_dihedral_type,atomKK->dihedral_type,nmax,
 
103
                      atomKK->dihedral_per_atom,"atom:dihedral_type");
 
104
  memory->grow_kokkos(atomKK->k_dihedral_atom1,atomKK->dihedral_atom1,nmax,
 
105
                      atomKK->dihedral_per_atom,"atom:dihedral_atom1");
 
106
  memory->grow_kokkos(atomKK->k_dihedral_atom2,atomKK->dihedral_atom2,nmax,
 
107
                      atomKK->dihedral_per_atom,"atom:dihedral_atom2");
 
108
  memory->grow_kokkos(atomKK->k_dihedral_atom3,atomKK->dihedral_atom3,nmax,
 
109
                      atomKK->dihedral_per_atom,"atom:dihedral_atom3");
 
110
  memory->grow_kokkos(atomKK->k_dihedral_atom4,atomKK->dihedral_atom4,nmax,
 
111
                      atomKK->dihedral_per_atom,"atom:dihedral_atom4");
 
112
 
 
113
  memory->grow_kokkos(atomKK->k_num_improper,atomKK->num_improper,nmax,"atom:num_improper");
 
114
  memory->grow_kokkos(atomKK->k_improper_type,atomKK->improper_type,nmax,
 
115
                      atomKK->improper_per_atom,"atom:improper_type");
 
116
  memory->grow_kokkos(atomKK->k_improper_atom1,atomKK->improper_atom1,nmax,
 
117
                      atomKK->improper_per_atom,"atom:improper_atom1");
 
118
  memory->grow_kokkos(atomKK->k_improper_atom2,atomKK->improper_atom2,nmax,
 
119
                      atomKK->improper_per_atom,"atom:improper_atom2");
 
120
  memory->grow_kokkos(atomKK->k_improper_atom3,atomKK->improper_atom3,nmax,
 
121
                      atomKK->improper_per_atom,"atom:improper_atom3");
 
122
  memory->grow_kokkos(atomKK->k_improper_atom4,atomKK->improper_atom4,nmax,
 
123
                      atomKK->improper_per_atom,"atom:improper_atom4");
 
124
 
 
125
  grow_reset();
 
126
  sync(Host,ALL_MASK);
 
127
 
 
128
  if (atom->nextra_grow)
 
129
    for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
 
130
      modify->fix[atom->extra_grow[iextra]]->grow_arrays(nmax);
 
131
}
 
132
 
 
133
/* ----------------------------------------------------------------------
 
134
   reset local array ptrs
 
135
------------------------------------------------------------------------- */
 
136
 
 
137
void AtomVecFullKokkos::grow_reset()
 
138
{
 
139
  tag = atomKK->tag;
 
140
  d_tag = atomKK->k_tag.d_view;
 
141
  h_tag = atomKK->k_tag.h_view;
 
142
 
 
143
  type = atomKK->type;
 
144
  d_type = atomKK->k_type.d_view;
 
145
  h_type = atomKK->k_type.h_view;
 
146
  mask = atomKK->mask;
 
147
  d_mask = atomKK->k_mask.d_view;
 
148
  h_mask = atomKK->k_mask.h_view;
 
149
  image = atomKK->image;
 
150
  d_image = atomKK->k_image.d_view;
 
151
  h_image = atomKK->k_image.h_view;
 
152
 
 
153
  x = atomKK->x;
 
154
  d_x = atomKK->k_x.d_view;
 
155
  h_x = atomKK->k_x.h_view;
 
156
  v = atomKK->v;
 
157
  d_v = atomKK->k_v.d_view;
 
158
  h_v = atomKK->k_v.h_view;
 
159
  f = atomKK->f;
 
160
  d_f = atomKK->k_f.d_view;
 
161
  h_f = atomKK->k_f.h_view;
 
162
 
 
163
  q = atomKK->q;
 
164
  d_q = atomKK->k_q.d_view;
 
165
  h_q = atomKK->k_q.h_view;
 
166
 
 
167
  molecule = atomKK->molecule;
 
168
  d_molecule = atomKK->k_molecule.d_view;
 
169
  h_molecule = atomKK->k_molecule.h_view;
 
170
 
 
171
  nspecial = atomKK->nspecial;
 
172
  d_nspecial = atomKK->k_nspecial.d_view;
 
173
  h_nspecial = atomKK->k_nspecial.h_view;
 
174
  special = atomKK->special;
 
175
  d_special = atomKK->k_special.d_view;
 
176
  h_special = atomKK->k_special.h_view;
 
177
 
 
178
  num_bond = atomKK->num_bond;
 
179
  d_num_bond = atomKK->k_num_bond.d_view;
 
180
  h_num_bond = atomKK->k_num_bond.h_view;
 
181
  bond_type = atomKK->bond_type;
 
182
  d_bond_type = atomKK->k_bond_type.d_view;
 
183
  h_bond_type = atomKK->k_bond_type.h_view;
 
184
  bond_atom = atomKK->bond_atom;
 
185
  d_bond_atom = atomKK->k_bond_atom.d_view;
 
186
  h_bond_atom = atomKK->k_bond_atom.h_view;
 
187
 
 
188
  num_angle = atomKK->num_angle;
 
189
  d_num_angle = atomKK->k_num_angle.d_view;
 
190
  h_num_angle = atomKK->k_num_angle.h_view;
 
191
  angle_type = atomKK->angle_type;
 
192
  d_angle_type = atomKK->k_angle_type.d_view;
 
193
  h_angle_type = atomKK->k_angle_type.h_view;
 
194
  angle_atom1 = atomKK->angle_atom1;
 
195
  d_angle_atom1 = atomKK->k_angle_atom1.d_view;
 
196
  h_angle_atom1 = atomKK->k_angle_atom1.h_view;
 
197
  angle_atom2 = atomKK->angle_atom2;
 
198
  d_angle_atom2 = atomKK->k_angle_atom2.d_view;
 
199
  h_angle_atom2 = atomKK->k_angle_atom2.h_view;
 
200
  angle_atom3 = atomKK->angle_atom3;
 
201
  d_angle_atom3 = atomKK->k_angle_atom3.d_view;
 
202
  h_angle_atom3 = atomKK->k_angle_atom3.h_view;
 
203
 
 
204
  num_dihedral = atomKK->num_dihedral;
 
205
  d_num_dihedral = atomKK->k_num_dihedral.d_view;
 
206
  h_num_dihedral = atomKK->k_num_dihedral.h_view;
 
207
  dihedral_type = atomKK->dihedral_type;
 
208
  d_dihedral_type = atomKK->k_dihedral_type.d_view;
 
209
  h_dihedral_type = atomKK->k_dihedral_type.h_view;
 
210
  dihedral_atom1 = atomKK->dihedral_atom1;
 
211
  d_dihedral_atom1 = atomKK->k_dihedral_atom1.d_view;
 
212
  h_dihedral_atom1 = atomKK->k_dihedral_atom1.h_view;
 
213
  dihedral_atom2 = atomKK->dihedral_atom2;
 
214
  d_dihedral_atom2 = atomKK->k_dihedral_atom2.d_view;
 
215
  h_dihedral_atom2 = atomKK->k_dihedral_atom2.h_view;
 
216
  dihedral_atom3 = atomKK->dihedral_atom3;
 
217
  d_dihedral_atom3 = atomKK->k_dihedral_atom3.d_view;
 
218
  h_dihedral_atom3 = atomKK->k_dihedral_atom3.h_view;
 
219
  dihedral_atom4 = atomKK->dihedral_atom4;
 
220
  d_dihedral_atom4 = atomKK->k_dihedral_atom4.d_view;
 
221
  h_dihedral_atom4 = atomKK->k_dihedral_atom4.h_view;
 
222
 
 
223
  num_improper = atomKK->num_improper;
 
224
  d_num_improper = atomKK->k_num_improper.d_view;
 
225
  h_num_improper = atomKK->k_num_improper.h_view;
 
226
  improper_type = atomKK->improper_type;
 
227
  d_improper_type = atomKK->k_improper_type.d_view;
 
228
  h_improper_type = atomKK->k_improper_type.h_view;
 
229
  improper_atom1 = atomKK->improper_atom1;
 
230
  d_improper_atom1 = atomKK->k_improper_atom1.d_view;
 
231
  h_improper_atom1 = atomKK->k_improper_atom1.h_view;
 
232
  improper_atom2 = atomKK->improper_atom2;
 
233
  d_improper_atom2 = atomKK->k_improper_atom2.d_view;
 
234
  h_improper_atom2 = atomKK->k_improper_atom2.h_view;
 
235
  improper_atom3 = atomKK->improper_atom3;
 
236
  d_improper_atom3 = atomKK->k_improper_atom3.d_view;
 
237
  h_improper_atom3 = atomKK->k_improper_atom3.h_view;
 
238
  improper_atom4 = atomKK->improper_atom4;
 
239
  d_improper_atom4 = atomKK->k_improper_atom4.d_view;
 
240
  h_improper_atom4 = atomKK->k_improper_atom4.h_view;
 
241
}
 
242
 
 
243
/* ----------------------------------------------------------------------
 
244
   copy atom I info to atom J
 
245
------------------------------------------------------------------------- */
 
246
 
 
247
void AtomVecFullKokkos::copy(int i, int j, int delflag)
 
248
{
 
249
  int k;
 
250
 
 
251
  h_tag[j] = h_tag[i];
 
252
  h_type[j] = h_type[i];
 
253
  mask[j] = mask[i];
 
254
  h_image[j] = h_image[i];
 
255
  h_x(j,0) = h_x(i,0);
 
256
  h_x(j,1) = h_x(i,1);
 
257
  h_x(j,2) = h_x(i,2);
 
258
  h_v(j,0) = h_v(i,0);
 
259
  h_v(j,1) = h_v(i,1);
 
260
  h_v(j,2) = h_v(i,2);
 
261
 
 
262
  h_q[j] = h_q[i];
 
263
  h_molecule(j) = h_molecule(i);
 
264
 
 
265
  h_num_bond(j) = h_num_bond(i);
 
266
  for (k = 0; k < h_num_bond(j); k++) {
 
267
    h_bond_type(j,k) = h_bond_type(i,k);
 
268
    h_bond_atom(j,k) = h_bond_atom(i,k);
 
269
  }
 
270
 
 
271
  h_nspecial(j,0) = h_nspecial(i,0);
 
272
  h_nspecial(j,1) = h_nspecial(i,1);
 
273
  h_nspecial(j,2) = h_nspecial(i,2);
 
274
  for (k = 0; k < h_nspecial(j,2); k++)
 
275
    h_special(j,k) = h_special(i,k);
 
276
 
 
277
  h_num_angle(j) = h_num_angle(i);
 
278
  for (k = 0; k < h_num_angle(j); k++) {
 
279
    h_angle_type(j,k) = h_angle_type(i,k);
 
280
    h_angle_atom1(j,k) = h_angle_atom1(i,k);
 
281
    h_angle_atom2(j,k) = h_angle_atom2(i,k);
 
282
    h_angle_atom3(j,k) = h_angle_atom3(i,k);
 
283
  }
 
284
 
 
285
  h_num_dihedral(j) = h_num_dihedral(i);
 
286
  for (k = 0; k < h_num_dihedral(j); k++) {
 
287
    h_dihedral_type(j,k) = h_dihedral_type(i,k);
 
288
    h_dihedral_atom1(j,k) = h_dihedral_atom1(i,k);
 
289
    h_dihedral_atom2(j,k) = h_dihedral_atom2(i,k);
 
290
    h_dihedral_atom3(j,k) = h_dihedral_atom3(i,k);
 
291
    h_dihedral_atom4(j,k) = h_dihedral_atom4(i,k);
 
292
  }
 
293
 
 
294
  h_num_improper(j) = h_num_improper(i);
 
295
  for (k = 0; k < h_num_improper(j); k++) {
 
296
    h_improper_type(j,k) = h_improper_type(i,k);
 
297
    h_improper_atom1(j,k) = h_improper_atom1(i,k);
 
298
    h_improper_atom2(j,k) = h_improper_atom2(i,k);
 
299
    h_improper_atom3(j,k) = h_improper_atom3(i,k);
 
300
    h_improper_atom4(j,k) = h_improper_atom4(i,k);
 
301
  }
 
302
 
 
303
  if (atom->nextra_grow)
 
304
    for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
 
305
      modify->fix[atom->extra_grow[iextra]]->copy_arrays(i,j,delflag);
 
306
}
 
307
 
 
308
/* ---------------------------------------------------------------------- */
 
309
 
 
310
template<class DeviceType,int PBC_FLAG,int TRICLINIC>
 
311
struct AtomVecFullKokkos_PackComm {
 
312
  typedef DeviceType device_type;
 
313
 
 
314
  typename ArrayTypes<DeviceType>::t_x_array_randomread _x;
 
315
  typename ArrayTypes<DeviceType>::t_xfloat_2d_um _buf;
 
316
  typename ArrayTypes<DeviceType>::t_int_2d_const _list;
 
317
  const int _iswap;
 
318
  X_FLOAT _xprd,_yprd,_zprd,_xy,_xz,_yz;
 
319
  X_FLOAT _pbc[6];
 
320
 
 
321
  AtomVecFullKokkos_PackComm(
 
322
      const typename DAT::tdual_x_array &x,
 
323
      const typename DAT::tdual_xfloat_2d &buf,
 
324
      const typename DAT::tdual_int_2d &list,
 
325
      const int & iswap,
 
326
      const X_FLOAT &xprd, const X_FLOAT &yprd, const X_FLOAT &zprd,
 
327
      const X_FLOAT &xy, const X_FLOAT &xz, const X_FLOAT &yz, const int* const pbc):
 
328
      _x(x.view<DeviceType>()),_list(list.view<DeviceType>()),_iswap(iswap),
 
329
      _xprd(xprd),_yprd(yprd),_zprd(zprd),
 
330
      _xy(xy),_xz(xz),_yz(yz) {
 
331
        const size_t maxsend = (buf.view<DeviceType>().dimension_0()
 
332
                                *buf.view<DeviceType>().dimension_1())/3;
 
333
        const size_t elements = 3;
 
334
        buffer_view<DeviceType>(_buf,buf,maxsend,elements);
 
335
        _pbc[0] = pbc[0]; _pbc[1] = pbc[1]; _pbc[2] = pbc[2];
 
336
        _pbc[3] = pbc[3]; _pbc[4] = pbc[4]; _pbc[5] = pbc[5];
 
337
  };
 
338
 
 
339
  KOKKOS_INLINE_FUNCTION
 
340
  void operator() (const int& i) const {
 
341
        const int j = _list(_iswap,i);
 
342
      if (PBC_FLAG == 0) {
 
343
          _buf(i,0) = _x(j,0);
 
344
          _buf(i,1) = _x(j,1);
 
345
          _buf(i,2) = _x(j,2);
 
346
      } else {
 
347
        if (TRICLINIC == 0) {
 
348
          _buf(i,0) = _x(j,0) + _pbc[0]*_xprd;
 
349
          _buf(i,1) = _x(j,1) + _pbc[1]*_yprd;
 
350
          _buf(i,2) = _x(j,2) + _pbc[2]*_zprd;
 
351
        } else {
 
352
          _buf(i,0) = _x(j,0) + _pbc[0]*_xprd + _pbc[5]*_xy + _pbc[4]*_xz;
 
353
          _buf(i,1) = _x(j,1) + _pbc[1]*_yprd + _pbc[3]*_yz;
 
354
          _buf(i,2) = _x(j,2) + _pbc[2]*_zprd;
 
355
        }
 
356
      }
 
357
  }
 
358
};
 
359
 
 
360
/* ---------------------------------------------------------------------- */
 
361
 
 
362
int AtomVecFullKokkos::pack_comm_kokkos(const int &n,
 
363
                                             const DAT::tdual_int_2d &list,
 
364
                                             const int & iswap,
 
365
                                             const DAT::tdual_xfloat_2d &buf,
 
366
                                             const int &pbc_flag,
 
367
                                             const int* const pbc)
 
368
{
 
369
  // Check whether to always run forward communication on the host
 
370
  // Choose correct forward PackComm kernel
 
371
 
 
372
  if(commKK->forward_comm_on_host) {
 
373
    sync(Host,X_MASK);
 
374
    if(pbc_flag) {
 
375
      if(domain->triclinic) {
 
376
        struct AtomVecFullKokkos_PackComm<LMPHostType,1,1>
 
377
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
378
            domain->xy,domain->xz,domain->yz,pbc);
 
379
        Kokkos::parallel_for(n,f);
 
380
      } else {
 
381
        struct AtomVecFullKokkos_PackComm<LMPHostType,1,0>
 
382
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
383
            domain->xy,domain->xz,domain->yz,pbc);
 
384
        Kokkos::parallel_for(n,f);
 
385
      }
 
386
    } else {
 
387
      if(domain->triclinic) {
 
388
        struct AtomVecFullKokkos_PackComm<LMPHostType,0,1>
 
389
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
390
            domain->xy,domain->xz,domain->yz,pbc);
 
391
        Kokkos::parallel_for(n,f);
 
392
      } else {
 
393
        struct AtomVecFullKokkos_PackComm<LMPHostType,0,0>
 
394
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
395
            domain->xy,domain->xz,domain->yz,pbc);
 
396
        Kokkos::parallel_for(n,f);
 
397
      }
 
398
    }
 
399
    LMPHostType::fence();
 
400
  } else {
 
401
    sync(Device,X_MASK);
 
402
    if(pbc_flag) {
 
403
      if(domain->triclinic) {
 
404
        struct AtomVecFullKokkos_PackComm<LMPDeviceType,1,1>
 
405
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
406
            domain->xy,domain->xz,domain->yz,pbc);
 
407
        Kokkos::parallel_for(n,f);
 
408
      } else {
 
409
        struct AtomVecFullKokkos_PackComm<LMPDeviceType,1,0>
 
410
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
411
            domain->xy,domain->xz,domain->yz,pbc);
 
412
        Kokkos::parallel_for(n,f);
 
413
      }
 
414
    } else {
 
415
      if(domain->triclinic) {
 
416
        struct AtomVecFullKokkos_PackComm<LMPDeviceType,0,1>
 
417
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
418
            domain->xy,domain->xz,domain->yz,pbc);
 
419
        Kokkos::parallel_for(n,f);
 
420
      } else {
 
421
        struct AtomVecFullKokkos_PackComm<LMPDeviceType,0,0>
 
422
          f(atomKK->k_x,buf,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
423
            domain->xy,domain->xz,domain->yz,pbc);
 
424
        Kokkos::parallel_for(n,f);
 
425
      }
 
426
    }
 
427
    LMPDeviceType::fence();
 
428
  }
 
429
 
 
430
        return n*size_forward;
 
431
}
 
432
 
 
433
/* ---------------------------------------------------------------------- */
 
434
 
 
435
template<class DeviceType,int PBC_FLAG,int TRICLINIC>
 
436
struct AtomVecFullKokkos_PackCommSelf {
 
437
  typedef DeviceType device_type;
 
438
 
 
439
  typename ArrayTypes<DeviceType>::t_x_array_randomread _x;
 
440
  typename ArrayTypes<DeviceType>::t_x_array _xw;
 
441
  int _nfirst;
 
442
  typename ArrayTypes<DeviceType>::t_int_2d_const _list;
 
443
  const int _iswap;
 
444
  X_FLOAT _xprd,_yprd,_zprd,_xy,_xz,_yz;
 
445
  X_FLOAT _pbc[6];
 
446
 
 
447
  AtomVecFullKokkos_PackCommSelf(
 
448
      const typename DAT::tdual_x_array &x,
 
449
      const int &nfirst,
 
450
      const typename DAT::tdual_int_2d &list,
 
451
      const int & iswap,
 
452
      const X_FLOAT &xprd, const X_FLOAT &yprd, const X_FLOAT &zprd,
 
453
      const X_FLOAT &xy, const X_FLOAT &xz, const X_FLOAT &yz, const int* const pbc):
 
454
    _x(x.view<DeviceType>()),_xw(x.view<DeviceType>()),_nfirst(nfirst),
 
455
    _list(list.view<DeviceType>()),_iswap(iswap),
 
456
    _xprd(xprd),_yprd(yprd),_zprd(zprd),
 
457
    _xy(xy),_xz(xz),_yz(yz) {
 
458
    _pbc[0] = pbc[0]; _pbc[1] = pbc[1]; _pbc[2] = pbc[2];
 
459
    _pbc[3] = pbc[3]; _pbc[4] = pbc[4]; _pbc[5] = pbc[5];
 
460
  };
 
461
 
 
462
  KOKKOS_INLINE_FUNCTION
 
463
  void operator() (const int& i) const {
 
464
        const int j = _list(_iswap,i);
 
465
      if (PBC_FLAG == 0) {
 
466
          _xw(i+_nfirst,0) = _x(j,0);
 
467
          _xw(i+_nfirst,1) = _x(j,1);
 
468
          _xw(i+_nfirst,2) = _x(j,2);
 
469
      } else {
 
470
        if (TRICLINIC == 0) {
 
471
          _xw(i+_nfirst,0) = _x(j,0) + _pbc[0]*_xprd;
 
472
          _xw(i+_nfirst,1) = _x(j,1) + _pbc[1]*_yprd;
 
473
          _xw(i+_nfirst,2) = _x(j,2) + _pbc[2]*_zprd;
 
474
        } else {
 
475
          _xw(i+_nfirst,0) = _x(j,0) + _pbc[0]*_xprd + _pbc[5]*_xy + _pbc[4]*_xz;
 
476
          _xw(i+_nfirst,1) = _x(j,1) + _pbc[1]*_yprd + _pbc[3]*_yz;
 
477
          _xw(i+_nfirst,2) = _x(j,2) + _pbc[2]*_zprd;
 
478
        }
 
479
      }
 
480
 
 
481
  }
 
482
};
 
483
 
 
484
/* ---------------------------------------------------------------------- */
 
485
 
 
486
int AtomVecFullKokkos::pack_comm_self(const int &n, const DAT::tdual_int_2d &list,
 
487
                                           const int & iswap,
 
488
                                           const int nfirst, const int &pbc_flag,
 
489
                                           const int* const pbc) {
 
490
  if(commKK->forward_comm_on_host) {
 
491
    sync(Host,X_MASK);
 
492
    modified(Host,X_MASK);
 
493
    if(pbc_flag) {
 
494
      if(domain->triclinic) {
 
495
      struct AtomVecFullKokkos_PackCommSelf<LMPHostType,1,1>
 
496
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
497
          domain->xy,domain->xz,domain->yz,pbc);
 
498
      Kokkos::parallel_for(n,f);
 
499
      } else {
 
500
      struct AtomVecFullKokkos_PackCommSelf<LMPHostType,1,0>
 
501
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
502
          domain->xy,domain->xz,domain->yz,pbc);
 
503
      Kokkos::parallel_for(n,f);
 
504
      }
 
505
    } else {
 
506
      if(domain->triclinic) {
 
507
      struct AtomVecFullKokkos_PackCommSelf<LMPHostType,0,1>
 
508
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
509
          domain->xy,domain->xz,domain->yz,pbc);
 
510
      Kokkos::parallel_for(n,f);
 
511
      } else {
 
512
      struct AtomVecFullKokkos_PackCommSelf<LMPHostType,0,0>
 
513
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
514
          domain->xy,domain->xz,domain->yz,pbc);
 
515
      Kokkos::parallel_for(n,f);
 
516
      }
 
517
    }
 
518
    LMPHostType::fence();
 
519
  } else {
 
520
    sync(Device,X_MASK);
 
521
    modified(Device,X_MASK);
 
522
    if(pbc_flag) {
 
523
      if(domain->triclinic) {
 
524
      struct AtomVecFullKokkos_PackCommSelf<LMPDeviceType,1,1>
 
525
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
526
          domain->xy,domain->xz,domain->yz,pbc);
 
527
      Kokkos::parallel_for(n,f);
 
528
      } else {
 
529
      struct AtomVecFullKokkos_PackCommSelf<LMPDeviceType,1,0>
 
530
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
531
          domain->xy,domain->xz,domain->yz,pbc);
 
532
      Kokkos::parallel_for(n,f);
 
533
      }
 
534
    } else {
 
535
      if(domain->triclinic) {
 
536
      struct AtomVecFullKokkos_PackCommSelf<LMPDeviceType,0,1>
 
537
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
538
          domain->xy,domain->xz,domain->yz,pbc);
 
539
      Kokkos::parallel_for(n,f);
 
540
      } else {
 
541
      struct AtomVecFullKokkos_PackCommSelf<LMPDeviceType,0,0>
 
542
        f(atomKK->k_x,nfirst,list,iswap,domain->xprd,domain->yprd,domain->zprd,
 
543
          domain->xy,domain->xz,domain->yz,pbc);
 
544
      Kokkos::parallel_for(n,f);
 
545
      }
 
546
    }
 
547
    LMPDeviceType::fence();
 
548
  }
 
549
        return n*3;
 
550
}
 
551
 
 
552
/* ---------------------------------------------------------------------- */
 
553
 
 
554
template<class DeviceType>
 
555
struct AtomVecFullKokkos_UnpackComm {
 
556
  typedef DeviceType device_type;
 
557
 
 
558
  typename ArrayTypes<DeviceType>::t_x_array _x;
 
559
  typename ArrayTypes<DeviceType>::t_xfloat_2d_const _buf;
 
560
  int _first;
 
561
 
 
562
  AtomVecFullKokkos_UnpackComm(
 
563
      const typename DAT::tdual_x_array &x,
 
564
      const typename DAT::tdual_xfloat_2d &buf,
 
565
      const int& first):_x(x.view<DeviceType>()),_buf(buf.view<DeviceType>()),
 
566
                        _first(first) {};
 
567
 
 
568
  KOKKOS_INLINE_FUNCTION
 
569
  void operator() (const int& i) const {
 
570
      _x(i+_first,0) = _buf(i,0);
 
571
      _x(i+_first,1) = _buf(i,1);
 
572
      _x(i+_first,2) = _buf(i,2);
 
573
  }
 
574
};
 
575
 
 
576
/* ---------------------------------------------------------------------- */
 
577
 
 
578
void AtomVecFullKokkos::unpack_comm_kokkos(const int &n, const int &first,
 
579
    const DAT::tdual_xfloat_2d &buf ) {
 
580
  if(commKK->forward_comm_on_host) {
 
581
    sync(Host,X_MASK);
 
582
    modified(Host,X_MASK);
 
583
    struct AtomVecFullKokkos_UnpackComm<LMPHostType> f(atomKK->k_x,buf,first);
 
584
    Kokkos::parallel_for(n,f);
 
585
    LMPDeviceType::fence();
 
586
  } else {
 
587
    sync(Device,X_MASK);
 
588
    modified(Device,X_MASK);
 
589
    struct AtomVecFullKokkos_UnpackComm<LMPDeviceType> f(atomKK->k_x,buf,first);
 
590
    Kokkos::parallel_for(n,f);
 
591
    LMPDeviceType::fence();
 
592
  }
 
593
}
 
594
 
 
595
/* ---------------------------------------------------------------------- */
 
596
 
 
597
int AtomVecFullKokkos::pack_comm(int n, int *list, double *buf,
 
598
                                      int pbc_flag, int *pbc)
 
599
{
 
600
  int i,j,m;
 
601
  double dx,dy,dz;
 
602
 
 
603
  m = 0;
 
604
  if (pbc_flag == 0) {
 
605
    for (i = 0; i < n; i++) {
 
606
      j = list[i];
 
607
      buf[m++] = h_x(j,0);
 
608
      buf[m++] = h_x(j,1);
 
609
      buf[m++] = h_x(j,2);
 
610
    }
 
611
  } else {
 
612
    if (domain->triclinic == 0) {
 
613
      dx = pbc[0]*domain->xprd;
 
614
      dy = pbc[1]*domain->yprd;
 
615
      dz = pbc[2]*domain->zprd;
 
616
    } else {
 
617
      dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz;
 
618
      dy = pbc[1]*domain->yprd + pbc[3]*domain->yz;
 
619
      dz = pbc[2]*domain->zprd;
 
620
    }
 
621
    for (i = 0; i < n; i++) {
 
622
      j = list[i];
 
623
      buf[m++] = h_x(j,0) + dx;
 
624
      buf[m++] = h_x(j,1) + dy;
 
625
      buf[m++] = h_x(j,2) + dz;
 
626
    }
 
627
  }
 
628
  return m;
 
629
}
 
630
 
 
631
/* ---------------------------------------------------------------------- */
 
632
 
 
633
int AtomVecFullKokkos::pack_comm_vel(int n, int *list, double *buf,
 
634
                                          int pbc_flag, int *pbc)
 
635
{
 
636
  int i,j,m;
 
637
  double dx,dy,dz,dvx,dvy,dvz;
 
638
 
 
639
  m = 0;
 
640
  if (pbc_flag == 0) {
 
641
    for (i = 0; i < n; i++) {
 
642
      j = list[i];
 
643
      buf[m++] = h_x(j,0);
 
644
      buf[m++] = h_x(j,1);
 
645
      buf[m++] = h_x(j,2);
 
646
      buf[m++] = h_v(j,0);
 
647
      buf[m++] = h_v(j,1);
 
648
      buf[m++] = h_v(j,2);
 
649
    }
 
650
  } else {
 
651
    if (domain->triclinic == 0) {
 
652
      dx = pbc[0]*domain->xprd;
 
653
      dy = pbc[1]*domain->yprd;
 
654
      dz = pbc[2]*domain->zprd;
 
655
    } else {
 
656
      dx = pbc[0]*domain->xprd + pbc[5]*domain->xy + pbc[4]*domain->xz;
 
657
      dy = pbc[1]*domain->yprd + pbc[3]*domain->yz;
 
658
      dz = pbc[2]*domain->zprd;
 
659
    }
 
660
    if (!deform_vremap) {
 
661
      for (i = 0; i < n; i++) {
 
662
        j = list[i];
 
663
        buf[m++] = h_x(j,0) + dx;
 
664
        buf[m++] = h_x(j,1) + dy;
 
665
        buf[m++] = h_x(j,2) + dz;
 
666
        buf[m++] = h_v(j,0);
 
667
        buf[m++] = h_v(j,1);
 
668
        buf[m++] = h_v(j,2);
 
669
      }
 
670
    } else {
 
671
      dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
 
672
      dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3];
 
673
      dvz = pbc[2]*h_rate[2];
 
674
      for (i = 0; i < n; i++) {
 
675
        j = list[i];
 
676
        buf[m++] = h_x(j,0) + dx;
 
677
        buf[m++] = h_x(j,1) + dy;
 
678
        buf[m++] = h_x(j,2) + dz;
 
679
        if (mask[i] & deform_groupbit) {
 
680
          buf[m++] = h_v(j,0) + dvx;
 
681
          buf[m++] = h_v(j,1) + dvy;
 
682
          buf[m++] = h_v(j,2) + dvz;
 
683
        } else {
 
684
          buf[m++] = h_v(j,0);
 
685
          buf[m++] = h_v(j,1);
 
686
          buf[m++] = h_v(j,2);
 
687
        }
 
688
      }
 
689
    }
 
690
  }
 
691
  return m;
 
692
}
 
693
 
 
694
/* ---------------------------------------------------------------------- */
 
695
 
 
696
void AtomVecFullKokkos::unpack_comm(int n, int first, double *buf)
 
697
{
 
698
  int i,m,last;
 
699
 
 
700
  m = 0;
 
701
  last = first + n;
 
702
  for (i = first; i < last; i++) {
 
703
    h_x(i,0) = buf[m++];
 
704
    h_x(i,1) = buf[m++];
 
705
    h_x(i,2) = buf[m++];
 
706
  }
 
707
}
 
708
 
 
709
/* ---------------------------------------------------------------------- */
 
710
 
 
711
void AtomVecFullKokkos::unpack_comm_vel(int n, int first, double *buf)
 
712
{
 
713
  int i,m,last;
 
714
 
 
715
  m = 0;
 
716
  last = first + n;
 
717
  for (i = first; i < last; i++) {
 
718
    h_x(i,0) = buf[m++];
 
719
    h_x(i,1) = buf[m++];
 
720
    h_x(i,2) = buf[m++];
 
721
    h_v(i,0) = buf[m++];
 
722
    h_v(i,1) = buf[m++];
 
723
    h_v(i,2) = buf[m++];
 
724
  }
 
725
}
 
726
 
 
727
/* ---------------------------------------------------------------------- */
 
728
 
 
729
int AtomVecFullKokkos::pack_reverse(int n, int first, double *buf)
 
730
{
 
731
  if(n > 0)
 
732
    sync(Host,F_MASK);
 
733
 
 
734
  int m = 0;
 
735
  const int last = first + n;
 
736
  for (int i = first; i < last; i++) {
 
737
    buf[m++] = h_f(i,0);
 
738
    buf[m++] = h_f(i,1);
 
739
    buf[m++] = h_f(i,2);
 
740
  }
 
741
  return m;
 
742
}
 
743
 
 
744
/* ---------------------------------------------------------------------- */
 
745
 
 
746
void AtomVecFullKokkos::unpack_reverse(int n, int *list, double *buf)
 
747
{
 
748
  if(n > 0)
 
749
    modified(Host,F_MASK);
 
750
 
 
751
  int m = 0;
 
752
  for (int i = 0; i < n; i++) {
 
753
    const int j = list[i];
 
754
    h_f(j,0) += buf[m++];
 
755
    h_f(j,1) += buf[m++];
 
756
    h_f(j,2) += buf[m++];
 
757
  }
 
758
}
 
759
 
 
760
/* ---------------------------------------------------------------------- */
 
761
 
 
762
template<class DeviceType,int PBC_FLAG>
 
763
struct AtomVecFullKokkos_PackBorder {
 
764
  union ubuf {
 
765
    double d;
 
766
    int64_t i;
 
767
    ubuf(double arg) : d(arg) {}
 
768
    ubuf(int64_t arg) : i(arg) {}
 
769
    ubuf(int arg) : i(arg) {}
 
770
  };
 
771
 
 
772
  typedef DeviceType device_type;
 
773
  typedef ArrayTypes<DeviceType> AT;
 
774
 
 
775
  typename AT::t_xfloat_2d _buf;
 
776
  const typename AT::t_int_2d_const _list;
 
777
  const int _iswap;
 
778
  const typename AT::t_x_array_randomread _x;
 
779
  const typename AT::t_tagint_1d _tag;
 
780
  const typename AT::t_int_1d _type;
 
781
  const typename AT::t_int_1d _mask;
 
782
  const typename AT::t_float_1d _q;
 
783
  const typename AT::t_tagint_1d _molecule;
 
784
  X_FLOAT _dx,_dy,_dz;
 
785
 
 
786
  AtomVecFullKokkos_PackBorder(
 
787
      const typename AT::t_xfloat_2d &buf,
 
788
      const typename AT::t_int_2d_const &list,
 
789
      const int & iswap,
 
790
      const typename AT::t_x_array &x,
 
791
      const typename AT::t_tagint_1d &tag,
 
792
      const typename AT::t_int_1d &type,
 
793
      const typename AT::t_int_1d &mask,
 
794
      const typename AT::t_float_1d &q,
 
795
      const typename AT::t_tagint_1d &molecule,
 
796
      const X_FLOAT &dx, const X_FLOAT &dy, const X_FLOAT &dz):
 
797
      _buf(buf),_list(list),_iswap(iswap),
 
798
      _x(x),_tag(tag),_type(type),_mask(mask),_q(q),_molecule(molecule),
 
799
      _dx(dx),_dy(dy),_dz(dz) {}
 
800
 
 
801
  KOKKOS_INLINE_FUNCTION
 
802
  void operator() (const int& i) const {
 
803
      const int j = _list(_iswap,i);
 
804
      if (PBC_FLAG == 0) {
 
805
          _buf(i,0) = _x(j,0);
 
806
          _buf(i,1) = _x(j,1);
 
807
          _buf(i,2) = _x(j,2);
 
808
          _buf(i,3) = ubuf(_tag(j)).d;
 
809
          _buf(i,4) = ubuf(_type(j)).d;
 
810
          _buf(i,5) = ubuf(_mask(j)).d;
 
811
          _buf(i,6) = _q(j);
 
812
          _buf(i,7) = ubuf(_molecule(j)).d;
 
813
      } else {
 
814
          _buf(i,0) = _x(j,0) + _dx;
 
815
          _buf(i,1) = _x(j,1) + _dy;
 
816
          _buf(i,2) = _x(j,2) + _dz;
 
817
          _buf(i,3) = ubuf(_tag(j)).d;
 
818
          _buf(i,4) = ubuf(_type(j)).d;
 
819
          _buf(i,5) = ubuf(_mask(j)).d;
 
820
          _buf(i,6) = _q(j);
 
821
          _buf(i,7) = ubuf(_molecule(j)).d;
 
822
      }
 
823
  }
 
824
};
 
825
 
 
826
/* ---------------------------------------------------------------------- */
 
827
 
 
828
int AtomVecFullKokkos::pack_border_kokkos(int n, DAT::tdual_int_2d k_sendlist,
 
829
                                               DAT::tdual_xfloat_2d buf,int iswap,
 
830
                                               int pbc_flag, int *pbc, ExecutionSpace space)
 
831
{
 
832
  X_FLOAT dx,dy,dz;
 
833
 
 
834
  if (pbc_flag != 0) {
 
835
    if (domain->triclinic == 0) {
 
836
      dx = pbc[0]*domain->xprd;
 
837
      dy = pbc[1]*domain->yprd;
 
838
      dz = pbc[2]*domain->zprd;
 
839
    } else {
 
840
      dx = pbc[0];
 
841
      dy = pbc[1];
 
842
      dz = pbc[2];
 
843
    }
 
844
    if(space==Host) {
 
845
      AtomVecFullKokkos_PackBorder<LMPHostType,1> f(
 
846
        buf.view<LMPHostType>(), k_sendlist.view<LMPHostType>(),
 
847
        iswap,h_x,h_tag,h_type,h_mask,h_q,h_molecule,dx,dy,dz);
 
848
      Kokkos::parallel_for(n,f);
 
849
      LMPHostType::fence();
 
850
    } else {
 
851
      AtomVecFullKokkos_PackBorder<LMPDeviceType,1> f(
 
852
        buf.view<LMPDeviceType>(), k_sendlist.view<LMPDeviceType>(),
 
853
        iswap,d_x,d_tag,d_type,d_mask,d_q,d_molecule,dx,dy,dz);
 
854
      Kokkos::parallel_for(n,f);
 
855
      LMPDeviceType::fence();
 
856
    }
 
857
 
 
858
  } else {
 
859
    dx = dy = dz = 0;
 
860
    if(space==Host) {
 
861
      AtomVecFullKokkos_PackBorder<LMPHostType,0> f(
 
862
        buf.view<LMPHostType>(), k_sendlist.view<LMPHostType>(),
 
863
        iswap,h_x,h_tag,h_type,h_mask,h_q,h_molecule,dx,dy,dz);
 
864
      Kokkos::parallel_for(n,f);
 
865
      LMPHostType::fence();
 
866
    } else {
 
867
      AtomVecFullKokkos_PackBorder<LMPDeviceType,0> f(
 
868
        buf.view<LMPDeviceType>(), k_sendlist.view<LMPDeviceType>(),
 
869
        iswap,d_x,d_tag,d_type,d_mask,d_q,d_molecule,dx,dy,dz);
 
870
      Kokkos::parallel_for(n,f);
 
871
      LMPDeviceType::fence();
 
872
    }
 
873
  }
 
874
  return n*size_border;
 
875
}
 
876
 
 
877
/* ---------------------------------------------------------------------- */
 
878
 
 
879
int AtomVecFullKokkos::pack_border(int n, int *list, double *buf,
 
880
                                        int pbc_flag, int *pbc)
 
881
{
 
882
  int i,j,m;
 
883
  double dx,dy,dz;
 
884
 
 
885
  m = 0;
 
886
  if (pbc_flag == 0) {
 
887
    for (i = 0; i < n; i++) {
 
888
      j = list[i];
 
889
      buf[m++] = h_x(j,0);
 
890
      buf[m++] = h_x(j,1);
 
891
      buf[m++] = h_x(j,2);
 
892
      buf[m++] = ubuf(h_tag(j)).d;
 
893
      buf[m++] = ubuf(h_type(j)).d;
 
894
      buf[m++] = ubuf(h_mask(j)).d;
 
895
      buf[m++] = h_q(j);
 
896
      buf[m++] = ubuf(h_molecule(j)).d;
 
897
    }
 
898
  } else {
 
899
    if (domain->triclinic == 0) {
 
900
      dx = pbc[0]*domain->xprd;
 
901
      dy = pbc[1]*domain->yprd;
 
902
      dz = pbc[2]*domain->zprd;
 
903
    } else {
 
904
      dx = pbc[0];
 
905
      dy = pbc[1];
 
906
      dz = pbc[2];
 
907
    }
 
908
    for (i = 0; i < n; i++) {
 
909
      j = list[i];
 
910
      buf[m++] = h_x(j,0) + dx;
 
911
      buf[m++] = h_x(j,1) + dy;
 
912
      buf[m++] = h_x(j,2) + dz;
 
913
      buf[m++] = ubuf(h_tag(j)).d;
 
914
      buf[m++] = ubuf(h_type(j)).d;
 
915
      buf[m++] = ubuf(h_mask(j)).d;
 
916
      buf[m++] = h_q(j);
 
917
      buf[m++] = ubuf(h_molecule(j)).d;
 
918
    }
 
919
  }
 
920
 
 
921
  if (atom->nextra_border)
 
922
    for (int iextra = 0; iextra < atom->nextra_border; iextra++)
 
923
      m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
 
924
 
 
925
  return m;
 
926
}
 
927
 
 
928
/* ---------------------------------------------------------------------- */
 
929
 
 
930
int AtomVecFullKokkos::pack_border_vel(int n, int *list, double *buf,
 
931
                                            int pbc_flag, int *pbc)
 
932
{
 
933
  int i,j,m;
 
934
  double dx,dy,dz,dvx,dvy,dvz;
 
935
 
 
936
  m = 0;
 
937
  if (pbc_flag == 0) {
 
938
    for (i = 0; i < n; i++) {
 
939
      j = list[i];
 
940
      buf[m++] = h_x(j,0);
 
941
      buf[m++] = h_x(j,1);
 
942
      buf[m++] = h_x(j,2);
 
943
      buf[m++] = ubuf(h_tag(j)).d;
 
944
      buf[m++] = ubuf(h_type(j)).d;
 
945
      buf[m++] = ubuf(h_mask(j)).d;
 
946
      buf[m++] = h_q(j);
 
947
      buf[m++] = ubuf(h_molecule(j)).d;
 
948
      buf[m++] = h_v(j,0);
 
949
      buf[m++] = h_v(j,1);
 
950
      buf[m++] = h_v(j,2);
 
951
    }
 
952
  } else {
 
953
    if (domain->triclinic == 0) {
 
954
      dx = pbc[0]*domain->xprd;
 
955
      dy = pbc[1]*domain->yprd;
 
956
      dz = pbc[2]*domain->zprd;
 
957
    } else {
 
958
      dx = pbc[0];
 
959
      dy = pbc[1];
 
960
      dz = pbc[2];
 
961
    }
 
962
    if (!deform_vremap) {
 
963
      for (i = 0; i < n; i++) {
 
964
        j = list[i];
 
965
        buf[m++] = h_x(j,0) + dx;
 
966
        buf[m++] = h_x(j,1) + dy;
 
967
        buf[m++] = h_x(j,2) + dz;
 
968
        buf[m++] = ubuf(h_tag(j)).d;
 
969
        buf[m++] = ubuf(h_type(j)).d;
 
970
        buf[m++] = ubuf(h_mask(j)).d;
 
971
        buf[m++] = h_q(j);
 
972
        buf[m++] = ubuf(h_molecule(j)).d;
 
973
        buf[m++] = h_v(j,0);
 
974
        buf[m++] = h_v(j,1);
 
975
        buf[m++] = h_v(j,2);
 
976
      }
 
977
    } else {
 
978
      dvx = pbc[0]*h_rate[0] + pbc[5]*h_rate[5] + pbc[4]*h_rate[4];
 
979
      dvy = pbc[1]*h_rate[1] + pbc[3]*h_rate[3];
 
980
      dvz = pbc[2]*h_rate[2];
 
981
      for (i = 0; i < n; i++) {
 
982
        j = list[i];
 
983
        buf[m++] = h_x(j,0) + dx;
 
984
        buf[m++] = h_x(j,1) + dy;
 
985
        buf[m++] = h_x(j,2) + dz;
 
986
        buf[m++] = ubuf(h_tag(j)).d;
 
987
        buf[m++] = ubuf(h_type(j)).d;
 
988
        buf[m++] = ubuf(h_mask(j)).d;
 
989
        buf[m++] = h_q(j);
 
990
        buf[m++] = ubuf(h_molecule(j)).d;
 
991
        if (mask[i] & deform_groupbit) {
 
992
          buf[m++] = h_v(j,0) + dvx;
 
993
          buf[m++] = h_v(j,1) + dvy;
 
994
          buf[m++] = h_v(j,2) + dvz;
 
995
        } else {
 
996
          buf[m++] = h_v(j,0);
 
997
          buf[m++] = h_v(j,1);
 
998
          buf[m++] = h_v(j,2);
 
999
        }
 
1000
      }
 
1001
    }
 
1002
  }
 
1003
 
 
1004
  if (atom->nextra_border)
 
1005
    for (int iextra = 0; iextra < atom->nextra_border; iextra++)
 
1006
      m += modify->fix[atom->extra_border[iextra]]->pack_border(n,list,&buf[m]);
 
1007
 
 
1008
  return m;
 
1009
}
 
1010
 
 
1011
/* ---------------------------------------------------------------------- */
 
1012
 
 
1013
int AtomVecFullKokkos::pack_border_hybrid(int n, int *list, double *buf)
 
1014
{
 
1015
  int i,j,m;
 
1016
 
 
1017
  m = 0;
 
1018
  for (i = 0; i < n; i++) {
 
1019
    j = list[i];
 
1020
    buf[m++] = h_q(j);
 
1021
    buf[m++] = ubuf(h_molecule(j)).d;
 
1022
  }
 
1023
  return m;
 
1024
}
 
1025
 
 
1026
/* ---------------------------------------------------------------------- */
 
1027
 
 
1028
template<class DeviceType>
 
1029
struct AtomVecFullKokkos_UnpackBorder {
 
1030
  union ubuf {
 
1031
    double d;
 
1032
    int64_t i;
 
1033
    ubuf(double arg) : d(arg) {}
 
1034
    ubuf(int64_t arg) : i(arg) {}
 
1035
    ubuf(int arg) : i(arg) {}
 
1036
  };
 
1037
 
 
1038
  typedef DeviceType device_type;
 
1039
  typedef ArrayTypes<DeviceType> AT;
 
1040
 
 
1041
  const typename AT::t_xfloat_2d_const _buf;
 
1042
  typename AT::t_x_array _x;
 
1043
  typename AT::t_tagint_1d _tag;
 
1044
  typename AT::t_int_1d _type;
 
1045
  typename AT::t_int_1d _mask;
 
1046
  typename AT::t_float_1d _q;
 
1047
  typename AT::t_tagint_1d _molecule;
 
1048
  int _first;
 
1049
 
 
1050
 
 
1051
  AtomVecFullKokkos_UnpackBorder(
 
1052
      const typename AT::t_xfloat_2d_const &buf,
 
1053
      typename AT::t_x_array &x,
 
1054
      typename AT::t_tagint_1d &tag,
 
1055
      typename AT::t_int_1d &type,
 
1056
      typename AT::t_int_1d &mask,
 
1057
      typename AT::t_float_1d &q,
 
1058
      typename AT::t_tagint_1d &molecule,
 
1059
      const int& first):
 
1060
    _buf(buf),_x(x),_tag(tag),_type(type),_mask(mask),_q(q),_molecule(molecule),
 
1061
    _first(first){
 
1062
  };
 
1063
 
 
1064
  KOKKOS_INLINE_FUNCTION
 
1065
  void operator() (const int& i) const {
 
1066
      _x(i+_first,0) = _buf(i,0);
 
1067
      _x(i+_first,1) = _buf(i,1);
 
1068
      _x(i+_first,2) = _buf(i,2);
 
1069
      _tag(i+_first) = (tagint) ubuf(_buf(i,3)).i;
 
1070
      _type(i+_first) = (int) ubuf(_buf(i,4)).i;
 
1071
      _mask(i+_first) = (int) ubuf(_buf(i,5)).i;
 
1072
      _q(i+_first) = _buf(i,6);
 
1073
      _molecule(i+_first) = (tagint) ubuf(_buf(i,7)).i;
 
1074
 
 
1075
  }
 
1076
};
 
1077
 
 
1078
/* ---------------------------------------------------------------------- */
 
1079
 
 
1080
void AtomVecFullKokkos::unpack_border_kokkos(const int &n, const int &first,
 
1081
                                                  const DAT::tdual_xfloat_2d &buf,
 
1082
                                                  ExecutionSpace space) {
 
1083
  modified(space,X_MASK|TAG_MASK|TYPE_MASK|MASK_MASK|Q_MASK|MOLECULE_MASK);
 
1084
  while (first+n >= nmax) grow(0);
 
1085
  modified(space,X_MASK|TAG_MASK|TYPE_MASK|MASK_MASK|Q_MASK|MOLECULE_MASK);
 
1086
  if(space==Host) {
 
1087
    struct AtomVecFullKokkos_UnpackBorder<LMPHostType>
 
1088
      f(buf.view<LMPHostType>(),h_x,h_tag,h_type,h_mask,h_q,h_molecule,first);
 
1089
    Kokkos::parallel_for(n,f);
 
1090
    LMPHostType::fence();
 
1091
  } else {
 
1092
    struct AtomVecFullKokkos_UnpackBorder<LMPDeviceType>
 
1093
      f(buf.view<LMPDeviceType>(),d_x,d_tag,d_type,d_mask,d_q,d_molecule,first);
 
1094
    Kokkos::parallel_for(n,f);
 
1095
    LMPDeviceType::fence();
 
1096
  }
 
1097
}
 
1098
 
 
1099
/* ---------------------------------------------------------------------- */
 
1100
 
 
1101
void AtomVecFullKokkos::unpack_border(int n, int first, double *buf)
 
1102
{
 
1103
  int i,m,last;
 
1104
 
 
1105
  m = 0;
 
1106
  last = first + n;
 
1107
  if(n > 0)
 
1108
    modified(Host,X_MASK|TAG_MASK|TYPE_MASK|MASK_MASK|Q_MASK|MOLECULE_MASK);
 
1109
  for (i = first; i < last; i++) {
 
1110
    if (i == nmax) grow(0);
 
1111
    h_x(i,0) = buf[m++];
 
1112
    h_x(i,1) = buf[m++];
 
1113
    h_x(i,2) = buf[m++];
 
1114
    h_tag(i) =  (tagint)  ubuf(buf[m++]).i;
 
1115
    h_type(i) = (int) ubuf(buf[m++]).i;
 
1116
    h_mask(i) = (int) ubuf(buf[m++]).i;
 
1117
    h_q(i) = buf[m++];
 
1118
    h_molecule(i) = (tagint) ubuf(buf[m++]).i;
 
1119
  }
 
1120
 
 
1121
  if (atom->nextra_border)
 
1122
    for (int iextra = 0; iextra < atom->nextra_border; iextra++)
 
1123
      m += modify->fix[atom->extra_border[iextra]]->
 
1124
        unpack_border(n,first,&buf[m]);
 
1125
}
 
1126
 
 
1127
/* ---------------------------------------------------------------------- */
 
1128
 
 
1129
void AtomVecFullKokkos::unpack_border_vel(int n, int first, double *buf)
 
1130
{
 
1131
  int i,m,last;
 
1132
 
 
1133
  m = 0;
 
1134
  last = first + n;
 
1135
  for (i = first; i < last; i++) {
 
1136
    if (i == nmax) grow(0);
 
1137
    modified(Host,X_MASK|TAG_MASK|TYPE_MASK|MASK_MASK|Q_MASK|MOLECULE_MASK);
 
1138
    h_x(i,0) = buf[m++];
 
1139
    h_x(i,1) = buf[m++];
 
1140
    h_x(i,2) = buf[m++];
 
1141
    h_tag(i) =  (tagint)  ubuf(buf[m++]).i;
 
1142
    h_type(i) = (int) ubuf(buf[m++]).i;
 
1143
    h_mask(i) = (int) ubuf(buf[m++]).i;
 
1144
    h_q(i) = buf[m++];
 
1145
    h_molecule(i) = (tagint) ubuf(buf[m++]).i;
 
1146
    h_v(i,0) = buf[m++];
 
1147
    h_v(i,1) = buf[m++];
 
1148
    h_v(i,2) = buf[m++];
 
1149
  }
 
1150
 
 
1151
  if (atom->nextra_border)
 
1152
    for (int iextra = 0; iextra < atom->nextra_border; iextra++)
 
1153
      m += modify->fix[atom->extra_border[iextra]]->
 
1154
        unpack_border(n,first,&buf[m]);
 
1155
}
 
1156
 
 
1157
/* ---------------------------------------------------------------------- */
 
1158
 
 
1159
int AtomVecFullKokkos::unpack_border_hybrid(int n, int first, double *buf)
 
1160
{
 
1161
  int i,m,last;
 
1162
 
 
1163
  m = 0;
 
1164
  last = first + n;
 
1165
  for (i = first; i < last; i++) {
 
1166
    h_q(i) = buf[m++];
 
1167
    h_molecule(i) = (tagint) ubuf(buf[m++]).i;
 
1168
  }
 
1169
  return m;
 
1170
}
 
1171
 
 
1172
/* ---------------------------------------------------------------------- */
 
1173
 
 
1174
template<class DeviceType>
 
1175
struct AtomVecFullKokkos_PackExchangeFunctor {
 
1176
 
 
1177
  union ubuf {
 
1178
    double d;
 
1179
    int64_t i;
 
1180
    ubuf(double arg) : d(arg) {}
 
1181
    ubuf(int64_t arg) : i(arg) {}
 
1182
    ubuf(int arg) : i(arg) {}
 
1183
  };
 
1184
 
 
1185
  typedef DeviceType device_type;
 
1186
  typedef ArrayTypes<DeviceType> AT;
 
1187
  typename AT::t_x_array_randomread _x;
 
1188
  typename AT::t_v_array_randomread _v;
 
1189
  typename AT::t_tagint_1d_randomread _tag;
 
1190
  typename AT::t_int_1d_randomread _type;
 
1191
  typename AT::t_int_1d_randomread _mask;
 
1192
  typename AT::t_imageint_1d_randomread _image;
 
1193
  typename AT::t_float_1d_randomread _q;
 
1194
  typename AT::t_tagint_1d_randomread _molecule;
 
1195
  typename AT::t_int_2d_randomread _nspecial;
 
1196
  typename AT::t_tagint_2d_randomread _special;
 
1197
  typename AT::t_int_1d_randomread _num_bond;
 
1198
  typename AT::t_int_2d_randomread _bond_type;
 
1199
  typename AT::t_tagint_2d_randomread _bond_atom;
 
1200
  typename AT::t_int_1d_randomread _num_angle;
 
1201
  typename AT::t_int_2d_randomread _angle_type;
 
1202
  typename AT::t_tagint_2d_randomread _angle_atom1,_angle_atom2,_angle_atom3;
 
1203
  typename AT::t_int_1d_randomread _num_dihedral;
 
1204
  typename AT::t_int_2d_randomread _dihedral_type;
 
1205
  typename AT::t_tagint_2d_randomread _dihedral_atom1,_dihedral_atom2,
 
1206
    _dihedral_atom3,_dihedral_atom4;
 
1207
  typename AT::t_int_1d_randomread _num_improper;
 
1208
  typename AT::t_int_2d_randomread _improper_type;
 
1209
  typename AT::t_tagint_2d_randomread _improper_atom1,_improper_atom2,
 
1210
    _improper_atom3,_improper_atom4;
 
1211
  typename AT::t_x_array _xw;
 
1212
  typename AT::t_v_array _vw;
 
1213
  typename AT::t_tagint_1d _tagw;
 
1214
  typename AT::t_int_1d _typew;
 
1215
  typename AT::t_int_1d _maskw;
 
1216
  typename AT::t_imageint_1d _imagew;
 
1217
  typename AT::t_float_1d _qw;
 
1218
  typename AT::t_tagint_1d _moleculew;
 
1219
  typename AT::t_int_2d _nspecialw;
 
1220
  typename AT::t_tagint_2d _specialw;
 
1221
  typename AT::t_int_1d _num_bondw;
 
1222
  typename AT::t_int_2d _bond_typew;
 
1223
  typename AT::t_tagint_2d _bond_atomw;
 
1224
  typename AT::t_int_1d _num_anglew;
 
1225
  typename AT::t_int_2d _angle_typew;
 
1226
  typename AT::t_tagint_2d _angle_atom1w,_angle_atom2w,_angle_atom3w;
 
1227
  typename AT::t_int_1d _num_dihedralw;
 
1228
  typename AT::t_int_2d _dihedral_typew;
 
1229
  typename AT::t_tagint_2d _dihedral_atom1w,_dihedral_atom2w,
 
1230
    _dihedral_atom3w,_dihedral_atom4w;
 
1231
  typename AT::t_int_1d _num_improperw;
 
1232
  typename AT::t_int_2d _improper_typew;
 
1233
  typename AT::t_tagint_2d _improper_atom1w,_improper_atom2w,
 
1234
    _improper_atom3w,_improper_atom4w;
 
1235
  typename AT::t_xfloat_2d_um _buf;
 
1236
  typename AT::t_int_1d_const _sendlist;
 
1237
  typename AT::t_int_1d_const _copylist;
 
1238
  int _nlocal,_dim;
 
1239
  X_FLOAT _lo,_hi;
 
1240
  size_t elements;
 
1241
 
 
1242
  AtomVecFullKokkos_PackExchangeFunctor(
 
1243
      const AtomKokkos* atom,
 
1244
      const typename AT::tdual_xfloat_2d buf,
 
1245
      typename AT::tdual_int_1d sendlist,
 
1246
      typename AT::tdual_int_1d copylist,int nlocal, int dim,
 
1247
                X_FLOAT lo, X_FLOAT hi):
 
1248
    _x(atom->k_x.view<DeviceType>()),
 
1249
    _v(atom->k_v.view<DeviceType>()),
 
1250
    _tag(atom->k_tag.view<DeviceType>()),
 
1251
    _type(atom->k_type.view<DeviceType>()),
 
1252
    _mask(atom->k_mask.view<DeviceType>()),
 
1253
    _image(atom->k_image.view<DeviceType>()),
 
1254
    _q(atom->k_q.view<DeviceType>()),
 
1255
    _molecule(atom->k_molecule.view<DeviceType>()),
 
1256
    _nspecial(atom->k_nspecial.view<DeviceType>()),
 
1257
    _special(atom->k_special.view<DeviceType>()),
 
1258
    _num_bond(atom->k_num_bond.view<DeviceType>()),
 
1259
    _bond_type(atom->k_bond_type.view<DeviceType>()),
 
1260
    _bond_atom(atom->k_bond_atom.view<DeviceType>()),
 
1261
    _num_angle(atom->k_num_angle.view<DeviceType>()),
 
1262
    _angle_type(atom->k_angle_type.view<DeviceType>()),
 
1263
    _angle_atom1(atom->k_angle_atom1.view<DeviceType>()),
 
1264
    _angle_atom2(atom->k_angle_atom2.view<DeviceType>()),
 
1265
    _angle_atom3(atom->k_angle_atom3.view<DeviceType>()),
 
1266
    _num_dihedral(atom->k_num_dihedral.view<DeviceType>()),
 
1267
    _dihedral_type(atom->k_dihedral_type.view<DeviceType>()),
 
1268
    _dihedral_atom1(atom->k_dihedral_atom1.view<DeviceType>()),
 
1269
    _dihedral_atom2(atom->k_dihedral_atom2.view<DeviceType>()),
 
1270
    _dihedral_atom3(atom->k_dihedral_atom3.view<DeviceType>()),
 
1271
    _dihedral_atom4(atom->k_dihedral_atom4.view<DeviceType>()),
 
1272
    _num_improper(atom->k_num_improper.view<DeviceType>()),
 
1273
    _improper_type(atom->k_improper_type.view<DeviceType>()),
 
1274
    _improper_atom1(atom->k_improper_atom1.view<DeviceType>()),
 
1275
    _improper_atom2(atom->k_improper_atom2.view<DeviceType>()),
 
1276
    _improper_atom3(atom->k_improper_atom3.view<DeviceType>()),
 
1277
    _improper_atom4(atom->k_improper_atom4.view<DeviceType>()),
 
1278
    _xw(atom->k_x.view<DeviceType>()),
 
1279
    _vw(atom->k_v.view<DeviceType>()),
 
1280
    _tagw(atom->k_tag.view<DeviceType>()),
 
1281
    _typew(atom->k_type.view<DeviceType>()),
 
1282
    _maskw(atom->k_mask.view<DeviceType>()),
 
1283
    _imagew(atom->k_image.view<DeviceType>()),
 
1284
    _qw(atom->k_q.view<DeviceType>()),
 
1285
    _moleculew(atom->k_molecule.view<DeviceType>()),
 
1286
    _nspecialw(atom->k_nspecial.view<DeviceType>()),
 
1287
    _specialw(atom->k_special.view<DeviceType>()),
 
1288
    _num_bondw(atom->k_num_bond.view<DeviceType>()),
 
1289
    _bond_typew(atom->k_bond_type.view<DeviceType>()),
 
1290
    _bond_atomw(atom->k_bond_atom.view<DeviceType>()),
 
1291
    _num_anglew(atom->k_num_angle.view<DeviceType>()),
 
1292
    _angle_typew(atom->k_angle_type.view<DeviceType>()),
 
1293
    _angle_atom1w(atom->k_angle_atom1.view<DeviceType>()),
 
1294
    _angle_atom2w(atom->k_angle_atom2.view<DeviceType>()),
 
1295
    _angle_atom3w(atom->k_angle_atom3.view<DeviceType>()),
 
1296
    _num_dihedralw(atom->k_num_dihedral.view<DeviceType>()),
 
1297
    _dihedral_typew(atom->k_dihedral_type.view<DeviceType>()),
 
1298
    _dihedral_atom1w(atom->k_dihedral_atom1.view<DeviceType>()),
 
1299
    _dihedral_atom2w(atom->k_dihedral_atom2.view<DeviceType>()),
 
1300
    _dihedral_atom3w(atom->k_dihedral_atom3.view<DeviceType>()),
 
1301
    _dihedral_atom4w(atom->k_dihedral_atom4.view<DeviceType>()),
 
1302
    _num_improperw(atom->k_num_improper.view<DeviceType>()),
 
1303
    _improper_typew(atom->k_improper_type.view<DeviceType>()),
 
1304
    _improper_atom1w(atom->k_improper_atom1.view<DeviceType>()),
 
1305
    _improper_atom2w(atom->k_improper_atom2.view<DeviceType>()),
 
1306
    _improper_atom3w(atom->k_improper_atom3.view<DeviceType>()),
 
1307
    _improper_atom4w(atom->k_improper_atom4.view<DeviceType>()),
 
1308
    _sendlist(sendlist.template view<DeviceType>()),
 
1309
    _copylist(copylist.template view<DeviceType>()),
 
1310
    _nlocal(nlocal),_dim(dim),
 
1311
    _lo(lo),_hi(hi){
 
1312
    // 3 comp of x, 3 comp of v, 1 tag, 1 type, 1 mask, 1 image, 1 molecule, 3 nspecial,
 
1313
    // maxspecial special, 1 num_bond, bond_per_atom bond_type, bond_per_atom bond_atom,
 
1314
    // 1 num_angle, angle_per_atom angle_type, angle_per_atom angle_atom1, angle_atom2,
 
1315
    // and angle_atom3
 
1316
    // 1 num_dihedral, dihedral_per_atom dihedral_type, 4*dihedral_per_atom
 
1317
    // 1 num_improper, 5*improper_per_atom
 
1318
    // 1 charge
 
1319
    // 1 to store buffer length
 
1320
    elements = 20+atom->maxspecial+2*atom->bond_per_atom+4*atom->angle_per_atom+
 
1321
      5*atom->dihedral_per_atom + 5*atom->improper_per_atom;
 
1322
    const int maxsendlist = (buf.template view<DeviceType>().dimension_0()*
 
1323
                             buf.template view<DeviceType>().dimension_1())/elements;
 
1324
    buffer_view<DeviceType>(_buf,buf,maxsendlist,elements);
 
1325
  }
 
1326
 
 
1327
  KOKKOS_INLINE_FUNCTION
 
1328
  void operator() (const int &mysend) const {
 
1329
    int k;
 
1330
    const int i = _sendlist(mysend);
 
1331
    _buf(mysend,0) = elements;
 
1332
    int m = 1;
 
1333
    _buf(mysend,m++) = _x(i,0);
 
1334
    _buf(mysend,m++) = _x(i,1);
 
1335
    _buf(mysend,m++) = _x(i,2);
 
1336
    _buf(mysend,m++) = _v(i,0);
 
1337
    _buf(mysend,m++) = _v(i,1);
 
1338
    _buf(mysend,m++) = _v(i,2);
 
1339
    _buf(mysend,m++) = ubuf(_tag(i)).d;
 
1340
    _buf(mysend,m++) = ubuf(_type(i)).d;
 
1341
    _buf(mysend,m++) = ubuf(_mask(i)).d;
 
1342
    _buf(mysend,m++) = ubuf(_image(i)).d;
 
1343
    _buf(mysend,m++) = _q(i);
 
1344
    _buf(mysend,m++) = ubuf(_molecule(i)).d;
 
1345
    _buf(mysend,m++) = ubuf(_num_bond(i)).d;
 
1346
    for (k = 0; k < _num_bond(i); k++) {
 
1347
      _buf(mysend,m++) = ubuf(_bond_type(i,k)).d;
 
1348
      _buf(mysend,m++) = ubuf(_bond_atom(i,k)).d;
 
1349
    }
 
1350
    _buf(mysend,m++) = ubuf(_num_angle(i)).d;
 
1351
    for (k = 0; k < _num_angle(i); k++) {
 
1352
      _buf(mysend,m++) = ubuf(_angle_type(i,k)).d;
 
1353
      _buf(mysend,m++) = ubuf(_angle_atom1(i,k)).d;
 
1354
      _buf(mysend,m++) = ubuf(_angle_atom2(i,k)).d;
 
1355
      _buf(mysend,m++) = ubuf(_angle_atom3(i,k)).d;
 
1356
    }
 
1357
    _buf(mysend,m++) = ubuf(_num_dihedral(i)).d;
 
1358
    for (k = 0; k < _num_dihedral(i); k++) {
 
1359
      _buf(mysend,m++) = ubuf(_dihedral_type(i,k)).d;
 
1360
      _buf(mysend,m++) = ubuf(_dihedral_atom1(i,k)).d;
 
1361
      _buf(mysend,m++) = ubuf(_dihedral_atom2(i,k)).d;
 
1362
      _buf(mysend,m++) = ubuf(_dihedral_atom3(i,k)).d;
 
1363
      _buf(mysend,m++) = ubuf(_dihedral_atom4(i,k)).d;
 
1364
    }
 
1365
    _buf(mysend,m++) = ubuf(_num_improper(i)).d;
 
1366
    for (k = 0; k < _num_improper(i); k++) {
 
1367
      _buf(mysend,m++) = ubuf(_improper_type(i,k)).d;
 
1368
      _buf(mysend,m++) = ubuf(_improper_atom1(i,k)).d;
 
1369
      _buf(mysend,m++) = ubuf(_improper_atom2(i,k)).d;
 
1370
      _buf(mysend,m++) = ubuf(_improper_atom3(i,k)).d;
 
1371
      _buf(mysend,m++) = ubuf(_improper_atom4(i,k)).d;
 
1372
    }
 
1373
 
 
1374
    _buf(mysend,m++) = ubuf(_nspecial(i,0)).d;
 
1375
    _buf(mysend,m++) = ubuf(_nspecial(i,1)).d;
 
1376
    _buf(mysend,m++) = ubuf(_nspecial(i,2)).d;
 
1377
    for (k = 0; k < _nspecial(i,2); k++)
 
1378
      _buf(mysend,m++) = ubuf(_special(i,k)).d;
 
1379
 
 
1380
    const int j = _copylist(mysend);
 
1381
 
 
1382
    if(j>-1) {
 
1383
    _xw(i,0) = _x(j,0);
 
1384
    _xw(i,1) = _x(j,1);
 
1385
    _xw(i,2) = _x(j,2);
 
1386
    _vw(i,0) = _v(j,0);
 
1387
    _vw(i,1) = _v(j,1);
 
1388
    _vw(i,2) = _v(j,2);
 
1389
    _tagw(i) = _tag(j);
 
1390
    _typew(i) = _type(j);
 
1391
    _maskw(i) = _mask(j);
 
1392
    _imagew(i) = _image(j);
 
1393
    _qw(i) = _q(j);
 
1394
    _moleculew(i) = _molecule(j);
 
1395
    _num_bondw(i) = _num_bond(j);
 
1396
    for (k = 0; k < _num_bond(j); k++) {
 
1397
      _bond_typew(i,k) = _bond_type(j,k);
 
1398
      _bond_atomw(i,k) = _bond_atom(j,k);
 
1399
    }
 
1400
    _num_anglew(i) = _num_angle(j);
 
1401
    for (k = 0; k < _num_angle(j); k++) {
 
1402
      _angle_typew(i,k) = _angle_type(j,k);
 
1403
      _angle_atom1w(i,k) = _angle_atom1(j,k);
 
1404
      _angle_atom2w(i,k) = _angle_atom2(j,k);
 
1405
      _angle_atom3w(i,k) = _angle_atom3(j,k);
 
1406
    }
 
1407
    _num_dihedralw(i) = _num_dihedral(j);
 
1408
    for (k = 0; k < _num_dihedral(j); k++) {
 
1409
      _dihedral_typew(i,k) = _dihedral_type(j,k);
 
1410
      _dihedral_atom1w(i,k) = _dihedral_atom1(j,k);
 
1411
      _dihedral_atom2w(i,k) = _dihedral_atom2(j,k);
 
1412
      _dihedral_atom3w(i,k) = _dihedral_atom3(j,k);
 
1413
      _dihedral_atom4w(i,k) = _dihedral_atom4(j,k);
 
1414
    }
 
1415
    _num_improperw(i) = _num_improper(j);
 
1416
    for (k = 0; k < _num_improper(j); k++) {
 
1417
      _improper_typew(i,k) = _improper_type(j,k);
 
1418
      _improper_atom1w(i,k) = _improper_atom1(j,k);
 
1419
      _improper_atom2w(i,k) = _improper_atom2(j,k);
 
1420
      _improper_atom3w(i,k) = _improper_atom3(j,k);
 
1421
      _improper_atom4w(i,k) = _improper_atom4(j,k);
 
1422
    }
 
1423
    _nspecialw(i,0) = _nspecial(j,0);
 
1424
    _nspecialw(i,1) = _nspecial(j,1);
 
1425
    _nspecialw(i,2) = _nspecial(j,2);
 
1426
    for (k = 0; k < _nspecial(j,2); k++)
 
1427
      _specialw(i,k) = _special(j,k);
 
1428
    }
 
1429
  }
 
1430
};
 
1431
 
 
1432
/* ---------------------------------------------------------------------- */
 
1433
 
 
1434
int AtomVecFullKokkos::pack_exchange_kokkos(const int &nsend,DAT::tdual_xfloat_2d &k_buf,
 
1435
                                                 DAT::tdual_int_1d k_sendlist,
 
1436
                                                 DAT::tdual_int_1d k_copylist,
 
1437
                                                 ExecutionSpace space,int dim,X_FLOAT lo,
 
1438
                                                 X_FLOAT hi )
 
1439
{
 
1440
  const int elements = 20+atom->maxspecial+2*atom->bond_per_atom+4*atom->angle_per_atom+
 
1441
      5*atom->dihedral_per_atom + 5*atom->improper_per_atom;
 
1442
  if(nsend > (int) (k_buf.view<LMPHostType>().dimension_0()*
 
1443
              k_buf.view<LMPHostType>().dimension_1())/elements) {
 
1444
    int newsize = nsend*elements/k_buf.view<LMPHostType>().dimension_1()+1;
 
1445
    k_buf.resize(newsize,k_buf.view<LMPHostType>().dimension_1());
 
1446
  }
 
1447
  if(space == Host) {
 
1448
    AtomVecFullKokkos_PackExchangeFunctor<LMPHostType>
 
1449
      f(atomKK,k_buf,k_sendlist,k_copylist,atom->nlocal,dim,lo,hi);
 
1450
    Kokkos::parallel_for(nsend,f);
 
1451
    LMPHostType::fence();
 
1452
    return nsend*elements;
 
1453
  } else {
 
1454
    AtomVecFullKokkos_PackExchangeFunctor<LMPDeviceType>
 
1455
      f(atomKK,k_buf,k_sendlist,k_copylist,atom->nlocal,dim,lo,hi);
 
1456
    Kokkos::parallel_for(nsend,f);
 
1457
    LMPDeviceType::fence();
 
1458
    return nsend*elements;
 
1459
  }
 
1460
}
 
1461
 
 
1462
/* ---------------------------------------------------------------------- */
 
1463
 
 
1464
int AtomVecFullKokkos::pack_exchange(int i, double *buf)
 
1465
{
 
1466
  int k;
 
1467
  int m = 1;
 
1468
  buf[m++] = h_x(i,0);
 
1469
  buf[m++] = h_x(i,1);
 
1470
  buf[m++] = h_x(i,2);
 
1471
  buf[m++] = h_v(i,0);
 
1472
  buf[m++] = h_v(i,1);
 
1473
  buf[m++] = h_v(i,2);
 
1474
  buf[m++] = ubuf(h_tag(i)).d;
 
1475
  buf[m++] = ubuf(h_type(i)).d;
 
1476
  buf[m++] = ubuf(h_mask(i)).d;
 
1477
  buf[m++] = ubuf(h_image(i)).d;
 
1478
  buf[m++] = h_q(i);
 
1479
  buf[m++] = ubuf(h_molecule(i)).d;
 
1480
  buf[m++] = ubuf(h_num_bond(i)).d;
 
1481
  for (k = 0; k < h_num_bond(i); k++) {
 
1482
    buf[m++] = ubuf(h_bond_type(i,k)).d;
 
1483
    buf[m++] = ubuf(h_bond_atom(i,k)).d;
 
1484
  }
 
1485
  buf[m++] = ubuf(h_num_angle(i)).d;
 
1486
  for (k = 0; k < h_num_angle(i); k++) {
 
1487
    buf[m++] = ubuf(h_angle_type(i,k)).d;
 
1488
    buf[m++] = ubuf(h_angle_atom1(i,k)).d;
 
1489
    buf[m++] = ubuf(h_angle_atom2(i,k)).d;
 
1490
    buf[m++] = ubuf(h_angle_atom3(i,k)).d;
 
1491
  }
 
1492
  buf[m++] = ubuf(h_num_dihedral(i)).d;
 
1493
  for (k = 0; k < h_num_dihedral(i); k++) {
 
1494
    buf[m++] = ubuf(h_dihedral_type(i,k)).d;
 
1495
    buf[m++] = ubuf(h_dihedral_atom1(i,k)).d;
 
1496
    buf[m++] = ubuf(h_dihedral_atom2(i,k)).d;
 
1497
    buf[m++] = ubuf(h_dihedral_atom3(i,k)).d;
 
1498
    buf[m++] = ubuf(h_dihedral_atom4(i,k)).d;
 
1499
  }
 
1500
  buf[m++] = ubuf(h_num_improper(i)).d;
 
1501
  for (k = 0; k < h_num_improper(i); k++) {
 
1502
    buf[m++] = ubuf(h_improper_type(i,k)).d;
 
1503
    buf[m++] = ubuf(h_improper_atom1(i,k)).d;
 
1504
    buf[m++] = ubuf(h_improper_atom2(i,k)).d;
 
1505
    buf[m++] = ubuf(h_improper_atom3(i,k)).d;
 
1506
    buf[m++] = ubuf(h_improper_atom4(i,k)).d;
 
1507
  }
 
1508
  buf[m++] = ubuf(h_nspecial(i,0)).d;
 
1509
  buf[m++] = ubuf(h_nspecial(i,1)).d;
 
1510
  buf[m++] = ubuf(h_nspecial(i,2)).d;
 
1511
  for (k = 0; k < h_nspecial(i,2); k++)
 
1512
    buf[m++] = ubuf(h_special(i,k)).d;
 
1513
 
 
1514
  if (atom->nextra_grow)
 
1515
    for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
 
1516
      m += modify->fix[atom->extra_grow[iextra]]->pack_exchange(i,&buf[m]);
 
1517
 
 
1518
  buf[0] = m;
 
1519
  return m;
 
1520
}
 
1521
 
 
1522
/* ---------------------------------------------------------------------- */
 
1523
 
 
1524
template<class DeviceType>
 
1525
struct AtomVecFullKokkos_UnpackExchangeFunctor {
 
1526
 
 
1527
  union ubuf {
 
1528
    double d;
 
1529
    int64_t i;
 
1530
    ubuf(double arg) : d(arg) {}
 
1531
    ubuf(int64_t arg) : i(arg) {}
 
1532
    ubuf(int arg) : i(arg) {}
 
1533
  };
 
1534
 
 
1535
  typedef DeviceType device_type;
 
1536
  typedef ArrayTypes<DeviceType> AT;
 
1537
  typename AT::t_x_array _x;
 
1538
  typename AT::t_v_array _v;
 
1539
  typename AT::t_tagint_1d _tag;
 
1540
  typename AT::t_int_1d _type;
 
1541
  typename AT::t_int_1d _mask;
 
1542
  typename AT::t_imageint_1d _image;
 
1543
  typename AT::t_float_1d _q;
 
1544
  typename AT::t_tagint_1d _molecule;
 
1545
  typename AT::t_int_2d _nspecial;
 
1546
  typename AT::t_tagint_2d _special;
 
1547
  typename AT::t_int_1d _num_bond;
 
1548
  typename AT::t_int_2d _bond_type;
 
1549
  typename AT::t_tagint_2d _bond_atom;
 
1550
  typename AT::t_int_1d _num_angle;
 
1551
  typename AT::t_int_2d _angle_type;
 
1552
  typename AT::t_tagint_2d _angle_atom1,_angle_atom2,_angle_atom3;
 
1553
  typename AT::t_int_1d _num_dihedral;
 
1554
  typename AT::t_int_2d _dihedral_type;
 
1555
  typename AT::t_tagint_2d _dihedral_atom1,_dihedral_atom2,
 
1556
    _dihedral_atom3,_dihedral_atom4;
 
1557
  typename AT::t_int_1d _num_improper;
 
1558
  typename AT::t_int_2d _improper_type;
 
1559
  typename AT::t_tagint_2d _improper_atom1,_improper_atom2,
 
1560
    _improper_atom3,_improper_atom4;
 
1561
 
 
1562
  typename AT::t_xfloat_2d_um _buf;
 
1563
  typename AT::t_int_1d _nlocal;
 
1564
  int _dim;
 
1565
  X_FLOAT _lo,_hi;
 
1566
  size_t elements;
 
1567
 
 
1568
  AtomVecFullKokkos_UnpackExchangeFunctor(
 
1569
      const AtomKokkos* atom,
 
1570
      const typename AT::tdual_xfloat_2d buf,
 
1571
      typename AT::tdual_int_1d nlocal,
 
1572
      int dim, X_FLOAT lo, X_FLOAT hi):
 
1573
    _x(atom->k_x.view<DeviceType>()),
 
1574
    _v(atom->k_v.view<DeviceType>()),
 
1575
    _tag(atom->k_tag.view<DeviceType>()),
 
1576
    _type(atom->k_type.view<DeviceType>()),
 
1577
    _mask(atom->k_mask.view<DeviceType>()),
 
1578
    _image(atom->k_image.view<DeviceType>()),
 
1579
    _q(atom->k_q.view<DeviceType>()),
 
1580
    _molecule(atom->k_molecule.view<DeviceType>()),
 
1581
    _nspecial(atom->k_nspecial.view<DeviceType>()),
 
1582
    _special(atom->k_special.view<DeviceType>()),
 
1583
    _num_bond(atom->k_num_bond.view<DeviceType>()),
 
1584
    _bond_type(atom->k_bond_type.view<DeviceType>()),
 
1585
    _bond_atom(atom->k_bond_atom.view<DeviceType>()),
 
1586
    _num_angle(atom->k_num_angle.view<DeviceType>()),
 
1587
    _angle_type(atom->k_angle_type.view<DeviceType>()),
 
1588
    _angle_atom1(atom->k_angle_atom1.view<DeviceType>()),
 
1589
    _angle_atom2(atom->k_angle_atom2.view<DeviceType>()),
 
1590
    _angle_atom3(atom->k_angle_atom3.view<DeviceType>()),
 
1591
    _num_dihedral(atom->k_num_dihedral.view<DeviceType>()),
 
1592
    _dihedral_type(atom->k_dihedral_type.view<DeviceType>()),
 
1593
    _dihedral_atom1(atom->k_dihedral_atom1.view<DeviceType>()),
 
1594
    _dihedral_atom2(atom->k_dihedral_atom2.view<DeviceType>()),
 
1595
    _dihedral_atom3(atom->k_dihedral_atom3.view<DeviceType>()),
 
1596
    _dihedral_atom4(atom->k_dihedral_atom4.view<DeviceType>()),
 
1597
    _num_improper(atom->k_num_improper.view<DeviceType>()),
 
1598
    _improper_type(atom->k_improper_type.view<DeviceType>()),
 
1599
    _improper_atom1(atom->k_improper_atom1.view<DeviceType>()),
 
1600
    _improper_atom2(atom->k_improper_atom2.view<DeviceType>()),
 
1601
    _improper_atom3(atom->k_improper_atom3.view<DeviceType>()),
 
1602
    _improper_atom4(atom->k_improper_atom4.view<DeviceType>()),
 
1603
    _nlocal(nlocal.template view<DeviceType>()),_dim(dim),
 
1604
    _lo(lo),_hi(hi){
 
1605
 
 
1606
    elements = 20+atom->maxspecial+2*atom->bond_per_atom+4*atom->angle_per_atom+
 
1607
      5*atom->dihedral_per_atom + 5*atom->improper_per_atom;
 
1608
    const int maxsendlist = (buf.template view<DeviceType>().dimension_0()*
 
1609
                             buf.template view<DeviceType>().dimension_1())/elements;
 
1610
    buffer_view<DeviceType>(_buf,buf,maxsendlist,elements);
 
1611
  }
 
1612
 
 
1613
  KOKKOS_INLINE_FUNCTION
 
1614
  void operator() (const int &myrecv) const {
 
1615
    X_FLOAT x = _buf(myrecv,_dim+1);
 
1616
    if (x >= _lo && x < _hi) {
 
1617
      int i = Kokkos::atomic_fetch_add(&_nlocal(0),1);
 
1618
      int m = 1;
 
1619
      _x(i,0) = _buf(myrecv,m++);
 
1620
      _x(i,1) = _buf(myrecv,m++);
 
1621
      _x(i,2) = _buf(myrecv,m++);
 
1622
      _v(i,0) = _buf(myrecv,m++);
 
1623
      _v(i,1) = _buf(myrecv,m++);
 
1624
      _v(i,2) = _buf(myrecv,m++);
 
1625
      _tag(i) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1626
      _type(i) = (int) ubuf(_buf(myrecv,m++)).i;
 
1627
      _mask(i) = (int) ubuf(_buf(myrecv,m++)).i;
 
1628
      _image(i) = (imageint) ubuf(_buf(myrecv,m++)).i;
 
1629
      _q(i) = _buf(myrecv,m++);
 
1630
      _molecule(i) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1631
      _num_bond(i) = (int) ubuf(_buf(myrecv,m++)).i;
 
1632
      int k;
 
1633
      for (k = 0; k < _num_bond(i); k++) {
 
1634
        _bond_type(i,k) = (int) ubuf(_buf(myrecv,m++)).i;
 
1635
        _bond_atom(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1636
      }
 
1637
      _num_angle(i) = (int) ubuf(_buf(myrecv,m++)).i;
 
1638
      for (k = 0; k < _num_angle(i); k++) {
 
1639
        _angle_type(i,k) = (int) ubuf(_buf(myrecv,m++)).i;
 
1640
        _angle_atom1(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1641
        _angle_atom2(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1642
        _angle_atom3(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1643
      }
 
1644
      _num_dihedral(i) = (int) ubuf(_buf(myrecv,m++)).i;
 
1645
      for (k = 0; k < _num_dihedral(i); k++) {
 
1646
        _dihedral_type(i,k) = (int) ubuf(_buf(myrecv,m++)).i;
 
1647
        _dihedral_atom1(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1648
        _dihedral_atom2(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1649
        _dihedral_atom3(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1650
        _dihedral_atom4(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1651
      }
 
1652
      _num_improper(i) = (int) ubuf(_buf(myrecv,m++)).i;
 
1653
      for (k = 0; k < _num_improper(i); k++) {
 
1654
        _improper_type(i,k) = (int) ubuf(_buf(myrecv,m++)).i;
 
1655
        _improper_atom1(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1656
        _improper_atom2(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1657
        _improper_atom3(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1658
        _improper_atom4(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1659
      }
 
1660
      _nspecial(i,0) = (int) ubuf(_buf(myrecv,m++)).i;
 
1661
      _nspecial(i,1) = (int) ubuf(_buf(myrecv,m++)).i;
 
1662
      _nspecial(i,2) = (int) ubuf(_buf(myrecv,m++)).i;
 
1663
      for (k = 0; k < _nspecial(i,2); k++)
 
1664
        _special(i,k) = (tagint) ubuf(_buf(myrecv,m++)).i;
 
1665
    }
 
1666
  }
 
1667
};
 
1668
 
 
1669
/* ---------------------------------------------------------------------- */
 
1670
 
 
1671
int AtomVecFullKokkos::unpack_exchange_kokkos(DAT::tdual_xfloat_2d &k_buf,int nrecv,
 
1672
                                              int nlocal,int dim,X_FLOAT lo,X_FLOAT hi,
 
1673
                                              ExecutionSpace space) {
 
1674
  const size_t elements = 20+atom->maxspecial+2*atom->bond_per_atom+4*atom->angle_per_atom+
 
1675
    5*atom->dihedral_per_atom + 5*atom->improper_per_atom;
 
1676
  if(space == Host) {
 
1677
    k_count.h_view(0) = nlocal;
 
1678
    AtomVecFullKokkos_UnpackExchangeFunctor<LMPHostType>
 
1679
      f(atomKK,k_buf,k_count,dim,lo,hi);
 
1680
    Kokkos::parallel_for(nrecv/elements,f);
 
1681
    LMPHostType::fence();
 
1682
    return k_count.h_view(0);
 
1683
  } else {
 
1684
    k_count.h_view(0) = nlocal;
 
1685
    k_count.modify<LMPHostType>();
 
1686
    k_count.sync<LMPDeviceType>();
 
1687
    AtomVecFullKokkos_UnpackExchangeFunctor<LMPDeviceType>
 
1688
      f(atomKK,k_buf,k_count,dim,lo,hi);
 
1689
    Kokkos::parallel_for(nrecv/elements,f);
 
1690
    LMPDeviceType::fence();
 
1691
    k_count.modify<LMPDeviceType>();
 
1692
    k_count.sync<LMPHostType>();
 
1693
 
 
1694
    return k_count.h_view(0);
 
1695
  }
 
1696
}
 
1697
 
 
1698
/* ---------------------------------------------------------------------- */
 
1699
 
 
1700
int AtomVecFullKokkos::unpack_exchange(double *buf)
 
1701
{
 
1702
  int nlocal = atom->nlocal;
 
1703
  if (nlocal == nmax) grow(0);
 
1704
  modified(Host,X_MASK | V_MASK | TAG_MASK | TYPE_MASK |
 
1705
           MASK_MASK | IMAGE_MASK | Q_MASK | MOLECULE_MASK | BOND_MASK |
 
1706
           ANGLE_MASK | DIHEDRAL_MASK | IMPROPER_MASK | SPECIAL_MASK);
 
1707
 
 
1708
  int k;
 
1709
  int m = 1;
 
1710
  h_x(nlocal,0) = buf[m++];
 
1711
  h_x(nlocal,1) = buf[m++];
 
1712
  h_x(nlocal,2) = buf[m++];
 
1713
  h_v(nlocal,0) = buf[m++];
 
1714
  h_v(nlocal,1) = buf[m++];
 
1715
  h_v(nlocal,2) = buf[m++];
 
1716
  h_tag(nlocal) = (tagint) ubuf(buf[m++]).i;
 
1717
  h_type(nlocal) = (int) ubuf(buf[m++]).i;
 
1718
  h_mask(nlocal) = (int) ubuf(buf[m++]).i;
 
1719
  h_image(nlocal) = (imageint) ubuf(buf[m++]).i;
 
1720
  h_q(nlocal) = buf[m++];
 
1721
  h_molecule(nlocal) = (tagint) ubuf(buf[m++]).i;
 
1722
 
 
1723
  h_num_bond(nlocal) = (int) ubuf(buf[m++]).i;
 
1724
  for (k = 0; k < h_num_bond(nlocal); k++) {
 
1725
    h_bond_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1726
    h_bond_atom(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1727
  }
 
1728
  h_num_angle(nlocal) = (int) ubuf(buf[m++]).i;
 
1729
  for (k = 0; k < h_num_angle(nlocal); k++) {
 
1730
    h_angle_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1731
    h_angle_atom1(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1732
    h_angle_atom2(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1733
    h_angle_atom3(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1734
  }
 
1735
  h_num_dihedral(nlocal) = (int) ubuf(buf[m++]).i;
 
1736
  for (k = 0; k < h_num_dihedral(nlocal); k++) {
 
1737
    h_dihedral_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1738
    h_dihedral_atom1(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1739
    h_dihedral_atom2(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1740
    h_dihedral_atom3(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1741
    h_dihedral_atom4(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1742
  }
 
1743
  h_num_improper(nlocal) = (int) ubuf(buf[m++]).i;
 
1744
  for (k = 0; k < h_num_improper(nlocal); k++) {
 
1745
    h_improper_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1746
    h_improper_atom1(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1747
    h_improper_atom2(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1748
    h_improper_atom3(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1749
    h_improper_atom4(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1750
  }
 
1751
  h_nspecial(nlocal,0) = (int) ubuf(buf[m++]).i;
 
1752
  h_nspecial(nlocal,1) = (int) ubuf(buf[m++]).i;
 
1753
  h_nspecial(nlocal,2) = (int) ubuf(buf[m++]).i;
 
1754
  for (k = 0; k < h_nspecial(nlocal,2); k++)
 
1755
         h_special(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1756
 
 
1757
  if (atom->nextra_grow)
 
1758
    for (int iextra = 0; iextra < atom->nextra_grow; iextra++)
 
1759
      m += modify->fix[atom->extra_grow[iextra]]->
 
1760
        unpack_exchange(nlocal,&buf[m]);
 
1761
 
 
1762
  atom->nlocal++;
 
1763
  return m;
 
1764
}
 
1765
 
 
1766
/* ----------------------------------------------------------------------
 
1767
   size of restart data for all atoms owned by this proc
 
1768
   include extra data stored by fixes
 
1769
------------------------------------------------------------------------- */
 
1770
 
 
1771
int AtomVecFullKokkos::size_restart()
 
1772
{
 
1773
  int i;
 
1774
 
 
1775
  int nlocal = atom->nlocal;
 
1776
  int n = 0;
 
1777
  for (i = 0; i < nlocal; i++)
 
1778
    n += 17 + 2*num_bond[i] + 4*num_angle[i] +
 
1779
      5*num_dihedral[i] + 5*num_improper[i];
 
1780
 
 
1781
  if (atom->nextra_restart)
 
1782
    for (int iextra = 0; iextra < atom->nextra_restart; iextra++)
 
1783
      for (i = 0; i < nlocal; i++)
 
1784
        n += modify->fix[atom->extra_restart[iextra]]->size_restart(i);
 
1785
 
 
1786
  return n;
 
1787
}
 
1788
 
 
1789
/* ----------------------------------------------------------------------
 
1790
   pack atom I's data for restart file including extra quantities
 
1791
   xyz must be 1st 3 values, so that read_restart can test on them
 
1792
   molecular types may be negative, but write as positive
 
1793
------------------------------------------------------------------------- */
 
1794
 
 
1795
int AtomVecFullKokkos::pack_restart(int i, double *buf)
 
1796
{
 
1797
  int m = 1;
 
1798
  buf[m++] = h_x(i,0);
 
1799
  buf[m++] = h_x(i,1);
 
1800
  buf[m++] = h_x(i,2);
 
1801
  buf[m++] = ubuf(h_tag(i)).d;
 
1802
  buf[m++] = ubuf(h_type(i)).d;
 
1803
  buf[m++] = ubuf(h_mask(i)).d;
 
1804
  buf[m++] = ubuf(h_image(i)).d;
 
1805
  buf[m++] = h_v(i,0);
 
1806
  buf[m++] = h_v(i,1);
 
1807
  buf[m++] = h_v(i,2);
 
1808
 
 
1809
  buf[m++] = h_q(i);
 
1810
  buf[m++] = ubuf(h_molecule(i)).d;
 
1811
 
 
1812
  buf[m++] = ubuf(h_num_bond(i)).d;
 
1813
  for (int k = 0; k < h_num_bond(i); k++) {
 
1814
    buf[m++] = ubuf(MAX(h_bond_type(i,k),-h_bond_type(i,k))).d;
 
1815
    buf[m++] = ubuf(h_bond_atom(i,k)).d;
 
1816
  }
 
1817
 
 
1818
  buf[m++] = ubuf(h_num_angle(i)).d;
 
1819
  for (int k = 0; k < h_num_angle(i); k++) {
 
1820
    buf[m++] = ubuf(MAX(h_angle_type(i,k),-h_angle_type(i,k))).d;
 
1821
    buf[m++] = ubuf(h_angle_atom1(i,k)).d;
 
1822
    buf[m++] = ubuf(h_angle_atom2(i,k)).d;
 
1823
    buf[m++] = ubuf(h_angle_atom3(i,k)).d;
 
1824
  }
 
1825
 
 
1826
  buf[m++] = ubuf(h_num_dihedral(i)).d;
 
1827
  for (int k = 0; k < h_num_dihedral(i); k++) {
 
1828
    buf[m++] = ubuf(MAX(h_dihedral_type(i,k),-h_dihedral_type(i,k))).d;
 
1829
    buf[m++] = ubuf(h_dihedral_atom1(i,k)).d;
 
1830
    buf[m++] = ubuf(h_dihedral_atom2(i,k)).d;
 
1831
    buf[m++] = ubuf(h_dihedral_atom3(i,k)).d;
 
1832
    buf[m++] = ubuf(h_dihedral_atom4(i,k)).d;
 
1833
  }
 
1834
 
 
1835
  buf[m++] = ubuf(h_num_improper(i)).d;
 
1836
  for (int k = 0; k < h_num_improper(i); k++) {
 
1837
    buf[m++] = ubuf(MAX(h_improper_type(i,k),-h_improper_type(i,k))).d;
 
1838
    buf[m++] = ubuf(h_improper_atom1(i,k)).d;
 
1839
    buf[m++] = ubuf(h_improper_atom2(i,k)).d;
 
1840
    buf[m++] = ubuf(h_improper_atom3(i,k)).d;
 
1841
    buf[m++] = ubuf(h_improper_atom4(i,k)).d;
 
1842
  }
 
1843
 
 
1844
  if (atom->nextra_restart)
 
1845
    for (int iextra = 0; iextra < atom->nextra_restart; iextra++)
 
1846
      m += modify->fix[atom->extra_restart[iextra]]->pack_restart(i,&buf[m]);
 
1847
 
 
1848
  buf[0] = m;
 
1849
  return m;
 
1850
}
 
1851
 
 
1852
/* ----------------------------------------------------------------------
 
1853
   unpack data for one atom from restart file including extra quantities
 
1854
------------------------------------------------------------------------- */
 
1855
 
 
1856
int AtomVecFullKokkos::unpack_restart(double *buf)
 
1857
{
 
1858
  int k;
 
1859
 
 
1860
  int nlocal = atom->nlocal;
 
1861
  if (nlocal == nmax) {
 
1862
    grow(0);
 
1863
    if (atom->nextra_store)
 
1864
      memory->grow(atom->extra,nmax,atom->nextra_store,"atom:extra");
 
1865
  }
 
1866
 
 
1867
  int m = 1;
 
1868
  h_x(nlocal,0) = buf[m++];
 
1869
  h_x(nlocal,1) = buf[m++];
 
1870
  h_x(nlocal,2) = buf[m++];
 
1871
  h_tag(nlocal) = (tagint) ubuf(buf[m++]).i;
 
1872
  h_type(nlocal) = (int) ubuf(buf[m++]).i;
 
1873
  h_mask(nlocal) = (int) ubuf(buf[m++]).i;
 
1874
  h_image(nlocal) = (imageint) ubuf(buf[m++]).i;
 
1875
  h_v(nlocal,0) = buf[m++];
 
1876
  h_v(nlocal,1) = buf[m++];
 
1877
  h_v(nlocal,2) = buf[m++];
 
1878
 
 
1879
  h_q(nlocal) = buf[m++];
 
1880
  h_molecule(nlocal) = (tagint) ubuf(buf[m++]).i;
 
1881
 
 
1882
  h_num_bond(nlocal) = (int) ubuf(buf[m++]).i;
 
1883
  for (k = 0; k < h_num_bond(nlocal); k++) {
 
1884
    h_bond_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1885
    h_bond_atom(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1886
  }
 
1887
 
 
1888
  h_num_angle(nlocal) = (int) ubuf(buf[m++]).i;
 
1889
  for (k = 0; k < h_num_angle(nlocal); k++) {
 
1890
    h_angle_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1891
    h_angle_atom1(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1892
    h_angle_atom2(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1893
    h_angle_atom3(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1894
  }
 
1895
 
 
1896
  h_num_dihedral(nlocal) = (int) ubuf(buf[m++]).i;
 
1897
  for (k = 0; k < h_num_dihedral(nlocal); k++) {
 
1898
    h_dihedral_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1899
    h_dihedral_atom1(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1900
    h_dihedral_atom2(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1901
    h_dihedral_atom3(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1902
    h_dihedral_atom4(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1903
  }
 
1904
 
 
1905
  h_num_improper(nlocal) = (int) ubuf(buf[m++]).i;
 
1906
  for (k = 0; k < h_num_improper(nlocal); k++) {
 
1907
    h_improper_type(nlocal,k) = (int) ubuf(buf[m++]).i;
 
1908
    h_improper_atom1(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1909
    h_improper_atom2(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1910
    h_improper_atom3(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1911
    h_improper_atom4(nlocal,k) = (tagint) ubuf(buf[m++]).i;
 
1912
  }
 
1913
 
 
1914
  h_nspecial(nlocal,0) = h_nspecial(nlocal,1) = h_nspecial(nlocal,2) = 0;
 
1915
 
 
1916
  double **extra = atom->extra;
 
1917
  if (atom->nextra_store) {
 
1918
    int size = static_cast<int> (ubuf(buf[m++]).i) - m;
 
1919
    for (int i = 0; i < size; i++) extra[nlocal][i] = buf[m++];
 
1920
  }
 
1921
 
 
1922
  atom->nlocal++;
 
1923
  return m;
 
1924
}
 
1925
 
 
1926
/* ----------------------------------------------------------------------
 
1927
   create one atom of itype at coord
 
1928
   set other values to defaults
 
1929
------------------------------------------------------------------------- */
 
1930
 
 
1931
void AtomVecFullKokkos::create_atom(int itype, double *coord)
 
1932
{
 
1933
  int nlocal = atom->nlocal;
 
1934
  if (nlocal == nmax) {
 
1935
    atomKK->modified(Host,ALL_MASK);
 
1936
    grow(0);
 
1937
  }
 
1938
  atomKK->modified(Host,ALL_MASK);
 
1939
 
 
1940
  tag[nlocal] = 0;
 
1941
  type[nlocal] = itype;
 
1942
  h_x(nlocal,0) = coord[0];
 
1943
  h_x(nlocal,1) = coord[1];
 
1944
  h_x(nlocal,2) = coord[2];
 
1945
  h_mask(nlocal) = 1;
 
1946
  h_image(nlocal) = ((imageint) IMGMAX << IMG2BITS) |
 
1947
    ((imageint) IMGMAX << IMGBITS) | IMGMAX;
 
1948
  h_v(nlocal,0) = 0.0;
 
1949
  h_v(nlocal,1) = 0.0;
 
1950
  h_v(nlocal,2) = 0.0;
 
1951
 
 
1952
  h_q(nlocal) = 0.0;
 
1953
  h_molecule(nlocal) = 0;
 
1954
  h_num_bond(nlocal) = 0;
 
1955
  h_num_angle(nlocal) = 0;
 
1956
  h_num_dihedral(nlocal) = 0;
 
1957
  h_num_improper(nlocal) = 0;
 
1958
  h_nspecial(nlocal,0) = h_nspecial(nlocal,1) = h_nspecial(nlocal,2) = 0;
 
1959
 
 
1960
  atom->nlocal++;
 
1961
}
 
1962
 
 
1963
/* ----------------------------------------------------------------------
 
1964
   unpack one line from Atoms section of data file
 
1965
   initialize other atom quantities
 
1966
------------------------------------------------------------------------- */
 
1967
 
 
1968
void AtomVecFullKokkos::data_atom(double *coord, imageint imagetmp,
 
1969
                                       char **values)
 
1970
{
 
1971
  int nlocal = atom->nlocal;
 
1972
  if (nlocal == nmax) grow(0);
 
1973
 
 
1974
  h_tag(nlocal) = atoi(values[0]);
 
1975
  h_molecule(nlocal) = atoi(values[1]);
 
1976
  h_type(nlocal) = atoi(values[2]);
 
1977
  if (h_type(nlocal) <= 0 || h_type(nlocal) > atom->ntypes)
 
1978
    error->one(FLERR,"Invalid atom type in Atoms section of data file");
 
1979
 
 
1980
  h_q(nlocal) = atof(values[3]);
 
1981
 
 
1982
  h_x(nlocal,0) = coord[0];
 
1983
  h_x(nlocal,1) = coord[1];
 
1984
  h_x(nlocal,2) = coord[2];
 
1985
 
 
1986
  h_image(nlocal) = imagetmp;
 
1987
 
 
1988
  h_mask(nlocal) = 1;
 
1989
  h_v(nlocal,0) = 0.0;
 
1990
  h_v(nlocal,1) = 0.0;
 
1991
  h_v(nlocal,2) = 0.0;
 
1992
  h_num_bond(nlocal) = 0;
 
1993
  h_num_angle(nlocal) = 0;
 
1994
  h_num_dihedral(nlocal) = 0;
 
1995
  h_num_improper(nlocal) = 0;
 
1996
 
 
1997
  atom->nlocal++;
 
1998
}
 
1999
 
 
2000
/* ----------------------------------------------------------------------
 
2001
   unpack hybrid quantities from one line in Atoms section of data file
 
2002
   initialize other atom quantities for this sub-style
 
2003
------------------------------------------------------------------------- */
 
2004
 
 
2005
int AtomVecFullKokkos::data_atom_hybrid(int nlocal, char **values)
 
2006
{
 
2007
  h_molecule(nlocal) = atoi(values[0]);
 
2008
  h_q(nlocal) = atof(values[1]);
 
2009
  h_num_bond(nlocal) = 0;
 
2010
  h_num_angle(nlocal) = 0;
 
2011
  h_num_dihedral(nlocal) = 0;
 
2012
  h_num_improper(nlocal) = 0;
 
2013
  return 2;
 
2014
}
 
2015
 
 
2016
/* ----------------------------------------------------------------------
 
2017
   pack atom info for data file including 3 image flags
 
2018
------------------------------------------------------------------------- */
 
2019
 
 
2020
void AtomVecFullKokkos::pack_data(double **buf)
 
2021
{
 
2022
  int nlocal = atom->nlocal;
 
2023
  for (int i = 0; i < nlocal; i++) {
 
2024
    buf[i][0] = h_tag(i);
 
2025
    buf[i][1] = h_molecule(i);
 
2026
    buf[i][2] = h_type(i);
 
2027
    buf[i][3] = h_q(i);
 
2028
    buf[i][4] = h_x(i,0);
 
2029
    buf[i][5] = h_x(i,1);
 
2030
    buf[i][6] = h_x(i,2);
 
2031
    buf[i][7] = (h_image[i] & IMGMASK) - IMGMAX;
 
2032
    buf[i][8] = (h_image[i] >> IMGBITS & IMGMASK) - IMGMAX;
 
2033
    buf[i][9] = (h_image[i] >> IMG2BITS) - IMGMAX;
 
2034
  }
 
2035
}
 
2036
 
 
2037
/* ----------------------------------------------------------------------
 
2038
   pack hybrid atom info for data file
 
2039
------------------------------------------------------------------------- */
 
2040
 
 
2041
int AtomVecFullKokkos::pack_data_hybrid(int i, double *buf)
 
2042
{
 
2043
  buf[0] = h_molecule(i);
 
2044
  buf[1] = h_q(i);
 
2045
  return 2;
 
2046
}
 
2047
 
 
2048
/* ----------------------------------------------------------------------
 
2049
   write atom info to data file including 3 image flags
 
2050
------------------------------------------------------------------------- */
 
2051
 
 
2052
void AtomVecFullKokkos::write_data(FILE *fp, int n, double **buf)
 
2053
{
 
2054
  for (int i = 0; i < n; i++)
 
2055
    fprintf(fp,"%d %d %d %-1.16e %-1.16e %-1.16e %-1.16e %d %d %d\n",
 
2056
            (int) buf[i][0],(int) buf[i][1], (int) buf[i][2], buf[i][3],
 
2057
            buf[i][4],buf[i][5],buf[i][6],
 
2058
            (int) buf[i][7],(int) buf[i][8],(int) buf[i][9]);
 
2059
}
 
2060
 
 
2061
/* ----------------------------------------------------------------------
 
2062
   write hybrid atom info to data file
 
2063
------------------------------------------------------------------------- */
 
2064
 
 
2065
int AtomVecFullKokkos::write_data_hybrid(FILE *fp, double *buf)
 
2066
{
 
2067
  fprintf(fp," " TAGINT_FORMAT " %-1.16e",(tagint) ubuf(buf[0]).i,buf[1]);
 
2068
  return 2;
 
2069
}
 
2070
 
 
2071
/* ----------------------------------------------------------------------
 
2072
   return # of bytes of allocated memory
 
2073
------------------------------------------------------------------------- */
 
2074
 
 
2075
bigint AtomVecFullKokkos::memory_usage()
 
2076
{
 
2077
  bigint bytes = 0;
 
2078
 
 
2079
  if (atom->memcheck("tag")) bytes += memory->usage(tag,nmax);
 
2080
  if (atom->memcheck("type")) bytes += memory->usage(type,nmax);
 
2081
  if (atom->memcheck("mask")) bytes += memory->usage(mask,nmax);
 
2082
  if (atom->memcheck("image")) bytes += memory->usage(image,nmax);
 
2083
  if (atom->memcheck("x")) bytes += memory->usage(x,nmax,3);
 
2084
  if (atom->memcheck("v")) bytes += memory->usage(v,nmax,3);
 
2085
  if (atom->memcheck("f")) bytes += memory->usage(f,nmax*commKK->nthreads,3);
 
2086
 
 
2087
  if (atom->memcheck("q")) bytes += memory->usage(q,nmax);
 
2088
  if (atom->memcheck("molecule")) bytes += memory->usage(molecule,nmax);
 
2089
  if (atom->memcheck("nspecial")) bytes += memory->usage(nspecial,nmax,3);
 
2090
  if (atom->memcheck("special"))
 
2091
    bytes += memory->usage(special,nmax,atom->maxspecial);
 
2092
 
 
2093
  if (atom->memcheck("num_bond")) bytes += memory->usage(num_bond,nmax);
 
2094
  if (atom->memcheck("bond_type"))
 
2095
    bytes += memory->usage(bond_type,nmax,atom->bond_per_atom);
 
2096
  if (atom->memcheck("bond_atom"))
 
2097
    bytes += memory->usage(bond_atom,nmax,atom->bond_per_atom);
 
2098
 
 
2099
  if (atom->memcheck("num_angle")) bytes += memory->usage(num_angle,nmax);
 
2100
  if (atom->memcheck("angle_type"))
 
2101
    bytes += memory->usage(angle_type,nmax,atom->angle_per_atom);
 
2102
  if (atom->memcheck("angle_atom1"))
 
2103
    bytes += memory->usage(angle_atom1,nmax,atom->angle_per_atom);
 
2104
  if (atom->memcheck("angle_atom2"))
 
2105
    bytes += memory->usage(angle_atom2,nmax,atom->angle_per_atom);
 
2106
  if (atom->memcheck("angle_atom3"))
 
2107
    bytes += memory->usage(angle_atom3,nmax,atom->angle_per_atom);
 
2108
 
 
2109
  if (atom->memcheck("num_dihedral")) bytes += memory->usage(num_dihedral,nmax);
 
2110
  if (atom->memcheck("dihedral_type"))
 
2111
    bytes += memory->usage(dihedral_type,nmax,atom->dihedral_per_atom);
 
2112
  if (atom->memcheck("dihedral_atom1"))
 
2113
    bytes += memory->usage(dihedral_atom1,nmax,atom->dihedral_per_atom);
 
2114
  if (atom->memcheck("dihedral_atom2"))
 
2115
    bytes += memory->usage(dihedral_atom2,nmax,atom->dihedral_per_atom);
 
2116
  if (atom->memcheck("dihedral_atom3"))
 
2117
    bytes += memory->usage(dihedral_atom3,nmax,atom->dihedral_per_atom);
 
2118
  if (atom->memcheck("dihedral_atom4"))
 
2119
    bytes += memory->usage(dihedral_atom4,nmax,atom->dihedral_per_atom);
 
2120
  if (atom->memcheck("num_improper")) bytes += memory->usage(num_improper,nmax);
 
2121
  if (atom->memcheck("improper_type"))
 
2122
    bytes += memory->usage(improper_type,nmax,atom->improper_per_atom);
 
2123
  if (atom->memcheck("improper_atom1"))
 
2124
    bytes += memory->usage(improper_atom1,nmax,atom->improper_per_atom);
 
2125
  if (atom->memcheck("improper_atom2"))
 
2126
    bytes += memory->usage(improper_atom2,nmax,atom->improper_per_atom);
 
2127
  if (atom->memcheck("improper_atom3"))
 
2128
    bytes += memory->usage(improper_atom3,nmax,atom->improper_per_atom);
 
2129
  if (atom->memcheck("improper_atom4"))
 
2130
    bytes += memory->usage(improper_atom4,nmax,atom->improper_per_atom);
 
2131
 
 
2132
  return bytes;
 
2133
}
 
2134
 
 
2135
/* ---------------------------------------------------------------------- */
 
2136
 
 
2137
void AtomVecFullKokkos::sync(ExecutionSpace space, unsigned int mask)
 
2138
{
 
2139
  if (space == Device) {
 
2140
    if (mask & X_MASK) atomKK->k_x.sync<LMPDeviceType>();
 
2141
    if (mask & V_MASK) atomKK->k_v.sync<LMPDeviceType>();
 
2142
    if (mask & F_MASK) atomKK->k_f.sync<LMPDeviceType>();
 
2143
    if (mask & TAG_MASK) atomKK->k_tag.sync<LMPDeviceType>();
 
2144
    if (mask & TYPE_MASK) atomKK->k_type.sync<LMPDeviceType>();
 
2145
    if (mask & MASK_MASK) atomKK->k_mask.sync<LMPDeviceType>();
 
2146
    if (mask & IMAGE_MASK) atomKK->k_image.sync<LMPDeviceType>();
 
2147
    if (mask & Q_MASK) atomKK->k_q.sync<LMPDeviceType>();
 
2148
    if (mask & MOLECULE_MASK) atomKK->k_molecule.sync<LMPDeviceType>();
 
2149
    if (mask & SPECIAL_MASK) {
 
2150
      atomKK->k_nspecial.sync<LMPDeviceType>();
 
2151
      atomKK->k_special.sync<LMPDeviceType>();
 
2152
    }
 
2153
    if (mask & BOND_MASK) {
 
2154
      atomKK->k_num_bond.sync<LMPDeviceType>();
 
2155
      atomKK->k_bond_type.sync<LMPDeviceType>();
 
2156
      atomKK->k_bond_atom.sync<LMPDeviceType>();
 
2157
    }
 
2158
    if (mask & ANGLE_MASK) {
 
2159
      atomKK->k_num_angle.sync<LMPDeviceType>();
 
2160
      atomKK->k_angle_type.sync<LMPDeviceType>();
 
2161
      atomKK->k_angle_atom1.sync<LMPDeviceType>();
 
2162
      atomKK->k_angle_atom2.sync<LMPDeviceType>();
 
2163
      atomKK->k_angle_atom3.sync<LMPDeviceType>();
 
2164
    }
 
2165
    if (mask & DIHEDRAL_MASK) {
 
2166
      atomKK->k_num_dihedral.sync<LMPDeviceType>();
 
2167
      atomKK->k_dihedral_type.sync<LMPDeviceType>();
 
2168
      atomKK->k_dihedral_atom1.sync<LMPDeviceType>();
 
2169
      atomKK->k_dihedral_atom2.sync<LMPDeviceType>();
 
2170
      atomKK->k_dihedral_atom3.sync<LMPDeviceType>();
 
2171
      atomKK->k_dihedral_atom4.sync<LMPDeviceType>();
 
2172
    }
 
2173
    if (mask & IMPROPER_MASK) {
 
2174
      atomKK->k_num_improper.sync<LMPDeviceType>();
 
2175
      atomKK->k_improper_type.sync<LMPDeviceType>();
 
2176
      atomKK->k_improper_atom1.sync<LMPDeviceType>();
 
2177
      atomKK->k_improper_atom2.sync<LMPDeviceType>();
 
2178
      atomKK->k_improper_atom3.sync<LMPDeviceType>();
 
2179
      atomKK->k_improper_atom3.sync<LMPDeviceType>();
 
2180
    }
 
2181
  } else {
 
2182
    if (mask & X_MASK) atomKK->k_x.sync<LMPHostType>();
 
2183
    if (mask & V_MASK) atomKK->k_v.sync<LMPHostType>();
 
2184
    if (mask & F_MASK) atomKK->k_f.sync<LMPHostType>();
 
2185
    if (mask & TAG_MASK) atomKK->k_tag.sync<LMPHostType>();
 
2186
    if (mask & TYPE_MASK) atomKK->k_type.sync<LMPHostType>();
 
2187
    if (mask & MASK_MASK) atomKK->k_mask.sync<LMPHostType>();
 
2188
    if (mask & IMAGE_MASK) atomKK->k_image.sync<LMPHostType>();
 
2189
    if (mask & Q_MASK) atomKK->k_q.sync<LMPHostType>();
 
2190
    if (mask & MOLECULE_MASK) atomKK->k_molecule.sync<LMPHostType>();
 
2191
    if (mask & SPECIAL_MASK) {
 
2192
      atomKK->k_nspecial.sync<LMPHostType>();
 
2193
      atomKK->k_special.sync<LMPHostType>();
 
2194
    }
 
2195
    if (mask & BOND_MASK) {
 
2196
      atomKK->k_num_bond.sync<LMPHostType>();
 
2197
      atomKK->k_bond_type.sync<LMPHostType>();
 
2198
      atomKK->k_bond_atom.sync<LMPHostType>();
 
2199
    }
 
2200
    if (mask & ANGLE_MASK) {
 
2201
      atomKK->k_num_angle.sync<LMPHostType>();
 
2202
      atomKK->k_angle_type.sync<LMPHostType>();
 
2203
      atomKK->k_angle_atom1.sync<LMPHostType>();
 
2204
      atomKK->k_angle_atom2.sync<LMPHostType>();
 
2205
      atomKK->k_angle_atom3.sync<LMPHostType>();
 
2206
    }
 
2207
    if (mask & DIHEDRAL_MASK) {
 
2208
      atomKK->k_num_dihedral.sync<LMPHostType>();
 
2209
      atomKK->k_dihedral_type.sync<LMPHostType>();
 
2210
      atomKK->k_dihedral_atom1.sync<LMPHostType>();
 
2211
      atomKK->k_dihedral_atom2.sync<LMPHostType>();
 
2212
      atomKK->k_dihedral_atom3.sync<LMPHostType>();
 
2213
      atomKK->k_dihedral_atom4.sync<LMPHostType>();
 
2214
    }
 
2215
    if (mask & IMPROPER_MASK) {
 
2216
      atomKK->k_num_improper.sync<LMPHostType>();
 
2217
      atomKK->k_improper_type.sync<LMPHostType>();
 
2218
      atomKK->k_improper_atom1.sync<LMPHostType>();
 
2219
      atomKK->k_improper_atom2.sync<LMPHostType>();
 
2220
      atomKK->k_improper_atom3.sync<LMPHostType>();
 
2221
      atomKK->k_improper_atom3.sync<LMPHostType>();
 
2222
    }
 
2223
  }
 
2224
}
 
2225
 
 
2226
/* ---------------------------------------------------------------------- */
 
2227
 
 
2228
void AtomVecFullKokkos::modified(ExecutionSpace space, unsigned int mask)
 
2229
{
 
2230
  if (space == Device) {
 
2231
    if (mask & X_MASK) atomKK->k_x.modify<LMPDeviceType>();
 
2232
    if (mask & V_MASK) atomKK->k_v.modify<LMPDeviceType>();
 
2233
    if (mask & F_MASK) atomKK->k_f.modify<LMPDeviceType>();
 
2234
    if (mask & TAG_MASK) atomKK->k_tag.modify<LMPDeviceType>();
 
2235
    if (mask & TYPE_MASK) atomKK->k_type.modify<LMPDeviceType>();
 
2236
    if (mask & MASK_MASK) atomKK->k_mask.modify<LMPDeviceType>();
 
2237
    if (mask & IMAGE_MASK) atomKK->k_image.modify<LMPDeviceType>();
 
2238
    if (mask & Q_MASK) atomKK->k_q.modify<LMPDeviceType>();
 
2239
    if (mask & MOLECULE_MASK) atomKK->k_molecule.modify<LMPDeviceType>();
 
2240
    if (mask & SPECIAL_MASK) {
 
2241
      atomKK->k_nspecial.modify<LMPDeviceType>();
 
2242
      atomKK->k_special.modify<LMPDeviceType>();
 
2243
    }
 
2244
    if (mask & BOND_MASK) {
 
2245
      atomKK->k_num_bond.modify<LMPDeviceType>();
 
2246
      atomKK->k_bond_type.modify<LMPDeviceType>();
 
2247
      atomKK->k_bond_atom.modify<LMPDeviceType>();
 
2248
    }
 
2249
    if (mask & ANGLE_MASK) {
 
2250
      atomKK->k_num_angle.modify<LMPDeviceType>();
 
2251
      atomKK->k_angle_type.modify<LMPDeviceType>();
 
2252
      atomKK->k_angle_atom1.modify<LMPDeviceType>();
 
2253
      atomKK->k_angle_atom2.modify<LMPDeviceType>();
 
2254
      atomKK->k_angle_atom3.modify<LMPDeviceType>();
 
2255
    }
 
2256
    if (mask & DIHEDRAL_MASK) {
 
2257
      atomKK->k_num_dihedral.modify<LMPDeviceType>();
 
2258
      atomKK->k_dihedral_type.modify<LMPDeviceType>();
 
2259
      atomKK->k_dihedral_atom1.modify<LMPDeviceType>();
 
2260
      atomKK->k_dihedral_atom2.modify<LMPDeviceType>();
 
2261
      atomKK->k_dihedral_atom3.modify<LMPDeviceType>();
 
2262
      atomKK->k_dihedral_atom4.modify<LMPDeviceType>();
 
2263
    }
 
2264
    if (mask & IMPROPER_MASK) {
 
2265
      atomKK->k_num_improper.modify<LMPDeviceType>();
 
2266
      atomKK->k_improper_type.modify<LMPDeviceType>();
 
2267
      atomKK->k_improper_atom1.modify<LMPDeviceType>();
 
2268
      atomKK->k_improper_atom2.modify<LMPDeviceType>();
 
2269
      atomKK->k_improper_atom3.modify<LMPDeviceType>();
 
2270
      atomKK->k_improper_atom3.modify<LMPDeviceType>();
 
2271
    }
 
2272
  } else {
 
2273
    if (mask & X_MASK) atomKK->k_x.modify<LMPHostType>();
 
2274
    if (mask & V_MASK) atomKK->k_v.modify<LMPHostType>();
 
2275
    if (mask & F_MASK) atomKK->k_f.modify<LMPHostType>();
 
2276
    if (mask & TAG_MASK) atomKK->k_tag.modify<LMPHostType>();
 
2277
    if (mask & TYPE_MASK) atomKK->k_type.modify<LMPHostType>();
 
2278
    if (mask & MASK_MASK) atomKK->k_mask.modify<LMPHostType>();
 
2279
    if (mask & IMAGE_MASK) atomKK->k_image.modify<LMPHostType>();
 
2280
    if (mask & Q_MASK) atomKK->k_q.modify<LMPHostType>();
 
2281
    if (mask & MOLECULE_MASK) atomKK->k_molecule.modify<LMPHostType>();
 
2282
    if (mask & SPECIAL_MASK) {
 
2283
      atomKK->k_nspecial.modify<LMPHostType>();
 
2284
      atomKK->k_special.modify<LMPHostType>();
 
2285
    }
 
2286
    if (mask & BOND_MASK) {
 
2287
      atomKK->k_num_bond.modify<LMPHostType>();
 
2288
      atomKK->k_bond_type.modify<LMPHostType>();
 
2289
      atomKK->k_bond_atom.modify<LMPHostType>();
 
2290
    }
 
2291
    if (mask & ANGLE_MASK) {
 
2292
      atomKK->k_num_angle.modify<LMPHostType>();
 
2293
      atomKK->k_angle_type.modify<LMPHostType>();
 
2294
      atomKK->k_angle_atom1.modify<LMPHostType>();
 
2295
      atomKK->k_angle_atom2.modify<LMPHostType>();
 
2296
      atomKK->k_angle_atom3.modify<LMPHostType>();
 
2297
    }
 
2298
    if (mask & DIHEDRAL_MASK) {
 
2299
      atomKK->k_num_dihedral.modify<LMPHostType>();
 
2300
      atomKK->k_dihedral_type.modify<LMPHostType>();
 
2301
      atomKK->k_dihedral_atom1.modify<LMPHostType>();
 
2302
      atomKK->k_dihedral_atom2.modify<LMPHostType>();
 
2303
      atomKK->k_dihedral_atom3.modify<LMPHostType>();
 
2304
      atomKK->k_dihedral_atom4.modify<LMPHostType>();
 
2305
    }
 
2306
    if (mask & IMPROPER_MASK) {
 
2307
      atomKK->k_num_improper.modify<LMPHostType>();
 
2308
      atomKK->k_improper_type.modify<LMPHostType>();
 
2309
      atomKK->k_improper_atom1.modify<LMPHostType>();
 
2310
      atomKK->k_improper_atom2.modify<LMPHostType>();
 
2311
      atomKK->k_improper_atom3.modify<LMPHostType>();
 
2312
      atomKK->k_improper_atom3.modify<LMPHostType>();
 
2313
    }
 
2314
  }
 
2315
}