def reboot_database(): """Delete and recreate the database between test classes""" settings = RaseSettings() if os.path.isdir(settings.getSampleDirectory()): shutil.rmtree(settings.getSampleDirectory()) if os.path.isfile(settings.getDatabaseFilepath()): os.remove(settings.getDatabaseFilepath()) initializeDatabase(settings.getDatabaseFilepath())
def complete_tests(): """Make sure no sample spectra are left after the final test is run""" settings = RaseSettings() original_data_dir = settings.getDataDirectory() settings.setDataDirectory(os.path.join(os.getcwd(), '__temp_test_rase')) yield None # anything before this line will be run prior to the tests print('CLEANING UP') # run after the last test settings = RaseSettings() if os.path.isdir(settings.getSampleDirectory()): shutil.rmtree(settings.getSampleDirectory()) if os.path.isfile(settings.getDatabaseFilepath()): os.remove(settings.getDatabaseFilepath()) settings.setDataDirectory(original_data_dir) print('CLEANUP COMPLETE')
def make_scenIdall(session, input_data): settings = RaseSettings() detector = session.query(Detector).filter_by( name=input_data['instrument']).first() repeat_scens = [] for bkgd_data in input_data['background']: bkgd = bkgd_data[0] repeat_scens = repeat_scens + session.query(Scenario).join( ScenarioMaterial).join(ScenarioBackgroundMaterial).filter( Scenario.acq_time == float(input_data['dwell_time'])).filter( ScenarioMaterial.fd_mode == input_data['source_fd'], ScenarioMaterial.material_name == input_data['source']).filter( ScenarioBackgroundMaterial.fd_mode == bkgd[0], ScenarioBackgroundMaterial.material_name == bkgd[1].name, ScenarioBackgroundMaterial.dose == bkgd[2]).all() common_scens = [ x for x in set(repeat_scens) if repeat_scens.count(x) == len(input_data['background']) ] scenIdall = [] for scen in common_scens: results_dir = get_results_dir(settings.getSampleDirectory(), detector, scen.id) if files_endswith_exists(results_dir, (".n42", ".res")): scenIdall.append(scen.id) return scenIdall
def check_edge_ids(session, replications, start_list, end_list, edge_ids, detector): """Check if there are results ready for values on the rising edge of the S-curve""" settings = RaseSettings() counter = [0] * 3 for i, ids_list in enumerate([edge_ids, start_list, end_list]): for id in ids_list: scen = session.query(Scenario).filter_by(id=id).first() results_dir = get_results_dir(settings.getSampleDirectory(), detector, id) if files_endswith_exists( results_dir, (".n42", ".res")) and scen.replication >= replications: counter[i] += 1 return counter[0], counter[1], counter[2]
def cleanup_scenarios(rangefind_rep, scenIds): """Remove scenarios from the database that were rangefinders, i.e.: low replication scenarios""" settings = RaseSettings() session = Session() scenarios = [] for scen in scenIds: scenarios.append(session.query(Scenario).filter_by(id=scen).first()) scens_to_delete = [] for scen in scenarios: if scen.replication == rangefind_rep: scens_to_delete.append(scen.id) delete_scenario(scens_to_delete, settings.getSampleDirectory()) session.commit()
def run_scenarios(r, scenIds, detector, replay_name, condition=False, expand=0, first_run=False): settings = RaseSettings() if condition: len_prog = len(scenIds) progress = QProgressDialog( 'S-curve range found!\n Generating higher statistics scenarios...', 'Abort', 0, len(scenIds), r) else: if not len(scenIds): return elif len(scenIds) == 1: len_prog = 3 progress = QProgressDialog( 'Expanding S-curve search...\n Steps taken = ' + str(expand - 1) + ', Scenario ID = ' + scenIds[0], 'Abort', 0, len_prog, r) else: if first_run: len_prog = len(scenIds) progress = QProgressDialog( 'Generating range-finding S-curve scenarios...', 'Abort', 0, len_prog, r) else: len_prog = len(scenIds) progress = QProgressDialog( 'Adding scenarios to rising edge...', 'Abort', 0, len_prog, r) progress.setMaximum(len_prog) count = 0 progress.setMinimumDuration(0) progress.setValue(count) progress.resize(QSize(300, 50)) progress.setWindowModality(Qt.WindowModal) for scenId in scenIds: if progress.wasCanceled(): progress.close() return True results_dir = get_results_dir(settings.getSampleDirectory(), detector, scenId) # do not regenerate already existing results # using scenIds instead of scenIds_no_persist in case the scenario exists but with no results if not files_endswith_exists(results_dir, (".n42", ".res")): r.genSpectra([scenId], [detector.name], False) if len(scenIds) == 1: count += 1 progress.setValue(count) r.runReplay([scenId], [detector.name], False) if len(scenIds) == 1: count += 1 progress.setValue(count) r.runTranslator([scenId], [detector.name], [replay_name], False) count += 1 progress.setValue(count) progress.setValue(len_prog)
def gen_scens(input_data, advanced, session, scenIdall, scenIds_no_persist, group_name, reps=1, condition=False): settings = RaseSettings() """Generate the scenarios, including source, background, dwell time, and replications""" scenGroup = session.query(ScenarioGroup).filter_by(name=group_name).first() test_points = logspace_gen(num_points=advanced['num_points'], start_g=advanced['min_guess'], end_g=advanced['max_guess']) if advanced['add_points'] and condition: # high-stats run test_points += advanced['add_points'] m = session.query(Material).filter_by(name=input_data['source']).first() scenIds = [ ] # scenarios that would be generated here regardless of persistence # to prevent accidental duplicates for d in set(test_points): sm = ScenarioMaterial(material=m, fd_mode=input_data['source_fd'], dose=d) sb = [] for [(mode, mat, dose)] in input_data['background']: bm = session.query(Material).filter_by(name=mat.name).first() sb.append( ScenarioBackgroundMaterial(material=bm, fd_mode=mode, dose=float(dose))) persist = session.query(Scenario).filter_by(id=Scenario.scenario_hash( input_data['dwell_time'], [sm], sb)).first() if persist: if persist.replication < reps: scenDelete = session.query(Scenario).filter( Scenario.id == persist.id) matDelete = session.query(ScenarioMaterial).filter( ScenarioMaterial.scenario_id == persist.id) backgMatDelete = session.query( ScenarioBackgroundMaterial).filter( ScenarioBackgroundMaterial.scenario_id == persist.id) matDelete.delete() backgMatDelete.delete() scenDelete.delete() folders = [ fd for fd in glob.glob( os.path.join(settings.getSampleDirectory(), "*" + persist.id + "*")) ] for folder in folders: shutil.rmtree(folder) scens = Scenario(input_data['dwell_time'], reps, [sm], sb, [], []) scenIds.append(scens.id) scenIds_no_persist.append(scens.id) else: scenIds.append(persist.id) else: scens = Scenario(input_data['dwell_time'], reps, [sm], sb, [], []) scenIds.append(scens.id) scenIds_no_persist.append(scens.id) scenGroup.scenarios.append(scens) scenIdall = scenIdall + [s for s in scenIds if not s in scenIdall] session.commit() return scenIds, scenIds_no_persist, scenIdall
class DetailedResultsDialog(ui_detailed_results_dialog.Ui_dlgDetailedResults, QDialog): def __init__(self, resultMap, scenario, detector): QDialog.__init__(self) self.setupUi(self) self.settings = RaseSettings() self.headerLabels = ['File', 'Tp', 'Fn', 'Fp', 'Precision', 'Recall', 'Fscore', 'IDs'] self.NUM_COLS = len(self.headerLabels) self.session = Session() self.scenario = scenario self.detector = detector self.tblDetailedResults.setContextMenuPolicy(Qt.CustomContextMenu) self.tblDetailedResults.setColumnCount(self.NUM_COLS) self.tblDetailedResults.setHorizontalHeaderLabels(self.headerLabels) self.tblDetailedResults.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch) self.tblDetailedResults.setRowCount(0) row=0 for file in sorted(resultMap, key=natural_keys): results = resultMap[file] results.insert(0, file) self.tblDetailedResults.insertRow(row) for col in range(self.NUM_COLS): self.tblDetailedResults.setItem(row, col, QTableWidgetItem(results[col])) row = row + 1 results.pop(0) self.tblDetailedResults.resizeColumnsToContents() self.tblDetailedResults.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch) self.buttonOK.clicked.connect(self.closeSelected) self.buttonExport.clicked.connect(self.handleExport) def handleExport(self): """ exports to CSV """ path = QFileDialog.getSaveFileName(self, 'Save File', self.settings.getDataDirectory(), 'CSV (*.csv)') if path[0]: with open(path[0], mode='w', newline='') as stream: writer = csv.writer(stream) writer.writerow(self.headerLabels) for row in range(self.tblDetailedResults.rowCount()): rowdata = [] for column in range(self.tblDetailedResults.columnCount()): item = self.tblDetailedResults.item(row, column) if item is not None: rowdata.append(item.text()) else: rowdata.append('') writer.writerow(rowdata) def get_selected_cells_as_text(self): """ Returns the selected cells of the table as plain text """ selected_rows = self.tblDetailedResults.selectedIndexes() text = "" # show the context menu only if on an a valid part of the table if selected_rows: cols = set(index.column() for index in self.tblDetailedResults.selectedIndexes()) for row in set(index.row() for index in self.tblDetailedResults.selectedIndexes()): text += "\t".join([self.tblDetailedResults.item(row, col).text() for col in cols]) text += '\n' return text def keyPressEvent(self, e): if e.key() == Qt.Key_Copy or e.key == QKeySequence(QKeySequence.Copy) or e.key() == 67: QApplication.clipboard().setText(self.get_selected_cells_as_text()) @pyqtSlot(QPoint) def on_tblDetailedResults_customContextMenuRequested(self, point): """ Handles "Copy" right click selections on the table """ copy_action = QAction('Copy', self) menu = QMenu(self.tblDetailedResults) menu.addAction(copy_action) action = menu.exec_(self.tblDetailedResults.mapToGlobal(point)) if action == copy_action: QApplication.clipboard().setText(self.get_selected_cells_as_text()) @pyqtSlot(int, int) def on_tblDetailedResults_cellDoubleClicked(self, row, col): """ Listens for cell double click and launches sample spectra viewer """ # FIXME: Note plotting order is guaranteed only if filenames of results files match sample spectra filenames if count_files_endwith(get_sample_dir(self.settings.getSampleDirectory(), self.detector, self.scenario.id), (".n42",)) > row: SampleSpectraViewerDialog(self, self.scenario, self.detector, row).exec_() else: QMessageBox.information(self, 'Information', 'Unable to display spectra.<br>' 'No sampled spectra available in native RASE format') def closeSelected(self): """ Closes dialog """ super().accept()