4257919060

Build # 4257919060

Build Type

github

Committed by GitHub

Commit Message

Merge ad0e9e5ee into e3a486be0

Pull Request Pull Request #4754: Support grid point distributions in Interval domain creator, refactor tests

Run Details

31 of 31 new or added lines in 5 files covered. (100.0%)

63947 of 66666 relevant lines covered (95.92%)

436327.36 hits per line

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

93.75

/src/Domain/Creators/Interval.cpp

// Distributed under the MIT License.
// See LICENSE.txt for details.

#include "Domain/Creators/Interval.hpp"

#include <array>
#include <memory>
#include <utility>
#include <vector>

#include "Domain/Block.hpp"
#include "Domain/BoundaryConditions/None.hpp"
#include "Domain/BoundaryConditions/Periodic.hpp"
#include "Domain/CoordinateMaps/CoordinateMap.hpp"
#include "Domain/CoordinateMaps/CoordinateMap.tpp"
#include "Domain/CoordinateMaps/Interval.hpp"
#include "Domain/Creators/DomainCreator.hpp"
#include "Domain/Creators/TimeDependence/None.hpp"
#include "Domain/Creators/TimeDependence/TimeDependence.hpp"
#include "Domain/Domain.hpp"
#include "Domain/DomainHelpers.hpp"
#include "Domain/Structure/BlockNeighbor.hpp"
#include "Domain/Structure/Direction.hpp"
#include "Domain/Structure/DirectionMap.hpp"

namespace Frame {
struct Inertial;
struct BlockLogical;
}  // namespace Frame

