Example #1
0
def test_build_resonance(input_values: List[str], asteroid_num: int, asteroid_indicies: List[int],
                         planets: Tuple[str], resonancesfixture):
    factory = get_resonance_factory(planets, input_values, asteroid_num)
    build_resonance(factory)
    planet_q = session.query(Planet)
    asteroid_q = session.query(Asteroid)
    body_count = BodyNumberEnum(len(planets) + 1)
    resonances_q = _build_resonances_query(body_count, input_values, asteroid_num, factory)

    def _check_bodies():
        """
        check values of entities from database with input values.
        :return:
        """
        resonances = resonances_q.all()
        assert len(resonances) == 1
        db_planets = planet_q.all()  # type: List[Planet]
        assert len(db_planets) == body_count.value - 1

        for planet, foreign in zip(db_planets, BODY_FOREIGNS):
            _check(planet, factory.bodies[foreign])
            assert getattr(resonances[0], foreign) == planet

        asteroids = asteroid_q.all()  # type: List[Asteroid]
        _check(asteroids[0], {'name': 'A%i' % asteroid_num,
                              LONG_COEFF: int(input_values[asteroid_indicies[0]]),
                              PERI_COEFF: int(input_values[asteroid_indicies[1]])})
        assert asteroids[0].axis == float(input_values[asteroid_indicies[2]])
        assert len(asteroids) == 1
        assert resonances[0].small_body == asteroids[0]

    _check_bodies()
    build_resonance(factory)
    _check_bodies()
Example #2
0
def _build_resonances_query(body_number: BodyNumberEnum, input_values: List[str],
                            asteroid_num: int, factory: ResonanceFactory) -> Query:
    planet_tables = [aliased(Planet) for _ in range(body_number.value - 1)]
    resonance_cls = factory.resonance_cls

    resonances_q = session.query(resonance_cls)
    for planet_table, body_foreign in zip(planet_tables, BODY_FOREIGNS):
        resonances_q = resonances_q \
            .join(planet_table, getattr(resonance_cls, body_foreign)) \
            .options(joinedload(body_foreign))

    and_args = []
    for planet_table, body_foreign in zip(planet_tables, BODY_FOREIGNS):
        body_data = factory.bodies[body_foreign]
        and_args.append(planet_table.longitude_coeff == body_data[LONG_COEFF])
        and_args.append(planet_table.perihelion_longitude_coeff == body_data[PERI_COEFF])

    body_data = factory.bodies['small_body']
    and_args += [
        Asteroid.longitude_coeff == body_data[LONG_COEFF],
        Asteroid.perihelion_longitude_coeff == body_data[PERI_COEFF],
        Asteroid.axis == body_data['axis'],
    ]

    resonances_q.join(resonance_cls.small_body).options(joinedload('small_body')) \
        .filter(and_(*and_args))
    return resonances_q
Example #3
0
 def __init__(self, for_bodies: BodyNumberEnum, load_related=False):
     self._load_related = load_related
     if for_bodies == BodyNumberEnum.three:
         self.resonance_cls = ThreeBodyResonance
     else:
         self.resonance_cls = TwoBodyResonance
     self.query = session.query(self.resonance_cls)
     self.for_bodies = for_bodies
     self._foreings = FOREIGNS[: for_bodies.value - 1]
     self._asteroid_alias = aliased(Asteroid)
Example #4
0
def _resonance_fixture_different_librations(request):
    asteroid_nums = 1, 211, 78
    planets = request.param['planets']
    line_data_set = request.param['line_data_set']
    _fixture_base(asteroid_nums, (planets,), line_data_set)
    request.addfinalizer(clear_resonance_finalizer)

    cls = ThreeBodyResonance if len(planets) == 2 else TwoBodyResonance
    libration_cls = Libration if len(planets) == 2 else TwoBodyLibration
    resonance = session.query(cls).outerjoin(Asteroid).filter(
        Asteroid.number == asteroid_nums[0]).first()
    libration = libration_cls(resonance, [], 0, False)
    session.commit()
    return asteroid_nums, planets, libration
Example #5
0
def test_id_sequences_errors(line_data: List[str], next_line_data: List[str], planets: List[Tuple],
                             test_table: Table,
                             _constraint_fixture):
    resonance_factory = get_resonance_factory(planets[0], line_data, 1)
    build_resonance(resonance_factory)

    conn = engine.connect()
    conn.execute('ALTER SEQUENCE %s_id_seq RESTART WITH 1;' % test_table.name)

    resonance_factory = get_resonance_factory(planets[1], next_line_data, 1)
    build_resonance(resonance_factory)

    for i, entry in enumerate(session.query(test_table).all()):
        assert (i + 1) == entry.id
