def compute_resonance(pl,
resonances,
beta,
safe_distance,
used_resos,
reso_dts,
rvt_outs,
rvt_ins,
rvt_pls,
dvs,
resos=None):
rvt_in = rvt_ins[-1] # current spaceship
rvt_pl = rvt_pls[-1] # current planet
reso = resonance(pl, rvt_in, rvt_pl, resonances)
reso_dt, used_reso = reso.select_resonance(beta, safe_distance)
if not resos is None:
resos.append(reso)
used_resos.append(used_reso)
reso_dts.append(reso_dt)
rvt_outs.append(reso._rvt_out)
tof = reso.tof()
time2 = reso._time + tof
rvt_pl2 = rvt_planet(pl, time2)
rvt_pls.append(rvt_pl2)
rvt_in2 = rvt(
rvt_pl2._r, reso._rvt_out._v, time2,
rvt_pl2._mu) # its a resonance, we arrive with same v as we started
rvt_ins.append(rvt_in2)
dvs.append(0) # # its a resonance, we don't need an impulse
def _dv_mga(pl1,
pl2,
tof,
max_revs,
rvt_outs,
rvt_ins,
rvt_pls,
dvs,
lps=None):
rvt_pl = rvt_pls[-1] # current planet
v_in = rvt_pl._v if rvt_ins[-1] is None else rvt_ins[-1]._v
rvt_pl2 = rvt_planet(pl2, rvt_pl._t + tof)
rvt_pls.append(rvt_pl2)
r = rvt_pl._r
vpl = rvt_pl._v
r2 = rvt_pl2._r
lp = lambert_problem(r, r2, tof, rvt_pl._mu, False, max_revs)
lp = lambert_problem_multirev_ga(v_in, lp, pl1, vpl)
if not lps is None:
lps.append(lp)
v_out = lp.get_v1()[0]
rvt_out = rvt(r, v_out, rvt_pl._t, rvt_pl._mu)
rvt_outs.append(rvt_out)
rvt_in = rvt(r2, lp.get_v2()[0], rvt_pl._t + tof, rvt_pl._mu)
rvt_ins.append(rvt_in)
vr_in = [a - b for a, b in zip(v_in, vpl)]
vr_out = [a - b for a, b in zip(v_out, vpl)]
dv = fb_vel(vr_in, vr_out, pl1)
dvs.append(dv)
def _compute_dvs(
self,
x: List[float],
lps=None,
resos=None
) -> Tuple[List[Any], List[Any], List[Any], List[float], List[float], ]:
t0 = x[0] * DAY2SEC # only direct encoding
tof01 = x[1] * DAY2SEC
tof23 = x[2] * DAY2SEC
tof34 = x[3] * DAY2SEC
betas = x[4:]
rvt_outs = []
rvt_ins = [None] # no rvt_in at first planet
rvt_pls = []
dvs = []
used_resos = []
reso_dts = []
rvt_pls.append(rvt_planet(self._seq[0], t0))
_dv_mga(self._seq[0], self._seq[1], tof01, self._max_revs, rvt_outs,
rvt_ins, rvt_pls, dvs, lps)
compute_resonance(self._seq[1], self._resonances[0], betas[0],
self._safe_distance, used_resos, reso_dts, rvt_outs,
rvt_ins, rvt_pls, dvs, resos)
_dv_mga(self._seq[2], self._seq[3], tof23, self._max_revs, rvt_outs,
rvt_ins, rvt_pls, dvs, lps)
_dv_mga(self._seq[3], self._seq[4], tof34, self._max_revs, rvt_outs,
rvt_ins, rvt_pls, dvs, lps)
for i in range(1, 6):
compute_resonance(self._seq[i + 3], self._resonances[i], betas[i],
self._safe_distance, used_resos, reso_dts,
rvt_outs, rvt_ins, rvt_pls, dvs, resos)
n = len(rvt_ins)
assert len(rvt_outs) == n - 1
assert len(rvt_pls) == n
assert len(rvt_ins) == n
assert len(dvs) == n - 1
return rvt_outs, rvt_ins, rvt_pls, reso_dts, dvs