16794483591

Committed 06 Aug 2025 09:06PM UTC coverage: 73.488% (+0.1%) from 73.386%

Build # 16794483591

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #703 from wdhawkins/documentation_updates

Documentation updates

Coverage Stats

18200 of 24766 relevant lines covered (73.49%)

43445053.18 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 "framework/physics/solver.h"
#include "framework/post_processors/post_processor.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 <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>>())

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);
    py::dict 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(PostProcessor);
  TO_PARAMBLOCK(ResponseEvaluator);
  TO_PARAMBLOCK(Problem);
  TO_PARAMBLOCK(Solver);
  TO_PARAMBLOCK(SurfaceMesh);
  TO_PARAMBLOCK(VolumetricSource);
  TO_PARAMBLOCK(VectorSpatialFunction);

  // 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 "framework/physics/solver.h"
17	#include "framework/post_processors/post_processor.h"
18	#include "modules/linear_boltzmann_solvers/discrete_ordinates_problem/acceleration/discrete_ordinates_keigen_acceleration.h"
19	#include "modules/linear_boltzmann_solvers/lbs_problem/point_source/point_source.h"
20	#include "modules/linear_boltzmann_solvers/lbs_problem/volumetric_source/volumetric_source.h"
21	#include "modules/linear_boltzmann_solvers/response_evaluator/response_evaluator.h"
22	#include <memory>
23	#include <stdexcept>
24	#include <string>
25
26	#define TO_PARAMBLOCK(class_name) \
27	if (py::isinstance<class_name>(obj)) \
28	return ParameterBlock(key, obj.cast<std::shared_ptr<class_name>>())
29
30	namespace opensn
31	{
32
33	// Convert a Python object into a ParameterBlock
34	ParameterBlock
35	pyobj_to_param_block(const std::string& key, const py::object& obj)	63,879✔
36	{
37	// basic types
38	if (py::isinstance<py::bool_>(obj))	63,879✔
39	{
40	return ParameterBlock(key, obj.cast<bool>());	1,028✔
41	}
42	if (py::isinstance<py::int_>(obj))	62,851✔
43	{
44	return ParameterBlock(key, obj.cast<int>());	3,101✔
45	}
46	if (py::isinstance<py::float_>(obj))	59,750✔
47	{
48	return ParameterBlock(key, obj.cast<double>());	51,455✔
49	}
50	if (py::isinstance<py::str>(obj))	8,295✔
51	{
52	return ParameterBlock(key, obj.cast<std::string>());	3,218✔
53	}
54
55	// dictionary (recursive add)
56	if (py::isinstance<py::dict>(obj))	6,686✔
57	{
58	ParameterBlock main(key);	1,617✔
59	py::dict dict_obj = obj.cast<py::dict>();	1,617✔
60	for (auto [key, value] : dict_obj)	8,290✔
61	{
62	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	5,056✔
63	}
64	return main;	1,617✔
65	}	1,617✔
66
67	// list or tuple (recursive add)
68	if (py::isinstance<py::list>(obj) \|\| py::isinstance<py::tuple>(obj))	5,069✔
69	{
70	ParameterBlock list(key);	3,273✔
71	list.ChangeToArray();	3,273✔
72	for (py::handle element : obj)	114,190✔
73	{
74	std::string index_string = std::to_string(list.GetNumParameters());	53,822✔
75	list.AddParameter(pyobj_to_param_block(index_string, element.cast<py::object>()));	53,822✔
76	}	57,095✔
77	return list;	3,273✔
78	}	3,273✔
79
80	// check for each class in the OpenSn library
81	TO_PARAMBLOCK(AngularQuadrature);	2,111✔
82	TO_PARAMBLOCK(FieldFunction);	1,513✔
83	TO_PARAMBLOCK(FieldFunctionInterpolation);	1,449✔
84	TO_PARAMBLOCK(GraphPartitioner);	1,535✔
85	TO_PARAMBLOCK(DiscreteOrdinatesKEigenAcceleration);	1,375✔
86	TO_PARAMBLOCK(LogicalVolume);	1,365✔
87	TO_PARAMBLOCK(MeshContinuum);	1,597✔
88	TO_PARAMBLOCK(MeshGenerator);	1,146✔
89	TO_PARAMBLOCK(MultiGroupXS);	1,413✔
90	TO_PARAMBLOCK(PointSource);	620✔
91	TO_PARAMBLOCK(PostProcessor);	586✔
92	TO_PARAMBLOCK(ResponseEvaluator);	586✔
93	TO_PARAMBLOCK(Problem);	870✔
94	TO_PARAMBLOCK(Solver);	302✔
95	TO_PARAMBLOCK(SurfaceMesh);	303✔
96	TO_PARAMBLOCK(VolumetricSource);	598✔
97	TO_PARAMBLOCK(VectorSpatialFunction);	8✔
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)	1,746✔
106	{
107	// initialize main parameter dict
108	ParameterBlock main;	1,746✔
109
110	// append corresponding parameters to the main
111	for (auto [key, value] : params)	13,494✔
112	{
113	// skip empty keys
114	if (key.cast<std::string>().empty())	5,001✔
115	{
116	continue;	×
117	}
118
119	// recursively add parameters
120	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	5,001✔
121	}
122
123	return main;	1,746✔
124	}	×
125
126	} // namespace opensn

Open-Sn / opensn / 16794483591

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