Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F86133623
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
Fri, Oct 4, 11:53
Size
22 KB
Mime Type
text/x-c
Expires
Sun, Oct 6, 11:53 (2 d)
Engine
blob
Format
Raw Data
Handle
21357438
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"
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
);
fix
[
i
]
->
setup
(
vflag
);
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
);
fix
[
i
]
->
min_setup
(
vflag
);
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
);
fix
[
list_pre_exchange
[
i
]]
->
setup_pre_exchange
();
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
);
fix
[
list_min_pre_exchange
[
i
]]
->
min_setup_pre_exchange
();
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
);
fix
[
list_pre_neighbor
[
i
]]
->
setup_pre_neighbor
();
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
);
fix
[
list_min_pre_neighbor
[
i
]]
->
min_setup_pre_neighbor
();
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
);
fix
[
list_pre_force
[
i
]]
->
setup_pre_force
(
vflag
);
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
);
fix
[
list_min_pre_force
[
i
]]
->
min_setup_pre_force
(
vflag
);
atomKK
->
modified
(
fix
[
list_min_pre_force
[
i
]]
->
execution_space
,
fix
[
list_min_pre_force
[
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
);
fix
[
list_initial_integrate
[
i
]]
->
initial_integrate
(
vflag
);
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
);
fix
[
list_post_integrate
[
i
]]
->
post_integrate
();
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
);
fix
[
list_pre_exchange
[
i
]]
->
pre_exchange
();
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
);
fix
[
list_pre_neighbor
[
i
]]
->
pre_neighbor
();
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
);
fix
[
list_pre_force
[
i
]]
->
pre_force
(
vflag
);
atomKK
->
modified
(
fix
[
list_pre_force
[
i
]]
->
execution_space
,
fix
[
list_pre_force
[
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
);
fix
[
list_post_force
[
i
]]
->
post_force
(
vflag
);
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
);
fix
[
list_final_integrate
[
i
]]
->
final_integrate
();
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
);
fix
[
list_end_of_step
[
i
]]
->
end_of_step
();
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
);
energy
+=
fix
[
list_thermo_energy
[
i
]]
->
compute_scalar
();
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
);
fix
[
list_pre_force
[
i
]]
->
setup_pre_force_respa
(
vflag
,
ilevel
);
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
);
fix
[
list_initial_integrate_respa
[
i
]]
->
initial_integrate_respa
(
vflag
,
ilevel
,
iloop
);
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
);
fix
[
list_post_integrate_respa
[
i
]]
->
post_integrate_respa
(
ilevel
,
iloop
);
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
);
fix
[
list_pre_force_respa
[
i
]]
->
pre_force_respa
(
vflag
,
ilevel
,
iloop
);
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
);
fix
[
list_post_force_respa
[
i
]]
->
post_force_respa
(
vflag
,
ilevel
,
iloop
);
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
);
fix
[
list_final_integrate_respa
[
i
]]
->
final_integrate_respa
(
ilevel
,
iloop
);
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
);
fix
[
list_min_pre_exchange
[
i
]]
->
min_pre_exchange
();
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
);
fix
[
list_min_pre_neighbor
[
i
]]
->
min_pre_neighbor
();
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
);
fix
[
list_min_pre_force
[
i
]]
->
min_pre_force
(
vflag
);
atomKK
->
modified
(
fix
[
list_min_pre_force
[
i
]]
->
execution_space
,
fix
[
list_min_pre_force
[
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
);
fix
[
list_min_post_force
[
i
]]
->
min_post_force
(
vflag
);
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
);
eng
+=
fix
[
ifix
]
->
min_energy
(
&
fextra
[
index
]);
index
+=
fix
[
ifix
]
->
min_dof
();
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
);
fix
[
list_min_energy
[
i
]]
->
min_store
();
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
);
fix
[
list_min_energy
[
i
]]
->
min_clearstore
();
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
);
fix
[
list_min_energy
[
i
]]
->
min_pushstore
();
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
);
fix
[
list_min_energy
[
i
]]
->
min_popstore
();
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
);
fix
[
ifix
]
->
min_step
(
alpha
,
&
hextra
[
index
]);
index
+=
fix
[
ifix
]
->
min_dof
();
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
);
double
alpha_one
=
fix
[
ifix
]
->
max_alpha
(
&
hextra
[
index
]);
alpha
=
MIN
(
alpha
,
alpha_one
);
index
+=
fix
[
ifix
]
->
min_dof
();
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
);
ndof
+=
fix
[
list_min_energy
[
i
]]
->
min_dof
();
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
);
itmp
=
fix
[
list_min_energy
[
i
]]
->
min_reset_ref
();
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