def get_elements(self, aei_data: List[str]) -> Iterable[str]:
"""
:param aei_data:
:return:
"""
for orbital_elements in self._get_body_orbital_elements(aei_data):
small_body = orbital_elements.small_body
resonant_phase = self._resonance.compute_resonant_phase(
_get_longitudes(orbital_elements.big_bodies + [small_body]))
resonant_phase = cutoff_angle(resonant_phase)
resonance_data = "%f %f %s %s\n" % (
orbital_elements.small_body.time, resonant_phase,
orbital_elements.small_body.serialize_as_asteroid(),
' '.join([x.serialize_as_planet() for x in orbital_elements.big_bodies])
)
yield resonance_data
def get_time_breaks(self) -> List[float]:
"""Find circulations in file.
"""
result_breaks = [] # circulation breaks by OX
p_break = 0
previous_resonant_phase = None
prev_year = None
if not self._in_serialized_phases:
raise NoPhaseException('no resonant phases for resonance_id: %i' %
self._resonance_id)
for phase in self._in_serialized_phases:
# If the distance (OY axis) between new point and previous morf
# than PI then there is a break (circulation)
if self._is_for_apocentric:
resonant_phase = cutoff_angle(phase['value'] + math.pi)
else:
resonant_phase = phase['value']
if resonant_phase:
if (previous_resonant_phase and
(abs(previous_resonant_phase - resonant_phase) >= math.pi)):
c_break = 1 if (previous_resonant_phase - resonant_phase) > 0 else -1
# For apocentric libration there could be some breaks by
# following schema: break on 2*Pi, then break on 2*Pi e.t.c
# So if the breaks are on the same value there is no
# circulation at this moment
if (c_break != p_break) and (p_break != 0):
del result_breaks[len(result_breaks) - 1]
assert prev_year is not None
result_breaks.append(prev_year)
p_break = c_break
previous_resonant_phase = resonant_phase
prev_year = phase['year']
return result_breaks
def test_compute_resonant_phase(asteroid_mockcls, jupiter_mockcls, saturn_mockcls,
jupiter, saturn, asteroid, cutoffed_resonant_phase,
jupiter_coeffs, saturn_coeffs, asteroid_coeffs):
asteroid_mock = asteroid_mockcls()
asteroid_mock.longitude_coeff = asteroid_coeffs[LONG]
asteroid_mock.perihelion_longitude_coeff = asteroid_coeffs[PERI]
jupiter_mock = jupiter_mockcls()
jupiter_mock.longitude_coeff = jupiter_coeffs[LONG]
jupiter_mock.perihelion_longitude_coeff = jupiter_coeffs[PERI]
saturn_mock = saturn_mockcls()
saturn_mock.longitude_coeff = saturn_coeffs[LONG]
saturn_mock.perihelion_longitude_coeff = saturn_coeffs[PERI]
resonance = ThreeBodyResonance()
resonance.first_body = jupiter_mock
resonance.second_body = saturn_mock
resonance.small_body = asteroid_mock
resonant_phase = resonance.compute_resonant_phase(jupiter, saturn, asteroid)
assert cutoff_angle(resonant_phase) == cutoffed_resonant_phase
def get_resonant_phases(self, aei_data: List[str]) -> Iterable[Tuple[float, float]]:
for orbital_elements in self._get_body_orbital_elements(aei_data):
small_body = orbital_elements.small_body
resonant_phase = self._resonance.compute_resonant_phase(
*_get_longitudes(orbital_elements.big_bodies + [small_body]))
yield small_body.time, cutoff_angle(resonant_phase)
def plot(start: int, stop: int, phase_storage: PhaseStorage, for_librations: bool,
integers: List[str], aei_paths: Tuple[str, ...], is_recursive: bool, planets: Tuple[str],
output: str, build_phases: bool):
is_s3 = _is_s3(output)
is_tar = _is_tar(output)
tarf = None
s3_bucket_key = None
if is_tar:
output_dir = opjoin(PROJECT_DIR, '.output')
else:
output_dir = output
if is_s3:
if not is_tar:
logging.error('You must point tar archive in AWS S3 bucket.')
exit(-1)
output = opjoin(PROJECT_DIR, os.path.basename(output))
s3_bucket_key = create_aws_s3_key(CONFIG['s3']['access_key'],
CONFIG['s3']['secret_key'],
CONFIG['s3']['bucket'], output)
output_images = opjoin(output_dir, CONFIG['output']['images'])
output_res_path = opjoin(output_dir, CONFIG['output']['angle'])
output_gnu_path = opjoin(output_dir, CONFIG['output']['gnuplot'])
pathbuilder = FilepathBuilder(aei_paths, is_recursive)
planet_aei_paths = [pathbuilder.build('%s.aei' % x) for x in planets]
resmaker = ResfileMaker(planets, planet_aei_paths)
if not os.path.exists(output_images):
os.makedirs(output_images)
if not os.path.exists(output_gnu_path):
os.makedirs(output_gnu_path)
phase_builder = PhaseBuilder(phase_storage)
orbital_element_sets = None
if build_phases:
orbital_element_sets = build_bigbody_elements(planet_aei_paths)
phase_loader = PhaseLoader(phase_storage)
aei_getter = AEIDataGetter(pathbuilder)
if is_tar:
tarf = tarfile.open(output, 'w')
for resonance, aei_data in get_aggregated_resonances(start, stop, for_librations, planets,
aei_getter, integers):
if build_phases:
orbital_elem_set_facade = ResonanceOrbitalElementSetFacade(
orbital_element_sets, resonance)
phase_builder.build(aei_data, resonance.id, orbital_elem_set_facade)
phases = phase_loader.load(resonance.id)
apocentric_phases = [cutoff_angle(x + pi) for x in phases]
res_filepath = opjoin(output_res_path, 'A%i_%i.res' %
(resonance.asteroid_number, resonance.id))
gnu_filepath = opjoin(output_gnu_path, 'A%i_%i.gnu' %
(resonance.asteroid_number, resonance.id))
title = 'Asteroid %i %s %s' % (resonance.asteroid_number, str(resonance), ' '.join(planets))
resmaker.make(phases, aei_data, res_filepath)
png_path = opjoin(PROJECT_DIR, output_images, 'A%i-res%i%s.png' % (
resonance.asteroid_number, resonance.id, ''))
make_plot(res_filepath, gnu_filepath, png_path, title)
if is_tar:
tarf.add(png_path, arcname=os.path.basename(png_path))
resmaker.make(apocentric_phases, aei_data, res_filepath)
png_path = opjoin(PROJECT_DIR, output_images, 'A%i-res%i%s.png' % (
resonance.asteroid_number, resonance.id, '-apocentric'))
make_plot(res_filepath, gnu_filepath, png_path, title)
if is_tar:
tarf.add(png_path, arcname=os.path.basename(png_path))
if is_tar:
tarf.close()
shutil.rmtree(output_dir, True)
if is_s3:
s3_bucket_key.set_contents_from_filename(output)
