16766938693

Committed 05 Aug 2025 03:26PM UTC coverage: 73.386% (+0.1%) from 73.282%

Build # 16766938693

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #693 from andrsd/move-bnds

Moving sweep boundaries into `DiscreteOrdinatesProblem`

Coverage Stats

247 of 311 new or added lines in 19 files covered. (79.42%)

625 existing lines in 49 files now uncovered.

18320 of 24964 relevant lines covered (73.39%)

43106214.05 hits per line

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

40.91

/framework/physics/solver.cc

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

#include "framework/physics/solver.h"
#include "framework/physics/time_steppers/time_stepper.h"
#include "framework/runtime.h"
#include "framework/logging/log.h"
#include "framework/physics/time_steppers/constant_time_stepper.h"
#include "framework/object_factory.h"

namespace opensn
{

InputParameters
Solver::GetInputParameters()
{
  InputParameters params;

  params.AddRequiredParameter<std::string>(
    "name",
    "A text name to associate with the solver. This name will be used "
    "in status messages and verbose iterative convergence monitors.");

  params.AddOptionalParameter("dt", 0.01, "Desired initial timestep size.");
  params.AddOptionalParameter("time", 0.0, "Current time of the solver.");
  params.AddOptionalParameter("start_time", 0.0, "Transient start-time if applicable.");
  params.AddOptionalParameter("end_time", 1.0, "Transient end-time if applicable.");
  params.AddOptionalParameter(
    "max_time_steps", -1, "Maximum number of timesteps to allow. Negative values disables this.");

  params.AddOptionalParameter("timestepper",
                              std::shared_ptr<TimeStepper>{},
                              "Handle to a timestepper. If not supplied then a ConstantTimeStepper "
                              "will be created.");

  params.ConstrainParameterRange("dt", AllowableRangeLowLimit::New(1.0e-12));

  return params;
}

Solver::Solver(std::string name)
  : timestepper_(InitTimeStepper(GetInputParameters())), name_(std::move(name))
{
}

Solver::Solver(const InputParameters& params)
  : timestepper_(InitTimeStepper(params)), name_(params.GetParamValue<std::string>("name"))
{
}

std::shared_ptr<TimeStepper>
Solver::InitTimeStepper(const InputParameters& params)
{
  if (params.IsParameterValid("timestepper"))
  {
    auto stepper = params.GetSharedPtrParam<TimeStepper>("timestepper");

    stepper->SetTimeStepSize(params.GetParamValue<double>("dt"));
    stepper->SetTime(params.GetParamValue<double>("time"));
    stepper->SetStartTime(params.GetParamValue<double>("start_time"));
    stepper->SetEndTime(params.GetParamValue<double>("end_time"));
    stepper->SetMaxTimeSteps(params.GetParamValue<int>("max_time_steps"));

    return stepper;
  }
  else
  {
    auto& factory = ObjectFactory::GetInstance();

    const std::string obj_type = "physics::ConstantTimeStepper";
    auto valid_params = factory.GetRegisteredObjectParameters(obj_type);
    ParameterBlock custom_params;

    if (params.GetNumParameters() != 0)
    {
      custom_params.AddParameter(params.GetParam("dt"));
      custom_params.AddParameter(params.GetParam("time"));
      custom_params.AddParameter(params.GetParam("start_time"));
      custom_params.AddParameter(params.GetParam("end_time"));
      custom_params.AddParameter(params.GetParam("max_time_steps"));
    }

    valid_params.AssignParameters(custom_params);

    auto stepper = std::make_shared<ConstantTimeStepper>(valid_params);

    return stepper;
  }
}

std::string
Solver::GetName() const
{
  return name_;
}

TimeStepper&
Solver::GetTimeStepper()
{
  OpenSnLogicalErrorIf(not timestepper_, "Bad trouble: Timestepper not assigned.");
  return *timestepper_;
}

const TimeStepper&
Solver::GetTimeStepper() const
{
  OpenSnLogicalErrorIf(not timestepper_, "Bad trouble: Timestepper not assigned.");
  return *timestepper_;
}

void
Solver::Initialize()
{
  log.Log() << "\"Initialize()\" method not defined for " << GetName();
}

void
Solver::Execute()
{
  log.Log() << "\"Execute()\" method not defined for " << GetName();
}

void
Solver::Step()
{
  log.Log() << "\"Step()\" method not defined for " << GetName();
}

void
Solver::Advance()
{
  log.Log() << "\"Advance()\" method not defined for " << GetName();
}

ParameterBlock
Solver::GetInfo(const ParameterBlock& params) const
{
  return ParameterBlock{};
}

ParameterBlock
Solver::GetInfoWithPreCheck(const ParameterBlock& params) const
{
  if (not params.Has("name"))
  {
    log.LogAllWarning() << "Solver::GetInfo called without "
                           "\"name\" in the parameter list";
    return ParameterBlock{};
  }
  return GetInfo(params);
}

void
Solver::SetProperties(const ParameterBlock& params)
{
  for (const auto& param : params)
  {
    const std::string param_name = param.GetName();

    if (param_name == "dt")
      timestepper_->SetTimeStepSize(param.GetValue<double>());
    if (param_name == "time")
      timestepper_->SetTime(param.GetValue<double>());
    if (param_name == "start_time")
      timestepper_->SetStartTime(param.GetValue<double>());
    if (param_name == "end_time")
      timestepper_->SetEndTime(param.GetValue<double>());
    if (param_name == "max_time_steps")
      timestepper_->SetMaxTimeSteps(param.GetValue<int>());
    if (param_name == "dt_min")
      timestepper_->SetMinimumTimeStepSize(param.GetValue<int>());
  }
}

} // namespace opensn

