diff --git a/include/openmc/physics_common.h b/include/openmc/physics_common.h
index e38a3c7f883..b0e395c1ea4 100644
--- a/include/openmc/physics_common.h
+++ b/include/openmc/physics_common.h
@@ -13,5 +13,9 @@ namespace openmc {
 //! \param[in] weight_survive Weight assigned to particles that survive
 void russian_roulette(Particle& p, double weight_survive);
 
+//! \brief Performs the global russian roulette operation on a particle
+//! \param[in,out] p  Particle object
+void apply_russian_roulette(Particle& p);
+
 } // namespace openmc
 #endif // OPENMC_PHYSICS_COMMON_H
diff --git a/include/openmc/weight_windows.h b/include/openmc/weight_windows.h
index 7638155228e..819a7ae821b 100644
--- a/include/openmc/weight_windows.h
+++ b/include/openmc/weight_windows.h
@@ -25,17 +25,6 @@ enum class WeightWindowUpdateMethod { MAGIC, FW_CADIS };
 
 constexpr double DEFAULT_WEIGHT_CUTOFF {1.0e-38}; // default low weight cutoff
 
-//==============================================================================
-// Non-member functions
-//==============================================================================
-
-//! Apply weight windows to a particle
-//! \param[in] p  Particle to apply weight windows to
-void apply_weight_windows(Particle& p);
-
-//! Free memory associated with weight windows
-void free_memory_weight_windows();
-
 //==============================================================================
 // Global variables
 //==============================================================================
@@ -135,10 +124,19 @@ class WeightWindows {
   //! \param[in] group  HDF5 group to write to
   void to_hdf5(hid_t group) const;
 
+  //! Get particle bin inside weight window mesh
+  //! \param[in] p  Particle to get weight window bin for
+  const int get_mesh_bin(const Particle& p) const;
+
   //! Retrieve the weight window for a particle
   //! \param[in] p  Particle to get weight window for
   WeightWindow get_weight_window(const Particle& p) const;
 
+  //! Retrieve the weight window for a mesh bin
+  //! \param[in] double E particle energy
+  //! \param[in] int mesh_bin mesh bin
+  WeightWindow get_weight_window(double E, const int mesh_bin) const;
+
   std::array<int, 2> bounds_size() const;
 
   const vector<double>& energy_bounds() const { return energy_bounds_; }
@@ -237,6 +235,26 @@ class WeightWindowsGenerator {
   double ratio_ {5.0};     //<! ratio of lower to upper weight window bounds
 };
 
+//==============================================================================
+// Non-member functions
+//==============================================================================
+
+//! Apply weight windows to a particle
+//! \param[in] p  Particle to apply weight windows to
+void apply_weight_windows(Particle& p);
+
+//! Apply weight window to a particle
+//! \param[in] p  Particle to apply weight window to
+//! \param[in] weight_window WeightWindow to apply
+void apply_weight_window(Particle& p, WeightWindow weight_window);
+
+//! Free memory associated with weight windows
+void free_memory_weight_windows();
+
+//! Search weight window that apply to a particle
+//! \param[in]  p  Particle to search weight window for
+WeightWindow search_weight_window(const Particle& p);
+
 //! Finalize variance reduction objects after all inputs have been read
 void finalize_variance_reduction();
 
diff --git a/src/physics.cpp b/src/physics.cpp
index 41509af97be..aa49a6e54c5 100644
--- a/src/physics.cpp
+++ b/src/physics.cpp
@@ -61,8 +61,25 @@ void collision(Particle& p)
     break;
   }
 
-  if (settings::weight_window_checkpoint_collision)
-    apply_weight_windows(p);
+  if (settings::weight_windows_on) {
+    if (settings::weight_window_checkpoint_collision) {
+      // If collision checkpoint is enabled, apply weight window
+      // if valid and apply global russian roulette if not.
+      auto ww = search_weight_window(p);
+      if (ww.is_valid()) {
+        apply_weight_window(p, ww);
+      } else if (p.type() == ParticleType::neutron) {
+        apply_russian_roulette(p);
+      }
+    } else if (p.type() == ParticleType::neutron) {
+      // If collision checkpoint is disabled and weight windows are enabled,
+      // apply russian roulette if the particle is a neutron and it is outside
+      // the weight window domain
+      auto ww = search_weight_window(p);
+      if (!ww.is_valid())
+        apply_russian_roulette(p);
+    }
+  }
 
   // Kill particle if energy falls below cutoff
   int type = static_cast<int>(p.type());
