correct handling of neighflag member variable in KOKKOS styles

src/KOKKOS/fix_acks2_reaxff_kokkos.cpp

@@ -98,11 +98,12 @@ void FixACKS2ReaxFFKokkos<DeviceType>::init()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag_qeq;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag_qeq == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 
   int ntypes = atom->ntypes;
   k_params = Kokkos::DualView<params_acks2*,Kokkos::LayoutRight,DeviceType>

src/KOKKOS/fix_qeq_reaxff_kokkos.cpp

@@ -100,11 +100,12 @@ void FixQEqReaxFFKokkos<DeviceType>::init()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag_qeq;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag_qeq == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 
   int ntypes = atom->ntypes;
   k_params = Kokkos::DualView<params_qeq*,Kokkos::LayoutRight,DeviceType>

src/KOKKOS/pair_buck_coul_cut_kokkos.cpp

@@ -290,11 +290,12 @@ void PairBuckCoulCutKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_buck_coul_long_kokkos.cpp

@@ -437,11 +437,12 @@ void PairBuckCoulLongKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_buck_kokkos.cpp

@@ -209,17 +209,17 @@ void PairBuckKokkos<DeviceType>::init_style()
     int respa = 0;
     if (((Respa *) update->integrate)->level_inner >= 0) respa = 1;
     if (((Respa *) update->integrate)->level_middle >= 0) respa = 2;
-    if (respa)
-      error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
+    if (respa) error->all(FLERR,"Cannot use Kokkos pair style with rRESPA inner/middle");
   }
 
   // adjust neighbor list request for KOKKOS
 
-  auto request = neighbor->find_request(this);
+  neighflag = lmp->kokkos->neighflag;
+    auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_coul_cut_kokkos.cpp

@@ -213,11 +213,12 @@ void PairCoulCutKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_coul_debye_kokkos.cpp

@@ -247,11 +247,12 @@ void PairCoulDebyeKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_coul_dsf_kokkos.cpp

@@ -202,11 +202,12 @@ void PairCoulDSFKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ---------------------------------------------------------------------- */

src/KOKKOS/pair_coul_long_kokkos.cpp

@@ -401,11 +401,12 @@ void PairCoulLongKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_coul_wolf_kokkos.cpp

@@ -203,11 +203,12 @@ void PairCoulWolfKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ---------------------------------------------------------------------- */

src/KOKKOS/pair_dpd_fdt_energy_kokkos.cpp

@@ -87,11 +87,12 @@ void PairDPDfdtEnergyKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 
 #ifdef DPD_USE_RAN_MARS
   rand_pool.init(random,seed);
@@ -112,11 +113,12 @@ void PairDPDfdtEnergyKokkos<LMPDeviceSpace>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 
 #ifdef DPD_USE_RAN_MARS
   rand_pool.init(random,seed);

src/KOKKOS/pair_eam_alloy_kokkos.cpp

@@ -301,11 +301,12 @@ void PairEAMAlloyKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_eam_fs_kokkos.cpp

@@ -301,11 +301,12 @@ void PairEAMFSKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_eam_kokkos.cpp

@@ -296,11 +296,12 @@ void PairEAMKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_exp6_rx_kokkos.cpp

@@ -101,11 +101,12 @@ void PairExp6rxKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ---------------------------------------------------------------------- */

src/KOKKOS/pair_gran_hooke_history_kokkos.cpp

@@ -83,11 +83,12 @@ void PairGranHookeHistoryKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) 
+  if (neighflag == FULL)
     error->all(FLERR,"Must use half neighbor list with gran/hooke/history/kk");
 }
 
@@ -166,7 +167,7 @@ void PairGranHookeHistoryKokkos<DeviceType>::compute(int eflag_in, int vflag_in)
 
   EV_FLOAT ev;
 
