25478472129

Committed 07 May 2026 04:23AM UTC coverage: 75.685% (+0.3%) from 75.416%

Build # 25478472129

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1057 from wdhawkins/c5g7_fixes

Updating tests.json for c5g7 tests and new iterative output.

Coverage Stats

22081 of 29175 relevant lines covered (75.68%)

65079358.06 hits per line

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

94.23

/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);
  TO_PARAMBLOCK(AngularFluxTimeFunction);

  // 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)	137,495✔
35	{
36	// basic types
37	if (py::isinstance<py::bool_>(obj))	137,495✔
38	{
39	return ParameterBlock(key, obj.cast<bool>());	9,036✔
40	}
41	if (py::isinstance<py::int_>(obj))	132,977✔
42	{
43	return ParameterBlock(key, obj.cast<int>());	17,298✔
44	}
45	if (py::isinstance<py::float_>(obj))	124,328✔
46	{
47	return ParameterBlock(key, obj.cast<double>());	184,166✔
48	}
49	if (py::isinstance<py::str>(obj))	32,245✔
50	{
51	return ParameterBlock(key, obj.cast<std::string>());	18,838✔
52	}
53
54	// dictionary (recursive add)
55	if (py::isinstance<py::dict>(obj))	22,826✔
56	{
57	ParameterBlock main(key);	7,109✔
58	auto dict_obj = obj.cast<py::dict>();	7,109✔
59	for (auto [key, value] : dict_obj)	35,019✔
60	{
61	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	20,801✔
62	}
63	return main;	7,109✔
64	}	7,109✔
65
66	// list or tuple (recursive add)
67	if (py::isinstance<py::list>(obj) \|\| py::isinstance<py::tuple>(obj))	15,717✔
68	{
69	ParameterBlock list(key);	9,660✔
70	list.ChangeToArray();	9,660✔
71	for (py::handle element : obj)	219,694✔
72	{
73	std::string index_string = std::to_string(list.GetNumParameters());	100,187✔
74	list.AddParameter(pyobj_to_param_block(index_string, element.cast<py::object>()));	100,187✔
75	}	109,847✔
76	return list;	9,660✔
77	}	9,660✔
78
79	// check for each class in the OpenSn library
80	TO_PARAMBLOCK(AngularQuadrature);	8,259✔
81	TO_PARAMBLOCK(FieldFunction);	4,956✔
82	TO_PARAMBLOCK(FieldFunctionInterpolation);	4,956✔
83	TO_PARAMBLOCK(GraphPartitioner);	5,234✔
84	TO_PARAMBLOCK(DiscreteOrdinatesKEigenAcceleration);	4,841✔
85	TO_PARAMBLOCK(LogicalVolume);	4,997✔
86	TO_PARAMBLOCK(MeshContinuum);	6,669✔
87	TO_PARAMBLOCK(MeshGenerator);	3,899✔
88	TO_PARAMBLOCK(MultiGroupXS);	6,502✔
89	TO_PARAMBLOCK(PointSource);	2,247✔
90	TO_PARAMBLOCK(ResponseEvaluator);	2,199✔
91	TO_PARAMBLOCK(Problem);	4,707✔
92	TO_PARAMBLOCK(Solver);	945✔
93	TO_PARAMBLOCK(SurfaceMesh);	949✔
94	TO_PARAMBLOCK(VolumetricSource);	2,525✔
95	TO_PARAMBLOCK(VectorSpatialFunction);	184✔
96	TO_PARAMBLOCK(AngularFluxFunction);	216✔
97	TO_PARAMBLOCK(AngularFluxTimeFunction);	288✔
98
99	// throw and return
100	throw std::invalid_argument("Unsupported argument type.");	×
101	}
102
103	// Translate a Python dictionary into a ParameterBlock
104	ParameterBlock
105	kwargs_to_param_block(const py::kwargs& params)	4,173✔
106	{
107	// initialize main parameter dict
108	ParameterBlock main;	4,173✔
109
110	// append corresponding parameters to the main
111	for (auto [key, value] : params)	37,132✔
112	{
113	// skip empty keys
114	if (key.cast<std::string>().empty())	14,393✔
115	{
116	continue;	×
117	}
118
119	// recursively add parameters
120	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	14,393✔
121	}
122
123	return main;	4,173✔
124	}	×
125
126	} // namespace opensn

Open-Sn / opensn / 25478472129

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