def test_circular_spotty_synchronous_overcontact_system(self):
bs = prepare_binary_system(PARAMS["over-contact"],
spots_primary=SPOTS_META["primary"],
spots_secondary=SPOTS_META["secondary"])
self.do_comparison(
bs, "overcontact.circ.spotty.sync.generic.bessel.v.json", TOL,
-0.2, 1.2, 0.01)
def test_closed_surface_over_contact(self):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS['over-contact'],
spots_primary=testutils.SPOTS_META["primary"],
spots_secondary=testutils.SPOTS_META["secondary"])
s.primary.discretization_factor = up.radians(7)
s.init()
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
for component in ['primary', 'secondary']:
instance = getattr(orbital_position_container, component)
points = instance.points
faces = instance.faces
if isinstance(instance.spots, (dict, )):
for idx, spot in instance.spots.items():
faces = up.concatenate((faces, spot.faces + len(points)),
axis=0)
points = up.concatenate((points, spot.points), axis=0)
setattr(instance, 'points', points)
setattr(instance, 'faces', faces)
points = np.concatenate((orbital_position_container.primary.points,
orbital_position_container.secondary.points))
faces = np.concatenate(
(orbital_position_container.primary.faces,
orbital_position_container.secondary.faces +
np.shape(orbital_position_container.primary.points)[0]))
self.assertTrue(testutils.surface_closed(faces=faces, points=points))
def test_cicular_spotty_asynchronous_detached_system(self):
settings.configure(**{"MAX_SPOT_D_LONGITUDE": up.pi / 45.0})
bs = prepare_binary_system(PARAMS["detached-async"],
spots_primary=SPOTS_META["primary"])
self.do_comparison(bs,
"detached.circ.spotty.async.generic.bessel.v.json",
TOL, -0.2, 1.2, 0.2)
def generator_test_gravity(self, key):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key],
spots_primary=testutils.SPOTS_META["primary"],
spots_secondary=testutils.SPOTS_META["secondary"])
s.primary.discretization_factor = up.radians(10)
s.secondary.discretization_factor = up.radians(10)
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
orbital_position_container.build_surface_areas()
orbital_position_container.build_faces_orientation(
components_distance=1.0)
orbital_position_container.build_surface_gravity(
components_distance=1.0)
self.assertTrue(
hasattr(orbital_position_container.primary.spots[0],
"potential_gradient_magnitudes"))
self.assertTrue(
hasattr(orbital_position_container.secondary.spots[0],
"potential_gradient_magnitudes"))
self.assertTrue(
hasattr(orbital_position_container.primary.spots[0], "log_g"))
self.assertTrue(
hasattr(orbital_position_container.secondary.spots[0], "log_g"))
self.assertTrue(
not is_empty(orbital_position_container.primary.spots[0].log_g))
self.assertTrue(
not is_empty(orbital_position_container.secondary.spots[0].log_g))
def test_mesh_for_duplicate_points_no_spot(self):
for params in testutils.BINARY_SYSTEM_PARAMS.values():
s = prepare_binary_system(params)
# reducing runtime of the test
s.primary.discretization_factor = up.radians(7)
s.init()
components_distance = s.orbit.orbital_motion(phase=0.0)[0][0]
orbital_position_container = OrbitalPositionContainer(
primary=StarContainer.from_properties_container(
s.primary.to_properties_container()),
secondary=StarContainer.from_properties_container(
s.secondary.to_properties_container()),
position=Position(*(0, 1.0, 0.0, 0.0, 0.0)),
**s.properties_serializer())
orbital_position_container.build_mesh(
components_distance=components_distance)
for component in ['primary', 'secondary']:
component_instance = getattr(orbital_position_container,
component)
distance = round(
find_nearest_dist_3d(list(component_instance.points)), 10)
if distance < 1e-10:
bad_points = []
for i, point in enumerate(component_instance.points):
for j, xx in enumerate(component_instance.points[i +
1:]):
dist = np.linalg.norm(point - xx)
if dist <= 1e-10:
print(f'Match: {point}, {i}, {j}')
bad_points.append(point)
self.assertFalse(distance < 1e-10)
def test_approximation_one(self):
bs = prepare_binary_system(PARAMS["eccentric"])
phase_step = 1.0 / 120
settings.configure(**APPROX_SETTINGS["approx_one"])
settings.configure(**{"NUMBER_OF_PROCESSES": 4})
o = Observer(passband=['Generic.Bessell.V'], system=bs)
ap_res = o.lc(from_phase=-0.1, to_phase=1.1, phase_step=phase_step)
ap_flux = normalize_lc_for_unittests(ap_res[1]["Generic.Bessell.V"])
# ap_flux = ap_res[1]["Generic.Bessell.V"]
settings.configure(**APPROX_SETTINGS["no_approx"])
o = Observer(passband=['Generic.Bessell.V'], system=bs)
ex_res = o.lc(from_phase=-0.1, to_phase=1.1, phase_step=phase_step)
ex_flux = normalize_lc_for_unittests(ex_res[1]["Generic.Bessell.V"])
# ex_flux = ex_res[1]["Generic.Bessell.V"]
# import matplotlib.pyplot as plt
# plt.plot(ex_res[0], ex_flux, label='exact')
# plt.plot(ap_res[0], ap_flux, label='approx')
# plt.plot(ap_res[0], ex_flux-ap_flux+1, label='diff')
# plt.legend()
# plt.show()
self.assertTrue(np.all(ex_flux - ap_flux < 3e-3))
def test_eccentric_system_approximation_two(self):
settings.configure(**APPROX_SETTINGS["approx_two"])
ec_params = PARAMS["eccentric"].copy()
ec_params["argument_of_periastron"] = 90 * u.deg
bs = prepare_binary_system(ec_params)
self.do_comparison(
bs, "detached.ecc.sync.generic.bessell.v.appx_two.json", TOL, -0.2,
1.15, 0.05)
def setUp(self):
super(IndempotenceTestCase, self).setUp()
self.s = testutils.prepare_binary_system(testutils.BINARY_SYSTEM_PARAMS['detached-physical'],
testutils.SPOTS_META["primary"])
self.s.primary.discretization_factor = up.radians(10)
self.single = testutils.prepare_single_system(testutils.SINGLE_SYSTEM_PARAMS['spherical'],
testutils.SPOTS_META["primary"])
self.base_path = op.dirname(op.abspath(__file__))
settings.configure(LD_TABLES=op.join(self.base_path, "data", "light_curves", "limbdarkening"))
def test_eccentric_system_approximation_three(self):
settings.configure(**APPROX_SETTINGS["approx_three"])
with open(self.CONFIG_FILE, "a") as f:
f.write(
f"[computational]"
f"\npoints_on_ecc_orbit={settings.POINTS_ON_ECC_ORBIT}"
f"\nmax_relative_d_r_point={settings.MAX_RELATIVE_D_R_POINT}")
bs = prepare_binary_system(PARAMS["eccentric"])
self.do_comparison(bs, 0.0, 0.01, 0.002, tol=1e-4)
def test_eccentric_system_approximation_two(self):
settings.configure(**APPROX_SETTINGS["approx_two"])
ec_params = PARAMS["eccentric"].copy()
ec_params["argument_of_periastron"] = 90 * u.deg
bs = prepare_binary_system(ec_params)
self.do_comparison(bs,
"detached.ecc.appx_two.json",
start_phs=-0.2,
stop_phs=1.2,
step=0.05)
def build_system(key, d):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key])
s.primary.discretization_factor = d
s.secondary.discretization_factor = d
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
return orbital_position_container
def test_circulcar_spotty_async_lc(self):
settings.configure(**{"MAX_SPOT_D_LONGITUDE": up.pi / 45.0})
# write config for stupid windows multiprocessing
with open(self.CONFIG_FILE, "a") as f:
f.write(f"[computational]"
f"\nmax_spot_d_longitude={settings.MAX_SPOT_D_LONGITUDE}"
f"\n")
bs = prepare_binary_system(PARAMS["detached-async"],
spots_primary=SPOTS_META["primary"])
self.do_comparison(bs)
def test_eccentric_system_approximation_two(self):
settings.configure(**APPROX_SETTINGS["approx_two"])
settings.configure(**{"MAX_RELATIVE_D_R_POINT": 0.0})
with open(self.CONFIG_FILE, "a") as f:
f.write(
f"[computational]"
f"\nmax_supplementar_d_distance={settings.MAX_SUPPLEMENTAR_D_DISTANCE}"
f"\npoints_on_ecc_orbit={settings.POINTS_ON_ECC_ORBIT}"
f"\nmax_relative_d_r_point={settings.MAX_RELATIVE_D_R_POINT}"
f"\n")
bs = prepare_binary_system(PARAMS["eccentric"])
self.do_comparison(bs, start_phs=-0.2, stop_phs=1.2, step=0.1)
def test_build_mesh_detached_with_overlapped_like_umbra():
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS['detached'],
spots_primary=list(reversed(testutils.SPOTS_OVERLAPPED)))
s.primary.discretization_factor = up.radians(5)
s.secondary.discretization_factor = up.radians(5)
orbital_position_container = OrbitalPositionContainer(
primary=StarContainer.from_properties_container(
s.primary.to_properties_container()),
secondary=StarContainer.from_properties_container(
s.secondary.to_properties_container()),
position=Position(*(0, 1.0, 0.0, 0.0, 0.0)),
**s.properties_serializer())
orbital_position_container.build_mesh(components_distance=1.0)
def test_visible_indices_when_darkside_filter_apply(self):
settings.configure(
**{
"LD_TABLES": op.join(self.lc_base_path, "limbdarkening"),
"CK04_ATM_TABLES": op.join(self.lc_base_path, "atmosphere")
})
bs = prepare_binary_system(BINARY_SYSTEM_PARAMS['detached-physical'])
from_this = dict(binary_system=bs,
position=const.Position(0, 1.0, 0.0, 0.0, 0.0))
system = OrbitalPositionContainer.from_binary_system(**from_this)
system.build(components_distance=1.0)
system.calculate_face_angles(line_of_sight=const.LINE_OF_SIGHT)
system.apply_darkside_filter()
self.assertTrue((not is_empty(system.primary.indices))
and (not is_empty(system.secondary.indices)))
def generator_test_temperatures(self, key, allowed_range=None):
settings.configure(
**{
"LIMB_DARKENING_LAW":
"linear",
"LD_TABLES":
op.join(op.dirname(op.abspath(__file__)), "data",
"light_curves", "limbdarkening")
})
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key])
s.primary.discretization_factor = up.radians(10)
s.secondary.discretization_factor = up.radians(10)
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
orbital_position_container.build_surface_areas()
orbital_position_container.build_surface_gravity(
components_distance=1.0)
orbital_position_container.build_faces_orientation(
components_distance=1.0)
orbital_position_container.build_temperature_distribution(
components_distance=1.0)
print()
i = np.argsort(orbital_position_container.secondary.temperatures)
print(orbital_position_container.secondary.points[
orbital_position_container.secondary.faces[i[:10]]])
print()
if allowed_range:
obtained_primary = [
np.min(orbital_position_container.primary.temperatures),
np.max(orbital_position_container.primary.temperatures)
]
obtained_secondary = [
np.min(orbital_position_container.secondary.temperatures),
np.max(orbital_position_container.secondary.temperatures)
]
self.assertTrue((obtained_primary[0] >= allowed_range[0][0])
& (obtained_primary[1] <= allowed_range[0][1]))
self.assertTrue((obtained_secondary[0] >= allowed_range[1][0])
& (obtained_secondary[1] <= allowed_range[1][1]))
def test_build_mesh_detached_with_overlapped_spots(self):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS['detached'],
spots_primary=testutils.SPOTS_OVERLAPPED)
s.primary.discretization_factor = up.radians(5)
s.secondary.discretization_factor = up.radians(5)
orbital_position_container = OrbitalPositionContainer(
primary=StarContainer.from_properties_container(
s.primary.to_properties_container()),
secondary=StarContainer.from_properties_container(
s.secondary.to_properties_container()),
position=Position(*(0, 1.0, 0.0, 0.0, 0.0)),
**s.properties_serializer())
with self.assertRaises(Exception) as context:
orbital_position_container.build_mesh(components_distance=1.0)
self.assertTrue(
"Please, specify spots wisely" in str(context.exception))
def test_closed_surface_over_contact(self):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS['over-contact'])
s.primary.discretization_factor = up.radians(10)
s.init()
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
points = np.concatenate((orbital_position_container.primary.points,
orbital_position_container.secondary.points))
faces = np.concatenate(
(orbital_position_container.primary.faces,
orbital_position_container.secondary.faces +
np.shape(orbital_position_container.primary.points)[0]))
self.assertTrue(testutils.surface_closed(faces=faces, points=points))
def generator_test_faces(key, d, length):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key],
spots_primary=testutils.SPOTS_META["primary"],
spots_secondary=testutils.SPOTS_META["secondary"])
s.primary.discretization_factor = d
s.init()
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
assert_array_equal([
len(orbital_position_container.primary.faces),
len(orbital_position_container.secondary.faces),
len(orbital_position_container.primary.spots[0].faces),
len(orbital_position_container.secondary.spots[0].faces)
], length)
def test_light_curve_pass_on_all_ld_law(self):
"""
no assert here, it just has to pass without error
"""
bs = prepare_binary_system(PARAMS["detached"])
start_phs, stop_phs, step = -0.2, 1.2, 0.1
# idea is to update configuration content for problematic values in default configuration file
content_tempalte = "[physics]limb_darkening_law={ld_law}"
for law in settings.LD_LAW_TO_FILE_PREFIX.keys():
settings.configure(**{"LIMB_DARKENING_LAW": law})
self.write_default_support(ld_tables=settings.LD_TABLES,
atm_tables=settings.CK04_ATM_TABLES)
with open(self.CONFIG_FILE, "a") as f:
f.write(content_tempalte.format(ld_law=law))
o = Observer(passband=['Generic.Bessell.V'], system=bs)
o.lc(from_phase=start_phs, to_phase=stop_phs, phase_step=step)
def generator_test_mesh(key, d, length):
s = prepare_binary_system(testutils.BINARY_SYSTEM_PARAMS[key])
s.primary.discretization_factor = d
s.secondary.discretization_factor = d
orbital_position_container = OrbitalPositionContainer(
primary=StarContainer.from_properties_container(
s.primary.to_properties_container()),
secondary=StarContainer.from_properties_container(
s.secondary.to_properties_container()),
position=Position(*(0, 1.0, 0.0, 0.0, 0.0)),
**s.properties_serializer())
orbital_position_container.build_mesh(components_distance=1.0)
obtained_primary = np.round(orbital_position_container.primary.points,
4)
obtained_secondary = np.round(
orbital_position_container.secondary.points, 4)
assert_array_equal([len(obtained_primary),
len(obtained_secondary)], length)
def generator_test_gravity(self, key, over):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key])
s.primary.discretization_factor = up.radians(10)
s.secondary.discretization_factor = up.radians(10)
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
orbital_position_container.build_surface_areas()
orbital_position_container.build_faces_orientation(
components_distance=1.0)
orbital_position_container.build_surface_gravity(
components_distance=1.0)
self.assertTrue(
np.all(orbital_position_container.primary.log_g > over))
self.assertTrue(
np.all(orbital_position_container.secondary.log_g > over))
def test_rvs_from_binary_system_instance_are_same(self):
s = prepare_binary_system(BINARY_SYSTEM_PARAMS["detached.ecc"])
s.inclination = 1.1
s.init()
std_rvdict = rv.com_radial_velocity(s, position_method=s.calculate_orbital_motion, phases=self.phases)
asini = np.float64((s.semi_major_axis * np.sin(s.inclination) * u.m).to(u.solRad))
rv_system = RadialVelocitySystem(eccentricity=s.eccentricity,
argument_of_periastron=np.degrees(s.argument_of_periastron),
period=s.period,
mass_ratio=s.mass_ratio,
asini=asini,
gamma=s.gamma)
o = Observer(passband='bolometric', system=rv_system)
phases, com_rv_dict = o.observe.rv(phases=self.phases, method='point_mass')
self.assertTrue(np.all(np.abs(std_rvdict['primary'] - com_rv_dict['primary']) < TOL))
self.assertTrue(np.all(np.abs(std_rvdict['secondary'] - com_rv_dict['secondary']) < TOL))
def generator_test_surface_areas(self, key, d, kind, less=None):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key],
spots_primary=testutils.SPOTS_META["primary"],
spots_secondary=testutils.SPOTS_META["secondary"])
s.primary.discretization_factor = d
s.init()
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
orbital_position_container.build_surface_areas()
if kind == "contain":
self.assertTrue(
not is_empty(orbital_position_container.primary.areas))
self.assertTrue(
not is_empty(orbital_position_container.secondary.areas))
self.assertTrue(not is_empty(
orbital_position_container.primary.spots[0].areas))
self.assertTrue(not is_empty(
orbital_position_container.secondary.spots[0].areas))
if kind == "size":
self.assertTrue(
np.all(up.less(orbital_position_container.primary.areas,
less)))
self.assertTrue(
np.all(
up.less(orbital_position_container.secondary.areas, less)))
self.assertTrue(
np.all(
up.less(orbital_position_container.primary.spots[0].areas,
less)))
self.assertTrue(
np.all(
up.less(
orbital_position_container.secondary.spots[0].areas,
less)))
def test_make_sure_spots_are_not_overwriten_in_star_instance(self):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS["detached"],
spots_primary=testutils.SPOTS_META["primary"],
spots_secondary=testutils.SPOTS_META["secondary"])
s.primary.discretization_factor = up.radians(10)
s.secondary.discretization_factor = up.radians(10)
orbital_position_container = OrbitalPositionContainer(
primary=StarContainer.from_properties_container(
s.primary.to_properties_container()),
secondary=StarContainer.from_properties_container(
s.secondary.to_properties_container()),
position=Position(*(0, 1.0, 0.0, 0.0, 0.0)),
**s.properties_serializer())
orbital_position_container.build_mesh(components_distance=1.0)
self.assertTrue(is_empty(s.primary.spots[0].points))
self.assertTrue(is_empty(s.secondary.spots[0].points))
self.assertTrue(is_empty(s.primary.spots[0].faces))
self.assertTrue(is_empty(s.secondary.spots[0].faces))
def test_approximation_two(self):
bs = prepare_binary_system(PARAMS["eccentric"])
settings.configure(**APPROX_SETTINGS["approx_two"])
settings.configure(**{"NUMBER_OF_PROCESSES": 4})
o = Observer(system=bs)
ap_res = o.rv(from_phase=-0.1,
to_phase=1.1,
phase_step=0.01,
method='radiometric')
ap_p = np.array(ap_res[1]['primary'])
ap_s = np.array(ap_res[1]['secondary'])
ap_p = ap_p[~np.isnan(ap_p)]
ap_s = ap_s[~np.isnan(ap_s)]
settings.configure(**APPROX_SETTINGS["no_approx"])
o = Observer(system=bs)
ex_res = o.rv(from_phase=-0.1,
to_phase=1.1,
phase_step=0.01,
method='radiometric')
ex_p = np.array(ex_res[1]['primary'])
ex_s = np.array(ex_res[1]['secondary'])
ex_p = ex_p[~np.isnan(ex_p)]
ex_s = ex_s[~np.isnan(ex_s)]
# import matplotlib.pyplot as plt
# plt.plot(ex_res[0], ex_p / ex_s.max())
# plt.plot(ex_res[0], ap_p / ex_s.max())
# plt.plot(ex_res[0], ex_s / ex_s.max())
# plt.plot(ex_res[0], ap_s / ex_s.max())
# plt.plot(ex_res[0], (ex_p - ap_p) / ex_s.max(), label='primary')
# plt.plot(ex_res[0], (ex_s - ap_s) / ex_s.max(), label='secondary')
# plt.legend()
# plt.show()
self.assertTrue(
np.all((up.abs(ex_p - ap_p) / np.abs(np.max(ex_s))) < 3e-3))
self.assertTrue(
np.all((up.abs(ex_s - ap_s) / np.abs(np.max(ex_s))) < 3e-3))
def test_light_curve_pass_on_all_ld_law(self):
"""
no assert here, it just has to pass without error
"""
bs = prepare_binary_system(PARAMS["detached"])
start_phs, stop_phs, step = -0.2, 1.2, 0.1
laws = settings.LD_LAW_TO_FILE_PREFIX.keys()
# idea is to update configuration content for problematic values in default configuration file
content_tempalte = "[physics]\n" \
"limb_darkening_law={ld_law}\n" \
"[computational]\n" \
"number_of_processes={cpu}\n"
for cpu_core in [-1, 2]:
for law in laws:
settings.configure(
**{
"NUMBER_OF_PROCESSES": cpu_core,
"LIMB_DARKENING_LAW": law,
"LD_TABLES": op.join(self.lc_base_path,
"limbdarkening"),
"CK04_ATM_TABLES": op.join(self.lc_base_path,
"atmosphere"),
"ATM_ATLAS": "ck04"
})
self.write_default_support(ld_tables=settings.LD_TABLES,
atm_tables=settings.CK04_ATM_TABLES)
with open(self.CONFIG_FILE, "a") as f:
f.write(content_tempalte.format(ld_law=law, cpu=cpu_core))
o = Observer(system=bs)
o.rv(from_phase=start_phs,
to_phase=stop_phs,
phase_step=step,
method='radiometric')
if op.isfile(self.CONFIG_FILE):
os.remove(self.CONFIG_FILE)
def check_consistency(binary_kwargs,
desired_delta,
spots_primary=None,
spots_secondary=None,
phases=None):
system = prepare_binary_system(binary_kwargs,
spots_primary=spots_primary,
spots_secondary=spots_secondary)
o = Observer(system=system)
_, rvdict1 = o.rv(phases=phases, method='radiometric')
_, rvdict2 = o.rv(phases=phases, method='point_mass')
rvdict1['primary'], rvdict1['secondary'] = normalize_lv_for_unittests(
rvdict1['primary'], rvdict1['secondary'])
rvdict2['primary'], rvdict2['secondary'] = normalize_lv_for_unittests(
rvdict2['primary'], rvdict2['secondary'])
assert_array_less(np.abs(rvdict1['primary'] - rvdict2['primary']),
desired_delta * np.ones(phases.shape))
assert_array_less(np.abs(rvdict2['secondary'] - rvdict2['secondary']),
desired_delta * np.ones(phases.shape))
def generator_test_mesh(self, key, d):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key],
spots_primary=testutils.SPOTS_META["primary"],
spots_secondary=testutils.SPOTS_META["secondary"])
s.primary.discretization_factor = d
s.secondary.discretization_factor = d
orbital_position_container = OrbitalPositionContainer(
primary=StarContainer.from_properties_container(
s.primary.to_properties_container()),
secondary=StarContainer.from_properties_container(
s.secondary.to_properties_container()),
position=Position(*(0, 1.0, 0.0, 0.0, 0.0)),
**s.properties_serializer())
orbital_position_container.build_mesh(components_distance=1.0)
self.assertTrue(
len(orbital_position_container.primary.spots) == 1
and len(orbital_position_container.secondary.spots) == 1)
self.assertTrue(
not is_empty(orbital_position_container.primary.spots[0].points))
self.assertTrue(
not is_empty(orbital_position_container.secondary.spots[0].points))
def build_system(key, d):
s = testutils.prepare_binary_system(
testutils.BINARY_SYSTEM_PARAMS[key],
spots_primary=testutils.SPOTS_META["primary"],
spots_secondary=testutils.SPOTS_META["secondary"])
s.primary.discretization_factor = d
s.init()
orbital_position_container = testutils.prepare_orbital_position_container(
s)
orbital_position_container.build_mesh(components_distance=1.0)
orbital_position_container.build_faces(components_distance=1.0)
for component in ['primary', 'secondary']:
instance = getattr(orbital_position_container, component)
points = instance.points
faces = instance.faces
if isinstance(instance.spots, (dict, )):
for idx, spot in instance.spots.items():
faces = up.concatenate((faces, spot.faces + len(points)),
axis=0)
points = up.concatenate((points, spot.points), axis=0)
setattr(instance, 'points', points)
setattr(instance, 'faces', faces)
return orbital_position_container