namespace domain::creators {
Interval::Interval(
    std::array<double, 1> lower_x, std::array<double, 1> upper_x,
    std::array<size_t, 1> initial_refinement_level_x,
    std::array<size_t, 1> initial_number_of_grid_points_in_x,
    std::array<bool, 1> is_periodic_in_x,
    domain::CoordinateMaps::Distribution distribution,
    std::optional<double> singularity,
    std::unique_ptr<domain::creators::time_dependence::TimeDependence<1>>
        time_dependence,
    const Options::Context& context)
    : lower_x_(lower_x),
      upper_x_(upper_x),
      distribution_(distribution),
      singularity_(singularity),
      is_periodic_in_x_(is_periodic_in_x),
      initial_refinement_level_x_(initial_refinement_level_x),
      initial_number_of_grid_points_in_x_(initial_number_of_grid_points_in_x),
      lower_boundary_condition_(nullptr),
      upper_boundary_condition_(nullptr),
      time_dependence_(std::move(time_dependence)) {
  if (time_dependence_ == nullptr) {
    time_dependence_ =
        std::make_unique<domain::creators::time_dependence::None<1>>();
  }
  if (lower_x_[0] >= upper_x_[0]) {
    PARSE_ERROR(context, "Lower bound ("
                             << lower_x_[0]
                             << ") must be strictly smaller than upper bound ("
                             << upper_x_[0] << ").");
  }
  if ((distribution_ == CoordinateMaps::Distribution::Logarithmic or
       distribution_ == CoordinateMaps::Distribution::Inverse) !=
      singularity_.has_value()) {
    PARSE_ERROR(context,
                "Specify a 'Singularity' for 'Logarithmic' or 'Inverse' grid "
                "point distributions, or 'None' otherwise.");
  }
  if (singularity_.has_value() and *singularity_ >= lower_x_[0] and
      *singularity_ <= upper_x_[0]) {
    PARSE_ERROR(context, "The 'Singularity' ("
                             << *singularity_ << ") falls inside the domain ["
                             << lower_x_[0] << ", " << upper_x_[0] << "].");
  }
}

Interval::Interval(
    std::array<double, 1> lower_x, std::array<double, 1> upper_x,
    std::array<size_t, 1> initial_refinement_level_x,
    std::array<size_t, 1> initial_number_of_grid_points_in_x,
    std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
        lower_boundary_condition,
    std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
        upper_boundary_condition,
    domain::CoordinateMaps::Distribution distribution,
    std::optional<double> singularity,
    std::unique_ptr<domain::creators::time_dependence::TimeDependence<1>>
        time_dependence,
    const Options::Context& context)
    : Interval(lower_x, upper_x, initial_refinement_level_x,
               initial_number_of_grid_points_in_x, {{false}}, distribution,
               singularity, std::move(time_dependence), context) {
  lower_boundary_condition_ = std::move(lower_boundary_condition);
  upper_boundary_condition_ = std::move(upper_boundary_condition);
  if ((lower_boundary_condition_ == nullptr) !=
      (upper_boundary_condition_ == nullptr)) {
    PARSE_ERROR(context,
                "Both upper and lower boundary conditions must be specified, "
                "or neither.");
  }
  using domain::BoundaryConditions::is_none;
  if (is_none(lower_boundary_condition_) or
      is_none(upper_boundary_condition_)) {
    PARSE_ERROR(
        context,
        "None boundary condition is not supported. If you would like an "
        "outflow-type boundary condition, you must use that.");
  }
  using domain::BoundaryConditions::is_periodic;
  if (is_periodic(lower_boundary_condition_) !=
      is_periodic(upper_boundary_condition_)) {
    PARSE_ERROR(
        context,
        "Both the upper and lower boundary condition must be set to periodic "
        "if imposing periodic boundary conditions.");
  }
  if (is_periodic(lower_boundary_condition_)) {
    is_periodic_in_x_[0] = true;
  }
}

Domain<1> Interval::create_domain() const {
  Domain<1> domain{
      make_vector_coordinate_map_base<Frame::BlockLogical, Frame::Inertial>(
          CoordinateMaps::Interval{-1., 1., lower_x_[0], upper_x_[0],
                                   distribution_, singularity_}),
      std::vector<std::array<size_t, 2>>{{{1, 2}}},
      is_periodic_in_x_[0] ? std::vector<PairOfFaces>{{{1}, {2}}}
                           : std::vector<PairOfFaces>{},
      {},
      block_names_};
  if (not time_dependence_->is_none()) {
    domain.inject_time_dependent_map_for_block(
        0, std::move(time_dependence_->block_maps_grid_to_inertial(1)[0]),
        std::move(time_dependence_->block_maps_grid_to_distorted(1)[0]),
        std::move(time_dependence_->block_maps_distorted_to_inertial(1)[0]));
  }
  return domain;
}

std::vector<DirectionMap<
    1, std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
Interval::external_boundary_conditions() const {
  if (upper_boundary_condition_ == nullptr) {
    return {};
  }
  std::vector<DirectionMap<
      1, std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
      boundary_conditions{1};
  if (is_periodic_in_x_[0]) {
    return boundary_conditions;
  }
  boundary_conditions[0][Direction<1>::lower_xi()] =
      lower_boundary_condition_->get_clone();
  boundary_conditions[0][Direction<1>::upper_xi()] =
      upper_boundary_condition_->get_clone();
  return boundary_conditions;
}

std::vector<std::array<size_t, 1>> Interval::initial_extents() const {
  return {{{initial_number_of_grid_points_in_x_}}};
}

std::vector<std::array<size_t, 1>> Interval::initial_refinement_levels() const {
  return {{{initial_refinement_level_x_}}};
}

std::unordered_map<std::string,
                   std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>
Interval::functions_of_time(const std::unordered_map<std::string, double>&
                                initial_expiration_times) const {
  if (time_dependence_->is_none()) {
    return {};
  } else {
    return time_dependence_->functions_of_time(initial_expiration_times);
  }
}
}  // namespace domain::creators