@@ -153,18 +170,9 @@ void sample_neutron_reaction(Particle& p)
     advance_prn_seed(data::nuclides.size(), &p.seeds(STREAM_URR_PTABLE));
   }
 
-  // Play russian roulette if survival biasing is turned on
-  if (settings::survival_biasing) {
-    // if survival normalization is on, use normalized weight cutoff and
-    // normalized weight survive
-    if (settings::survival_normalization) {
-      if (p.wgt() < settings::weight_cutoff * p.wgt_born()) {
-        russian_roulette(p, settings::weight_survive * p.wgt_born());
-      }
-    } else if (p.wgt() < settings::weight_cutoff) {
-      russian_roulette(p, settings::weight_survive);
-    }
-  }
+  // Play russian roulette if there are no weight windows
+  if (!settings::weight_windows_on)
+    apply_russian_roulette(p);
 }
 
 void create_fission_sites(Particle& p, int i_nuclide, const Reaction& rx)
diff --git a/src/physics_common.cpp b/src/physics_common.cpp
index e25ae6b97ab..10760ce2da1 100644
--- a/src/physics_common.cpp
+++ b/src/physics_common.cpp
@@ -18,4 +18,20 @@ void russian_roulette(Particle& p, double weight_survive)
   }
 }
 
+void apply_russian_roulette(Particle& p)
+{
+  // Exit if survival biasing is turned off
+  if (!settings::survival_biasing)
+    return;
+
+  // if survival normalization is on, use normalized weight cutoff and
+  // normalized weight survive
+  if (settings::survival_normalization) {
+    if (p.wgt() < settings::weight_cutoff * p.wgt_born()) {
+      russian_roulette(p, settings::weight_survive * p.wgt_born());
+    }
+  } else if (p.wgt() < settings::weight_cutoff) {
+    russian_roulette(p, settings::weight_survive);
+  }
+}
 } // namespace openmc
diff --git a/src/physics_mg.cpp b/src/physics_mg.cpp
index 4c28cb1795a..c8bd65eff1f 100644
--- a/src/physics_mg.cpp
+++ b/src/physics_mg.cpp
@@ -31,8 +31,15 @@ void collision_mg(Particle& p)
   // Sample the reaction type
   sample_reaction(p);
 
-  if (settings::weight_window_checkpoint_collision)
-    apply_weight_windows(p);
+  if (settings::weight_windows_on) {
+    auto ww = search_weight_window(p);
+    if (ww.is_valid()) {
+      if (settings::weight_window_checkpoint_collision)
+        apply_weight_window(p, ww);
+    } else {
+      apply_russian_roulette(p);
+    }
+  }
 
   // Display information about collision
   if ((settings::verbosity >= 10) || p.trace()) {
@@ -66,18 +73,9 @@ void sample_reaction(Particle& p)
   // Sample a scattering event to determine the energy of the exiting neutron
   scatter(p);
 
-  // Play Russian roulette if survival biasing is turned on
-  if (settings::survival_biasing) {
-    // if survival normalization is applicable, use normalized weight cutoff and
-    // normalized weight survive
-    if (settings::survival_normalization) {
-      if (p.wgt() < settings::weight_cutoff * p.wgt_born()) {
-        russian_roulette(p, settings::weight_survive * p.wgt_born());
-      }
-    } else if (p.wgt() < settings::weight_cutoff) {
-      russian_roulette(p, settings::weight_survive);
-    }
-  }
+  // Play russian roulette if there are no weight windows
+  if (!settings::weight_windows_on)
+    apply_russian_roulette(p);
 }
 
 void scatter(Particle& p)
diff --git a/src/settings.cpp b/src/settings.cpp
index 5b472468fc4..65790277d80 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -1264,6 +1264,13 @@ void read_settings_xml(pugi::xml_node root)
     }
   }
 
+  if (weight_windows_on) {
+    if (!weight_window_checkpoint_surface &&
+        !weight_window_checkpoint_collision)
+      fatal_error(
+        "Weight Windows are enabled but there are no valid checkpoints.");
+  }
+
   if (check_for_node(root, "use_decay_photons")) {
     settings::use_decay_photons =
       get_node_value_bool(root, "use_decay_photons");
diff --git a/src/weight_windows.cpp b/src/weight_windows.cpp
index 4838e459152..becf3fc36f2 100644
--- a/src/weight_windows.cpp
+++ b/src/weight_windows.cpp
@@ -49,108 +49,6 @@ openmc::vector<unique_ptr<WeightWindowsGenerator>> weight_windows_generators;
 
 } // namespace variance_reduction
 
