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_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_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_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_closed_surface_semi_detached(self):
orbital_position_container = self.build_system('semi-detached',
up.radians(10))
self.assertTrue(
testutils.surface_closed(
faces=orbital_position_container.primary.faces,
points=orbital_position_container.primary.points))
def test_mesh_for_duplicate_points(self):
for params in testutils.SINGLE_SYSTEM_PARAMS.values():
s = prepare_single_system(params)
# reducing runtime of the test
s.star.discretization_factor = up.radians(7)
s.init()
system_container = testutils.prepare_single_system_container(s)
system_container.build_mesh()
star_instance = getattr(system_container, 'star')
distance = round(find_nearest_dist_3d(list(star_instance.points)),
10)
if distance < 1e-10:
bad_points = []
for i, point in enumerate(star_instance.points):
for j, xx in enumerate(star_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_build_mesh_detached_with_overlapped_like_umbra():
s = prepare_single_system(testutils.SINGLE_SYSTEM_PARAMS['spherical'],
spots=list(
reversed(testutils.SPOTS_OVERLAPPED)))
s.star.discretization_factor = up.radians(5)
system_container = testutils.prepare_single_system_container(s)
system_container.build_mesh()
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 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 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_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_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 test_build_surface_areas_semi_detached_size(self):
self.generator_test_surface_areas('semi-detached',
up.radians(10),
kind="size",
less=8e-3)
def generator_test_face_orientaion(self, key, kind):
s = testutils.prepare_single_system(testutils.SINGLE_SYSTEM_PARAMS[key],
spots=testutils.SPOTS_META["primary"],
)
s.star.discretization_factor = up.radians(7)
s.init()
position_container = testutils.prepare_single_system_container(s)
position_container.build_mesh()
position_container.build_faces()
position_container.build_surface_areas()
position_container.build_faces_orientation()
if kind == 'present':
self.assertTrue(not is_empty(position_container.star.normals))
self.assertTrue(not is_empty(position_container.star.spots[0].normals))
_assert = self.assertTrue
if kind == 'direction':
o = position_container
face_points = o.star.points[o.star.faces]
spot_face_points = o.star.spots[0].points[o.star.spots[0].faces]
# x axis
all_positive = (face_points[:, :, 0] >= 0).all(axis=1)
_assert(np.all(o.star.normals[all_positive][:, 0] > 0))
all_negative = (face_points[:, :, 0] <= 0).all(axis=1)
_assert(np.all(o.star.normals[all_negative][:, 0] < 0))
all_positive = (spot_face_points[:, :, 0] >= 0).all(axis=1)
_assert(np.all(o.star.spots[0].normals[all_positive][:, 0] > 0))
all_negative = (spot_face_points[:, :, 0] <= 0).all(axis=1)
_assert(np.all(o.star.spots[0].normals[all_negative][:, 0] < 0))
# y axis
all_positive = (face_points[:, :, 1] >= 0).all(axis=1)
_assert(np.all(o.star.normals[all_positive][:, 1] > 0))
all_negative = (face_points[:, :, 1] <= 0).all(axis=1)
_assert(np.all(o.star.normals[all_negative][:, 1] < 0))
all_positive = (spot_face_points[:, :, 1] >= 0).all(axis=1)
_assert(np.all(o.star.spots[0].normals[all_positive][:, 1] > 0))
all_negative = (spot_face_points[:, :, 1] <= 0).all(axis=1)
_assert(np.all(o.star.spots[0].normals[all_negative][:, 1] < 0))
# z axis
all_positive = (face_points[:, :, 2] >= 0).all(axis=1)
_assert(np.all(o.star.normals[all_positive][:, 2] > 0))
all_negative = (face_points[:, :, 2] <= 0).all(axis=1)
_assert(np.all(o.star.normals[all_negative][:, 2] < 0))
all_positive = (spot_face_points[:, :, 2] >= 0).all(axis=1)
_assert(np.all(o.star.spots[0].normals[all_positive][:, 2] > 0))
all_negative = (spot_face_points[:, :, 2] <= 0).all(axis=1)
_assert(np.all(o.star.spots[0].normals[all_negative][:, 2] < 0))
if kind == 'size':
o = position_container
normals_size = np.linalg.norm(o.star.normals, axis=1)
_assert((np.round(normals_size, 5) == 1).all())
spot_normals_size = np.linalg.norm(o.star.spots[0].normals, axis=1)
_assert((np.round(spot_normals_size, 5) == 1).all())
def test_closed_surface_squashed(self):
position_container = self.build_system('squashed', up.radians(10))
self.assertTrue(testutils.surface_closed(faces=position_container.star.faces,
points=position_container.star.points))
def test_build_mesh_overcontact_no_spot(self):
self.generator_test_mesh(key="over-contact",
d=up.radians(10),
length=[413, 401])
def test_build_faces_semi_detached(self):
self.generator_test_faces('semi-detached', up.radians(10), [848, 848])
def test_build_mesh_semi_detached_no_spot(self):
self.generator_test_mesh(key="semi-detached",
d=up.radians(10),
length=[426, 426])
def test_build_faces_detached(self):
self.generator_test_faces('detached', up.radians(10),
[785, 186, 97, 6])
def test_build_faces_over_contact(self):
self.generator_test_faces('over-contact', up.radians(10), [812, 784])
def test_build_surface_areas_over_contact_size(self):
self.generator_test_surface_areas('over-contact',
up.radians(10),
kind="size",
less=8e-3)
def test_build_mesh(self):
for key in testutils.SINGLE_SYSTEM_PARAMS.keys():
self.generator_test_mesh(key=key, d=up.radians(5))
def test_build_surface_areas_detached_size(self):
self.generator_test_surface_areas('detached',
up.radians(10),
kind="size",
less=5e-6)
def setUp(self):
self.s = testutils.prepare_binary_system(testutils.BINARY_SYSTEM_PARAMS['detached-physical'])
self.s.primary.discretization_factor = up.radians(10)
self.s.secondary.discretization_factor = up.radians(10)
def test_build_surface_areas_over_contact(self):
self.generator_test_surface_areas('over-contact',
up.radians(10),
kind="contain")
def test_build_faces_over_contact(self):
self.generator_test_faces('over-contact', up.radians(10),
[751, 374, 97, 24])
def test_build_faces_semi_detached(self):
self.generator_test_faces('semi-detached', up.radians(10),
[785, 400, 97, 24])
def test_build_surface_areas_semi_detached(self):
self.generator_test_surface_areas('semi-detached',
up.radians(10),
kind="contain")
def generator_test_face_orientaion(self, key, kind):
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(7)
s.init()
orbital_position_container: OrbitalPositionContainer = 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)
if kind == 'present':
self.assertTrue(
not is_empty(orbital_position_container.primary.normals))
self.assertTrue(
not is_empty(orbital_position_container.secondary.normals))
self.assertTrue(not is_empty(
orbital_position_container.primary.spots[0].normals))
self.assertTrue(not is_empty(
orbital_position_container.secondary.spots[0].normals))
_assert = self.assertTrue
if kind == 'direction':
o = orbital_position_container
for component in ['primary', 'secondary']:
star = getattr(o, component)
face_points = star.points[star.faces]
spot_face_points = star.spots[0].points[star.spots[0].faces]
face_points[:, :,
0] = face_points[:, :,
0] - 1 if component == 'secondary' else face_points[:, :,
0]
spot_face_points[:, :, 0] = spot_face_points[:, :, 0] - 1 if component == 'secondary' else \
spot_face_points[:, :, 0]
# x axis
all_positive = (face_points[:, :, 0] > 0).all(axis=1)
_assert(np.all(star.normals[all_positive][:, 0] > 0))
all_negative = (face_points[:, :, 0] < 0).all(axis=1)
_assert(np.all(star.normals[all_negative][:, 0] < 0))
all_positive = (spot_face_points[:, :, 0] > 0).all(axis=1)
_assert(np.all(star.spots[0].normals[all_positive][:, 0] > 0))
all_negative = (spot_face_points[:, :, 0] <= 0).all(axis=1)
_assert(np.all(star.spots[0].normals[all_negative][:, 0] < 0))
# y axis
all_positive = (face_points[:, :, 1] > 0).all(axis=1)
_assert(np.all(star.normals[all_positive][:, 1] > 0))
all_negative = (face_points[:, :, 1] < 0).all(axis=1)
_assert(np.all(star.normals[all_negative][:, 1] < 0))
all_positive = (spot_face_points[:, :, 1] > 0).all(axis=1)
_assert(np.all(star.spots[0].normals[all_positive][:, 1] > 0))
all_negative = (spot_face_points[:, :, 1] < 0).all(axis=1)
_assert(np.all(star.spots[0].normals[all_negative][:, 1] < 0))
# z axis
all_positive = (face_points[:, :, 2] > 0).all(axis=1)
_assert(np.all(star.normals[all_positive][:, 2] > 0))
all_negative = (face_points[:, :, 2] < 0).all(axis=1)
_assert(np.all(star.normals[all_negative][:, 2] < 0))
all_positive = (spot_face_points[:, :, 2] > 0).all(axis=1)
_assert(np.all(star.spots[0].normals[all_positive][:, 2] > 0))
all_negative = (spot_face_points[:, :, 2] < 0).all(axis=1)
_assert(np.all(star.spots[0].normals[all_negative][:, 2] < 0))
if kind == 'size':
o = orbital_position_container
for component in ['primary', 'secondary']:
star = getattr(o, component)
normals_size = np.linalg.norm(star.normals, axis=1)
_assert((np.round(normals_size, 5) == 1).all())
spot_normals_size = np.linalg.norm(star.spots[0].normals,
axis=1)
_assert((np.round(spot_normals_size, 5) == 1).all())
