20943481625

Committed 13 Jan 2026 01:13AM UTC coverage: 74.47% (+0.03%) from 74.437%

Build # 20943481625

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #892 from andrsd/issue/90-quad-order

Quadrature order, number of polar, number of azimuthal is `unsigned int`

Run Details

15 of 17 new or added lines in 5 files covered. (88.24%)

248 existing lines in 10 files now uncovered.

18733 of 25155 relevant lines covered (74.47%)

66799244.41 hits per line

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

94.12

/python/lib/parameter.cc

// SPDX-FileCopyrightText: 2025 The OpenSn Authors <https://open-sn.github.io/opensn/>
// SPDX-License-Identifier: MIT

#include "python/lib/py_wrappers.h"
#include "framework/field_functions/field_function.h"
#include "framework/field_functions/field_function_grid_based.h"
#include "framework/field_functions/interpolation/ffinterpolation.h"
#include "framework/graphs/graph_partitioner.h"
#include "framework/math/functions/function.h"
#include "framework/math/quadratures/angular/angular_quadrature.h"
#include "framework/materials/multi_group_xs/multi_group_xs.h"
#include "framework/mesh/logical_volume/logical_volume.h"
#include "framework/mesh/mesh_continuum/mesh_continuum.h"
#include "framework/mesh/mesh_generator/mesh_generator.h"
#include "framework/mesh/surface_mesh/surface_mesh.h"
#include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/acceleration/discrete_ordinates_keigen_acceleration.h"
#include "modules/linear_boltzmann_solvers/lbs_problem/point_source/point_source.h"
#include "modules/linear_boltzmann_solvers/lbs_problem/volumetric_source/volumetric_source.h"
#include "modules/linear_boltzmann_solvers/response_evaluator/response_evaluator.h"
#include "modules/solver.h"
#include <memory>
#include <stdexcept>
#include <string>

#define TO_PARAMBLOCK(class_name)                                                                  \
  if (py::isinstance<class_name>(obj))                                                             \
  return ParameterBlock(key, obj.cast<std::shared_ptr<class_name>>()) // NOLINT

namespace opensn
{

// Convert a Python object into a ParameterBlock
ParameterBlock
pyobj_to_param_block(const std::string& key, const py::object& obj)
{
  // basic types
  if (py::isinstance<py::bool_>(obj))
  {
    return ParameterBlock(key, obj.cast<bool>());
  }
  if (py::isinstance<py::int_>(obj))
  {
    return ParameterBlock(key, obj.cast<int>());
  }
  if (py::isinstance<py::float_>(obj))
  {
    return ParameterBlock(key, obj.cast<double>());
  }
  if (py::isinstance<py::str>(obj))
  {
    return ParameterBlock(key, obj.cast<std::string>());
  }

  // dictionary (recursive add)
  if (py::isinstance<py::dict>(obj))
  {
    ParameterBlock main(key);
    auto dict_obj = obj.cast<py::dict>();
    for (auto [key, value] : dict_obj)
    {
      main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));
    }
    return main;
  }

  // list or tuple (recursive add)
  if (py::isinstance<py::list>(obj) || py::isinstance<py::tuple>(obj))
  {
    ParameterBlock list(key);
    list.ChangeToArray();
    for (py::handle element : obj)
    {
      std::string index_string = std::to_string(list.GetNumParameters());
      list.AddParameter(pyobj_to_param_block(index_string, element.cast<py::object>()));
    }
    return list;
  }

  // check for each class in the OpenSn library
  TO_PARAMBLOCK(AngularQuadrature);
  TO_PARAMBLOCK(FieldFunction);
  TO_PARAMBLOCK(FieldFunctionInterpolation);
  TO_PARAMBLOCK(GraphPartitioner);
  TO_PARAMBLOCK(DiscreteOrdinatesKEigenAcceleration);
  TO_PARAMBLOCK(LogicalVolume);
  TO_PARAMBLOCK(MeshContinuum);
  TO_PARAMBLOCK(MeshGenerator);
  TO_PARAMBLOCK(MultiGroupXS);
  TO_PARAMBLOCK(PointSource);
  TO_PARAMBLOCK(ResponseEvaluator);
  TO_PARAMBLOCK(Problem);
  TO_PARAMBLOCK(Solver);
  TO_PARAMBLOCK(SurfaceMesh);
  TO_PARAMBLOCK(VolumetricSource);
  TO_PARAMBLOCK(VectorSpatialFunction);
  TO_PARAMBLOCK(AngularFluxFunction);

  // throw and return
  throw std::invalid_argument("Unsupported argument type.");
}

// Translate a Python dictionary into a ParameterBlock
ParameterBlock
kwargs_to_param_block(const py::kwargs& params)
{
  // initialize main parameter dict
  ParameterBlock main;

  // append corresponding parameters to the main
  for (auto [key, value] : params)
  {
    // skip empty keys
    if (key.cast<std::string>().empty())
    {
      continue;
    }

    // recursively add parameters
    main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));
  }

  return main;
}

} // namespace opensn

