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

86.27

/python/lib/py_app.cc

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

#include "python/lib/py_app.h"
#include "python/lib/console.h"
#include "python/lib/py_wrappers.h"
#include "framework/logging/log.h"
#include "framework/utils/utils.h"
#include "framework/utils/timer.h"
#include "framework/runtime.h"
#include "caliper/cali.h"
#include "cxxopts/cxxopts.h"
#include "petsc.h"
#include <string>

using namespace opensn;
namespace py = pybind11;

namespace opensnpy
{

PyApp::PyApp(const mpi::Communicator& comm) : allow_petsc_error_handler_(false)
{
  opensn::mpi_comm = comm;

  py::module sys = py::module::import("sys");
  py::exec("rank = " + std::to_string(comm.rank()));
  py::exec("size = " + std::to_string(comm.size()));
  py::exec("opensn_console = True");

  console.BindBarrier(comm);

  console.BindModule(WrapYlm);
  console.BindModule(WrapVector3);
  console.BindModule(WrapFunctors);

  console.BindModule(WrapQuadraturePointPhiTheta);
  console.BindModule(WrapQuadrature);
  console.BindModule(WrapProductQuadrature);
  console.BindModule(WrapCurvilinearQuadrature);
  console.BindModule(WrapSLDFESQuadrature);

  console.BindModule(WrapMesh);
  console.BindModule(WrapMeshGenerator);
  console.BindModule(WrapGraphPartitioner);

  console.BindModule(WrapLogicalVolume);

  console.BindModule(WrapPointSource);
  console.BindModule(WrapVolumetricSource);

  console.BindModule(WrapMultiGroupXS);

  console.BindModule(WrapFieldFunction);
  console.BindModule(WrapFieldFunctionGridBased);
  console.BindModule(WrapFieldFunctionInterpolation);

  console.BindModule(WrapResEval);

  console.BindModule(WrapProblem);
  console.BindModule(WrapSolver);
  console.BindModule(WrapLBS);
  console.BindModule(WrapSteadyState);
  console.BindModule(WrapNLKEigen);
  console.BindModule(WrapPIteration);
  console.BindModule(WrapDiscreteOrdinatesKEigenAcceleration);
}

int
PyApp::InitPETSc(int argc, char** argv)
{
  PetscOptionsInsertString(nullptr, "-error_output_stderr");
  if (!allow_petsc_error_handler_)
    PetscOptionsInsertString(nullptr, "-no_signal_handler");
  PetscCall(PetscInitialize(&argc, &argv, nullptr, nullptr));
  return 0;
}

int
PyApp::Run(int argc, char** argv)
{
  if (opensn::mpi_comm.rank() == 0)
  {
    std::cout << opensn::program << " version " << GetVersionStr() << "\n"
              << Timer::GetLocalDateTimeString() << " Running " << opensn::program << " with "
              << opensn::mpi_comm.size() << " processes.\n"
              << opensn::program << " number of arguments supplied: " << argc - 1 << "\n"
              << std::endl;
  }

  if (ProcessArguments(argc, argv))
  {
    PetscOptionsSetValue(NULL, "-options_left", "0");
    InitPETSc(argc, argv);

    opensn::Initialize();
    console.InitConsole();
    console.ExecuteFile(opensn::input_path.string());
    opensn::Finalize();

    PetscFinalize();

    if (opensn::mpi_comm.rank() == 0)
    {
      std::cout << "\nElapsed execution time: " << program_timer.GetTimeString() << "\n"
                << Timer::GetLocalDateTimeString() << " " << opensn::program
                << " finished execution." << std::endl;
    }
  }
  else
    return EXIT_FAILURE;

  cali_mgr.flush();
  return EXIT_SUCCESS;
}

bool
PyApp::ProcessArguments(int argc, char** argv)
{
  cxxopts::Options options(LowerCase(opensn::program), "");

  try
  {
    /* clang-format off */
    options.add_options("User")
    ("h,help",                      "Help message")
    ("c,suppress-color",            "Suppress color output")
    ("v,verbose",                   "Verbosity level (0 to 3). Default is 0.", cxxopts::value<int>())
    ("caliper",                     "Enable Caliper reporting",
      cxxopts::value<std::string>()->implicit_value("runtime-report(calc.inclusive=true),max_column_width=80"))
    ("i,input",                     "Input file", cxxopts::value<std::string>())
    ("allow-petsc-error-handler",   "Allow PETSc error handler")
    ("p,py",                        "Python expression", cxxopts::value<std::vector<std::string>>());
    /* clang-format on */

    auto result = options.parse(argc, argv);

    if (result.count("help"))
    {
      if (opensn::mpi_comm.rank() == 0)
        std::cout << options.help({"User"}) << std::endl;
      return false;
    }

    if (result.count("verbose"))
    {
      int verbosity = result["verbose"].as<int>();
      opensn::log.SetVerbosity(verbosity);
    }

    if (result.count("allow-petsc-error-handler"))
      allow_petsc_error_handler_ = true;

    if (result.count("suppress-color"))
      opensn::suppress_color = true;

    if (result.count("caliper"))
    {
      opensn::use_caliper = true;
      opensn::cali_config = result["caliper"].as<std::string>();
    }

    if (result.count("py"))
    {
      for (const auto& pyarg : result["py"].as<std::vector<std::string>>())
        console.GetCommandBuffer().push_back(pyarg);
    }

    opensn::input_path = result["input"].as<std::string>();
    if (not std::filesystem::exists(input_path) or not std::filesystem::is_regular_file(input_path))
    {
      if (opensn::mpi_comm.rank() == 0)
        std::cerr << "Invalid input file: " << input_path.string() << "\n" << std::endl;
      return false;
    }
  }
  catch (const std::exception& e)
  {
    if (opensn::mpi_comm.rank() == 0)
      std::cerr << e.what() << "\n" << options.help({"User"}) << std::endl;
    return false;
  }

  return true;
}

} // namespace opensnpy

