22109060455

Committed 17 Feb 2026 05:38PM UTC coverage: 81.693% (-0.03%) from 81.721%

Build # 22109060455

Build Type

Pull #3813

github

Committed by

web-flow

Commit Message

Merge d2d368c60 into 977ade79a

Pull Request Pull Request #3813: Check for positive radii

Run Details

16733 of 23304 branches covered (71.8%)

Branch coverage included in aggregate %.

4 of 11 new or added lines in 1 file covered. (36.36%)

1361 existing lines in 48 files now uncovered.

56648 of 66521 relevant lines covered (85.16%)

43301606.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

61.16

/src/thermal.cpp

#include "openmc/thermal.h"

#include <algorithm> // for sort, move, min, max, find
#include <cmath>     // for round, sqrt, abs

#include "openmc/tensor.h"
#include <fmt/core.h>

#include "openmc/constants.h"
#include "openmc/endf.h"
#include "openmc/error.h"
#include "openmc/random_lcg.h"
#include "openmc/search.h"
#include "openmc/secondary_correlated.h"
#include "openmc/secondary_thermal.h"
#include "openmc/settings.h"
#include "openmc/string_utils.h"

namespace openmc {

//==============================================================================
// Global variables
//==============================================================================

namespace data {
std::unordered_map<std::string, int> thermal_scatt_map;
vector<unique_ptr<ThermalScattering>> thermal_scatt;
} // namespace data

//==============================================================================
// ThermalScattering implementation
//==============================================================================

ThermalScattering::ThermalScattering(
  hid_t group, const vector<double>& temperature)
{
  // Get name of table from group
  name_ = object_name(group);

  // Get rid of leading '/'
  name_ = name_.substr(1);

  read_attribute(group, "atomic_weight_ratio", awr_);
  read_attribute(group, "energy_max", energy_max_);
  read_attribute(group, "nuclides", nuclides_);

  // Read temperatures
  hid_t kT_group = open_group(group, "kTs");

  // Determine temperatures available
  auto dset_names = dataset_names(kT_group);
  auto n = dset_names.size();
  auto temps_available = tensor::Tensor<double>({n});
  for (int i = 0; i < dset_names.size(); ++i) {
    // Read temperature value
    double T;
    read_dataset(kT_group, dset_names[i].data(), T);
    temps_available[i] = std::round(T / K_BOLTZMANN);
  }
  std::sort(temps_available.begin(), temps_available.end());

  // Determine actual temperatures to read -- start by checking whether a
  // temperature range was given, in which case all temperatures in the range
  // are loaded irrespective of what temperatures actually appear in the model
  vector<int> temps_to_read;
  if (settings::temperature_range[1] > 0.0) {
    for (const auto& T : temps_available) {
      if (settings::temperature_range[0] <= T &&
          T <= settings::temperature_range[1]) {
        temps_to_read.push_back(std::round(T));
      }
    }
  }

  switch (settings::temperature_method) {
  case TemperatureMethod::NEAREST:
    // Determine actual temperatures to read
    for (const auto& T : temperature) {

      auto i_closest = tensor::abs(temps_available - T).argmin();
      auto temp_actual = temps_available[i_closest];
      if (std::abs(temp_actual - T) < settings::temperature_tolerance) {
        if (std::find(temps_to_read.begin(), temps_to_read.end(),
              std::round(temp_actual)) == temps_to_read.end()) {
          temps_to_read.push_back(std::round(temp_actual));
        }
      } else {
        fatal_error(fmt::format(
          "Nuclear data library does not contain cross sections "
          "for {}  at or near {} K. Available temperatures "
          "are {} K. Consider making use of openmc.Settings.temperature "
          "to specify how intermediate temperatures are treated.",
          name_, std::round(T), concatenate(temps_available)));
      }
    }
    break;

  case TemperatureMethod::INTERPOLATION:
    // If temperature interpolation or multipole is selected, get a list of
    // bounding temperatures for each actual temperature present in the model
    for (const auto& T : temperature) {
      bool found = false;
      for (int j = 0; j < temps_available.size() - 1; ++j) {
        if (temps_available[j] <= T && T < temps_available[j + 1]) {
          int T_j = temps_available[j];
          int T_j1 = temps_available[j + 1];
          if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j) ==
              temps_to_read.end()) {
            temps_to_read.push_back(T_j);
          }
          if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j1) ==
              temps_to_read.end()) {
            temps_to_read.push_back(T_j1);
          }
          found = true;
        }
      }
      if (!found) {
        // If no pairs found, check if the desired temperature falls within
        // bounds' tolerance
        if (std::abs(T - temps_available[0]) <=
            settings::temperature_tolerance) {
          if (std::find(temps_to_read.begin(), temps_to_read.end(),
                temps_available[0]) == temps_to_read.end()) {
            temps_to_read.push_back(temps_available[0]);
          }
        } else if (std::abs(T - temps_available[n - 1]) <=
                   settings::temperature_tolerance) {
          if (std::find(temps_to_read.begin(), temps_to_read.end(),
                temps_available[n - 1]) == temps_to_read.end()) {
            temps_to_read.push_back(temps_available[n - 1]);
          }
        } else {
          fatal_error(
            fmt::format("Nuclear data library does not contain cross "
                        "sections for {} at temperatures that bound {} K.",
              name_, std::round(T)));
        }
      }
    }
  }

  // Sort temperatures to read
  std::sort(temps_to_read.begin(), temps_to_read.end());

  auto n_temperature = temps_to_read.size();
  kTs_.reserve(n_temperature);
  data_.reserve(n_temperature);

  for (auto T : temps_to_read) {
    // Get temperature as a string
    std::string temp_str = fmt::format("{}K", T);

    // Read exact temperature value
    double kT;
    read_dataset(kT_group, temp_str.data(), kT);
    kTs_.push_back(kT);

    // Open group for this temperature
    hid_t T_group = open_group(group, temp_str.data());
    data_.emplace_back(T_group);
    close_group(T_group);
  }

  close_group(kT_group);
}

