modify_kokkos.cpp
No OneTemporary
Actions

Subscribers

None

File Metadata

Created: Thu, May 23, 19:07

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);
	if (!fix[i]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[i]->setup(vflag);
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[i]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[i]->min_setup(vflag);
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_pre_exchange[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_pre_exchange[i]]->setup_pre_exchange();
	lmp->kokkos->auto_sync = 0;
	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);
	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 = 0;
	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);
	if (!fix[list_pre_neighbor[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_pre_neighbor[i]]->setup_pre_neighbor();
	lmp->kokkos->auto_sync = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	if (!fix[list_initial_integrate[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_initial_integrate[i]]->initial_integrate(vflag);
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_post_integrate[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_post_integrate[i]]->post_integrate();
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_pre_exchange[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_pre_exchange[i]]->pre_exchange();
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_pre_neighbor[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_pre_neighbor[i]]->pre_neighbor();
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_pre_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_pre_force[i]]->pre_force(vflag);
	lmp->kokkos->auto_sync = 0;
	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);
	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 = 0;
	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);
	if (!fix[list_post_force[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_post_force[i]]->post_force(vflag);
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_final_integrate[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_final_integrate[i]]->final_integrate();
	lmp->kokkos->auto_sync = 0;
	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);
	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 = 0;
	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);
	if (!fix[list_thermo_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	energy += fix[list_thermo_energy[i]]->compute_scalar();
	lmp->kokkos->auto_sync = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_min_energy[i]]->min_store();
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_min_energy[i]]->min_clearstore();
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_min_energy[i]]->min_pushstore();
	lmp->kokkos->auto_sync = 0;
	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);
	if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	fix[list_min_energy[i]]->min_popstore();
	lmp->kokkos->auto_sync = 0;
	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);
	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 = 0;
	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);
	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 = 0;
	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);
	if (!fix[list_min_energy[i]]->kokkosable) lmp->kokkos->auto_sync = 1;
	ndof += fix[list_min_energy[i]]->min_dof();
	lmp->kokkos->auto_sync = 0;
	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);
	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 = 0;
	if (itmp) itmpall = 1;
	atomKK->modified(fix[list_min_energy[i]]->execution_space,
	fix[list_min_energy[i]]->datamask_modify);
	}
	return itmpall;
	}

modify_kokkos.cppNo OneTemporaryActions

File Metadata

modify_kokkos.cppView Options

Event Timeline

modify_kokkos.cpp
No OneTemporary
Actions

modify_kokkos.cpp
View Options