Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F64296407
modify_kokkos.cpp
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Sat, May 25, 22:48
Size
31 KB
Mime Type
text/x-c
Expires
Mon, May 27, 22:48 (2 d)
Engine
blob
Format
Raw Data
Handle
17869865
Attached To
rLAMMPS lammps
modify_kokkos.cpp
View Options
/* ----------------------------------------------------------------------
LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
http://lammps.sandia.gov, Sandia National Laboratories
Steve Plimpton, sjplimp@sandia.gov
Copyright (2003) Sandia Corporation. Under the terms of Contract
DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
certain rights in this software. This software is distributed under
the GNU General Public License.
See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */
#include "modify_kokkos.h"
#include "atom_kokkos.h"
#include "update.h"
#include "fix.h"
#include "compute.h"
#include "kokkos.h"
using
namespace
LAMMPS_NS
;
#define BIG 1.0e20
/* ---------------------------------------------------------------------- */
ModifyKokkos
::
ModifyKokkos
(
LAMMPS
*
lmp
)
:
Modify
(
lmp
)
{
atomKK
=
(
AtomKokkos
*
)
atom
;
}
/* ----------------------------------------------------------------------
setup for run, calls setup() of all fixes and computes
called from Verlet, RESPA, Min
------------------------------------------------------------------------- */
void
ModifyKokkos
::
setup
(
int
vflag
)
{
// compute setup needs to come before fix setup
// b/c NH fixes need use DOF of temperature computes
for
(
int
i
=
0
;
i
<
ncompute
;
i
++
)
compute
[
i
]
->
setup
();
if
(
update
->
whichflag
==
1
)
for
(
int
i
=
0
;
i
<
nfix
;
i
++
)
{
atomKK
->
sync
(
fix
[
i
]
->
execution_space
,
fix
[
i
]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
i
]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
i
]
->
setup
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
i
]
->
execution_space
,
fix
[
i
]
->
datamask_modify
);
}
else
if
(
update
->
whichflag
==
2
)
for
(
int
i
=
0
;
i
<
nfix
;
i
++
)
{
atomKK
->
sync
(
fix
[
i
]
->
execution_space
,
fix
[
i
]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
i
]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
i
]
->
min_setup
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
i
]
->
execution_space
,
fix
[
i
]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
setup pre_exchange call, only for fixes that define pre_exchange
called from Verlet, RESPA, Min, and WriteRestart with whichflag = 0
------------------------------------------------------------------------- */
void
ModifyKokkos
::
setup_pre_exchange
()
{
if
(
update
->
whichflag
<=
1
)
for
(
int
i
=
0
;
i
<
n_pre_exchange
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_pre_exchange
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_exchange
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_exchange
[
i
]]
->
setup_pre_exchange
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_pre_exchange
[
i
]]
->
datamask_modify
);
}
else
if
(
update
->
whichflag
==
2
)
for
(
int
i
=
0
;
i
<
n_min_pre_exchange
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_min_pre_exchange
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_exchange
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_exchange
[
i
]]
->
setup_pre_exchange
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_min_pre_exchange
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
setup pre_neighbor call, only for fixes that define pre_neighbor
called from Verlet, RESPA
------------------------------------------------------------------------- */
void
ModifyKokkos
::
setup_pre_neighbor
()
{
if
(
update
->
whichflag
==
1
)
for
(
int
i
=
0
;
i
<
n_pre_neighbor
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_pre_neighbor
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_neighbor
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_neighbor
[
i
]]
->
setup_pre_neighbor
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_pre_neighbor
[
i
]]
->
datamask_modify
);
}
else
if
(
update
->
whichflag
==
2
)
for
(
int
i
=
0
;
i
<
n_min_pre_neighbor
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_min_pre_neighbor
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_neighbor
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_neighbor
[
i
]]
->
setup_pre_neighbor
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_min_pre_neighbor
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
setup pre_force call, only for fixes that define pre_force
called from Verlet, RESPA, Min
------------------------------------------------------------------------- */
void
ModifyKokkos
::
setup_pre_force
(
int
vflag
)
{
if
(
update
->
whichflag
==
1
)
for
(
int
i
=
0
;
i
<
n_pre_force
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_force
[
i
]]
->
execution_space
,
fix
[
list_pre_force
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_force
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_force
[
i
]]
->
setup_pre_force
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_force
[
i
]]
->
execution_space
,
fix
[
list_pre_force
[
i
]]
->
datamask_modify
);
}
else
if
(
update
->
whichflag
==
2
)
for
(
int
i
=
0
;
i
<
n_min_pre_force
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_force
[
i
]]
->
execution_space
,
fix
[
list_min_pre_force
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_force
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_force
[
i
]]
->
setup_pre_force
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_force
[
i
]]
->
execution_space
,
fix
[
list_min_pre_force
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
setup pre_reverse call, only for fixes that define pre_reverse
called from Verlet, RESPA, Min
------------------------------------------------------------------------- */
void
ModifyKokkos
::
setup_pre_reverse
(
int
eflag
,
int
vflag
)
{
if
(
update
->
whichflag
==
1
)
for
(
int
i
=
0
;
i
<
n_pre_reverse
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_pre_reverse
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_reverse
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_reverse
[
i
]]
->
setup_pre_reverse
(
eflag
,
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_pre_reverse
[
i
]]
->
datamask_modify
);
}
else
if
(
update
->
whichflag
==
2
)
for
(
int
i
=
0
;
i
<
n_min_pre_reverse
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_min_pre_reverse
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_reverse
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_reverse
[
i
]]
->
setup_pre_reverse
(
eflag
,
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_min_pre_reverse
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
1st half of integrate call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
initial_integrate
(
int
vflag
)
{
for
(
int
i
=
0
;
i
<
n_initial_integrate
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_initial_integrate
[
i
]]
->
execution_space
,
fix
[
list_initial_integrate
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_initial_integrate
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_initial_integrate
[
i
]]
->
initial_integrate
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_initial_integrate
[
i
]]
->
execution_space
,
fix
[
list_initial_integrate
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
post_integrate call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
post_integrate
()
{
for
(
int
i
=
0
;
i
<
n_post_integrate
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_post_integrate
[
i
]]
->
execution_space
,
fix
[
list_post_integrate
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_post_integrate
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_post_integrate
[
i
]]
->
post_integrate
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_post_integrate
[
i
]]
->
execution_space
,
fix
[
list_post_integrate
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
pre_exchange call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
pre_exchange
()
{
for
(
int
i
=
0
;
i
<
n_pre_exchange
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_pre_exchange
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_exchange
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_exchange
[
i
]]
->
pre_exchange
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_pre_exchange
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
pre_neighbor call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
pre_neighbor
()
{
for
(
int
i
=
0
;
i
<
n_pre_neighbor
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_pre_neighbor
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_neighbor
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_neighbor
[
i
]]
->
pre_neighbor
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_pre_neighbor
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
pre_force call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
pre_force
(
int
vflag
)
{
for
(
int
i
=
0
;
i
<
n_pre_force
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_force
[
i
]]
->
execution_space
,
fix
[
list_pre_force
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_force
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_force
[
i
]]
->
pre_force
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_force
[
i
]]
->
execution_space
,
fix
[
list_pre_force
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
pre_reverse call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
pre_reverse
(
int
eflag
,
int
vflag
)
{
for
(
int
i
=
0
;
i
<
n_pre_reverse
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_pre_reverse
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_reverse
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_reverse
[
i
]]
->
pre_reverse
(
eflag
,
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_pre_reverse
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
post_force call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
post_force
(
int
vflag
)
{
for
(
int
i
=
0
;
i
<
n_post_force
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_post_force
[
i
]]
->
execution_space
,
fix
[
list_post_force
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_post_force
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_post_force
[
i
]]
->
post_force
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_post_force
[
i
]]
->
execution_space
,
fix
[
list_post_force
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
2nd half of integrate call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
final_integrate
()
{
for
(
int
i
=
0
;
i
<
n_final_integrate
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_final_integrate
[
i
]]
->
execution_space
,
fix
[
list_final_integrate
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_final_integrate
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_final_integrate
[
i
]]
->
final_integrate
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_final_integrate
[
i
]]
->
execution_space
,
fix
[
list_final_integrate
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
end-of-timestep call, only for relevant fixes
only call fix->end_of_step() on timesteps that are multiples of nevery
------------------------------------------------------------------------- */
void
ModifyKokkos
::
end_of_step
()
{
for
(
int
i
=
0
;
i
<
n_end_of_step
;
i
++
)
if
(
update
->
ntimestep
%
end_of_step_every
[
i
]
==
0
)
{
atomKK
->
sync
(
fix
[
list_end_of_step
[
i
]]
->
execution_space
,
fix
[
list_end_of_step
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_end_of_step
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_end_of_step
[
i
]]
->
end_of_step
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_end_of_step
[
i
]]
->
execution_space
,
fix
[
list_end_of_step
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
thermo energy call, only for relevant fixes
called by Thermo class
compute_scalar() is fix call to return energy
------------------------------------------------------------------------- */
double
ModifyKokkos
::
thermo_energy
()
{
double
energy
=
0.0
;
for
(
int
i
=
0
;
i
<
n_thermo_energy
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_thermo_energy
[
i
]]
->
execution_space
,
fix
[
list_thermo_energy
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_thermo_energy
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
energy
+=
fix
[
list_thermo_energy
[
i
]]
->
compute_scalar
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_thermo_energy
[
i
]]
->
execution_space
,
fix
[
list_thermo_energy
[
i
]]
->
datamask_modify
);
}
return
energy
;
}
/* ----------------------------------------------------------------------
post_run call
------------------------------------------------------------------------- */
void
ModifyKokkos
::
post_run
()
{
for
(
int
i
=
0
;
i
<
nfix
;
i
++
)
{
atomKK
->
sync
(
fix
[
i
]
->
execution_space
,
fix
[
i
]
->
datamask_read
);
fix
[
i
]
->
post_run
();
atomKK
->
modified
(
fix
[
i
]
->
execution_space
,
fix
[
i
]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
setup rRESPA pre_force call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
setup_pre_force_respa
(
int
vflag
,
int
ilevel
)
{
for
(
int
i
=
0
;
i
<
n_pre_force
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_force
[
i
]]
->
execution_space
,
fix
[
list_pre_force
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_force
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_force
[
i
]]
->
setup_pre_force_respa
(
vflag
,
ilevel
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_force
[
i
]]
->
execution_space
,
fix
[
list_pre_force
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
1st half of rRESPA integrate call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
initial_integrate_respa
(
int
vflag
,
int
ilevel
,
int
iloop
)
{
for
(
int
i
=
0
;
i
<
n_initial_integrate_respa
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_initial_integrate_respa
[
i
]]
->
execution_space
,
fix
[
list_initial_integrate_respa
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_initial_integrate_respa
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_initial_integrate_respa
[
i
]]
->
initial_integrate_respa
(
vflag
,
ilevel
,
iloop
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_initial_integrate_respa
[
i
]]
->
execution_space
,
fix
[
list_initial_integrate_respa
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
rRESPA post_integrate call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
post_integrate_respa
(
int
ilevel
,
int
iloop
)
{
for
(
int
i
=
0
;
i
<
n_post_integrate_respa
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_post_integrate_respa
[
i
]]
->
execution_space
,
fix
[
list_post_integrate_respa
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_post_integrate_respa
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_post_integrate_respa
[
i
]]
->
post_integrate_respa
(
ilevel
,
iloop
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_post_integrate_respa
[
i
]]
->
execution_space
,
fix
[
list_post_integrate_respa
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
rRESPA pre_force call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
pre_force_respa
(
int
vflag
,
int
ilevel
,
int
iloop
)
{
for
(
int
i
=
0
;
i
<
n_pre_force_respa
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_pre_force_respa
[
i
]]
->
execution_space
,
fix
[
list_pre_force_respa
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_pre_force_respa
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_pre_force_respa
[
i
]]
->
pre_force_respa
(
vflag
,
ilevel
,
iloop
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_pre_force_respa
[
i
]]
->
execution_space
,
fix
[
list_pre_force_respa
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
rRESPA post_force call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
post_force_respa
(
int
vflag
,
int
ilevel
,
int
iloop
)
{
for
(
int
i
=
0
;
i
<
n_post_force_respa
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_post_force_respa
[
i
]]
->
execution_space
,
fix
[
list_post_force_respa
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_post_force_respa
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_post_force_respa
[
i
]]
->
post_force_respa
(
vflag
,
ilevel
,
iloop
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_post_force_respa
[
i
]]
->
execution_space
,
fix
[
list_post_force_respa
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
2nd half of rRESPA integrate call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
final_integrate_respa
(
int
ilevel
,
int
iloop
)
{
for
(
int
i
=
0
;
i
<
n_final_integrate_respa
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_final_integrate_respa
[
i
]]
->
execution_space
,
fix
[
list_final_integrate_respa
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_final_integrate_respa
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_final_integrate_respa
[
i
]]
->
final_integrate_respa
(
ilevel
,
iloop
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_final_integrate_respa
[
i
]]
->
execution_space
,
fix
[
list_final_integrate_respa
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
minimizer pre-exchange call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_pre_exchange
()
{
for
(
int
i
=
0
;
i
<
n_min_pre_exchange
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_min_pre_exchange
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_exchange
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_exchange
[
i
]]
->
min_pre_exchange
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_exchange
[
i
]]
->
execution_space
,
fix
[
list_min_pre_exchange
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
minimizer pre-neighbor call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_pre_neighbor
()
{
for
(
int
i
=
0
;
i
<
n_min_pre_neighbor
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_min_pre_neighbor
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_neighbor
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_neighbor
[
i
]]
->
min_pre_neighbor
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_neighbor
[
i
]]
->
execution_space
,
fix
[
list_min_pre_neighbor
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
minimizer pre-force call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_pre_force
(
int
vflag
)
{
for
(
int
i
=
0
;
i
<
n_min_pre_force
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_force
[
i
]]
->
execution_space
,
fix
[
list_min_pre_force
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_force
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_force
[
i
]]
->
min_pre_force
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_force
[
i
]]
->
execution_space
,
fix
[
list_min_pre_force
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
minimizer pre-reverse call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_pre_reverse
(
int
eflag
,
int
vflag
)
{
for
(
int
i
=
0
;
i
<
n_min_pre_reverse
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_min_pre_reverse
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_pre_reverse
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_pre_reverse
[
i
]]
->
min_pre_reverse
(
eflag
,
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_pre_reverse
[
i
]]
->
execution_space
,
fix
[
list_min_pre_reverse
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
minimizer force adjustment call, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_post_force
(
int
vflag
)
{
for
(
int
i
=
0
;
i
<
n_min_post_force
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_post_force
[
i
]]
->
execution_space
,
fix
[
list_min_post_force
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_post_force
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_post_force
[
i
]]
->
min_post_force
(
vflag
);
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_post_force
[
i
]]
->
execution_space
,
fix
[
list_min_post_force
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
minimizer energy/force evaluation, only for relevant fixes
return energy and forces on extra degrees of freedom
------------------------------------------------------------------------- */
double
ModifyKokkos
::
min_energy
(
double
*
fextra
)
{
int
ifix
,
index
;
index
=
0
;
double
eng
=
0.0
;
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
ifix
=
list_min_energy
[
i
];
atomKK
->
sync
(
fix
[
ifix
]
->
execution_space
,
fix
[
ifix
]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
ifix
]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
eng
+=
fix
[
ifix
]
->
min_energy
(
&
fextra
[
index
]);
index
+=
fix
[
ifix
]
->
min_dof
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
ifix
]
->
execution_space
,
fix
[
ifix
]
->
datamask_modify
);
}
return
eng
;
}
/* ----------------------------------------------------------------------
store current state of extra dof, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_store
()
{
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_energy
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_energy
[
i
]]
->
min_store
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
mange state of extra dof on a stack, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_clearstore
()
{
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_energy
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_energy
[
i
]]
->
min_clearstore
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_modify
);
}
}
void
ModifyKokkos
::
min_pushstore
()
{
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_energy
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_energy
[
i
]]
->
min_pushstore
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_modify
);
}
}
void
ModifyKokkos
::
min_popstore
()
{
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_energy
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
list_min_energy
[
i
]]
->
min_popstore
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
displace extra dof along vector hextra, only for relevant fixes
------------------------------------------------------------------------- */
void
ModifyKokkos
::
min_step
(
double
alpha
,
double
*
hextra
)
{
int
ifix
,
index
;
index
=
0
;
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
ifix
=
list_min_energy
[
i
];
atomKK
->
sync
(
fix
[
ifix
]
->
execution_space
,
fix
[
ifix
]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
ifix
]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
fix
[
ifix
]
->
min_step
(
alpha
,
&
hextra
[
index
]);
index
+=
fix
[
ifix
]
->
min_dof
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
ifix
]
->
execution_space
,
fix
[
ifix
]
->
datamask_modify
);
}
}
/* ----------------------------------------------------------------------
compute max allowed step size along vector hextra, only for relevant fixes
------------------------------------------------------------------------- */
double
ModifyKokkos
::
max_alpha
(
double
*
hextra
)
{
int
ifix
,
index
;
double
alpha
=
BIG
;
index
=
0
;
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
ifix
=
list_min_energy
[
i
];
atomKK
->
sync
(
fix
[
ifix
]
->
execution_space
,
fix
[
ifix
]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
ifix
]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
double
alpha_one
=
fix
[
ifix
]
->
max_alpha
(
&
hextra
[
index
]);
alpha
=
MIN
(
alpha
,
alpha_one
);
index
+=
fix
[
ifix
]
->
min_dof
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
ifix
]
->
execution_space
,
fix
[
ifix
]
->
datamask_modify
);
}
return
alpha
;
}
/* ----------------------------------------------------------------------
extract extra dof for minimization, only for relevant fixes
------------------------------------------------------------------------- */
int
ModifyKokkos
::
min_dof
()
{
int
ndof
=
0
;
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_energy
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
ndof
+=
fix
[
list_min_energy
[
i
]]
->
min_dof
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
atomKK
->
modified
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_modify
);
}
return
ndof
;
}
/* ----------------------------------------------------------------------
reset reference state of fix, only for relevant fixes
------------------------------------------------------------------------- */
int
ModifyKokkos
::
min_reset_ref
()
{
int
itmp
,
itmpall
;
itmpall
=
0
;
for
(
int
i
=
0
;
i
<
n_min_energy
;
i
++
)
{
atomKK
->
sync
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_read
);
int
prev_auto_sync
=
lmp
->
kokkos
->
auto_sync
;
if
(
!
fix
[
list_min_energy
[
i
]]
->
kokkosable
)
lmp
->
kokkos
->
auto_sync
=
1
;
itmp
=
fix
[
list_min_energy
[
i
]]
->
min_reset_ref
();
lmp
->
kokkos
->
auto_sync
=
prev_auto_sync
;
if
(
itmp
)
itmpall
=
1
;
atomKK
->
modified
(
fix
[
list_min_energy
[
i
]]
->
execution_space
,
fix
[
list_min_energy
[
i
]]
->
datamask_modify
);
}
return
itmpall
;
}
Event Timeline
Log In to Comment