27922676724

Committed 21 Jun 2026 09:16PM UTC coverage: 78.584% (+1.1%) from 77.467%

Build # 27922676724

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1108 from wdhawkins/disable_hip_tests

Temporarily disable HIP tests

Coverage Stats

26280 of 33442 relevant lines covered (78.58%)

86617107.22 hits per line

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

85.86

/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 "cxxopts/cxxopts.h"
#include <string>

using namespace opensn;
namespace py = pybind11;

namespace opensnpy
{

PyApp::PyApp(const mpi::Communicator& comm)
{
  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.BindAllReduce(comm);

  Console::BindModule(WrapYlm);
  Console::BindModule(WrapVector3);
  Console::BindModule(WrapFunctors);

  Console::BindModule(WrapQuadraturePointPhiTheta);
  Console::BindModule(WrapQuadrature);
  Console::BindModule(WrapProductQuadrature);
  Console::BindModule(WrapTriangularQuadrature);
  Console::BindModule(WrapCurvilinearProductQuadrature);
  Console::BindModule(WrapSLDFEsqQuadrature);
  Console::BindModule(WrapLebedevQuadrature);

  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(WrapUncollidedSolver);
  Console::BindModule(WrapSteadyState);
  Console::BindModule(WrapTransient);
  Console::BindModule(WrapNLKEigen);
  Console::BindModule(WrapPIteration);
  Console::BindModule(WrapDiscreteOrdinatesKEigenAcceleration);
  Console::BindModule(WrapPostprocessors);
}

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))
  {
    opensn::Initialize();
    console.InitConsole();
    console.ExecuteFile(opensn::input_path.string());
    opensn::Finalize();

    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;

  if (opensn::use_caliper and opensn::mpi_comm.rank() == 0)
    std::cout << std::endl;

  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<unsigned 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>())
    ("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"))
    {
      auto verbosity = result["verbose"].as<unsigned int>();
      opensn::log.SetVerbosity(verbosity);
    }

    if (result.count("suppress-color"))
      opensn::log.SetColorEnabled(false);

    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 "cxxopts/cxxopts.h"