1	// SPDX-FileCopyrightText: 2025 The OpenSn Authors <https://open-sn.github.io/opensn/>
2	// SPDX-License-Identifier: MIT
3
4	#include "python/lib/py_wrappers.h"
5	#include "framework/field_functions/field_function.h"
6	#include "framework/field_functions/field_function_grid_based.h"
7	#include "framework/field_functions/interpolation/ffinterpolation.h"
8	#include "framework/graphs/graph_partitioner.h"
9	#include "framework/math/functions/function.h"
10	#include "framework/math/quadratures/angular/angular_quadrature.h"
11	#include "framework/materials/multi_group_xs/multi_group_xs.h"
12	#include "framework/mesh/logical_volume/logical_volume.h"
13	#include "framework/mesh/mesh_continuum/mesh_continuum.h"
14	#include "framework/mesh/mesh_generator/mesh_generator.h"
15	#include "framework/mesh/surface_mesh/surface_mesh.h"
16	#include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/acceleration/discrete_ordinates_keigen_acceleration.h"
17	#include "modules/linear_boltzmann_solvers/lbs_problem/point_source/point_source.h"
18	#include "modules/linear_boltzmann_solvers/lbs_problem/volumetric_source/volumetric_source.h"
19	#include "modules/linear_boltzmann_solvers/response_evaluator/response_evaluator.h"
20	#include "modules/solver.h"
21	#include <memory>
22	#include <stdexcept>
23	#include <string>
24
25	#define TO_PARAMBLOCK(class_name) \
26	if (py::isinstance<class_name>(obj)) \
27	return ParameterBlock(key, obj.cast<std::shared_ptr<class_name>>()) // NOLINT
28
29	namespace opensn
30	{
31
32	// Convert a Python object into a ParameterBlock
33	ParameterBlock
34	pyobj_to_param_block(const std::string& key, const py::object& obj)	82,581✔
35	{
36	// basic types
37	if (py::isinstance<py::bool_>(obj))	82,581✔
38	{
39	return ParameterBlock(key, obj.cast<bool>());	2,852✔
40	}
41	if (py::isinstance<py::int_>(obj))	81,155✔
42	{
43	return ParameterBlock(key, obj.cast<int>());	7,484✔
44	}
45	if (py::isinstance<py::float_>(obj))	77,413✔
46	{
47	return ParameterBlock(key, obj.cast<double>());	131,856✔
48	}
49	if (py::isinstance<py::str>(obj))	11,485✔
50	{
51	return ParameterBlock(key, obj.cast<std::string>());	4,842✔
52	}
53
54	// dictionary (recursive add)
55	if (py::isinstance<py::dict>(obj))	9,064✔
56	{
57	ParameterBlock main(key);	2,288✔
58	auto dict_obj = obj.cast<py::dict>();	2,288✔
59	for (auto [key, value] : dict_obj)	11,197✔
60	{
61	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	6,621✔
62	}
63	return main;	2,288✔
64	}	2,288✔
65
66	// list or tuple (recursive add)
67	if (py::isinstance<py::list>(obj) \|\| py::isinstance<py::tuple>(obj))	6,776✔
68	{
69	ParameterBlock list(key);	4,320✔
70	list.ChangeToArray();	4,320✔
71	for (py::handle element : obj)	146,640✔
72	{
73	std::string index_string = std::to_string(list.GetNumParameters());	69,000✔
74	list.AddParameter(pyobj_to_param_block(index_string, element.cast<py::object>()));	69,000✔
75	}	73,320✔
76	return list;	4,320✔
77	}	4,320✔
78
79	// check for each class in the OpenSn library
80	TO_PARAMBLOCK(AngularQuadrature);	3,298✔
81	TO_PARAMBLOCK(FieldFunction);	2,035✔
82	TO_PARAMBLOCK(FieldFunctionInterpolation);	2,035✔
83	TO_PARAMBLOCK(GraphPartitioner);	2,255✔
84	TO_PARAMBLOCK(DiscreteOrdinatesKEigenAcceleration);	1,949✔
85	TO_PARAMBLOCK(LogicalVolume);	1,981✔
86	TO_PARAMBLOCK(MeshContinuum);	2,603✔
87	TO_PARAMBLOCK(MeshGenerator);	1,663✔
88	TO_PARAMBLOCK(MultiGroupXS);	2,682✔
89	TO_PARAMBLOCK(PointSource);	859✔
90	TO_PARAMBLOCK(ResponseEvaluator);	808✔
91	TO_PARAMBLOCK(Problem);	1,616✔
92	TO_PARAMBLOCK(Solver);	404✔
93	TO_PARAMBLOCK(SurfaceMesh);	406✔
94	TO_PARAMBLOCK(VolumetricSource);	1,169✔
95	TO_PARAMBLOCK(VectorSpatialFunction);	52✔
96	TO_PARAMBLOCK(AngularFluxFunction);	12✔
97
98	// throw and return
UNCOV 99	throw std::invalid_argument("Unsupported argument type.");	×
100	}
101
102	// Translate a Python dictionary into a ParameterBlock
103	ParameterBlock
104	kwargs_to_param_block(const py::kwargs& params)	2,379✔
105	{
106	// initialize main parameter dict
107	ParameterBlock main;	2,379✔
108
109	// append corresponding parameters to the main
110	for (auto [key, value] : params)	18,678✔
111	{
112	// skip empty keys
113	if (key.cast<std::string>().empty())	6,960✔
114	{
UNCOV 115	continue;	×
116	}
117
118	// recursively add parameters
119	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	6,960✔
120	}
121
122	return main;	2,379✔
UNCOV 123	}	×
124
125	} // namespace opensn

Open-Sn / opensn / 20943481625

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