1	// SPDX-FileCopyrightText: 2025 The OpenSn Authors <https://open-sn.github.io/opensn/>
2	// SPDX-License-Identifier: MIT
3
4	#include "python/lib/py_app.h"
5	#include "python/lib/console.h"
6	#include "python/lib/py_wrappers.h"
7	#include "framework/logging/log.h"
8	#include "framework/utils/utils.h"
9	#include "framework/utils/timer.h"
10	#include "framework/runtime.h"
11	#include "caliper/cali.h"
12	#include "cxxopts/cxxopts.h"
13	#include "petsc.h"
14	#include <string>
15
16	using namespace opensn;
17	namespace py = pybind11;
18
19	namespace opensnpy
20	{
21
22	PyApp::PyApp(const mpi::Communicator& comm) : allow_petsc_error_handler_(false)	346✔
23	{
24	opensn::mpi_comm = comm;	346✔
25
26	py::module sys = py::module::import("sys");	346✔
27	py::exec("rank = " + std::to_string(comm.rank()));	1,038✔
28	py::exec("size = " + std::to_string(comm.size()));	1,038✔
29	py::exec("opensn_console = True");	692✔
30
31	console.BindBarrier(comm);	346✔
32
33	console.BindModule(WrapYlm);	346✔
34	console.BindModule(WrapVector3);	346✔
35	console.BindModule(WrapFunctors);	346✔
36
37	console.BindModule(WrapQuadraturePointPhiTheta);	346✔
38	console.BindModule(WrapQuadrature);	346✔
39	console.BindModule(WrapProductQuadrature);	346✔
40	console.BindModule(WrapCurvilinearQuadrature);	346✔
41	console.BindModule(WrapSLDFESQuadrature);	346✔
42
43	console.BindModule(WrapMesh);	346✔
44	console.BindModule(WrapMeshGenerator);	346✔
45	console.BindModule(WrapGraphPartitioner);	346✔
46
47	console.BindModule(WrapLogicalVolume);	346✔
48
49	console.BindModule(WrapPointSource);	346✔
50	console.BindModule(WrapVolumetricSource);	346✔
51
52	console.BindModule(WrapMultiGroupXS);	346✔
53
54	console.BindModule(WrapFieldFunction);	346✔
55	console.BindModule(WrapFieldFunctionGridBased);	346✔
56	console.BindModule(WrapFieldFunctionInterpolation);	346✔
57
58	console.BindModule(WrapResEval);	346✔
59
60	console.BindModule(WrapProblem);	346✔
61	console.BindModule(WrapSolver);	346✔
62	console.BindModule(WrapLBS);	346✔
63	console.BindModule(WrapSteadyState);	346✔
64	console.BindModule(WrapNLKEigen);	346✔
65	console.BindModule(WrapPIteration);	346✔
66	console.BindModule(WrapDiscreteOrdinatesKEigenAcceleration);	692✔
67	}	346✔
68
69	int
70	PyApp::InitPETSc(int argc, char** argv)	346✔
71	{
72	PetscOptionsInsertString(nullptr, "-error_output_stderr");	346✔
73	if (!allow_petsc_error_handler_)	346✔
74	PetscOptionsInsertString(nullptr, "-no_signal_handler");	346✔
75	PetscCall(PetscInitialize(&argc, &argv, nullptr, nullptr));	346✔
76	return 0;
77	}
78
79	int
80	PyApp::Run(int argc, char** argv)	346✔
81	{
82	if (opensn::mpi_comm.rank() == 0)	346✔
83	{
84	std::cout << opensn::program << " version " << GetVersionStr() << "\n"	327✔
85	<< Timer::GetLocalDateTimeString() << " Running " << opensn::program << " with "	436✔
86	<< opensn::mpi_comm.size() << " processes.\n"
87	<< opensn::program << " number of arguments supplied: " << argc - 1 << "\n"	109✔
88	<< std::endl;	109✔
89	}
90
91	if (ProcessArguments(argc, argv))	346✔
92	{
93	PetscOptionsSetValue(NULL, "-options_left", "0");	346✔
94	InitPETSc(argc, argv);	346✔
95
96	opensn::Initialize();	346✔
97	console.InitConsole();	346✔
98	console.ExecuteFile(opensn::input_path.string());	346✔
99	opensn::Finalize();	346✔
100
101	PetscFinalize();	346✔
102
103	if (opensn::mpi_comm.rank() == 0)	346✔
104	{
105	std::cout << "\nElapsed execution time: " << program_timer.GetTimeString() << "\n"	218✔
106	<< Timer::GetLocalDateTimeString() << " " << opensn::program	218✔
107	<< " finished execution." << std::endl;	327✔
108	}
109	}
110	else
111	return EXIT_FAILURE;
112
113	cali_mgr.flush();	346✔
114	return EXIT_SUCCESS;	346✔
115	}
116
117	bool
118	PyApp::ProcessArguments(int argc, char** argv)	346✔
119	{
120	cxxopts::Options options(LowerCase(opensn::program), "");	692✔
121
122	try	346✔
123	{
124	/* clang-format off */
125	options.add_options("User")	692✔
126	("h,help", "Help message")	1,038✔
127	("c,suppress-color", "Suppress color output")	1,038✔
128	("v,verbose", "Verbosity level (0 to 3). Default is 0.", cxxopts::value<int>())	1,038✔
129	("caliper", "Enable Caliper reporting",	1,038✔
130	cxxopts::value<std::string>()->implicit_value("runtime-report(calc.inclusive=true),max_column_width=80"))	1,038✔
131	("i,input", "Input file", cxxopts::value<std::string>())	1,038✔
132	("allow-petsc-error-handler", "Allow PETSc error handler")	1,038✔
133	("p,py", "Python expression", cxxopts::value<std::vector<std::string>>());	1,038✔
134	/* clang-format on */
135
136	auto result = options.parse(argc, argv);	346✔
137
138	if (result.count("help"))	346✔
139	{
UNCOV 140	if (opensn::mpi_comm.rank() == 0)	×
UNCOV 141	std::cout << options.help({"User"}) << std::endl;	×
UNCOV 142	return false;	×
143	}
144
145	if (result.count("verbose"))	346✔
146	{
147	int verbosity = result["verbose"].as<int>();	4✔
148	opensn::log.SetVerbosity(verbosity);	4✔
149	}
150
151	if (result.count("allow-petsc-error-handler"))	346✔
UNCOV 152	allow_petsc_error_handler_ = true;	×
153
154	if (result.count("suppress-color"))	346✔
155	opensn::suppress_color = true;	346✔
156
157	if (result.count("caliper"))	346✔
158	{
UNCOV 159	opensn::use_caliper = true;	×
UNCOV 160	opensn::cali_config = result["caliper"].as<std::string>();	×
161	}
162
163	if (result.count("py"))	346✔
164	{
165	for (const auto& pyarg : result["py"].as<std::vector<std::string>>())	692✔
166	console.GetCommandBuffer().push_back(pyarg);	346✔
167	}
168
169	opensn::input_path = result["input"].as<std::string>();	346✔
170	if (not std::filesystem::exists(input_path) or not std::filesystem::is_regular_file(input_path))	692✔
171	{
UNCOV 172	if (opensn::mpi_comm.rank() == 0)	×
UNCOV 173	std::cerr << "Invalid input file: " << input_path.string() << "\n" << std::endl;	×
UNCOV 174	return false;	×
175	}
176	}	346✔
177	catch (const std::exception& e)	×
178	{
UNCOV 179	if (opensn::mpi_comm.rank() == 0)	×
180	std::cerr << e.what() << "\n" << options.help({"User"}) << std::endl;	×
UNCOV 181	return false;	×
182	}	×
183
184	return true;	346✔
185	}	346✔
186
187	} // namespace opensnpy

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