void ThermalScattering::calculate_xs(double E, double sqrtkT, int* i_temp,
  double* elastic, double* inelastic, uint64_t* seed) const
{
  // Determine temperature for S(a,b) table
  double kT = sqrtkT * sqrtkT;
  int i = 0;

  auto n = kTs_.size();
  if (n > 1) {
    if (settings::temperature_method == TemperatureMethod::NEAREST) {
      while (kTs_[i + 1] < kT && i + 1 < n - 1)
        ++i;
      // Pick closer of two bounding temperatures
      if (kT - kTs_[i] > kTs_[i + 1] - kT)
        ++i;
    } else {
      // If current kT outside of the bounds of available, snap to the bound
      if (kT < kTs_.front()) {
        i = 0;
      } else if (kT > kTs_.back()) {
        i = kTs_.size() - 1;
      } else {
        // Find temperatures that bound the actual temperature
        while (kTs_[i + 1] < kT && i + 1 < n - 1)
          ++i;
        // Randomly sample between temperature i and i+1
        double f = (kT - kTs_[i]) / (kTs_[i + 1] - kTs_[i]);
        if (f > prn(seed))
          ++i;
      }
    }
  }

  // Set temperature index
  *i_temp = i;

  // Calculate cross sections for ith temperature
  data_[i].calculate_xs(E, elastic, inelastic);
}

bool ThermalScattering::has_nuclide(const char* name) const
{
  std::string nuc {name};
  return std::find(nuclides_.begin(), nuclides_.end(), nuc) != nuclides_.end();
}

//==============================================================================
// ThermalData implementation
//==============================================================================

