16821314466

Committed 07 Aug 2025 04:57PM UTC coverage: 74.527% (+1.0%) from 73.488%

Build # 16821314466

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #708 from wdhawkins/curvilinear_warning

Adding experimental warning to curvilinear solver

Coverage Stats

3 of 3 new or added lines in 1 file covered. (100.0%)

250 existing lines in 17 files now uncovered.

17543 of 23539 relevant lines covered (74.53%)

44793362.81 hits per line

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

94.0

/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 "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(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 "modules/linear_boltzmann_solvers/discrete_ordinates_problem/acceleration/discrete_ordinates_keigen_acceleration.h"
18	#include "modules/linear_boltzmann_solvers/lbs_problem/point_source/point_source.h"
19	#include "modules/linear_boltzmann_solvers/lbs_problem/volumetric_source/volumetric_source.h"
20	#include "modules/linear_boltzmann_solvers/response_evaluator/response_evaluator.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>>())
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)	63,783✔
35	{
36	// basic types
37	if (py::isinstance<py::bool_>(obj))	63,783✔
38	{
39	return ParameterBlock(key, obj.cast<bool>());	1,044✔
40	}
41	if (py::isinstance<py::int_>(obj))	62,739✔
42	{
43	return ParameterBlock(key, obj.cast<int>());	3,101✔
44	}
45	if (py::isinstance<py::float_>(obj))	59,638✔
46	{
47	return ParameterBlock(key, obj.cast<double>());	51,455✔
48	}
49	if (py::isinstance<py::str>(obj))	8,183✔
50	{
51	return ParameterBlock(key, obj.cast<std::string>());	3,058✔
52	}
53
54	// dictionary (recursive add)
55	if (py::isinstance<py::dict>(obj))	6,654✔
56	{
57	ParameterBlock main(key);	1,617✔
58	py::dict dict_obj = obj.cast<py::dict>();	1,617✔
59	for (auto [key, value] : dict_obj)	8,290✔
60	{
61	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	5,056✔
62	}
63	return main;	1,617✔
64	}	1,617✔
65
66	// list or tuple (recursive add)
67	if (py::isinstance<py::list>(obj) \|\| py::isinstance<py::tuple>(obj))	5,037✔
68	{
69	ParameterBlock list(key);	3,273✔
70	list.ChangeToArray();	3,273✔
71	for (py::handle element : obj)	114,190✔
72	{
73	std::string index_string = std::to_string(list.GetNumParameters());	53,822✔
74	list.AddParameter(pyobj_to_param_block(index_string, element.cast<py::object>()));	53,822✔
75	}	57,095✔
76	return list;	3,273✔
77	}	3,273✔
78
79	// check for each class in the OpenSn library
80	TO_PARAMBLOCK(AngularQuadrature);	2,079✔
81	TO_PARAMBLOCK(FieldFunction);	1,449✔
82	TO_PARAMBLOCK(FieldFunctionInterpolation);	1,449✔
83	TO_PARAMBLOCK(GraphPartitioner);	1,535✔
84	TO_PARAMBLOCK(DiscreteOrdinatesKEigenAcceleration);	1,375✔
85	TO_PARAMBLOCK(LogicalVolume);	1,365✔
86	TO_PARAMBLOCK(MeshContinuum);	1,597✔
87	TO_PARAMBLOCK(MeshGenerator);	1,146✔
88	TO_PARAMBLOCK(MultiGroupXS);	1,413✔
89	TO_PARAMBLOCK(PointSource);	620✔
90	TO_PARAMBLOCK(ResponseEvaluator);	586✔
91	TO_PARAMBLOCK(Problem);	870✔
92	TO_PARAMBLOCK(Solver);	302✔
93	TO_PARAMBLOCK(SurfaceMesh);	303✔
94	TO_PARAMBLOCK(VolumetricSource);	598✔
95	TO_PARAMBLOCK(VectorSpatialFunction);	8✔
96
97	// throw and return
UNCOV 98	throw std::invalid_argument("Unsupported argument type.");	×
99	}
100
101	// Translate a Python dictionary into a ParameterBlock
102	ParameterBlock
103	kwargs_to_param_block(const py::kwargs& params)	1,730✔
104	{
105	// initialize main parameter dict
106	ParameterBlock main;	1,730✔
107
108	// append corresponding parameters to the main
109	for (auto [key, value] : params)	13,270✔
110	{
111	// skip empty keys
112	if (key.cast<std::string>().empty())	4,905✔
113	{
UNCOV 114	continue;	×
115	}
116
117	// recursively add parameters
118	main.AddParameter(pyobj_to_param_block(key.cast<std::string>(), value.cast<py::object>()));	4,905✔
119	}
120
121	return main;	1,730✔
UNCOV 122	}	×
123
124	} // namespace opensn

Open-Sn / opensn / 16821314466

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