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