ThermalData::ThermalData(hid_t group)
{
  // Coherent/incoherent elastic data
  if (object_exists(group, "elastic")) {
    // Read cross section data
    hid_t elastic_group = open_group(group, "elastic");

    // Read elastic cross section
    elastic_.xs = read_function(elastic_group, "xs");

    // Read angle-energy distribution
    hid_t dgroup = open_group(elastic_group, "distribution");
    std::string temp;
    read_attribute(dgroup, "type", temp);
    if (temp == "coherent_elastic") {
      auto xs = dynamic_cast<CoherentElasticXS*>(elastic_.xs.get());
      elastic_.distribution = make_unique<CoherentElasticAE>(*xs);
    } else if (temp == "incoherent_elastic") {
      elastic_.distribution = make_unique<IncoherentElasticAE>(dgroup);
    } else if (temp == "incoherent_elastic_discrete") {
      auto xs = dynamic_cast<Tabulated1D*>(elastic_.xs.get());
      elastic_.distribution =
        make_unique<IncoherentElasticAEDiscrete>(dgroup, xs->x());
    } else if (temp == "mixed_elastic") {
      // Get coherent/incoherent cross sections
      auto mixed_xs = dynamic_cast<Sum1D*>(elastic_.xs.get());
      const auto& coh_xs =
        dynamic_cast<const CoherentElasticXS*>(mixed_xs->functions(0).get());
      const auto& incoh_xs = mixed_xs->functions(1).get();

      // Create mixed elastic distribution
      elastic_.distribution =
        make_unique<MixedElasticAE>(dgroup, *coh_xs, *incoh_xs);
    }

    close_group(elastic_group);
  }

  // Inelastic data
  if (object_exists(group, "inelastic")) {
    // Read type of inelastic data
    hid_t inelastic_group = open_group(group, "inelastic");

    // Read inelastic cross section
    inelastic_.xs = read_function(inelastic_group, "xs");

    // Read angle-energy distribution
    hid_t dgroup = open_group(inelastic_group, "distribution");
    std::string temp;
    read_attribute(dgroup, "type", temp);
    if (temp == "incoherent_inelastic") {
      inelastic_.distribution = make_unique<IncoherentInelasticAE>(dgroup);
    } else if (temp == "incoherent_inelastic_discrete") {
      auto xs = dynamic_cast<Tabulated1D*>(inelastic_.xs.get());
      inelastic_.distribution =
        make_unique<IncoherentInelasticAEDiscrete>(dgroup, xs->x());
    }

    close_group(inelastic_group);
  }
}

void ThermalData::calculate_xs(
  double E, double* elastic, double* inelastic) const
{
  // Calculate thermal elastic scattering cross section
  if (elastic_.xs) {
    *elastic = (*elastic_.xs)(E);
  } else {
    *elastic = 0.0;
  }

  // Calculate thermal inelastic scattering cross section
  *inelastic = (*inelastic_.xs)(E);
}

void ThermalData::sample(const NuclideMicroXS& micro_xs, double E,
  double* E_out, double* mu, uint64_t* seed)
{
  // Determine whether inelastic or elastic scattering will occur
  if (prn(seed) < micro_xs.thermal_elastic / micro_xs.thermal) {
    elastic_.distribution->sample(E, *E_out, *mu, seed);
  } else {
    inelastic_.distribution->sample(E, *E_out, *mu, seed);
  }

  // Because of floating-point roundoff, it may be possible for mu to be
  // outside of the range [-1,1). In these cases, we just set mu to exactly
  // -1 or 1
  if (std::abs(*mu) > 1.0)
    *mu = std::copysign(1.0, *mu);
}

void free_memory_thermal()
{
  data::thermal_scatt.clear();
  data::thermal_scatt_map.clear();
}

} // namespace openmc