-//==============================================================================
-// Non-member functions
-//==============================================================================
-
-void apply_weight_windows(Particle& p)
-{
-  if (!settings::weight_windows_on)
-    return;
-
-  // WW on photon and neutron only
-  if (p.type() != ParticleType::neutron && p.type() != ParticleType::photon)
-    return;
-
-  // skip dead or no energy
-  if (p.E() <= 0 || !p.alive())
-    return;
-
-  bool in_domain = false;
-  // TODO: this is a linear search - should do something more clever
-  WeightWindow weight_window;
-  for (const auto& ww : variance_reduction::weight_windows) {
-    weight_window = ww->get_weight_window(p);
-    if (weight_window.is_valid())
-      break;
-  }
-
-  // If particle has not yet had its birth weight window value set, set it to
-  // the current weight window (or 1.0 if not born in a weight window).
-  if (p.wgt_ww_born() == -1.0) {
-    if (weight_window.is_valid()) {
-      p.wgt_ww_born() =
-        (weight_window.lower_weight + weight_window.upper_weight) / 2;
-    } else {
-      p.wgt_ww_born() = 1.0;
-    }
-  }
-
-  // particle is not in any of the ww domains, do nothing
-  if (!weight_window.is_valid())
-    return;
-
-  // Normalize weight windows based on particle's starting weight
-  // and the value of the weight window the particle was born in.
-  weight_window.scale(p.wgt_born() / p.wgt_ww_born());
-
-  // get the paramters
-  double weight = p.wgt();
-
-  // first check to see if particle should be killed for weight cutoff
-  if (p.wgt() < weight_window.weight_cutoff) {
-    p.wgt() = 0.0;
-    return;
-  }
-
-  // check if particle is far above current weight window
-  // only do this if the factor is not already set on the particle and a
-  // maximum lower bound ratio is specified
-  if (p.ww_factor() == 0.0 && weight_window.max_lb_ratio > 1.0 &&
-      p.wgt() > weight_window.lower_weight * weight_window.max_lb_ratio) {
-    p.ww_factor() =
-      p.wgt() / (weight_window.lower_weight * weight_window.max_lb_ratio);
-  }
-
-  // move weight window closer to the particle weight if needed
-  if (p.ww_factor() > 1.0)
-    weight_window.scale(p.ww_factor());
-
-  // if particle's weight is above the weight window split until they are within
-  // the window
-  if (weight > weight_window.upper_weight) {
-    // do not further split the particle if above the limit
-    if (p.n_split() >= settings::max_history_splits)
-      return;
-
-    double n_split = std::ceil(weight / weight_window.upper_weight);
-    double max_split = weight_window.max_split;
-    n_split = std::min(n_split, max_split);
-
-    p.n_split() += n_split;
-
-    // Create secondaries and divide weight among all particles
-    int i_split = std::round(n_split);
-    for (int l = 0; l < i_split - 1; l++) {
-      p.split(weight / n_split);
-    }
-    // remaining weight is applied to current particle
-    p.wgt() = weight / n_split;
-
-  } else if (weight <= weight_window.lower_weight) {
-    // if the particle weight is below the window, play Russian roulette
-    double weight_survive =
-      std::min(weight * weight_window.max_split, weight_window.survival_weight);
-    russian_roulette(p, weight_survive);
-  } // else particle is in the window, continue as normal
-}
-
-void free_memory_weight_windows()
-{
-  variance_reduction::ww_map.clear();
-  variance_reduction::weight_windows.clear();
-}
-
 //==============================================================================
 // WeightWindowSettings implementation
 //==============================================================================
@@ -372,26 +270,34 @@ void WeightWindows::set_mesh(const Mesh* mesh)
   set_mesh(model::mesh_map[mesh->id_]);
 }
 