-  if (lmp->kokkos->neighflag == HALF) {
+  if (neighflag == HALF) {
     if (force->newton_pair) {
       if (vflag_atom) {
         if (shearupdate) {

src/KOKKOS/pair_hybrid_kokkos.cpp

@@ -71,8 +71,7 @@ void PairHybridKokkos::compute(int eflag, int vflag)
   // if so, reset vflag as if global component were VIRIAL_PAIR
   // necessary since one or more sub-styles cannot compute virial as F dot r
 
-  int neighflag = lmp->kokkos->neighflag;
-  if (neighflag == FULL) no_virial_fdotr_compute = 1;
+  if (lmp->kokkos->neighflag == FULL) no_virial_fdotr_compute = 1;
 
   if (no_virial_fdotr_compute && (vflag & VIRIAL_FDOTR))
     vflag = VIRIAL_PAIR | (vflag & ~VIRIAL_FDOTR);

src/KOKKOS/pair_lj_charmm_coul_charmm_implicit_kokkos.cpp

@@ -436,11 +436,12 @@ void PairLJCharmmCoulCharmmImplicitKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_charmm_coul_charmm_kokkos.cpp

@@ -437,11 +437,12 @@ void PairLJCharmmCoulCharmmKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_charmm_coul_long_kokkos.cpp

@@ -445,11 +445,12 @@ void PairLJCharmmCoulLongKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_class2_coul_cut_kokkos.cpp

@@ -287,11 +287,12 @@ void PairLJClass2CoulCutKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_class2_coul_long_kokkos.cpp

@@ -445,11 +445,12 @@ void PairLJClass2CoulLongKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_class2_kokkos.cpp

@@ -226,11 +226,12 @@ void PairLJClass2Kokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_cut_coul_cut_kokkos.cpp

@@ -278,11 +278,12 @@ void PairLJCutCoulCutKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_cut_coul_debye_kokkos.cpp

@@ -307,11 +307,12 @@ void PairLJCutCoulDebyeKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_cut_coul_dsf_kokkos.cpp

@@ -302,11 +302,12 @@ void PairLJCutCoulDSFKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_cut_coul_long_kokkos.cpp

@@ -438,11 +438,12 @@ void PairLJCutCoulLongKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_cut_kokkos.cpp

@@ -218,11 +218,12 @@ void PairLJCutKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_expand_kokkos.cpp

@@ -230,11 +230,12 @@ void PairLJExpandKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_gromacs_coul_gromacs_kokkos.cpp

@@ -422,11 +422,12 @@ void PairLJGromacsCoulGromacsKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_gromacs_kokkos.cpp

@@ -265,11 +265,12 @@ void PairLJGromacsKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_lj_sdk_kokkos.cpp

@@ -257,11 +257,12 @@ void PairLJSDKKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_morse_kokkos.cpp

@@ -233,11 +233,12 @@ void PairMorseKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_multi_lucy_rx_kokkos.cpp

@@ -99,11 +99,12 @@ void PairMultiLucyRXKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ---------------------------------------------------------------------- */

src/KOKKOS/pair_reaxff_kokkos.cpp

@@ -168,11 +168,12 @@ void PairReaxFFKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL)
+  if (neighflag == FULL)
     error->all(FLERR,"Must use half neighbor list with pair style reaxff/kk");
 
   allocate();

src/KOKKOS/pair_snap_kokkos_impl.h

@@ -17,20 +17,22 @@
                          Evan Weinberg (NVIDIA)
 ------------------------------------------------------------------------- */
 
+#include "pair_snap_kokkos.h"
+
+#include "atom_kokkos.h"
+#include "atom_masks.h"
+#include "comm.h"
+#include "error.h"
+#include "force.h"
+#include "kokkos.h"
+#include "memory_kokkos.h"
+#include "neighbor_kokkos.h"
+#include "neigh_request.h"
+#include "sna.h"
+
 #include <cmath>
 #include <cstdlib>
 #include <cstring>
-#include "pair_snap_kokkos.h"
-#include "atom_kokkos.h"
-#include "error.h"
-#include "force.h"
-#include "atom_masks.h"
-#include "memory_kokkos.h"
-#include "neigh_request.h"
-#include "neighbor_kokkos.h"
-#include "kokkos.h"
-#include "sna.h"
-#include "comm.h"
 
 #define MAXLINE 1024
 #define MAXWORD 3
@@ -100,23 +102,14 @@ void PairSNAPKokkos<DeviceType, real_type, vector_length>::init_style()
   if (force->newton_pair == 0)
     error->all(FLERR,"Pair style SNAP requires newton pair on");
 
-  // irequest = neigh request made by parent class
+  // adjust neighbor list request for KOKKOS
 
-  neighflag = lmp->kokkos->neighflag;
-  int irequest = neighbor->request(this,instance_me);
-
-  neighbor->requests[irequest]->
-    kokkos_host = std::is_same<DeviceType,LMPHostType>::value &&
-    !std::is_same<DeviceType,LMPDeviceType>::value;
-  neighbor->requests[irequest]->
-    kokkos_device = std::is_same<DeviceType,LMPDeviceType>::value;
-
-  if (neighflag == HALF || neighflag == HALFTHREAD) { // still need atomics, even though using a full neigh list
-    neighbor->requests[irequest]->full = 1;
-    neighbor->requests[irequest]->half = 0;
-  } else {
+  auto request = neighbor->find_request(this);
+  request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
+                           !std::is_same<DeviceType,LMPDeviceType>::value);
+  request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
+  if (lmp->kokkos->neighflag == FULL)
     error->all(FLERR,"Must use half neighbor list style with pair snap/kk");
-  }
 }
 
 /* ---------------------------------------------------------------------- */

src/KOKKOS/pair_sw_kokkos.cpp

@@ -608,13 +608,14 @@ void PairSWKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
   // always request a full neighbor list
   request->enable_full();
-  if (lmp->kokkos->neighflag == FULL) request->enable_ghost();
+  if (neighflag == FULL) request->enable_ghost();
 }
 
 /* ---------------------------------------------------------------------- */

src/KOKKOS/pair_table_kokkos.cpp

@@ -512,11 +512,12 @@ void PairTableKokkos<DeviceType>::compute_table(Table *tb)
 template<class DeviceType>
 void PairTableKokkos<DeviceType>::init_style()
 {
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->add_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 namespace LAMMPS_NS {

src/KOKKOS/pair_table_rx_kokkos.cpp

@@ -1265,11 +1265,12 @@ void PairTableRXKokkos<DeviceType>::compute_table(Table *tb)
 template<class DeviceType>
 void PairTableRXKokkos<DeviceType>::init_style()
 {
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->add_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 namespace LAMMPS_NS {

src/KOKKOS/pair_tersoff_kokkos.cpp

@@ -100,12 +100,13 @@ void PairTersoffKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
   request->enable_full();
-  if (lmp->kokkos->neighflag == FULL)
+  if (neighflag == FULL)
     error->all(FLERR,"Cannot (yet) use full neighbor list style with tersoff/kk");
 }
 

src/KOKKOS/pair_tersoff_mod_kokkos.cpp

@@ -90,11 +90,12 @@ void PairTersoffMODKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL)
+  if (neighflag == FULL)
     error->all(FLERR,"Cannot (yet) use full neighbor list style with tersoff/mod/kk");
 }
 

src/KOKKOS/pair_tersoff_zbl_kokkos.cpp

@@ -103,12 +103,13 @@ void PairTersoffZBLKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
   request->enable_full();
-  if (lmp->kokkos->neighflag == FULL)
+  if (neighflag == FULL)
     error->all(FLERR,"Cannot (yet) use full neighbor list style with tersoff/zbl/kk");
 }
 

src/KOKKOS/pair_vashishta_kokkos.cpp

@@ -582,12 +582,13 @@ void PairVashishtaKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
   request->enable_full();
-  if (lmp->kokkos->neighflag == FULL) request->enable_ghost();
+  if (neighflag == FULL) request->enable_ghost();
 }
 
 /* ---------------------------------------------------------------------- */

src/KOKKOS/pair_yukawa_kokkos.cpp

@@ -106,11 +106,12 @@ void PairYukawaKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ----------------------------------------------------------------------

src/KOKKOS/pair_zbl_kokkos.cpp

@@ -92,11 +92,12 @@ void PairZBLKokkos<DeviceType>::init_style()
 
   // adjust neighbor list request for KOKKOS
 
+  neighflag = lmp->kokkos->neighflag;
   auto request = neighbor->find_request(this);
   request->set_kokkos_host(std::is_same<DeviceType,LMPHostType>::value &&
                            !std::is_same<DeviceType,LMPDeviceType>::value);
   request->set_kokkos_device(std::is_same<DeviceType,LMPDeviceType>::value);
-  if (lmp->kokkos->neighflag == FULL) request->enable_full();
+  if (neighflag == FULL) request->enable_full();
 }
 
 /* ---------------------------------------------------------------------- */