1	// Distributed under the MIT License.
2	// See LICENSE.txt for details.
3
4	#include "Domain/Creators/Interval.hpp"
5
6	#include <array>
7	#include <memory>
8	#include <utility>
9	#include <vector>
10
11	#include "Domain/Block.hpp"
12	#include "Domain/BoundaryConditions/None.hpp"
13	#include "Domain/BoundaryConditions/Periodic.hpp"
14	#include "Domain/CoordinateMaps/CoordinateMap.hpp"
15	#include "Domain/CoordinateMaps/CoordinateMap.tpp"
16	#include "Domain/CoordinateMaps/Interval.hpp"
17	#include "Domain/Creators/DomainCreator.hpp"
18	#include "Domain/Creators/TimeDependence/None.hpp"
19	#include "Domain/Creators/TimeDependence/TimeDependence.hpp"
20	#include "Domain/Domain.hpp"
21	#include "Domain/DomainHelpers.hpp"
22	#include "Domain/Structure/BlockNeighbor.hpp"
23	#include "Domain/Structure/Direction.hpp"
24	#include "Domain/Structure/DirectionMap.hpp"
25
26	namespace Frame {
27	struct Inertial;
28	struct BlockLogical;
29	} // namespace Frame
30
31	namespace domain::creators {
32	Interval::Interval(	50✔
33	std::array<double, 1> lower_x, std::array<double, 1> upper_x,
34	std::array<size_t, 1> initial_refinement_level_x,
35	std::array<size_t, 1> initial_number_of_grid_points_in_x,
36	std::array<bool, 1> is_periodic_in_x,
37	domain::CoordinateMaps::Distribution distribution,
38	std::optional<double> singularity,
39	std::unique_ptr<domain::creators::time_dependence::TimeDependence<1>>
40	time_dependence,
41	const Options::Context& context)	50✔
42	: lower_x_(lower_x),
43	upper_x_(upper_x),
44	distribution_(distribution),
45	singularity_(singularity),
46	is_periodic_in_x_(is_periodic_in_x),
47	initial_refinement_level_x_(initial_refinement_level_x),
48	initial_number_of_grid_points_in_x_(initial_number_of_grid_points_in_x),
49	lower_boundary_condition_(nullptr),
50	upper_boundary_condition_(nullptr),
51	time_dependence_(std::move(time_dependence)) {	50✔
52	if (time_dependence_ == nullptr) {	50✔
53	time_dependence_ =
54	std::make_unique<domain::creators::time_dependence::None<1>>();	38✔
55	}
56	if (lower_x_[0] >= upper_x_[0]) {	50✔
57	PARSE_ERROR(context, "Lower bound ("	×
58	<< lower_x_[0]
59	<< ") must be strictly smaller than upper bound ("
60	<< upper_x_[0] << ").");
61	}
62	if ((distribution_ == CoordinateMaps::Distribution::Logarithmic or	92✔
63	distribution_ == CoordinateMaps::Distribution::Inverse) !=	92✔
64	singularity_.has_value()) {	50✔
65	PARSE_ERROR(context,	×
66	"Specify a 'Singularity' for 'Logarithmic' or 'Inverse' grid "
67	"point distributions, or 'None' otherwise.");
68	}
69	if (singularity_.has_value() and *singularity_ >= lower_x_[0] and	50✔
70	*singularity_ <= upper_x_[0]) {	×
71	PARSE_ERROR(context, "The 'Singularity' ("	×
72	<< *singularity_ << ") falls inside the domain ["
73	<< lower_x_[0] << ", " << upper_x_[0] << "].");
74	}
75	}	50✔
76
77	Interval::Interval(	23✔
78	std::array<double, 1> lower_x, std::array<double, 1> upper_x,
79	std::array<size_t, 1> initial_refinement_level_x,
80	std::array<size_t, 1> initial_number_of_grid_points_in_x,
81	std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
82	lower_boundary_condition,
83	std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>
84	upper_boundary_condition,
85	domain::CoordinateMaps::Distribution distribution,
86	std::optional<double> singularity,
87	std::unique_ptr<domain::creators::time_dependence::TimeDependence<1>>
88	time_dependence,
89	const Options::Context& context)	23✔
90	: Interval(lower_x, upper_x, initial_refinement_level_x,
91	initial_number_of_grid_points_in_x, {{false}}, distribution,
92	singularity, std::move(time_dependence), context) {	29✔
93	lower_boundary_condition_ = std::move(lower_boundary_condition);	23✔
94	upper_boundary_condition_ = std::move(upper_boundary_condition);	23✔
95	if ((lower_boundary_condition_ == nullptr) !=	46✔
96	(upper_boundary_condition_ == nullptr)) {	23✔
97	PARSE_ERROR(context,	2✔
98	"Both upper and lower boundary conditions must be specified, "
99	"or neither.");
100	}
101	using domain::BoundaryConditions::is_none;
102	if (is_none(lower_boundary_condition_) or	41✔
103	is_none(upper_boundary_condition_)) {	20✔
104	PARSE_ERROR(	2✔
105	context,
106	"None boundary condition is not supported. If you would like an "
107	"outflow-type boundary condition, you must use that.");
108	}
109	using domain::BoundaryConditions::is_periodic;
110	if (is_periodic(lower_boundary_condition_) !=	19✔
111	is_periodic(upper_boundary_condition_)) {	19✔
112	PARSE_ERROR(	2✔
113	context,
114	"Both the upper and lower boundary condition must be set to periodic "
115	"if imposing periodic boundary conditions.");
116	}
117	if (is_periodic(lower_boundary_condition_)) {	17✔
118	is_periodic_in_x_[0] = true;	5✔
119	}
120	}	17✔
121
122	Domain<1> Interval::create_domain() const {	45✔
123	Domain<1> domain{
124	make_vector_coordinate_map_base<Frame::BlockLogical, Frame::Inertial>(	45✔
125	CoordinateMaps::Interval{-1., 1., lower_x_[0], upper_x_[0],	45✔
126	distribution_, singularity_}),	45✔
127	std::vector<std::array<size_t, 2>>{{{1, 2}}},	90✔
128	is_periodic_in_x_[0] ? std::vector<PairOfFaces>{{{1}, {2}}}	155✔
129	: std::vector<PairOfFaces>{},
130	{},
131	block_names_};	90✔
132	if (not time_dependence_->is_none()) {	45✔
133	domain.inject_time_dependent_map_for_block(	30✔
134	0, std::move(time_dependence_->block_maps_grid_to_inertial(1)[0]),	20✔
135	std::move(time_dependence_->block_maps_grid_to_distorted(1)[0]),	20✔
136	std::move(time_dependence_->block_maps_distorted_to_inertial(1)[0]));	20✔
137	}
138	return domain;	45✔
139	}
140
141	std::vector<DirectionMap<
142	1, std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
143	Interval::external_boundary_conditions() const {	55✔
144	if (upper_boundary_condition_ == nullptr) {	55✔
145	return {};	20✔
146	}
147	std::vector<DirectionMap<
148	1, std::unique_ptr<domain::BoundaryConditions::BoundaryCondition>>>
149	boundary_conditions{1};	70✔
150	if (is_periodic_in_x_[0]) {	35✔
151	return boundary_conditions;	9✔
152	}
153	boundary_conditions[0][Direction<1>::lower_xi()] =	26✔
154	lower_boundary_condition_->get_clone();	52✔
155	boundary_conditions[0][Direction<1>::upper_xi()] =	26✔
156	upper_boundary_condition_->get_clone();	52✔
157	return boundary_conditions;	26✔
158	}
159
160	std::vector<std::array<size_t, 1>> Interval::initial_extents() const {	45✔
161	return {{{initial_number_of_grid_points_in_x_}}};	45✔
162	}
163
164	std::vector<std::array<size_t, 1>> Interval::initial_refinement_levels() const {	36✔
165	return {{{initial_refinement_level_x_}}};	36✔
166	}
167
168	std::unordered_map<std::string,
169	std::unique_ptr<domain::FunctionsOfTime::FunctionOfTime>>
170	Interval::functions_of_time(const std::unordered_map<std::string, double>&	40✔
171	initial_expiration_times) const {
172	if (time_dependence_->is_none()) {	40✔
173	return {};	20✔
174	} else {
175	return time_dependence_->functions_of_time(initial_expiration_times);	20✔
176	}
177	}
178	} // namespace domain::creators

sxs-collaboration / spectre / 4257919060

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