Example #6
0
def genres(asteroid_number: int, integers: List[int], filepaths: List[str], planets: Tuple):
    t1 = aliased(Planet)
    t2 = aliased(Planet)
    cond = len(integers) == 3
    resonance_cls = ThreeBodyResonance if cond else TwoBodyResonance
    query = (
        session.query(resonance_cls).outerjoin(t1, t1.id == resonance_cls.first_body_id).filter(t1.name == planets[0])
    )
    if cond:
        query = query.outerjoin(t2, t2.id == resonance_cls.second_body_id).filter(t2.name == planets[1])
    query = query.outerjoin(Asteroid, Asteroid.id == resonance_cls.small_body_id).filter(
        Asteroid.name == "A%i" % asteroid_number
    )

    resonance = query.first()
    if not resonance:
        logging.warning("There is no resonance by pointed filter.")
        return
    resonance_id = resonance.id

    phase_storage = PhaseStorage.file
    phase_builder = PhaseBuilder(phase_storage)
    phase_loader = PhaseLoader(phase_storage)
    phase_cleaner = PhaseCleaner(phase_storage)

    print("Loading aei files.")
    builder = FilepathBuilder(filepaths, True)
    planet_aei_paths = [builder.build("%s.aei" % x) for x in planets]
    resmaker = ResfileMaker(planets, planet_aei_paths)
    getter = AEIDataGetter(builder)
    orbital_element_sets = build_bigbody_elements(planet_aei_paths)
    orbital_elem_set_facade = ResonanceOrbitalElementSetFacade(orbital_element_sets, resonance)

    aei_data = getter.get_aei_data(asteroid_number)
    phase_builder.build(aei_data, resonance_id, orbital_elem_set_facade)
    phases = phase_loader.load(resonance_id)

    folder = opjoin(getcwd(), "res")
    if not exists(folder):
        mkdir(folder)
    resmaker.make(
        phases,
        aei_data,
        opjoin(folder, "A%i_%s_%s.res" % (asteroid_number, "_".join(planets), "_".join([str(x) for x in integers]))),
    )
    phase_cleaner.delete(resonance_id)
Example #7
0
def get_resonance_query(for_bodies: BodyNumberEnum) -> Query:
    """
    Make select query for getting two or three body resonances.
    :param for_bodies: is need for pointing the type of resonances.
    :return:
    """
    if for_bodies == BodyNumberEnum.three:
        resonance_cls = ThreeBodyResonance
    else:
        resonance_cls = TwoBodyResonance

    query = session.query(resonance_cls).options(joinedload("small_body")).join(resonance_cls.small_body)

    for i, key in enumerate(FOREIGNS):
        if i >= (for_bodies.value - 1):
            break
        planet_table = PLANET_TABLES[key]
        resonance_attr = getattr(resonance_cls, "%s_id" % key)
        query = query.join(planet_table, resonance_attr == planet_table.id).options(joinedload(key))

    return query
Example #8
0
def show_broken_bodies():
    items = session.query(BrokenAsteroid).order_by(BrokenAsteroid.name).all()
    for item in items:
        print(item.name)
Example #9
0
 def check(self):
     with session.no_autoflush:
         query = exists().where(BrokenAsteroid.name == self._asteroid_name)
         return session.query(query).scalar()
Example #10
0
def test_three_body_resonance_count(line_data: List[str], next_line_data: List[str],
                                    planets: List[Tuple], resonance_count: int,
                                    _constraint_fixture):
    _create_two_resonances(line_data, next_line_data, planets)
    assert session.query(ThreeBodyResonance).count() == resonance_count
Example #11
0
def test_planet_count(line_data: List[str], next_line_data: List[str], planets: List[Tuple],
                      planet_count: int, _constraint_fixture):
    _create_two_resonances(line_data, next_line_data, planets)
    assert session.query(Planet).count() == planet_count
Example #12
0
 def get_planets(self) -> Query:
     cols = [PLANET_TABLES[x].name.label("%s_name1" % x) for x in self._foreings]
     query = session.query(*cols).select_from(self.resonance_cls)
     query = self._add_join(query).group_by(*cols)
     return query