1	#include "openmc/thermal.h"
2
3	#include <algorithm> // for sort, move, min, max, find
4	#include <cmath> // for round, sqrt, abs
5
6	#include "openmc/tensor.h"
7	#include <fmt/core.h>
8
9	#include "openmc/constants.h"
10	#include "openmc/endf.h"
11	#include "openmc/error.h"
12	#include "openmc/random_lcg.h"
13	#include "openmc/search.h"
14	#include "openmc/secondary_correlated.h"
15	#include "openmc/secondary_thermal.h"
16	#include "openmc/settings.h"
17	#include "openmc/string_utils.h"
18
19	namespace openmc {
20
21	//==============================================================================
22	// Global variables
23	//==============================================================================
24
25	namespace data {
26	std::unordered_map<std::string, int> thermal_scatt_map;
27	vector<unique_ptr<ThermalScattering>> thermal_scatt;
28	} // namespace data
29
30	//==============================================================================
31	// ThermalScattering implementation
32	//==============================================================================
33
34	ThermalScattering::ThermalScattering(	1,011✔
35	hid_t group, const vector<double>& temperature)	1,011✔
36	{
37	// Get name of table from group
38	name_ = object_name(group);	1,011✔
39
40	// Get rid of leading '/'
41	name_ = name_.substr(1);	1,011✔
42
43	read_attribute(group, "atomic_weight_ratio", awr_);	1,011✔
44	read_attribute(group, "energy_max", energy_max_);	1,011✔
45	read_attribute(group, "nuclides", nuclides_);	1,011✔
46
47	// Read temperatures
48	hid_t kT_group = open_group(group, "kTs");	1,011✔
49
50	// Determine temperatures available
51	auto dset_names = dataset_names(kT_group);	1,011✔
52	auto n = dset_names.size();	1,011✔
53	auto temps_available = tensor::Tensor<double>({n});	1,011✔
54	for (int i = 0; i < dset_names.size(); ++i) {	2,022✔
55	// Read temperature value
56	double T;
57	read_dataset(kT_group, dset_names[i].data(), T);	1,011✔
58	temps_available[i] = std::round(T / K_BOLTZMANN);	1,011✔
59	}
60	std::sort(temps_available.begin(), temps_available.end());	1,011✔
61
62	// Determine actual temperatures to read -- start by checking whether a
63	// temperature range was given, in which case all temperatures in the range
64	// are loaded irrespective of what temperatures actually appear in the model
65	vector<int> temps_to_read;	1,011✔
66	if (settings::temperature_range[1] > 0.0) {	1,011✔
67	for (const auto& T : temps_available) {	108✔
68	if (settings::temperature_range[0] <= T &&	108!
69	T <= settings::temperature_range[1]) {	54!
70	temps_to_read.push_back(std::round(T));	54✔
71	}
72	}
73	}
74
75	switch (settings::temperature_method) {	1,011!
76	case TemperatureMethod::NEAREST:	993✔
77	// Determine actual temperatures to read
78	for (const auto& T : temperature) {	1,986✔
79
80	auto i_closest = tensor::abs(temps_available - T).argmin();	993✔
81	auto temp_actual = temps_available[i_closest];	993✔
82	if (std::abs(temp_actual - T) < settings::temperature_tolerance) {	993!
83	if (std::find(temps_to_read.begin(), temps_to_read.end(),	993✔
84	std::round(temp_actual)) == temps_to_read.end()) {	1,986✔
85	temps_to_read.push_back(std::round(temp_actual));	939✔
86	}
87	} else {
UNCOV 88	fatal_error(fmt::format(	×
89	"Nuclear data library does not contain cross sections "
90	"for {} at or near {} K. Available temperatures "
91	"are {} K. Consider making use of openmc.Settings.temperature "
92	"to specify how intermediate temperatures are treated.",
93	name_, std::round(T), concatenate(temps_available)));	×
94	}
95	}
96	break;	993✔
97
98	case TemperatureMethod::INTERPOLATION:	18✔
99	// If temperature interpolation or multipole is selected, get a list of
100	// bounding temperatures for each actual temperature present in the model
101	for (const auto& T : temperature) {	36✔
102	bool found = false;	18✔
103	for (int j = 0; j < temps_available.size() - 1; ++j) {	18!
UNCOV 104	if (temps_available[j] <= T && T < temps_available[j + 1]) {	×
UNCOV 105	int T_j = temps_available[j];	×
UNCOV 106	int T_j1 = temps_available[j + 1];	×
UNCOV 107	if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j) ==	×
UNCOV 108	temps_to_read.end()) {	×
109	temps_to_read.push_back(T_j);	×
110	}
111	if (std::find(temps_to_read.begin(), temps_to_read.end(), T_j1) ==	×
112	temps_to_read.end()) {	×
113	temps_to_read.push_back(T_j1);	×
114	}
UNCOV 115	found = true;	×
116	}
117	}
118	if (!found) {	18!
119	// If no pairs found, check if the desired temperature falls within
120	// bounds' tolerance
121	if (std::abs(T - temps_available[0]) <=	18!
122	settings::temperature_tolerance) {
123	if (std::find(temps_to_read.begin(), temps_to_read.end(),	18✔
124	temps_available[0]) == temps_to_read.end()) {	36!
125	temps_to_read.push_back(temps_available[0]);	18✔
126	}
UNCOV 127	} else if (std::abs(T - temps_available[n - 1]) <=	×
128	settings::temperature_tolerance) {
UNCOV 129	if (std::find(temps_to_read.begin(), temps_to_read.end(),	×
UNCOV 130	temps_available[n - 1]) == temps_to_read.end()) {	×
UNCOV 131	temps_to_read.push_back(temps_available[n - 1]);	×
132	}
133	} else {
134	fatal_error(	×
135	fmt::format("Nuclear data library does not contain cross "	×
136	"sections for {} at temperatures that bound {} K.",
UNCOV 137	name_, std::round(T)));	×
138	}
139	}
140	}
141	}
142
143	// Sort temperatures to read
144	std::sort(temps_to_read.begin(), temps_to_read.end());	1,011✔
145
146	auto n_temperature = temps_to_read.size();	1,011✔
147	kTs_.reserve(n_temperature);	1,011✔
148	data_.reserve(n_temperature);	1,011✔
149
150	for (auto T : temps_to_read) {	2,022✔
151	// Get temperature as a string
152	std::string temp_str = fmt::format("{}K", T);	773✔
153
154	// Read exact temperature value
155	double kT;
156	read_dataset(kT_group, temp_str.data(), kT);	1,011✔
157	kTs_.push_back(kT);	1,011✔
158
159	// Open group for this temperature
160	hid_t T_group = open_group(group, temp_str.data());	1,011✔
161	data_.emplace_back(T_group);	1,011✔
162	close_group(T_group);	1,011✔
163	}	1,011✔
164
165	close_group(kT_group);	1,011✔
166	}	1,011✔
167
168	void ThermalScattering::calculate_xs(double E, double sqrtkT, int* i_temp,	121,622,817✔
169	double* elastic, double* inelastic, uint64_t* seed) const
170	{
171	// Determine temperature for S(a,b) table
172	double kT = sqrtkT * sqrtkT;	121,622,817✔
173	int i = 0;	121,622,817✔
174
175	auto n = kTs_.size();	121,622,817✔
176	if (n > 1) {	121,622,817!
UNCOV 177	if (settings::temperature_method == TemperatureMethod::NEAREST) {	×
UNCOV 178	while (kTs_[i + 1] < kT && i + 1 < n - 1)	×
UNCOV 179	++i;	×
180	// Pick closer of two bounding temperatures
UNCOV 181	if (kT - kTs_[i] > kTs_[i + 1] - kT)	×
182	++i;	×
183	} else {
184	// If current kT outside of the bounds of available, snap to the bound
UNCOV 185	if (kT < kTs_.front()) {	×
186	i = 0;	×
187	} else if (kT > kTs_.back()) {	×
UNCOV 188	i = kTs_.size() - 1;	×
189	} else {
190	// Find temperatures that bound the actual temperature
191	while (kTs_[i + 1] < kT && i + 1 < n - 1)	×
192	++i;	×
193	// Randomly sample between temperature i and i+1
UNCOV 194	double f = (kT - kTs_[i]) / (kTs_[i + 1] - kTs_[i]);	×
UNCOV 195	if (f > prn(seed))	×
196	++i;	×
197	}
198	}
199	}
200
201	// Set temperature index
202	*i_temp = i;	121,622,817✔
203
204	// Calculate cross sections for ith temperature
205	data_[i].calculate_xs(E, elastic, inelastic);	121,622,817✔
206	}	121,622,817✔
207
UNCOV 208	bool ThermalScattering::has_nuclide(const char* name) const	×
209	{
UNCOV 210	std::string nuc {name};	×
UNCOV 211	return std::find(nuclides_.begin(), nuclides_.end(), nuc) != nuclides_.end();	×
UNCOV 212	}	×
213
214	//==============================================================================
215	// ThermalData implementation
216	//==============================================================================
217
218	ThermalData::ThermalData(hid_t group)	1,011✔
219	{
220	// Coherent/incoherent elastic data
221	if (object_exists(group, "elastic")) {	1,011✔
222	// Read cross section data
223	hid_t elastic_group = open_group(group, "elastic");	108✔
224
225	// Read elastic cross section
226	elastic_.xs = read_function(elastic_group, "xs");	108✔
227
228	// Read angle-energy distribution
229	hid_t dgroup = open_group(elastic_group, "distribution");	108✔
230	std::string temp;	108✔
231	read_attribute(dgroup, "type", temp);	108✔
232	if (temp == "coherent_elastic") {	108✔
233	auto xs = dynamic_cast<CoherentElasticXS*>(elastic_.xs.get());	72!
234	elastic_.distribution = make_unique<CoherentElasticAE>(*xs);	72✔
235	} else if (temp == "incoherent_elastic") {	36!
UNCOV 236	elastic_.distribution = make_unique<IncoherentElasticAE>(dgroup);	×
237	} else if (temp == "incoherent_elastic_discrete") {	36!
UNCOV 238	auto xs = dynamic_cast<Tabulated1D*>(elastic_.xs.get());	×
239	elastic_.distribution =
UNCOV 240	make_unique<IncoherentElasticAEDiscrete>(dgroup, xs->x());	×
241	} else if (temp == "mixed_elastic") {	36!
242	// Get coherent/incoherent cross sections
243	auto mixed_xs = dynamic_cast<Sum1D*>(elastic_.xs.get());	36!
244	const auto& coh_xs =
245	dynamic_cast<const CoherentElasticXS*>(mixed_xs->functions(0).get());	36!
246	const auto& incoh_xs = mixed_xs->functions(1).get();	36✔
247
248	// Create mixed elastic distribution
249	elastic_.distribution =
250	make_unique<MixedElasticAE>(dgroup, coh_xs, incoh_xs);	36✔
251	}
252
253	close_group(elastic_group);	108✔
254	}	108✔
255
256	// Inelastic data
257	if (object_exists(group, "inelastic")) {	1,011!
258	// Read type of inelastic data
259	hid_t inelastic_group = open_group(group, "inelastic");	1,011✔
260
261	// Read inelastic cross section
262	inelastic_.xs = read_function(inelastic_group, "xs");	1,011✔
263
264	// Read angle-energy distribution
265	hid_t dgroup = open_group(inelastic_group, "distribution");	1,011✔
266	std::string temp;	1,011✔
267	read_attribute(dgroup, "type", temp);	1,011✔
268	if (temp == "incoherent_inelastic") {	1,011✔
269	inelastic_.distribution = make_unique<IncoherentInelasticAE>(dgroup);	36✔
270	} else if (temp == "incoherent_inelastic_discrete") {	975!
271	auto xs = dynamic_cast<Tabulated1D*>(inelastic_.xs.get());	975!
272	inelastic_.distribution =
273	make_unique<IncoherentInelasticAEDiscrete>(dgroup, xs->x());	975✔
274	}
275
276	close_group(inelastic_group);	1,011✔
277	}	1,011✔
278	}	1,011✔
279
280	void ThermalData::calculate_xs(	121,622,817✔
281	double E, double* elastic, double* inelastic) const
282	{
283	// Calculate thermal elastic scattering cross section
284	if (elastic_.xs) {	121,622,817✔
285	elastic = (elastic_.xs)(E);	4,003,749✔
286	} else {
287	*elastic = 0.0;	117,619,068✔
288	}
289
290	// Calculate thermal inelastic scattering cross section
291	inelastic = (inelastic_.xs)(E);	121,622,817✔
292	}	121,622,817✔
293
294	void ThermalData::sample(const NuclideMicroXS& micro_xs, double E,	104,289,993✔
295	double* E_out, double* mu, uint64_t* seed)
296	{
297	// Determine whether inelastic or elastic scattering will occur
298	if (prn(seed) < micro_xs.thermal_elastic / micro_xs.thermal) {	104,289,993✔
299	elastic_.distribution->sample(E, E_out, mu, seed);	146,745✔
300	} else {
301	inelastic_.distribution->sample(E, E_out, mu, seed);	104,143,248✔
302	}
303
304	// Because of floating-point roundoff, it may be possible for mu to be
305	// outside of the range [-1,1). In these cases, we just set mu to exactly
306	// -1 or 1
307	if (std::abs(*mu) > 1.0)	104,289,993!
UNCOV 308	mu = std::copysign(1.0, mu);	×
309	}	104,289,993✔
310
311	void free_memory_thermal()	6,552✔
312	{
313	data::thermal_scatt.clear();	6,552✔
314	data::thermal_scatt_map.clear();	6,552✔
315	}	6,552✔
316
317	} // namespace openmc

openmc-dev / openmc / 22109060455

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous