def get_dependencies_sc(self, a_sc): """ Get the s/c on which a_sc depends on (e.g. one of its trajectories depend on another s/c's given trajectory. :param a_sc: the s/c to which query all its dependencies s/cs. :return: str """ sonet_log(SonetLogType.INFO, 'SonetCanvasQt.get_dependencies_sc') res = {} # It can be a list of one or two filters (e.g. Earth-Mars, or E-M + Mars-Earth). the_filters = a_sc.get_filter(p_get_list=True) for f in the_filters: # Get the ComplexDate filter (only consider activated ones). data = SonetTrajectoryFilter._get_activated_filters_of_a_given_type(f.get_data(), True, 'ComplexDate') n = len(data) # LESSON LEARNED: if you put len(data) inside range(), strange things happen. :S if n: data = data.to_list() for row in range(n): # Add all the ComplexDate filters (aka rows) of this filter. complex_date_filter = data[row] dependency_name = complex_date_filter[6] dependency_payload = self.get_sc_payload(database.get_spacecraft(dependency_name)) my_trip = TripType.convert_to_str(f.get_trip_type()) dependency_trip = complex_date_filter[7] dependency_type = self.get_dependency_type(my_trip, dependency_trip) res[dependency_name] = dependency_payload + ' ' + dependency_type return res
def clicked_view_mission(self): sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_view_mission') # self.statusbar.showMessage('Not yet implemented :).', SONET_MSG_TIMEOUT) # self.statusbar.showMessage('Drawing the mission...', 1000) self.canvas_window = SonetCanvasQt(mw=self) self.canvas_window.init()
def get_trajectory_selection_status(self): """ Getter method. Returns the current trajectory selection status: 0 if no trajectory is selected. 0.5 if 1 out of 2 trajectories are selected (for two-way spacecrafts). 1 if all the trajectories are selected. :return: 0, 0.5, or 1. """ if self._has_return_trajectory: # Two-way s/c. A = (self._trajectory1 is None) and (self._trajectory2 is None) B = (self._trajectory1 is None) or (self._trajectory2 is None) C = isinstance(self._trajectory1, pd.Series) and isinstance(self._trajectory2, pd.Series) if A: return 0 elif C: return 1 elif B: return 0.5 else: sonet_log(SonetLogType.ERROR, 'SonetSpacecraft.get_trajectory_selection_status."Wrong trajectory type"') return else: # One-way s/c. if self._trajectory is None: return 0 elif isinstance(self._trajectory, pd.Series): return 1 else: sonet_log(SonetLogType.ERROR, 'SonetSpacecraft.get_trajectory_selection_status."Wrong trajectory type"') return
def set_trajectory(self, a_trajectory=None, a_index=False, a_is_incoming_trajectory=False): """ Setter method. Sets the trajectories fields for a given s/c, the a_is_incoming_trajectory paramenter controls whether we are setting the outgoing or incoming trajectory, in case the s/c has both. It's a bit weird but... @param a_is_incoming_trajectory: flag to control which trajectory are we setting. @param a_trajectory: Pandas Series representing a pcp row. @param a_index: the position of the pcp row. """ # Check. if not (isinstance(a_trajectory, pd.Series) or isinstance(a_trajectory, list) or (a_index != None)): if a_trajectory is None: sonet_log(SonetLogType.INFO, 'SonetSpacecraft.set_trajectory."No trajectory selected"') self._p_main_window.statusbar.showMessage('No trajectory selected.', SONET_MSG_TIMEOUT) return else: sonet_log(SonetLogType.ERROR, 'SonetSpacecraft.set_trajectory."Wrong trajectory type"') self._p_main_window.statusbar.showMessage('UUups. Internal error, check debug log.') return False if self._has_return_trajectory: # Two-way s/c. if a_is_incoming_trajectory: self._trajectory2 = a_trajectory self._trajectory2_index = a_index else: self._trajectory1 = a_trajectory self._trajectory1_index = a_index else: # One-way s/c. self._trajectory = a_trajectory self._trajectory_index = a_index return True
def clicked_select_trajectory(self, p_called_from_pcp_viewer=False, p_pcp_viewer_selected_trajectory=None, p_idx=None): """ Gets the current selection for the current selected s/c and stores it inside the s/c. If no selection, displays a msg in the main window status bar. It also informs to the user, by updating the relevant widgets. Update: Refactored to include also the possibility to be called from clicked_pcp_viewer. Update: Refactored to include also the possibility to be called by passing directly the df index. """ sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_select_trajectory') # Get the current selected s/c. idx = self.sonet_mission_tree_qlv.currentIndex().row() sc = self._list_model.get_spacecraft(a_row=idx) # Check if sc is None: sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_select_trajectory."No s/c selected"') self.statusbar.showMessage('No s/c selected.', SONET_MSG_TIMEOUT) return False # Set the selected trajectory within the s/c. the_selected_trajectory: pd.Series the_selected_trajectory, idx, is_incoming_trajectory = self.get_selected_trajectory(p_called_from_pcp_viewer, p_pcp_viewer_selected_trajectory, p_idx=p_idx) sc.set_trajectory(the_selected_trajectory, idx, a_is_incoming_trajectory=is_incoming_trajectory) # Update the trajectory label & progress bar. status = sc.get_trajectory_selection_status() self.update_trajectory_label_and_progress_bar(status) force_table_view_update() # Force focus on main window. self.raise_()
def clicked_unselect_trajectory(self): """ Gets the current selected s/c and resets its selected trajectory, if any. If no selection, displays a msg in the main window status bar. It also informs to the user, by updating the relevant widgets. """ sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_unselect_trajectory') # Get the current selected s/c. index = self.sonet_mission_tree_qlv.currentIndex().row() sc = self._list_model.get_spacecraft(a_row=index) # Check if sc is None: sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_unselect_trajectory."No s/c selected"') self.statusbar.showMessage('No s/c selected.', SONET_MSG_TIMEOUT) return # Reset the selected trajectory, if any. sc.reset_trajectory(p_all_trajectories=False, p_trajectory=self.sonet_pcp_tabs_qtw.currentIndex()) # Update the trajectory label & progress bar. status = sc.get_trajectory_selection_status() self.update_trajectory_label_and_progress_bar(status) force_table_view_update() # Force focus on main window. self.raise_()
def set_filters(self): """ Method for constructing a SonetSpacecraft object. The spacecraft has one filter per trajectory. TODO: Bad practice - defining instance attributes outside the class constructor. :return: True if everything was ok, false otherwise. """ sonet_log(SonetLogType.INFO, 'SonetSpacecraft.set_filters') has_return_trajectory = self._has_return_trajectory # Type check. if not isinstance(has_return_trajectory, bool): return False if has_return_trajectory: # Two way trip. self._pcp_filter1 = SonetTrajectoryFilter(self, TripType.OUTGOING) self._pcp_filter2 = SonetTrajectoryFilter(self, TripType.INCOMING) self._trajectory1 = None self._trajectory2 = None self._trajectory1_index = QModelIndex() self._trajectory2_index = QModelIndex() else: # One way trip. self._pcp_filter = SonetTrajectoryFilter(self, TripType.OUTGOING) self._trajectory = None self._trajectory_index = QModelIndex() return True
def get_trajectory_selected(self, p_get_trajectories=False): """ Returns a list with the current selected trajectories. @return: ['Earth - Mars'] or ['Earth - Mars', 'Mars - Earth'] :rtype: list """ sonet_log(SonetLogType.INFO, 'SonetSpacecraft.get_trajectory_selected') if p_get_trajectories: the_selected_trajectories = {} else: the_selected_trajectories = [] if self._has_return_trajectory: # Two-way s/c. if self._trajectory1 is not None: if p_get_trajectories: the_selected_trajectories['Earth - Mars'] = self._trajectory1 else: the_selected_trajectories.append('Earth - Mars') if self._trajectory2 is not None: if p_get_trajectories: the_selected_trajectories['Mars - Earth'] = self._trajectory2 else: the_selected_trajectories.append('Mars - Earth') else: # One-way s/c. if self._trajectory is not None: if p_get_trajectories: the_selected_trajectories['Earth - Mars'] = self._trajectory else: the_selected_trajectories.append('Earth - Mars') return the_selected_trajectories
def get_filter_data(self, p_get_dataframe_copy=False): """ Getter method. It's not the same to return a dataframe and a dataframe.copy(). get_dataframe_copy controls if we are getting the pointers to the original dataframes or copies of them. - If I return a dataframe, I am returning a pointer to the original dataframe, so all modifications are going to affect to the original dataframe. - If I return a dataframe copy, I am returning a new dataframe, so all modifications are not going to affect to the original dataframe. :param p_get_dataframe_copy: bool representing if we want original dataframes or copies. :return: a pandas dataframe or a list of them. :rtype: DataFrame :rtype: list """ # Type check. if not isinstance(self._has_return_trajectory, bool): sonet_log(SonetLogType.ERROR, 'SonetSpacecraft.get_filter_data."Bad constructed S/C"') return False # _has_return_trajectory should be bool, if not, there's some error. if self._has_return_trajectory: # If there are both outgoing and incoming trajectories, we return a list with both filter's dataframes. if p_get_dataframe_copy: return [self._pcp_filter1.get_data().copy(), self._pcp_filter2.get_data().copy()] else: return [self._pcp_filter1.get_data(), self._pcp_filter2.get_data()] else: # In case the spacecraft has no return trajectory, we just get the filter dataframe of the outgoing one. if p_get_dataframe_copy: return self._pcp_filter.get_data().copy() else: return self._pcp_filter.get_data()
def get_sc_payload(self, a_sc): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.get_sc_payload') sc_payload = SpacecraftType.get_str(a_sc.get_type()) # Add a '*' if the s/c has also Earth-Mars trajectory. if a_sc.get_has_return_trajectory(): sc_payload = sc_payload + '*' return sc_payload
def reset_model(self): """ Reset the table model. """ sonet_log(SonetLogType.INFO, 'TableModel.reset_model') self.beginResetModel() self._data = None self.endResetModel() return True
def expand_tree_widget(self, p_tw='All'): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.expand_tree_widget') # For the selected tree widgets. tree_widgets = self.get_tree_widgets(p_tw) # Expand their items. for tw in tree_widgets: for item in SonetCanvasQt.iter_tree_widget(tw): item.setExpanded(True)
def resize_columns_to_contents(self, p_tw='All'): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.resize_columns_to_contents') # For the selected tree widgets. tree_widgets = self.get_tree_widgets(p_tw) # Resize their columns to the contents. for tw in tree_widgets: n_cols = tw.columnCount() for col in range(n_cols): tw.resizeColumnToContents(col)
def fill_tree_widget_sc_info(self, a_sc: SonetSpacecraft): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.fill_tree_widget_sc_info') self.treeW_sc_info_filter.setHeaderLabels(['S/C', '']) tw_item_sc = QTreeWidgetItem(self.treeW_sc_info_filter, [a_sc.get_name(), self.get_sc_payload(a_sc)]) tw_item_sc_dependencies = QTreeWidgetItem(tw_item_sc, ['Dependencies', '']) self.fill_dependencies(tw_item_sc_dependencies, a_sc) tw_item_sc_dependents = QTreeWidgetItem(tw_item_sc, ['Dependents', '']) self.fill_dependents(tw_item_sc_dependents, a_sc)
def fill_dependents(self, a_tw_dependents_root, a_sc): """ Add the items which depend on a_sc. :param a_tw_dependents_root: dependents item root. :param a_sc: s/c """ sonet_log(SonetLogType.INFO, 'SonetCanvasQt.fill_dependents') sc_dependents = self.get_dependents_sc(a_sc) for dependent in sc_dependents: new_item = QTreeWidgetItem(a_tw_dependents_root, [dependent, sc_dependents.get(dependent)])
def fill_dependencies(self, a_tw_dependencies_root, a_sc): """ Add the items which a_sc depends on. :param a_tw_dependencies_root: dependencies item root. :param a_sc: s/c """ sonet_log(SonetLogType.INFO, 'SonetCanvasQt.fill_dependencies') sc_dependencies = self.get_dependencies_sc(a_sc) for dependency in sc_dependencies: new_item = QTreeWidgetItem(a_tw_dependencies_root, [dependency, sc_dependencies.get(dependency)])
def __init__(self, a_spacecraft_name=None, a_spacecraft_type_crew=None, a_spacecraft_type_return=None, ap_main_window=None): sonet_log(SonetLogType.INFO, 'SonetSpacecraft.__init__') # Instance members self._p_main_window = ap_main_window self._spacecraft_type = None self._has_return_trajectory = None self.set_spacecraft_name(a_spacecraft_name) self.set_spacecraft_type(a_spacecraft_type_crew) self.set_has_return_trajectory(a_spacecraft_type_return) self.set_filters()
def init(self): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.init') # Align the window position with the main window. new_pos = self.mw.pos() new_pos.setX(new_pos.x() + self.mw.width()) new_pos.setY(self.mw.y()) self.move(new_pos) # Widgets settings. # Connect the main window list click event to the canvas window. self.mw.sonet_mission_tree_qlv.clicked.connect(self.clicked_sc)
def fill_tree_widget_trajectories_filter(self, a_sc: SonetSpacecraft): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.fill_tree_widget_trajectories_filter') self.treeW_trajectories_filter.setHeaderLabels(['Trip', 'Filter Type', 'Filter']) if a_sc.get_has_return_trajectory(): tw_item_earth_mars = QTreeWidgetItem(self.treeW_trajectories_filter, ['Earth - Mars', '', '']) self.fill_filter(a_sc, 'Earth - Mars', tw_item_earth_mars) tw_item_mars_earth = QTreeWidgetItem(self.treeW_trajectories_filter, ['Mars - Earth', '', '']) self.fill_filter(a_sc, 'Mars - Earth', tw_item_mars_earth) else: tw_item_earth_mars = QTreeWidgetItem(self.treeW_trajectories_filter, ['Earth - Mars', '', '']) self.fill_filter(a_sc, 'Earth - Mars', tw_item_earth_mars)
def clicked_pcp_viewer(self): """ When user clicks over 'PCP Viewer' btn, the current pcp being displayed should be sent to matlab and a contour plot generated. The user selects the desired trajectory, and when closing the window, the selected trajectory appears selected back in the python app. """ sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_pcp_viewer') # self.statusbar.showMessage('Not yet implemented :).', SONET_MSG_TIMEOUT) # Get the current displayed pcp, as dataframe. df = self.sonet_pcp_tabs_qtw.currentWidget().children()[1].model()._data # Check. if df is None: self.statusbar.showMessage('No PCP selected.', SONET_MSG_TIMEOUT) return elif df.empty: self.statusbar.showMessage('No PCP selected.', SONET_MSG_TIMEOUT) return # Save it to a temporary mat file, which is read by matlab. if self.sonet_pcp_tabs_qtw.currentWidget().objectName() == 'sonet_pcp_table_transit_1': departure_planet = 'Earth' arrival_planet = 'Mars' else: departure_planet = 'Mars' arrival_planet = 'Earth' mat_file = SONET_DATA_DIR + 'pcp_viewer_tmp.mat' savemat(mat_file, {'departure_planet': departure_planet, 'arrival_planet': arrival_planet, 'jd0': QDate.toJulianDay(df.iloc[0].DepDates), 'cal0': [df.iloc[0].DepDates.year(), df.iloc[0].DepDates.month(), df.iloc[0].DepDates.day()], 'departure_dates': df.DepDates.apply(QDate.toJulianDay).tolist(), 'arrival_dates': df.ArrivDates.apply(QDate.toJulianDay).tolist(), 'm_departure_dates': df.attrs['m_departure_dates'], # This are the original dep dates in the mat file, before filtering trajectories by max dvt. 'tofs': df.tof.tolist(), 'm_tofs': df.attrs['m_tofs'], # This are the original dep dates in the mat file, before filtering trajectories by max dvt. 'dvd': df.dvd.tolist(), 'dva': df.dva.tolist(), 'dvt': df.dvt.tolist(), 'theta': df.theta.tolist()}) # In degrees! # Read mat file with matlab, display pcp plot, and return last selected trajectory when closed the app. selected_trajectory = matlab_engine.PCP_Viewer(mat_file, nargout=1) self.clicked_select_trajectory(p_called_from_pcp_viewer=True, p_pcp_viewer_selected_trajectory=int(selected_trajectory)) print(df.iloc[int(selected_trajectory)])
def __init__(self, a_parent, a_trip_type=TripType.NA): """ :param a_parent: pointer to the parent, a s/c to which pertains this filter. :param a_trip_type: the type of trip to which apply this filter, OUTGOING|INCOMING. """ self._data = pd.DataFrame(columns=['Status', 'Type', 'Filter']) if not TripType.is_valid(a_trip_type): sonet_log( SonetLogType.ERROR, 'SonetTrajectoryFilter.__init__."Wrong TripType passed as argument"' ) self._p_the_spacecraft = a_parent self._trip_type = a_trip_type
def fill_tree_widget_active_trips(self, a_sc: SonetSpacecraft): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.fill_tree_widget_active_trips') selected_trajectories = a_sc.get_trajectory_selected(p_get_trajectories=True) self.treeW_active_trips.setHeaderLabels(['Trip', 'DepDates', 'ArrivDates','tof', 'dvt']) if a_sc.get_has_return_trajectory(): tw_item_earth_mars = QTreeWidgetItem(self.treeW_active_trips, ['Earth - Mars', '', '', '', '']) self.fill_active_trips(a_sc, 'Earth - Mars', tw_item_earth_mars) tw_item_mars_earth = QTreeWidgetItem(self.treeW_active_trips, ['Mars - Earth', '', '', '', '']) self.fill_active_trips(a_sc, 'Mars - Earth', tw_item_mars_earth) else: tw_item_earth_mars = QTreeWidgetItem(self.treeW_active_trips, ['Earth - Mars', '', '', '', '']) self.fill_active_trips(a_sc, 'Earth - Mars', tw_item_earth_mars)
def clicked_sc(self, a_index): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.clicked_sc') sc: SonetSpacecraft = self.mw.get_list_model().get_spacecraft(a_index=a_index) if a_index.row() is -1: sonet_log(SonetLogType.INFO, 'SonetCanvasQt.clicked_sc."No s/c selected"') return # Update the tree widgets. self.clear_tree_view(p_tw='All') self.fill_tree_widget_sc_info(sc) self.fill_tree_widget_trajectories_filter(sc) self.fill_tree_widget_active_trips(sc) self.post_actions()
def get_dependency_type(self, a_sc_trip: str, a_dependency_trip: str): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.get_dependency_type') res = '' if a_sc_trip == 'Earth - Mars': res = res + '>' elif a_sc_trip == 'Mars - Earth': res = res + '<' if a_dependency_trip == 'Earth - Mars': res = res + '>' elif a_dependency_trip == 'Mars - Earth': res = res + '<' return '(' + res + ')'
def get_tree_widgets(self, p_tw='All'): sonet_log(SonetLogType.INFO, 'SonetCanvasQt.get_tree_widgets') res = [] if p_tw == 'All': res.append(self.treeW_sc_info_filter) res.append(self.treeW_trajectories_filter) res.append(self.treeW_active_trips) elif p_tw == 'S/C Info': res.append(self.treeW_sc_info_filter) elif p_tw == 'Trajectories Filter': res.append(self.treeW_trajectories_filter) elif p_tw == 'Active Trips': res.append(self.treeW_active_trips) return res
def clicked_new_spacecraft(self): """ This method is called when clicking over 'Add SonetSpacecraft' QPushButton, it creates a new SonetSpacecraft. :rtype: bool """ sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_new_spacecraft') db = database.db # Create new SonetSpacecraft. # Get the widgets values. spacecraft_type_crew = self.sonet_spacecraft_type_qcmb.currentText() spacecraft_type_return = self.sonet_spacecraft_type_has_return_trajectory_qcmb.currentText() spacecraft_name = self.sonet_sc_name_le.text() # If the input s/c name is empty, popup a msg and exit. if spacecraft_name == '': popup_msg(window_title='Empty s/c name', icon=QMessageBox.Information, text='Please, select a different s/c name.', info_text='') return False # If the input s/c name is already in the db, popup a msg and exit. if spacecraft_name in db: popup_msg(window_title='Duplicated s/c name', icon=QMessageBox.Information, text='Please, select a different s/c name.', info_text='') return False # Create the s/c. The ap_main_window parameter is to pass a pointer to the main window to the s/c, so she can access # to main window's methods and properties. db[spacecraft_name] = SonetSpacecraft(spacecraft_name, spacecraft_type_crew, spacecraft_type_return, ap_main_window=main_window) # Update list model lm = self.get_list_model() lm.update() msg = ('Created Spacecraft ' + spacecraft_name + ' (' + spacecraft_type_crew + ', ' + spacecraft_type_return + ')') sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_new_spacecraft."' + msg + '"') return True
def set_model_data(self, a_the_spacecraft=None, a_the_filtered_dataframe=None): """ Set the table model's internal _data, stored as dataframe. """ sonet_log(SonetLogType.INFO, 'TableModel.set_model_data."' + str(self._trip_type) + '"') if type(a_the_filtered_dataframe) == bool \ or a_the_spacecraft is None \ or a_the_filtered_dataframe is None: sonet_log(SonetLogType.ERROR,'SonetMainWindow.TableModel.set_model_data."Wrong arguments type"') return # The spacecraft which owns the data. self._spacecraft = a_the_spacecraft # The data. self.beginResetModel() self._data = a_the_filtered_dataframe.reset_index(drop=True) self.endResetModel()
def clear_tree_view(self, p_tw='All'): """ Clear the all the tree widgets (p_tw='All') or a specific one. :param p_tw: 'All'|'S/C Info'|'Trajectories Filter'|'Active Trips' """ sonet_log(SonetLogType.INFO, 'SonetCanvasQt.clear_tree_view') if p_tw == 'All': self.treeW_sc_info_filter.clear() self.treeW_trajectories_filter.clear() self.treeW_active_trips.clear() elif p_tw == 'S/C Info': self.treeW_sc_info_filter.clear() elif p_tw == 'Trajectories Filter': self.treeW_trajectories_filter.clear() elif p_tw == 'Active Trips': self.treeW_active_trips.clear()
def clicked_pcp_manager(self): sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_pcp_manager') pcp_manager_window = SonetPCPManagerQt(self, p_main_window=self, p_mat_eng=matlab_engine) pcp_manager_window.exec_() # Update the trajectory label & progress bar. sc = self._list_model.get_spacecraft(self.sonet_mission_tree_qlv.currentIndex()) if sc is None: sonet_log(SonetLogType.INFO, 'SonetMainWindow.clicked_pcp_manager."No s/c selected"') # self.statusbar.showMessage('Not yet implemented :).', SONET_MSG_TIMEOUT) return status = sc.get_trajectory_selection_status() self.update_trajectory_label_and_progress_bar(status) self.update_trajectory_selection_in_table_view(sc) force_table_view_update() # Force focus on main window. self.raise_()
def set_data(self, a_data: pd.DataFrame) -> bool: """ Setter method. :param a_data: the filter to be applied. """ sonet_log(SonetLogType.INFO, 'SonetTrajectoryFilter.set_data') # Check that input is a pandas DataFrame. if not isinstance(a_data, pd.DataFrame): sonet_log(SonetLogType.ERROR, 'SonetTrajectoryFilter.set_data."Wrong input type"') return # Check columns. if not list(a_data.columns) == ['Status', 'Type', 'Filter']: sonet_log(SonetLogType.ERROR, 'SonetTrajectoryFilter.set_data."Wrong filter columns"') return # If the filter is the same, do not apply it. if a_data.equals(self._data): return else: # If not, set the new filter self._data = a_data.copy() # And reset the current selected trajectory for this trip. self._p_the_spacecraft.reset_trajectory( p_all_trajectories=False, p_trajectory=self._trip_type) return