1	// SPDX-FileCopyrightText: 2024 The OpenSn Authors <https://open-sn.github.io/opensn/>
2	// SPDX-License-Identifier: MIT
3
4	#include "framework/physics/solver.h"
5	#include "framework/physics/time_steppers/time_stepper.h"
6	#include "framework/runtime.h"
7	#include "framework/logging/log.h"
8	#include "framework/physics/time_steppers/constant_time_stepper.h"
9	#include "framework/object_factory.h"
10
11	namespace opensn
12	{
13
14	InputParameters
15	Solver::GetInputParameters()	260✔
16	{
17	InputParameters params;	260✔
18
19	params.AddRequiredParameter<std::string>(	520✔
20	"name",
21	"A text name to associate with the solver. This name will be used "
22	"in status messages and verbose iterative convergence monitors.");
23
24	params.AddOptionalParameter("dt", 0.01, "Desired initial timestep size.");	520✔
25	params.AddOptionalParameter("time", 0.0, "Current time of the solver.");	520✔
26	params.AddOptionalParameter("start_time", 0.0, "Transient start-time if applicable.");	520✔
27	params.AddOptionalParameter("end_time", 1.0, "Transient end-time if applicable.");	520✔
28	params.AddOptionalParameter(	520✔
29	"max_time_steps", -1, "Maximum number of timesteps to allow. Negative values disables this.");
30
31	params.AddOptionalParameter("timestepper",	520✔
32	std::shared_ptr<TimeStepper>{},	520✔
33	"Handle to a timestepper. If not supplied then a ConstantTimeStepper "
34	"will be created.");
35
36	params.ConstrainParameterRange("dt", AllowableRangeLowLimit::New(1.0e-12));	780✔
37
38	return params;	260✔
39	}	×
40
41	Solver::Solver(std::string name)	×
42	: timestepper_(InitTimeStepper(GetInputParameters())), name_(std::move(name))	×
43	{
44	}	×
45
46	Solver::Solver(const InputParameters& params)	260✔
47	: timestepper_(InitTimeStepper(params)), name_(params.GetParamValue<std::string>("name"))	260✔
48	{
49	}	260✔
50
51	std::shared_ptr<TimeStepper>
52	Solver::InitTimeStepper(const InputParameters& params)	260✔
53	{
54	if (params.IsParameterValid("timestepper"))	260✔
55	{
UNCOV 56	auto stepper = params.GetSharedPtrParam<TimeStepper>("timestepper");	×
57
58	stepper->SetTimeStepSize(params.GetParamValue<double>("dt"));	×
UNCOV 59	stepper->SetTime(params.GetParamValue<double>("time"));	×
60	stepper->SetStartTime(params.GetParamValue<double>("start_time"));	×
61	stepper->SetEndTime(params.GetParamValue<double>("end_time"));	×
62	stepper->SetMaxTimeSteps(params.GetParamValue<int>("max_time_steps"));	×
63
64	return stepper;	×
UNCOV 65	}	×
66	else
67	{
68	auto& factory = ObjectFactory::GetInstance();	260✔
69
70	const std::string obj_type = "physics::ConstantTimeStepper";	260✔
71	auto valid_params = factory.GetRegisteredObjectParameters(obj_type);	260✔
72	ParameterBlock custom_params;	260✔
73
74	if (params.GetNumParameters() != 0)	260✔
75	{
76	custom_params.AddParameter(params.GetParam("dt"));	260✔
77	custom_params.AddParameter(params.GetParam("time"));	260✔
78	custom_params.AddParameter(params.GetParam("start_time"));	260✔
79	custom_params.AddParameter(params.GetParam("end_time"));	260✔
80	custom_params.AddParameter(params.GetParam("max_time_steps"));	260✔
81	}
82
83	valid_params.AssignParameters(custom_params);	260✔
84
85	auto stepper = std::make_shared<ConstantTimeStepper>(valid_params);	260✔
86
87	return stepper;	260✔
88	}	260✔
89	}
90
91	std::string
92	Solver::GetName() const	1,068✔
93	{
94	return name_;	1,068✔
95	}
96
97	TimeStepper&
98	Solver::GetTimeStepper()	260✔
99	{
100	OpenSnLogicalErrorIf(not timestepper_, "Bad trouble: Timestepper not assigned.");	260✔
101	return *timestepper_;	260✔
102	}
103
104	const TimeStepper&
UNCOV 105	Solver::GetTimeStepper() const	×
106	{
UNCOV 107	OpenSnLogicalErrorIf(not timestepper_, "Bad trouble: Timestepper not assigned.");	×
UNCOV 108	return *timestepper_;	×
109	}
110
111	void
112	Solver::Initialize()	×
113	{
UNCOV 114	log.Log() << "\"Initialize()\" method not defined for " << GetName();	×
UNCOV 115	}	×
116
117	void
118	Solver::Execute()	×
119	{
UNCOV 120	log.Log() << "\"Execute()\" method not defined for " << GetName();	×
UNCOV 121	}	×
122
123	void
124	Solver::Step()	×
125	{
UNCOV 126	log.Log() << "\"Step()\" method not defined for " << GetName();	×
UNCOV 127	}	×
128
129	void
130	Solver::Advance()	×
131	{
UNCOV 132	log.Log() << "\"Advance()\" method not defined for " << GetName();	×
UNCOV 133	}	×
134
135	ParameterBlock
136	Solver::GetInfo(const ParameterBlock& params) const	×
137	{
UNCOV 138	return ParameterBlock{};	×
139	}
140
141	ParameterBlock
142	Solver::GetInfoWithPreCheck(const ParameterBlock& params) const	×
143	{
UNCOV 144	if (not params.Has("name"))	×
145	{
146	log.LogAllWarning() << "Solver::GetInfo called without "	×
UNCOV 147	"\"name\" in the parameter list";	×
148	return ParameterBlock{};	×
149	}
150	return GetInfo(params);	×
151	}
152
153	void
154	Solver::SetProperties(const ParameterBlock& params)	×
155	{
UNCOV 156	for (const auto& param : params)	×
157	{
158	const std::string param_name = param.GetName();	×
159
160	if (param_name == "dt")	×
UNCOV 161	timestepper_->SetTimeStepSize(param.GetValue<double>());	×
162	if (param_name == "time")	×
UNCOV 163	timestepper_->SetTime(param.GetValue<double>());	×
164	if (param_name == "start_time")	×
165	timestepper_->SetStartTime(param.GetValue<double>());	×
166	if (param_name == "end_time")	×
167	timestepper_->SetEndTime(param.GetValue<double>());	×
168	if (param_name == "max_time_steps")	×
169	timestepper_->SetMaxTimeSteps(param.GetValue<int>());	×
170	if (param_name == "dt_min")	×
171	timestepper_->SetMinimumTimeStepSize(param.GetValue<int>());	×
172	}	×
173	}	×
174
175	} // namespace opensn

Open-Sn / opensn / 16766938693

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