12	#include <string>
13
14	using namespace opensn;
15	namespace py = pybind11;
16
17	namespace opensnpy
18	{
19
20	PyApp::PyApp(const mpi::Communicator& comm)	939✔
21	{
22	opensn::mpi_comm = comm;	939✔
23
24	py::module sys = py::module::import("sys");	939✔
25	py::exec("rank = " + std::to_string(comm.rank()));	2,817✔
26	py::exec("size = " + std::to_string(comm.size()));	2,817✔
27	py::exec("opensn_console = True");	1,878✔
28
29	console.BindBarrier(comm);	939✔
30	console.BindAllReduce(comm);	939✔
31
32	Console::BindModule(WrapYlm);	939✔
33	Console::BindModule(WrapVector3);	939✔
34	Console::BindModule(WrapFunctors);	939✔
35
36	Console::BindModule(WrapQuadraturePointPhiTheta);	939✔
37	Console::BindModule(WrapQuadrature);	939✔
38	Console::BindModule(WrapProductQuadrature);	939✔
39	Console::BindModule(WrapTriangularQuadrature);	939✔
40	Console::BindModule(WrapCurvilinearProductQuadrature);	939✔
41	Console::BindModule(WrapSLDFEsqQuadrature);	939✔
42	Console::BindModule(WrapLebedevQuadrature);	939✔
43
44	Console::BindModule(WrapMesh);	939✔
45	Console::BindModule(WrapMeshGenerator);	939✔
46	Console::BindModule(WrapGraphPartitioner);	939✔
47
48	Console::BindModule(WrapLogicalVolume);	939✔
49
50	Console::BindModule(WrapPointSource);	939✔
51	Console::BindModule(WrapVolumetricSource);	939✔
52
53	Console::BindModule(WrapMultiGroupXS);	939✔
54
55	Console::BindModule(WrapFieldFunction);	939✔
56	Console::BindModule(WrapFieldFunctionGridBased);	939✔
57	Console::BindModule(WrapFieldFunctionInterpolation);	939✔
58
59	Console::BindModule(WrapResEval);	939✔
60
61	Console::BindModule(WrapProblem);	939✔
62	Console::BindModule(WrapSolver);	939✔
63	Console::BindModule(WrapLBS);	939✔
64	Console::BindModule(WrapUncollidedSolver);	939✔
65	Console::BindModule(WrapSteadyState);	939✔
66	Console::BindModule(WrapTransient);	939✔
67	Console::BindModule(WrapNLKEigen);	939✔
68	Console::BindModule(WrapPIteration);	939✔
69	Console::BindModule(WrapDiscreteOrdinatesKEigenAcceleration);	939✔
70	Console::BindModule(WrapPostprocessors);	1,878✔
71	}	939✔
72
73	int
74	PyApp::Run(int argc, char** argv)	939✔
75	{
76	if (opensn::mpi_comm.rank() == 0)	939✔
77	{
78	std::cout << opensn::program << " version " << GetVersionStr() << "\n"	837✔
79	<< Timer::GetLocalDateTimeString() << " Running " << opensn::program << " with "	1,116✔
80	<< opensn::mpi_comm.size() << " processes.\n"
81	<< opensn::program << " number of arguments supplied: " << argc - 1 << "\n"	279✔
82	<< std::endl;	279✔
83	}
84
85	if (ProcessArguments(argc, argv))	939✔
86	{
87	opensn::Initialize();	939✔
88	console.InitConsole();	939✔
89	console.ExecuteFile(opensn::input_path.string());	939✔
90	opensn::Finalize();	937✔
91
92	if (opensn::mpi_comm.rank() == 0)	937✔
93	{
94	std::cout << "\nElapsed execution time: " << program_timer.GetTimeString() << "\n"	554✔
95	<< Timer::GetLocalDateTimeString() << " " << opensn::program	554✔
96	<< " finished execution." << std::endl;	831✔
97	}
98	}
99	else
100	return EXIT_FAILURE;
101
102	if (opensn::use_caliper and opensn::mpi_comm.rank() == 0)	937✔
103	std::cout << std::endl;	×
104
105	cali_mgr.flush();	937✔
106	return EXIT_SUCCESS;	937✔
107	}
108
109	bool
110	PyApp::ProcessArguments(int argc, char** argv)	939✔
111	{
112	cxxopts::Options options(LowerCase(opensn::program), "");	1,878✔
113
114	try	939✔
115	{
116	/* clang-format off */
117	options.add_options("User")	1,878✔
118	("h,help", "Help message")	2,817✔
119	("c,suppress-color", "Suppress color output")	2,817✔
120	("v,verbose", "Verbosity level (0 to 3). Default is 0.", cxxopts::value<unsigned int>())	2,817✔
121	("caliper", "Enable Caliper reporting",	2,817✔
122	cxxopts::value<std::string>()->implicit_value("runtime-report(calc.inclusive=true),max_column_width=80"))	2,817✔
123	("i,input", "Input file", cxxopts::value<std::string>())	2,817✔
124	("p,py", "Python expression", cxxopts::value<std::vector<std::string>>());	2,817✔
125	/* clang-format on */
126
127	auto result = options.parse(argc, argv);	939✔
128
129	if (result.count("help"))	939✔
130	{
131	if (opensn::mpi_comm.rank() == 0)	×
132	std::cout << options.help({"User"}) << std::endl;	×
133	return false;	×
134	}
135
136	if (result.count("verbose"))	939✔
137	{
138	auto verbosity = result["verbose"].as<unsigned int>();	4✔
139	opensn::log.SetVerbosity(verbosity);	4✔
140	}
141
142	if (result.count("suppress-color"))	939✔
143	opensn::log.SetColorEnabled(false);	939✔
144
145	if (result.count("caliper"))	939✔
146	{
147	opensn::use_caliper = true;	×
148	opensn::cali_config = result["caliper"].as<std::string>();	×
149	}
150
151	if (result.count("py"))	939✔
152	{
153	for (const auto& pyarg : result["py"].as<std::vector<std::string>>())	1,928✔
154	console.GetCommandBuffer().push_back(pyarg);	989✔
155	}
156
157	opensn::input_path = result["input"].as<std::string>();	939✔
158	if (not std::filesystem::exists(input_path) or not std::filesystem::is_regular_file(input_path))	1,878✔
159	{
160	if (opensn::mpi_comm.rank() == 0)	×
161	std::cerr << "Invalid input file: " << input_path.string() << "\n" << std::endl;	×
162	return false;	×
163	}
164	}	939✔
165	catch (const std::exception& e)	×
166	{
167	if (opensn::mpi_comm.rank() == 0)	×
168	std::cerr << e.what() << "\n" << options.help({"User"}) << std::endl;	×
169	return false;	×
170	}	×
171
172	return true;	939✔
173	}	939✔
174
175	} // namespace opensnpy

Open-Sn / opensn / 27922676724

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