-WeightWindow WeightWindows::get_weight_window(const Particle& p) const
+const int WeightWindows::get_mesh_bin(const Particle& p) const
 {
   // check for particle type
-  if (particle_type_ != p.type()) {
-    return {};
-  }
-
-  // Get mesh index for particle's position
-  const auto& mesh = this->mesh();
-  int mesh_bin = mesh->get_bin(p.r());
-
-  // particle is outside the weight window mesh
-  if (mesh_bin < 0)
-    return {};
+  if (particle_type_ != p.type())
+    return C_NONE;
 
   // particle energy
   double E = p.E();
 
   // check to make sure energy is in range, expects sorted energy values
   if (E < energy_bounds_.front() || E > energy_bounds_.back())
+    return C_NONE;
+
+  // Get mesh index for particle's position
+  const auto& mesh = this->mesh();
+  return mesh->get_bin(p.r());
+}
+
+WeightWindow WeightWindows::get_weight_window(const Particle& p) const
+{
+  return get_weight_window(p.E(), get_mesh_bin(p));
+}
+
+WeightWindow WeightWindows::get_weight_window(
+  double E, const int mesh_bin) const
+{
+  // particle is outside the weight window mesh
+  if (mesh_bin < 0)
     return {};
 
   // get the mesh bin in energy group
@@ -997,6 +903,117 @@ void WeightWindowsGenerator::update() const
 // Non-member functions
 //==============================================================================
 
+WeightWindow search_weight_window(const Particle& p)
+{
+  // TODO: this is a linear search - should do something more clever
+  int mesh_bin;
+  WeightWindow weight_window;
+  for (const auto& ww : variance_reduction::weight_windows) {
+    mesh_bin = ww->get_mesh_bin(p);
+    if (mesh_bin < 0)
+      continue;
+    weight_window = ww->get_weight_window(p.E(), mesh_bin);
+    if (weight_window.is_valid())
+      return weight_window;
+  }
+  return {};
+}
+
+void apply_weight_windows(Particle& p)
+{
+  if (!settings::weight_windows_on)
+    return;
+
+  // WW on photon and neutron only
+  if (p.type() != ParticleType::neutron && p.type() != ParticleType::photon)
+    return;
+
+  // skip dead or no energy
+  if (p.E() <= 0 || !p.alive())
+    return;
+
+  auto ww = search_weight_window(p);
+  if (ww.is_valid()) {
+    apply_weight_window(p, ww);
+  } else {
+    if (p.wgt_ww_born() == -1.0)
+      p.wgt_ww_born() = 1.0;
+  }
+}
+
+void apply_weight_window(Particle& p, WeightWindow weight_window)
+{
+  // skip dead or no energy
+  if (p.E() <= 0 || !p.alive())
+    return;
+
+  // If particle has not yet had its birth weight window value set, set it to
+  // the current weight window.
+  if (p.wgt_ww_born() == -1.0)
+    p.wgt_ww_born() =
+      (weight_window.lower_weight + weight_window.upper_weight) / 2;
+
+  // Normalize weight windows based on particle's starting weight
+  // and the value of the weight window the particle was born in.
+  weight_window.scale(p.wgt_born() / p.wgt_ww_born());
+
+  // get the paramters
+  double weight = p.wgt();
+
+  // first check to see if particle should be killed for weight cutoff
+  if (p.wgt() < weight_window.weight_cutoff) {
+    p.wgt() = 0.0;
+    return;
+  }
+
+  // check if particle is far above current weight window
+  // only do this if the factor is not already set on the particle and a
+  // maximum lower bound ratio is specified
+  if (p.ww_factor() == 0.0 && weight_window.max_lb_ratio > 1.0 &&
+      p.wgt() > weight_window.lower_weight * weight_window.max_lb_ratio) {
+    p.ww_factor() =
+      p.wgt() / (weight_window.lower_weight * weight_window.max_lb_ratio);
+  }
+
+  // move weight window closer to the particle weight if needed
+  if (p.ww_factor() > 1.0)
+    weight_window.scale(p.ww_factor());
+
+  // if particle's weight is above the weight window split until they are within
+  // the window
+  if (weight > weight_window.upper_weight) {
+    // do not further split the particle if above the limit
+    if (p.n_split() >= settings::max_history_splits)
+      return;
+
+    double n_split = std::ceil(weight / weight_window.upper_weight);
+    double max_split = weight_window.max_split;
+    n_split = std::min(n_split, max_split);
+
+    p.n_split() += n_split;
+
+    // Create secondaries and divide weight among all particles
+    int i_split = std::round(n_split);
+    for (int l = 0; l < i_split - 1; l++) {
+      p.split(weight / n_split);
+    }
+    // remaining weight is applied to current particle
+    p.wgt() = weight / n_split;
+
+  } else if (weight <= weight_window.lower_weight) {
+    // if the particle weight is below the window, play Russian roulette
+    double weight_survive =
+      std::min(weight * weight_window.max_split, weight_window.survival_weight);
+    russian_roulette(p, weight_survive);
+  } // else particle is in the window, continue as normal
+}
+
+void free_memory_weight_windows()
+{
+  variance_reduction::ww_map.clear();
+  variance_reduction::weight_windows.clear();
+}
+
 void finalize_variance_reduction()
 {
   for (const auto& wwg : variance_reduction::weight_windows_generators) {