def start_optimize(self):
if g.showorbitcontrol is not None:
g.showorbitcontrol.close()
orgjd = float(self.ui.jdedit.text())
dialog = StartOptimizeDialog(orgjd, self)
ans = dialog.exec_()
if ans == QDialog.Rejected:
self.showorbit()
return
self.editman['time'] = dialog.result_it
self.editman['dv'] = dialog.result_dv
self.editman['phi'] = dialog.result_phi
self.editman['elv'] = dialog.result_elv
self.dispman()
self.dispSysMes(self.sysMes03)
self.showorbit()
if g.options['log']:
logstring = []
logstring.append('apply start optimize: ' + nowtimestr() + '\n')
logstring.append(' start time: ' +
common.jd2isot(dialog.result_it) + '\n')
logstring.append(' target: ' + g.mytarget.name + '\n')
logstring.append(' dv: ' + str(dialog.result_dv) + '\n')
logstring.append(' phi: ' + str(dialog.result_phi) + '\n')
logstring.append(' elv: ' + str(dialog.result_elv) + '\n')
logstring.append(' arrival time: ' +
common.jd2isot(dialog.result_tt) + '\n')
logstring.append(' flight time: ' +
str(dialog.result_tt - dialog.result_it) + '\n')
g.logfile.writelines(logstring)
g.logfile.flush()
def isotReturnPressed(self):
text = self.ui.lineEditISOT.text()
stext = text.split('.')
if len(stext) == 2:
isot = stext[0] + '.' + (stext[1] + '0000')[0:4]
elif len(stext) == 1:
isot = stext[0] + '.0000'
else:
QMessageBox.critical(self, self.mbTtl01, self.mbMes01,
QMessageBox.Ok)
return
try:
jd = common.isot2jd(isot)
except ValueError:
QMessageBox.critical(self, self.mbTtl01, self.mbMes01,
QMessageBox.Ok)
return
if jd < self.fromjd or jd >= self.tojd:
mes = self.mbMes02.format(common.jd2isot(self.fromjd),
common.jd2isot(self.tojd))
QMessageBox.critical(self, self.mbTtl02, mes, QMessageBox.Ok)
return
self.ui.lineEditISOT.setText(common.jd2isot(jd))
self.ui.lineEditJD.setText('{:.8f}'.format(jd))
if self.activateDuration:
dt = jd - g.myprobe.jd
self.ui.lineEditDuration.setText('{:.8f}'.format(dt))
def finish_clicked(self):
if self.ui.radioISOT.isChecked():
text = self.ui.lineEditISOT.text()
stext = text.split('.')
if len(stext) == 2:
isot = stext[0] + '.' + (stext[1] + '0000')[0:4]
elif len(stext) == 1:
isot = stext[0] + '.0000'
else:
QMessageBox.critical(self, self.mbTtl01, self.mbMes01,
QMessageBox.Ok)
return
try:
jd = common.isot2jd(isot)
except ValueError:
QMessageBox.critical(self, self.mbTtl01, self.mbMes01,
QMessageBox.Ok)
return
if jd < self.fromjd or jd >= self.tojd:
mes = self.mbMes02.format(common.jd2isot(self.fromjd),
common.jd2isot(self.tojd))
QMessageBox.critical(self, self.mbTtl02, mes, QMessageBox.Ok)
return
elif self.ui.radioJD.isChecked():
try:
jd = float(self.ui.lineEditJD.text())
except ValueError:
QMessageBox.critical(self, self.mbTtl01, self.mbMes03,
QMessageBox.Ok)
return
if jd < self.fromjd or jd >= self.tojd:
mes = self.mbMes04.format(self.fromjd, self.tojd)
QMessageBox.critical(self, self.mbTtl02, mes, QMessageBox.Ok)
return
elif self.ui.radioDuration.isChecked():
try:
dt = float(self.ui.lineEditDuration.text())
except ValueError:
QMessageBox.critical(self, self.mbTtl01, self.mbMes05,
QMessageBox.Ok)
return
if dt < 0.0:
QMessageBox.critical(self, self.mbTtl01, self.mbMes06,
QMessageBox.Ok)
return
jd = dt + g.myprobe.jd
if jd >= self.tojd:
mes = self.mbMes07.format(self.tojd - g.myprobe.jd)
QMessageBox.critical(self, self.mbTtl07, mes, QMessageBox.Ok)
return
self.maneuverEditor.editedjd = jd
self.accept()
def dispit(self):
fromjd = self.sl_pos2real(self.itfrom, self.itto, self.sl_minval) \
+ self.itcenter
fromdate = common.jd2isot(fromjd).split('T')[0]
self.ui.label_itfrom.setText(fromdate)
tojd = self.sl_pos2real(self.itfrom, self.itto, self.sl_maxval) \
+ self.itcenter
todate = common.jd2isot(tojd).split('T')[0]
self.ui.label_itto.setText(todate)
self.ui.initialtime.setText(common.jd2isot(self.itcurrent).split('.')[0])
def itslchanged(self, pos):
self.itcurrent = self.sl_pos2real(self.itfrom, self.itto, pos) \
+ self.itcenter
self.ui.initialtime.setText(common.jd2isot(self.itcurrent).split('.')[0])
if self.ui.radio_fd.isChecked():
self.ttcurrent = self.itcurrent + self.cduration
self.ui.terminaltime.setText(common.jd2isot(self.ttcurrent).split('.')[0])
else:
self.cduration = self.ttcurrent - self.itcurrent
self.ui.duration.setText('{:.1f}'.format(self.cduration))
self.draworbit()
def disptt(self):
if self.ui.radio_fd.isChecked():
self.ui.label_ttfrom.setText('{:.0f}'.format(self.ttfrom))
self.ui.label_ttto.setText('{:.0f}'.format(self.ttto))
else:
fromjd = self.sl_pos2real(self.ttfrom, self.ttto, self.sl_minval) \
+ self.ttcenter
fromdate = common.jd2isot(fromjd).split('T')[0]
self.ui.label_ttfrom.setText(fromdate)
tojd = self.sl_pos2real(self.ttfrom, self.ttto, self.sl_maxval) \
+ self.ttcenter
todate = common.jd2isot(tojd).split('T')[0]
self.ui.label_ttto.setText(todate)
self.ui.duration.setText('{:.1f}'.format(self.cduration))
self.ui.terminaltime.setText(common.jd2isot(self.ttcurrent).split('.')[0])
def settime(self, jd):
# this method is called from Show Orbit
self.editman[self.paramname[0]] = jd
self.ui.isotedit.setText(common.jd2isot(jd))
self.ui.jdedit.setText('{:.8f}'.format(jd))
dt = jd - g.myprobe.jd
self.ui.duration.setText('{:.8f}'.format(dt))
self.dispSysMes(self.sysMes01)
def cp_optimize(self):
if g.showorbitcontrol is not None:
g.showorbitcontrol.close()
orgjd = g.myprobe.jd
dialog = CpOptimizeDialog(orgjd, self)
ans = dialog.exec_()
if ans == QDialog.Rejected:
self.showorbit()
return
if orgjd != dialog.result_it:
mantime = common.jd2isot(dialog.result_it)
g.clipboard.setText(mantime)
mes = self.mbMes10.format(mantime)
QMessageBox.warning(self, self.mbTtl10, mes, QMessageBox.Ok)
self.editman['dv'] = dialog.result_dv
self.editman['phi'] = dialog.result_phi
self.editman['elv'] = dialog.result_elv
self.dispman()
self.dispSysMes(self.sysMes03)
self.showorbit()
if g.options['log']:
logstring = []
logstring.append('apply CP optimize: ' + nowtimestr() + '\n')
logstring.append(' fix maneuver time to current time: ' +
str(dialog.fixed_to_ct) + '\n')
logstring.append(' maneuver time: ' +
common.jd2isot(dialog.result_it) + '\n')
logstring.append(' target: ' + g.mytarget.name + '\n')
logstring.append(' dv: ' + str(dialog.result_dv) + '\n')
logstring.append(' phi: ' + str(dialog.result_phi) + '\n')
logstring.append(' elv: ' + str(dialog.result_elv) + '\n')
logstring.append(' arrival time: ' +
common.jd2isot(dialog.result_tt) + '\n')
logstring.append(' flight time: ' +
str(dialog.result_tt - dialog.result_it) + '\n')
g.logfile.writelines(logstring)
g.logfile.flush()
def enableDateTime(self, jd, duration):
self.ui.frameDT.setEnabled(True)
self.ui.label_time.setEnabled(True)
self.ui.isotedit.setText(common.jd2isot(jd))
self.ui.jdedit.setText('{:.8f}'.format(jd))
if duration:
self.ui.label_duration.setEnabled(True)
dt = jd - g.myprobe.jd
self.ui.duration.setText('{:.8f}'.format(dt))
else:
self.ui.label_duration.setEnabled(False)
self.ui.duration.setText('')
def jdReturnPressed(self):
try:
jd = float(self.ui.lineEditJD.text())
except ValueError:
QMessageBox.critical(self, self.mbTtl01, self.mbMes03,
QMessageBox.Ok)
return
if jd < self.fromjd or jd >= self.tojd:
mes = self.mbMes04.format(self.fromjd, self.tojd)
QMessageBox.critical(self, self.mbTtl02, mes, QMessageBox.Ok)
return
self.ui.lineEditISOT.setText(common.jd2isot(jd))
self.ui.lineEditJD.setText('{:.8f}'.format(jd))
if self.activateDuration:
dt = jd - g.myprobe.jd
self.ui.lineEditDuration.setText('{:.8f}'.format(dt))
def writeloglines(self):
if not g.options['log']:
return
logstring = []
logstring.append('finish maneuver editing: ' + nowtimestr() + '\n')
logstring.append(' type: ' + self.editman['type'] + '\n')
ix = self.typedict[self.editman['type']]
if self.paramflag[ix][0] == 1:
isot = common.jd2isot(self.editman['time'])
logstring.append(' time: ' + isot + '\n')
for i in range(1, 9):
if self.paramflag[ix][i] == 1:
pname = self.paramname[i]
datastr = self.fmttbl[i].format(self.editman[pname])
logstring.append(' ' + pname + ': ' + datastr + '\n')
g.logfile.writelines(logstring)
g.logfile.flush()
def redraw(self):
if g.myprobe is None:
QMessageBox.information(self, 'Info', 'You have no valid probe.',
QMessageBox.Ok)
return False
if not g.myprobe.onflight:
QMessageBox.information(self, 'Info',
'Your probe has no valid orbit.',
QMessageBox.Ok)
return False
self.jd = g.myprobe.jd
self.ui.currentdate.setText(common.jd2isot(self.jd))
self.ui.delta_t_edit.setText('{:.8f}'.format(self.delta_jd))
self.ppos = g.myprobe.pos
self.pvel = g.myprobe.vel
if self.tbpred is None:
self.tbpred = TwoBodyPred(g.myprobe.name)
erase_Ptrj()
if self.ui.check_Ptrj.isChecked():
draw_Ptrj()
self.tbpred.fix_state(self.jd, self.ppos, self.pvel)
self.tbpred.set_pred_dv(self.dv, self.phi, self.elv)
x, y, z, t = self.tbpred.points(g.ndata)
g.probe_Kepler = [x, y, z]
erase_PKepler()
if self.ui.check_PKepler.isChecked():
draw_PKepler()
xs, ys, zs, ts = g.mytarget.points(self.jd, g.ndata)
g.target_Kepler = [xs, ys, zs]
erase_TKepler()
if self.ui.check_TKepler.isChecked():
draw_TKepler()
self.ui.man_dv.setText('{:.3f}'.format(self.dv))
self.ui.man_phi.setText('{:.2f}'.format(self.phi))
self.ui.man_elv.setText('{:.2f}'.format(self.elv))
self.restore_settings()
return self._redrawmark()
def __init__(self, parent=None, orgjd=0.0, fromjd=0.0, tojd=0.0, duration=False):
super().__init__(parent)
flags = self.windowFlags() ^ Qt.WindowContextHelpButtonHint
self.setWindowFlags(flags)
self.ui = Ui_edittimedialog()
self.ui.setupUi(self)
self.ui.radioISOT.clicked.connect(self.radioclicked)
self.ui.radioJD.clicked.connect(self.radioclicked)
self.ui.radioDuration.clicked.connect(self.radioclicked)
self.ui.finishbutton.clicked.connect(self.finish_clicked)
self.ui.cancelbutton.clicked.connect(self.reject)
self.ui.lineEditISOT.returnPressed.connect(self.isotReturnPressed)
self.ui.lineEditJD.returnPressed.connect(self.jdReturnPressed)
self.ui.lineEditDuration.returnPressed.connect(self.durationReturnPressed)
self._translate = QtCore.QCoreApplication.translate
self.mbTtl01 = self._translate('editdatetime.py', 'Input Error')
self.mbMes01 = self._translate('editdatetime.py', 'Invalid ISOT')
self.mbTtl02 = self._translate('editdatetime.py', 'Inappropriate Date & Time')
self.mbMes02 = self._translate('editdatetime.py', 'ISOT is out of range.\nIn this Flight Plan, ISOT should be in following range:\n from {0}\n to {1}')
self.mbMes03 = self._translate('editdatetime.py', 'Invalid JD')
self.mbMes04 = self._translate('editdatetime.py', 'JD is out of range.\nIn this Flight Plan, JD should be in following range:\n from {0:.2f}\n to {1:.2f}')
self.mbMes05 = self._translate('editdatetime.py', 'Invalid Duration')
self.mbMes06 = self._translate('editdatetime.py', 'Duration should be positive')
self.mbTtl07 = self._translate('editdatetime.py', 'Inappropriate Duration')
self.mbMes07 = self._translate('editdatetime.py', 'Duration is too long.\nIn this case, Duration should less than {:.2f}')
self.orgjd = orgjd
self.fromjd = fromjd
self.tojd = tojd
self.activateDuration = duration
self.maneuverEditor = parent
self.ui.lineEditISOT.setText(common.jd2isot(self.orgjd))
self.ui.lineEditJD.setText('{:.8f}'.format(self.orgjd))
if self.activateDuration:
self.ui.radioDuration.setEnabled(True)
dt = self.orgjd - g.myprobe.jd
self.ui.lineEditDuration.setText('{:.8f}'.format(dt))
def redraw(self):
self.jd = self.editman['time']
self.ui.currentdate.setText(common.jd2isot(self.jd))
self.ui.delta_t_edit.setText('{:.8f}'.format(self.delta_jd))
self.ui.timescale.setValue(0)
self.ppos, self.pvel = g.myprobe.pseudostart(self.jd, 0.0, 0.0, 0.0)
self.dv = self.editman['dv']
self.phi = self.editman['phi']
self.elv = self.editman['elv']
# Check time
tsjd, tejd = g.mytarget.getsejd()
if self.jd < tsjd or self.jd >= tejd:
oormes = self.mbMes02
QMessageBox.critical(self, self.mbTtl02, oormes, QMessageBox.Ok)
return
if self.tbpred is None:
self.tbpred = TwoBodyPred(g.myprobe.name)
self.tbpred.fix_state(self.jd, self.ppos, self.pvel)
self.tbpred.set_pred_dv(self.dv, self.phi, self.elv)
x, y, z, t = self.tbpred.points(g.ndata)
g.probe_Kepler = [x, y, z]
erase_PKepler()
if self.ui.check_PKepler.isChecked():
draw_PKepler()
xs, ys, zs, ts = g.mytarget.points(self.jd, g.ndata)
g.target_Kepler = [xs, ys, zs]
erase_TKepler()
if self.ui.check_TKepler.isChecked():
draw_TKepler()
self.ui.man_dv.setText('{:.3f}'.format(self.dv))
self.ui.man_phi.setText('{:.2f}'.format(self.phi))
self.ui.man_elv.setText('{:.2f}'.format(self.elv))
self.restore_settings()
self._redrawmark()
def durationReturnPressed(self):
try:
dt = float(self.ui.lineEditDuration.text())
except ValueError:
QMessageBox.critical(self, self.mbTtl01, self.mbMes05,
QMessageBox.Ok)
return
if dt < 0.0:
QMessageBox.critical(self, self.mbTtl01, self.mbMes06,
QMessageBox.Ok)
return
jd = dt + g.myprobe.jd
if jd >= self.tojd:
mes = self.mbMes07.format(self.tojd - g.myprobe.jd)
QMessageBox.critical(self, self.mbTtl07, mes, QMessageBox.Ok)
return
self.ui.lineEditISOT.setText(common.jd2isot(jd))
self.ui.lineEditJD.setText('{:.8f}'.format(jd))
if self.activateDuration:
dt = jd - g.myprobe.jd
self.ui.lineEditDuration.setText('{:.8f}'.format(dt))
def redraw(self):
if g.myprobe is None:
QMessageBox.information(self, 'Info', 'You have no valid probe.',
QMessageBox.Ok)
return
if not g.myprobe.onflight:
QMessageBox.information(self, 'Info',
'Your probe has no valid orbit.',
QMessageBox.Ok)
return
if g.myprobe.trj_record[-1][0]['type'] != 'FLYTO':
QMessageBox.information(self, 'Info',
'Last maneuver was not FLYTO.',
QMessageBox.Ok)
return
self.last_trj = g.probe_trj[-1][1:]
self.maninfo = g.probe_trj[-1][0]
self.start_time = self.last_trj[0][0]
self.ui.starttime.setText(common.jd2isot(self.start_time))
xs, ys, zs, ts = g.mytarget.points(self.start_time, g.ndata)
g.target_Kepler = [xs, ys, zs]
erase_Ptrj()
if self.ui.check_Ptrj.isChecked():
draw_Ptrj()
erase_TKepler()
if self.ui.check_TKepler.isChecked():
draw_TKepler()
self._redrawmark()
self.ui.sysMessage.appendPlainText(self.sysMes01)
self.ui.sysMessage.appendPlainText(self.sysMes02.format(g.nextman))
self.ui.sysMessage.centerCursor()
def _redrawmark(self):
tempjd = self.jd + self.delta_jd
self.ui.preddate.setText(common.jd2isot(tempjd))
if self.artist_of_probe is not None:
self.artist_of_probe.remove()
self.artist_of_probe = None
if self.artist_of_target is not None:
self.artist_of_target.remove()
self.artist_of_target = None
if self.artist_of_sun is not None:
self.artist_of_sun.remove()
self.artist_of_sun = None
remove_planets()
remove_time()
# Check time
tsjd, tejd = g.mytarget.getsejd()
if tempjd < tsjd or tempjd >= tejd:
self.dispSysMes(self.sysMes04)
self.unableDrawMark = True
return False
try:
probe_pos, probe_vel = self.tbpred.posvelatt(tempjd)
except RuntimeError:
self.dispSysMes(self.sysMes05)
self.unableDrawMark = True
return False
if self.unableDrawMark:
self.dispSysMes(self.sysMes06)
self.unableDrawMark = False
self.target_pos, target_vel = g.mytarget.posvel(tempjd)
sunpos = common.SPKkernel[0, 10].compute(tempjd)
self.sun_pos = common.eqn2ecl(sunpos) * 1000.0
xlim = g.ax.get_xlim3d()
hw = (xlim[1] - xlim[0]) * 0.5
if self.ui.tobarycenter.isChecked():
cent = [0.0, 0.0, 0.0]
elif self.ui.toprobe.isChecked():
cent = probe_pos
else:
cent = self.target_pos
g.ax.set_xlim3d(cent[0] - hw, cent[0] + hw)
g.ax.set_ylim3d(cent[1] - hw, cent[1] + hw)
g.ax.set_zlim3d(cent[2] - hw, cent[2] + hw)
self.artist_of_probe = g.ax.scatter(*probe_pos,
s=40,
c='r',
depthshade=False,
marker='x')
self.artist_of_target = g.ax.scatter(*self.target_pos,
s=50,
c='g',
depthshade=False,
marker='+')
self.artist_of_sun = g.ax.scatter(*self.sun_pos,
s=50,
c='#FFAF00',
depthshade=False,
marker='o')
# redraw planets
if self.ui.showplanets.isChecked():
replot_planets(tempjd)
if self.delta_jd == 0.0:
replot_time(tempjd, self.timecap_Real)
else:
replot_time(tempjd, self.timecap_Pred)
if g.fig is not None: plt.draw()
# display relative position and velocity
rel_pos = self.target_pos - probe_pos
rel_pos = common.eclv2lv(rel_pos, probe_pos, probe_vel,
self.tbpred.sunpos, self.tbpred.sunvel)
trange, tphi, telv = common.rect2polar(rel_pos)
rel_vel = target_vel - probe_vel
rel_vel = common.eclv2lv(rel_vel, probe_pos, probe_vel,
self.tbpred.sunpos, self.tbpred.sunvel)
relabsvel, tvphi, tvelv = common.rect2polar(rel_vel)
losvel = np.dot(rel_vel, rel_pos) / trange
self.ui.RPTrange.setText('{:.3f}'.format(trange / 1000.0))
self.ui.RPTphi.setText('{:.2f}'.format(tphi))
self.ui.RPTelv.setText('{:.2f}'.format(telv))
self.ui.RVTvel.setText('{:.3f}'.format(relabsvel))
self.ui.RVTphi.setText('{:.2f}'.format(tvphi))
self.ui.RVTelv.setText('{:.2f}'.format(tvelv))
self.ui.LoSVvel.setText('{:.3f}'.format(losvel))
return True
def exec_man(self, man, target, pbar=None, plabel=None, ptext=''):
if man['type'] != 'START' and not self.onflight:
return False, self.errormes06.format(man['type'])
if man['type'] == 'START' and self.onflight:
return False, self.errormes07.format(man['type'])
cman = man.copy()
cman['epon'] = False
cman['epdvpd'] = 0.0
cman['epmode'] = 'L'
cman['sson'] = False
cman['ssmode'] = 'L'
status = np.zeros(7)
tsjd, tejd = target.getsejd()
if man['type'] == 'START':
self.jd = man['time']
if self.jd < tsjd or self.jd >= tejd:
return False, self.errormes05
self.pos, self.vel = self.pseudostart(self.jd, dv=man['dv'],
elv=man['elv'], phi=man['phi'])
self.orbit.setCurrentCart(self.jd*common.secofday, self.pos,
self.vel)
self.onflight = True
status[0] = self.jd
status[1:4] = self.pos.copy()
status[4:] = self.vel.copy()
self.get_epssstatus(cman)
self.trj_record.append([cman, status])
return True, ''
elif man['type'] == 'CP':
dv = man['dv']
elv = math.radians(man['elv'])
phi = math.radians(man['phi'])
ldv = np.array([ \
dv * np.cos(elv) * np.cos(phi), \
dv * np.cos(elv) * np.sin(phi), \
dv * np.sin(elv) \
])
sunpos, sunvel = common.SPKposvel(10, self.jd)
self.vel += common.ldv2ecldv(ldv, self.pos, self.vel, sunpos,
sunvel)
self.orbit.setCurrentCart(self.jd*common.secofday, self.pos,
self.vel)
status[0] = self.jd
status[1:4] = self.pos.copy()
status[4:] = self.vel.copy()
self.get_epssstatus(cman)
self.trj_record.append([cman, status])
self.accumdv['CP'] += dv
return True, ''
elif man['type'] == 'EP_ON':
dv = man['dvpd'] / common.secofday
phi = math.radians(man['phi'])
elv = math.radians(man['elv'])
self.orbit.set_epstatus(True, dv, phi, elv, man['tvmode'],
common.SPKkernel)
status[0] = self.jd
status[1:4] = self.pos.copy()
status[4:] = self.vel.copy()
self.get_epssstatus(cman)
self.trj_record.append([cman, status])
return True, ''
elif man['type'] == 'EP_OFF':
self.orbit.set_epstatus(False, 0.0, 0.0, 0.0)
status[0] = self.jd
status[1:4] = self.pos.copy()
status[4:] = self.vel.copy()
self.get_epssstatus(cman)
self.trj_record.append([cman, status])
return True, ''
elif man['type'] == 'SS_ON':
area = man['area']
theta = math.radians(man['theta'])
elv = math.radians(man['elv'])
self.orbit.set_ssstatus(True, area, theta, elv, man['tvmode'],
common.SPKkernel)
status[0] = self.jd
status[1:4] = self.pos.copy()
status[4:] = self.vel.copy()
self.get_epssstatus(cman)
self.trj_record.append([cman, status])
return True, ''
elif man['type'] == 'SS_OFF':
self.orbit.set_ssstatus(False, 0.0, 0.0, 0.0)
status[0] = self.jd
status[1:4] = self.pos.copy()
status[4:] = self.vel.copy()
self.get_epssstatus(cman)
self.trj_record.append([cman, status])
return True, ''
elif man['type'] == 'FLYTO':
jdto = man['time']
if jdto < self.jd:
return False, self.errormes01
if jdto >= tejd:
return False, self.errormes02
duration = jdto - self.jd
if pbar is not None:
pbar.setVisible(True)
pbar.setValue(0)
plabel.setText(ptext)
inter = man['inter'] * common.secofday
secto = jdto * common.secofday
pt, px, py, pz, pxd, pyd, pzd, ssdvpd, runerror = self.orbit.trj(
secto, inter, common.SPKkernel, common.planets_grav,
common.planets_mu, common.integ_abs_tol, common.integ_rel_tol,
pbar)
if pbar is not None:
pbar.setVisible(False)
plabel.setText('')
if runerror:
lastsuccess = 0.0
length = len(pt)
for i in range(length):
if pt[i] < 1.0: break
lastsuccess = pt[i]
lastsuccess = lastsuccess / common.secofday
return False, self.errormes04.format(common.jd2isot(lastsuccess))
pt = pt / common.secofday
self.get_epssstatus(cman)
self.trj_record.append([cman, pt, px, py, pz, pxd, pyd, pzd,
ssdvpd])
self.jd = pt[-1]
self.pos = np.array([px[-1], py[-1], pz[-1]])
self.vel = np.array([pxd[-1], pyd[-1], pzd[-1]])
self.orbit.setCurrentCart(self.jd*common.secofday, self.pos,
self.vel)
if cman['epon']:
self.accumdv['EP'] += duration * cman['epdvpd']
if cman['sson']:
ssdv = man['inter'] * ssdvpd[0]
for i in range(1, len(pt)):
ssdv += (pt[i] -pt[i-1]) * ssdvpd[i]
self.accumdv['SS'] += ssdv
return True, ''
else:
return False, self.errormes03.format(man['type'])
def replot_time(jd, ttype=''):
s = common.jd2isot(jd) + ' (' + ttype + ')'
g.artist_of_time = g.ax.text2D(0.02, 0.96, s, transform=g.ax.transAxes)
def drawFLYTO(self):
c_time = self.last_trj[0][self.c_index]
delta_jd = c_time - self.start_time
self.ui.currenttime.setText(common.jd2isot(c_time))
self.ui.delta_t_edit.setText('{:.8f}'.format(delta_jd))
ppos = np.zeros(3)
pvel = np.zeros(3)
ppos[0] = self.last_trj[1][self.c_index]
ppos[1] = self.last_trj[2][self.c_index]
ppos[2] = self.last_trj[3][self.c_index]
pvel[0] = self.last_trj[4][self.c_index]
pvel[1] = self.last_trj[5][self.c_index]
pvel[2] = self.last_trj[6][self.c_index]
ssacc = self.last_trj[7][self.c_index]
self.savedstatus[0] = np.copy(c_time)
self.savedstatus[1:4] = np.copy(ppos)
self.savedstatus[4:7] = np.copy(pvel)
erase_PKepler()
if self.ui.check_PKepler.isChecked():
self.tbpred.fix_state(c_time, ppos, pvel)
x, y, z, t = self.tbpred.points(g.ndata_s)
g.probe_Kepler = [x, y, z]
draw_PKepler()
target_pos, target_vel = g.mytarget.posvel(c_time)
sun_pos, sun_vel = common.SPKposvel(10, c_time)
xlim = g.ax.get_xlim3d()
hw = (xlim[1] - xlim[0]) * 0.5
if self.ui.tobarycenter.isChecked():
cent = [0.0, 0.0, 0.0]
elif self.ui.toprobe.isChecked():
cent = ppos
else:
cent = target_pos
g.ax.set_xlim3d(cent[0]-hw, cent[0]+hw)
g.ax.set_ylim3d(cent[1]-hw, cent[1]+hw)
g.ax.set_zlim3d(cent[2]-hw, cent[2]+hw)
# redraw planets
remove_planets()
if self.ui.showplanets.isChecked():
replot_planets(c_time)
if self.artist_of_probe is not None:
self.artist_of_probe.remove()
self.artist_of_probe = None
self.artist_of_probe = g.ax.scatter(*ppos, s=40, c='r',
depthshade=False, marker='x')
if self.artist_of_target is not None:
self.artist_of_target.remove()
self.artist_of_target = None
# Maneuver Type
if self.artist_of_type is not None:
self.artist_of_type.remove()
self.artist_of_type = None
if self.ui.showmantype.isChecked():
acctext = ''
if self.c_maninfo['sson']:
acctext = ' SSacc={:.3f}'.format(ssacc)
if self.c_index == 0:
self.artist_of_type = g.ax.text(*ppos, self.mantext+acctext+
' (start)', color='r', fontsize=10)
elif self.c_index + 1 == len(self.last_trj[0]):
self.artist_of_type = g.ax.text(*ppos, self.mantext+acctext+
' (end)', color='r', fontsize=10)
else:
self.artist_of_type = g.ax.text(*ppos, self.mantext+acctext,
color='r', fontsize=10)
self.artist_of_target = g.ax.scatter(*target_pos, s=50, c='g',
depthshade=False, marker='+')
if self.artist_of_sun is not None:
self.artist_of_sun.remove()
self.artist_of_sun = None
self.artist_of_sun = g.ax.scatter(*sun_pos, s=50, c='#FFAF00',
depthshade=False, marker='o')
remove_time()
replot_time(c_time, self.timecap_real)
if g.fig is not None: plt.draw()
# display relative position and velocity
rel_pos = target_pos - ppos
rel_pos = common.eclv2lv(rel_pos, ppos, pvel, sun_pos, sun_vel)
trange, tphi, telv = common.rect2polar(rel_pos)
rel_vel = target_vel - pvel
rel_vel = common.eclv2lv(rel_vel, ppos, pvel, sun_pos, sun_vel)
relabsvel, tvphi, tvelv = common.rect2polar(rel_vel)
losvel = np.dot(rel_vel, rel_pos) / trange
self.ui.RPTrange.setText('{:.3f}'.format(trange / 1000.0))
self.ui.RPTphi.setText('{:.2f}'.format(tphi))
self.ui.RPTelv.setText('{:.2f}'.format(telv))
self.ui.RVTvel.setText('{:.3f}'.format(relabsvel))
self.ui.RVTphi.setText('{:.2f}'.format(tvphi))
self.ui.RVTelv.setText('{:.2f}'.format(tvelv))
self.ui.LoSVvel.setText('{:.3f}'.format(losvel))
def drawman(self):
record = g.myprobe.trj_record[self.man_index]
mantype = record[0]['type']
self.c_maninfo = record[0]
self.c_mantype = mantype
self.mantext = ' ' + str(self.man_index + 1) + ' ' + mantype
status = np.zeros(7)
self.ui.sysMessage.appendPlainText(self.sysMes02.format(self.c_mantype, self.man_index+1))
self.ui.sysMessage.centerCursor()
if mantype == 'FLYTO':
status[0] = record[1][0]
status[1] = record[2][0]
status[2] = record[3][0]
status[3] = record[4][0]
status[4] = record[5][0]
status[5] = record[6][0]
status[6] = record[7][0]
ssacc = record[8][0]
self.last_trj = record[1:]
if self.fromNextman:
self.c_index = len(self.last_trj[0]) - 1
self.ui.fastbackward.setEnabled(True)
self.ui.backward.setEnabled(True)
self.ui.forward.setEnabled(False)
self.ui.fastforward.setEnabled(False)
else:
self.c_index = 0
self.ui.fastbackward.setEnabled(False)
self.ui.backward.setEnabled(False)
self.ui.forward.setEnabled(True)
self.ui.fastforward.setEnabled(True)
self.ui.timescale.setEnabled(True)
self.ui.label_2.setEnabled(True)
if self.c_maninfo['epon']:
self.mantext = self.mantext + ' EP(' + \
self.c_maninfo['epmode'] + ')'
if self.c_maninfo['sson']:
self.mantext = self.mantext + ' SS(' + \
self.c_maninfo['ssmode'] + ')'
else:
status = record[1]
self.ui.fastbackward.setEnabled(False)
self.ui.backward.setEnabled(False)
self.ui.forward.setEnabled(False)
self.ui.fastforward.setEnabled(False)
self.ui.timescale.setEnabled(False)
self.ui.label_2.setEnabled(False)
self.savedstatus = np.copy(status)
if mantype == 'START':
self.ui.starttime.setText(common.jd2isot(record[1][0]))
self.start_time = status[0]
target_pos, target_vel = g.mytarget.posvel(status[0])
erase_Ptrj()
if self.ui.check_Ptrj.isChecked():
draw_Ptrj()
# Kepler Orbit of target
xs, ys, zs, ts = g.mytarget.points(status[0], g.ndata)
g.target_Kepler = [xs, ys, zs]
erase_TKepler()
if self.ui.check_TKepler.isChecked():
draw_TKepler()
self.mainwindow.ui.manplans.selectRow(self.man_index)
if mantype == 'FLYTO':
self.drawFLYTO()
return
# adjust center of image
xlim = g.ax.get_xlim3d()
hw = (xlim[1] - xlim[0]) * 0.5
if self.ui.tobarycenter.isChecked():
cent = [0.0, 0.0, 0.0]
elif self.ui.toprobe.isChecked():
cent = status[1:4]
else:
cent = target_pos
g.ax.set_xlim3d(cent[0]-hw, cent[0]+hw)
g.ax.set_ylim3d(cent[1]-hw, cent[1]+hw)
g.ax.set_zlim3d(cent[2]-hw, cent[2]+hw)
# Kepler Orbit of probe
erase_PKepler()
if self.ui.check_PKepler.isChecked():
self.tbpred.fix_state(status[0], status[1:4], status[4:])
x, y, z, t = self.tbpred.points(g.ndata)
g.probe_Kepler = [x, y, z]
if self.ui.check_PKepler.isChecked():
draw_PKepler()
# Planets
remove_planets()
if self.ui.showplanets.isChecked():
replot_planets(status[0])
# Probe mark
if self.artist_of_probe is not None:
self.artist_of_probe.remove()
self.artist_of_probe = None
self.artist_of_probe = g.ax.scatter(*status[1:4], s=40, c='r',
depthshade=False, marker='x')
# Maneuver Type
if self.artist_of_type is not None:
self.artist_of_type.remove()
self.artist_of_type = None
if self.ui.showmantype.isChecked():
self.artist_of_type = g.ax.text(*status[1:4], self.mantext,
color='r', fontsize=10)
# Target mark
if self.artist_of_target is not None:
self.artist_of_target.remove()
self.artist_of_target = None
self.artist_of_target = g.ax.scatter(*target_pos, s=50, c='g',
depthshade=False, marker='+')
# Sun mark
if self.artist_of_sun is not None:
self.artist_of_sun.remove()
self.artist_of_sun = None
sun_pos, sun_vel = common.SPKposvel(10, status[0])
self.artist_of_sun = g.ax.scatter(*sun_pos, s=50, c='#FFAF00',
depthshade=False, marker='o')
# time
remove_time()
replot_time(status[0], self.timecap_real)
if g.fig is not None: plt.draw()
# display relative position and velocity, and time
rel_pos = target_pos - status[1:4]
rel_pos = common.eclv2lv(rel_pos, status[1:4], status[4:], sun_pos,
sun_vel)
trange, tphi, telv = common.rect2polar(rel_pos)
rel_vel = target_vel - status[4:]
rel_vel = common.eclv2lv(rel_vel, status[1:4], status[4:], sun_pos,
sun_vel)
relabsvel, tvphi, tvelv = common.rect2polar(rel_vel)
losvel = np.dot(rel_vel, rel_pos) / trange
self.ui.RPTrange.setText('{:.3f}'.format(trange / 1000.0))
self.ui.RPTphi.setText('{:.2f}'.format(tphi))
self.ui.RPTelv.setText('{:.2f}'.format(telv))
self.ui.RVTvel.setText('{:.3f}'.format(relabsvel))
self.ui.RVTphi.setText('{:.2f}'.format(tvphi))
self.ui.RVTelv.setText('{:.2f}'.format(tvelv))
self.ui.LoSVvel.setText('{:.3f}'.format(losvel))
delta_jd = status[0] - self.start_time
self.ui.currenttime.setText(common.jd2isot(status[0]))
self.ui.delta_t_edit.setText('{:.8f}'.format(delta_jd))