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 accept(self):
"""
Stores the selected values in the RaseSettings class
"""
selected = [cb.text().replace('&&', '&') for cb in self.cb_list if cb.isChecked()]
RaseSettings().setResultsTableSettings(selected)
return QDialog.accept(self)
def __init__(self, resultMap):
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.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 resultMap:
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 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 __init__(self, parent):
QDialog.__init__(self, parent)
self.settings = RaseSettings()
self.setupUi(self)
self.txtDataDir.setReadOnly(True)
self.txtDataDir.setText(self.settings.getDataDirectory())
self.dataDirectoryChanged = False
self.algoDictionary = {}
algoCount = 0
for name, data in inspect.getmembers(sampling_algos,
predicate=inspect.isfunction):
try:
readable_name = data.__doc__.splitlines()[0].strip()
if readable_name == '':
raise Exception("")
except:
readable_name = name
self.downSapmplingAlgoComboBox.addItem(readable_name)
self.algoDictionary[algoCount] = data
if data == self.settings.getSamplingAlgo():
self.downSapmplingAlgoComboBox.setCurrentIndex(algoCount)
algoCount += 1
self.algorithmSelected = False
self.downSapmplingAlgoComboBox.currentIndexChanged.connect(
self.chooseSamplingAlgo)
def viewResults(r, scenIdall, detector):
"""
Opens Results table
"""
# need a correspondence table in order to display results!
session = Session()
settings = RaseSettings()
default_corr_table = session.query(CorrespondenceTable).filter_by(
is_default=True).one_or_none()
if not default_corr_table:
msgbox = QMessageBox(
QMessageBox.Question, 'No Correspondence Table set!',
'No correspondence table set! Would you like to set a correspondence table now?'
)
msgbox.addButton(QMessageBox.Yes)
msgbox.addButton(QMessageBox.No)
answer = msgbox.exec()
if answer == QMessageBox.Yes:
CorrespondenceTableDialog().exec_()
settings.setIsAfterCorrespondenceTableCall(True)
else:
return
selected_scenarios = scenIdall
r.calculateScenarioStats(1, selected_scenarios, detector)
ViewResultsDialog(r, selected_scenarios, detector).exec_()
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 test_set_db_loc(self):
"""
Verifies that the database location can be set
"""
import os
data_dir = os.getcwd()
settings = RaseSettings()
settings.setDataDirectory(data_dir)
assert data_dir == settings.getDataDirectory()
def handleExport(self):
"""
Exports Results Dataframe to CSV format
"""
path = QFileDialog.getSaveFileName(self, 'Save File', RaseSettings().getDataDirectory(), 'CSV (*.csv)')
if path[0]:
df = self.parent.scenario_stats_df.copy()
df['Scen Desc'] = df['Scen Desc'].apply(lambda x: re.sub('<[^<]+?>', '', x))
df.to_csv(path[0])
def set_current_settings(self):
"""
Loads and apply the stored settings
"""
for cb in self.cb_list:
if cb.text().replace('&&', '&') in RaseSettings().getResultsTableSettings():
cb.setChecked(True)
else:
cb.setChecked(False)
def reset_data(self, data):
"""
Reset and reformat the data.
Should be called always after the data have been recomputed or columns selection changed
:param data: the new input pandas dataframe from the identification results analysis
"""
self.layoutAboutToBeChanged.emit()
self._data = data.copy()
self.col_settings = RaseSettings().getResultsTableSettings()
self._reformat_data()
self.layoutChanged.emit()
def __init__(self, parent = None):
QDialog.__init__(self)
self.parent = parent
self.session = Session()
self.settings = RaseSettings()
self.setupUi(self)
self.setReplaysTable()
self.deleteSelectedReplaysButton.clicked.connect(self.deleteSelectedReplays)
self.btnOK.clicked.connect(self.oK)
self.buttonExport.clicked.connect(self.handleExport)
self.buttonImport.clicked.connect(self.handleImport)
self.addNewReplayButton.clicked.connect(self.on_btnNewReplay_clicked)
def __init__(self):
QDialog.__init__(self)
self.setupUi(self)
self.settings = RaseSettings()
self.NUM_COLS = 3
self.tableEdited = False
self.session = Session()
# Query the entries in the current default table
corTableRows = self.readCorrTableRows()
if not corTableRows:
self.NUM_ROWS = 0
else:
self.NUM_ROWS = corTableRows.count()
self.tblCCCLists.setItemDelegate(
Delegate(self.tblCCCLists, isotopeCol=0))
self.tblCCCLists.setRowCount(self.NUM_ROWS)
self.tblCCCLists.setColumnCount(self.NUM_COLS)
self.columnLabels = ['Source', 'Correct ID', 'Allowed ID']
self.tblCCCLists.setHorizontalHeaderLabels(self.columnLabels)
self.tblCCCLists.horizontalHeader().setSectionResizeMode(
1, QHeaderView.Stretch)
self.tblCCCLists.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.tblCCCLists.setContextMenuPolicy(Qt.CustomContextMenu)
self.tblCCCLists.customContextMenuRequested.connect(self.openMenu)
self.tblCCCLists.setSortingEnabled(False)
if corTableRows:
for row, line in enumerate(corTableRows):
self.tblCCCLists.setItem(row, 0,
QTableWidgetItem(line.isotope))
self.tblCCCLists.setItem(row, 1,
QTableWidgetItem(line.corrList1))
self.tblCCCLists.setItem(row, 2,
QTableWidgetItem(line.corrList2))
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.btnAddRow.clicked.connect(self.addRow)
self.populateDefaultComboBox()
self.setSaveAsTableName()
self.buttonImport.clicked.connect(self.handleImport)
self.buttonExport.clicked.connect(self.handleExport)
self.buttonApplyDefaultSetting.clicked.connect(self.applySettings)
self.btnDeleteSelected.clicked.connect(self.deleteSelected)
self.btnClose.clicked.connect(self.closeSelected)
def __init__(self, parent):
QDialog.__init__(self, parent)
self.settings = RaseSettings()
self.setupUi(self)
self.txtRandomVal.setText(str(self.settings.getRandomSeed()))
if self.settings.getRandomSeedFixed():
self.txtRandomVal.setEnabled(True)
self.checkBox.setChecked(True)
else:
self.txtRandomVal.setDisabled(True)
self.checkBox.setChecked(False)
self.checkBox.stateChanged.connect(self.checkChanged)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
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 __init__(self,
tblMat,
materialCol,
intensityCol=-1,
unitsCol=2,
selected_detname=None,
editable=False,
auto_s=False):
QItemDelegate.__init__(self)
self.tblMat = tblMat
self.matCol = materialCol
self.intensityCol = intensityCol
self.unitsCol = unitsCol
self.editable = editable
self.selected_detname = selected_detname
self.auto_s = auto_s
self.settings = RaseSettings()
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 handleExport(self):
"""
Exports to CSV
"""
path = QFileDialog.getSaveFileName(self, 'Save File',
RaseSettings().getDataDirectory(),
'CSV (*.csv)')
if path[0]:
with open(path[0], mode='w', newline='') as stream:
writer = csv.writer(stream)
writer.writerow(self.columnLabelList)
for row in range(self.tblResults.rowCount()):
rowdata = []
for column in range(self.tblResults.columnCount()):
item = self.tblResults.item(row, column)
if item is not None:
rowdata.append(item.text())
else:
rowdata.append('')
writer.writerow(rowdata)
def __init__(self, parent=None):
QDialog.__init__(self)
self.parent = parent
self.session = Session()
self.settings = RaseSettings()
self.setupUi(self)
self.setWeightsTable()
self.check_usemweights.setChecked(
self.settings.getUseMWeightsInCalcs())
self.check_useconfs.setChecked(
self.settings.getUseConfidencesInCalcs())
self.btnDeleteSelectedMaterials.clicked.connect(
self.deleteSelectedMaterials)
self.buttonExport.clicked.connect(self.handleExport)
self.buttonImport.clicked.connect(self.handleImport)
self.btnAddNewMaterial.clicked.connect(self.on_btnNewMaterial_clicked)
self.setWindowTitle('Modify Material Weights')
self.materialsToDelete = []
def __init__(self, parent):
QDialog.__init__(self, parent)
cols_list = ['Det/Replay', 'Scen Desc', 'Dose', 'Flux', 'Background Dose', 'Background Flux',
'Infl', 'AcqTime', 'Repl', 'PID', 'PID CI', 'C&C', 'C&C CI', 'TP', 'FP', 'FN',
'Precision', 'Recall', 'F_Score', 'wTP', 'wFP', 'wFN', 'wPrecision', 'wRecall', 'wF_Score']
# QT treats the ampersand symbol as a special character, so it needs special treatment
self.cb_list = [QCheckBox(v.replace('&', '&&')) for v in cols_list]
layout = QVBoxLayout()
for cb in self.cb_list:
# if not (cb.text() == self.not_fd_mode):
layout.addWidget(cb)
self.buttonBox = QDialogButtonBox(self)
self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel|QDialogButtonBox.Ok)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
layout.addWidget(self.buttonBox)
self.setLayout(layout)
if RaseSettings().getResultsTableSettings():
self.set_current_settings()
else:
self.set_default()
def __init__(self, parent=None, modify_flag=False):
QDialog.__init__(self)
self.parent = parent
self.modify_flag = modify_flag
self.session = Session()
self.settings = RaseSettings()
self.setupUi(self)
self.setInfluencesTable()
self.btnDeleteSelectedInfluences.clicked.connect(
self.deleteSelectedInfluences)
self.buttonExport.clicked.connect(self.handleExport)
self.buttonImport.clicked.connect(self.handleImport)
self.btnAddNewInfluence.clicked.connect(
self.on_btnNewInfluence_clicked)
if self.modify_flag:
self.setWindowTitle('Modify Influences')
else:
self.setWindowTitle('Add Influences')
self.influencesToDelete = []
def __init__(self, parent, replay=None, resultsTranslator=None):
QDialog.__init__(self, parent)
self.parent = parent
self.setupUi(self)
self.settings = RaseSettings()
self.replay = replay
self.resultsTranslator = resultsTranslator
if replay:
self.setWindowTitle('Edit Replay Software')
self.txtName.setReadOnly(True)
self.txtName.setText(replay.name)
self.txtCmdLine.setText(replay.exe_path)
self.txtSettings.setText(replay.settings)
self.cbCmdLine.setChecked(bool(replay.is_cmd_line))
self.txtTemplatePath.setText(replay.n42_template_path)
self.txtFilenameSuffix.setText(replay.input_filename_suffix)
if resultsTranslator:
self.txtResultsTranslator.setText(resultsTranslator.exe_path)
self.txtSettings_3.setText(resultsTranslator.settings)
self.cbCmdLine_3.setChecked(bool(resultsTranslator.is_cmd_line))
def __init__(self, parent, scenario, detector, selected, file_list=None):
QDialog.__init__(self, parent)
self.setupUi(self)
self.scenario = scenario
self.detector = detector
self.selected = selected
self.session = Session()
self.json_file = os.path.join(get_bundle_dir(), "d3_resources", "spectrum.json")
self.index = selected
self.file_list = file_list
if not self.file_list:
sample_path = get_sample_dir(RaseSettings().getSampleDirectory(), self.detector, self.scenario.id)
self.file_list = glob.glob(os.path.join(sample_path, "*.n42"))
self.file_list.sort(key=natural_keys)
self.browser = WebSpectraView(self)
self.plot_spectrum()
self.plot_layout = QVBoxLayout(self.widget)
self.plot_layout.addWidget(self.browser)
self.widget.setFocus()
def __init__(self, session):
QDialog.__init__(self)
self.setupUi(self)
self.buttonBox.addButton("Create", QDialogButtonBox.AcceptRole)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
self.settings = RaseSettings()
# TODO: Add a delegate to the flux column as well; doing so now via a simple copy and paste operation is
# creating a SIGSEGV
self.sourceTable.setItemDelegateForColumn(hh['dose'],
PositiveDoubleDelegate())
self.sourceTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.sourceTable.setColumnHidden(
hh['folder'],
True) # folder is hidden but shown as tooltip on filename cell
self.txtVendorID.setValidator(
QRegExpValidator(QRegExp('[a-zA-Z0-9]{0,4}')))
self.txtModelID.setValidator(
QRegExpValidator(QRegExp('[a-zA-Z0-9]{0,3}')))
self.btnRemoveSrc.clicked.connect(self.delete_selected)
self.sourceTable.itemChanged.connect(self.update_base_fname)
self.txtVendorID.textChanged.connect(self.update_base_fname_all)
self.txtModelID.textChanged.connect(self.update_base_fname_all)
self.btnExport.clicked.connect(self.handleExport)
self.btnImport.clicked.connect(self.handleImport)
self.btnClearBkgSel.clicked.connect(self.clear_background_selection)
self.sourceTable.itemSelectionChanged.connect(
self.activate_SetAsBkg_button)
self.backgroundFileName = None
self.backgroundFileFolder = None
self.unselectedBkgColor = None
self.btnSetAsBkg.setEnabled(False)
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
def __init__(self, rase_gui, id=None, duplicate=[], auto_s=False):
QDialog.__init__(self)
self.setupUi(self)
self.rase_gui = rase_gui
self.tblMaterial.setContextMenuPolicy(Qt.CustomContextMenu)
self.tblBackground.setContextMenuPolicy(Qt.CustomContextMenu)
self.id = id
self.auto_s = auto_s
self.settings = RaseSettings()
self.scenarioHasChanged = False
self.groupHasChanged = False
self.duplicate = duplicate
self.session = Session()
self.txtAcqTime.setText('30')
self.txtAcqTime.setToolTip(
"Enter comma-separated values OR range as min-max:step OR range followed by comma-separated values"
)
self.txtReplication_2.setText('100')
int_validator = QIntValidator()
self.txtAcqTime.setValidator(RegExpSetValidator())
self.txtReplication_2.setValidator(int_validator)
self.tblMaterial.setHorizontalHeaderItem(INTENSITY,
QTableWidgetItem('Intensity'))
self.tblBackground.setHorizontalHeaderItem(
INTENSITY, QTableWidgetItem('Intensity'))
self.tblMaterial.customContextMenuRequested.connect(
lambda x, table=self.tblMaterial: self.context_auto_range(
x, self.tblMaterial))
self.tblBackground.customContextMenuRequested.connect(
lambda x, table=self.tblBackground: self.context_auto_range(
x, self.tblBackground))
# set material table
self.tblMaterial.setItemDelegate(
MaterialDoseDelegate(self.tblMaterial,
unitsCol=UNITS,
materialCol=MATERIAL,
intensityCol=INTENSITY))
self.tblMaterial.setRowCount(10)
for row in range(self.tblMaterial.rowCount()):
self.tblMaterial.setItem(row, UNITS, QTableWidgetItem())
self.tblMaterial.setItem(row, INTENSITY, QTableWidgetItem())
self.tblMaterial.setItem(row, MATERIAL, QTableWidgetItem())
self.tblMaterial.item(row, INTENSITY).setToolTip(
"Enter comma-separated values OR range as min-max:step OR range followed by comma-separated values"
)
self.tblMaterial.setRowHeight(row, 22)
# set background table
self.tblBackground.setItemDelegate(
MaterialDoseDelegate(self.tblBackground,
unitsCol=UNITS,
materialCol=MATERIAL,
intensityCol=INTENSITY,
auto_s=self.auto_s))
self.tblBackground.setRowCount(10)
for row in range(self.tblBackground.rowCount()):
self.tblBackground.setItem(row, UNITS, QTableWidgetItem())
self.tblBackground.setItem(row, INTENSITY, QTableWidgetItem())
self.tblBackground.setItem(row, MATERIAL, QTableWidgetItem())
self.tblBackground.item(row, INTENSITY).setToolTip(
"Enter comma-separated values OR range as min-max:step OR range followed by comma-separated values"
)
self.tblBackground.setRowHeight(row, 22)
# fill influence list
for influence in self.session.query(Influence):
self.lstInfluences.addItem(QListWidgetItem(influence.name))
self.comboDetectorSelect.addItems(
["all detectors"] +
[s.name for s in self.session.query(Detector).all()])
self.comboDetectorSelect.currentIndexChanged.connect(
self.updateTableDelegate)
# display a previous scenario if defined
if self.id:
if not self.duplicate:
self.setWindowTitle("Scenario Edit")
scenario = self.session.query(Scenario).get(id)
materials = scenario.scen_materials
bckg_materials = scenario.scen_bckg_materials
influences = scenario.influences
for table, mat_list in zip(
(self.tblMaterial, self.tblBackground),
(materials, bckg_materials)):
for rowCount, mat in enumerate(mat_list):
item = QTableWidgetItem(units_labels[mat.fd_mode])
item.setData(Qt.UserRole, mat.fd_mode)
table.setItem(rowCount, 0, item)
table.setItem(rowCount, 1,
QTableWidgetItem(mat.material_name))
table.setItem(rowCount, 2,
QTableWidgetItem(str(mat.dose)))
self.txtAcqTime.setText(str(scenario.acq_time))
self.txtReplication_2.setText(str(scenario.replication))
for influence in influences:
lst = self.lstInfluences.findItems(influence.name,
Qt.MatchExactly)[0]
lst.setSelected(True)
self.groups = self.getGroups()
else:
self.setWindowTitle("Build Scenario from Other Scenario")
scens = [
self.session.query(Scenario).filter_by(id=scen).first()
for scen in self.duplicate
]
scenario = scens[0]
materials = scenario.scen_materials
back_materials = scenario.scen_bckg_materials
influences = scenario.influences
mat_dict = {}
back_dict = {}
mat_fd = []
back_fd = []
for mat in materials:
mat_fd.append((mat.material_name, mat.fd_mode))
mat_dict[mat.material_name] = set([mat.dose])
for back in back_materials:
back_fd.append((back.material_name, back.fd_mode))
back_dict[back.material_name] = set([back.dose])
if len(scens) > 1:
for scen in scens[1:]:
mat_dict = self.make_matDict(scen.scen_materials,
mat_dict)
back_dict = self.make_matDict(scen.scen_bckg_materials,
back_dict)
if influences:
influences.append[scen.influences]
else:
influences = scen.influences
for table, material_dictionary, fd_list in \
zip((self.tblMaterial, self.tblBackground), (mat_dict, back_dict), (mat_fd, back_fd)):
mat_list_tup = [(k, v)
for k, v in material_dictionary.items()]
for rowCount, (mat, fd_mode) in enumerate(
zip(mat_list_tup, fd_list)):
doses = [str(d) for d in sorted(mat[1])]
item = QTableWidgetItem(units_labels[fd_mode[1]])
item.setData(Qt.UserRole, fd_mode[1])
table.setItem(rowCount, 0, item)
table.setItem(rowCount, 1,
QTableWidgetItem(str(mat[0])))
table.setItem(rowCount, 2,
QTableWidgetItem(str(','.join(doses))))
self.txtAcqTime.setText(str(scenario.acq_time))
for influence in influences:
lst = self.lstInfluences.findItems(influence.name,
Qt.MatchExactly)[0]
lst.setSelected(True)
self.groups = self.getGroups()
else:
self.groups = []
if self.auto_s and self.rase_gui.static_background:
for rowCount, mat in enumerate(self.rase_gui.static_background):
mat = mat[0]
item = QTableWidgetItem(units_labels[mat[0]])
item.setData(Qt.UserRole, mat[0])
self.tblBackground.setItem(rowCount, 0, item)
self.tblBackground.setItem(rowCount, 1,
QTableWidgetItem(mat[1].name))
self.tblBackground.setItem(rowCount, 2,
QTableWidgetItem(str(mat[2])))
# signal/slot connections (this has to be done after_ the previous scenario is loaded)
self.tblMaterial.cellChanged.connect(self.scenarioChanged)
self.tblBackground.cellChanged.connect(self.scenarioChanged)
self.tblMaterial.cellChanged.connect(self.updateScenariosList)
self.tblBackground.cellChanged.connect(self.updateScenariosList)
self.lstInfluences.itemSelectionChanged.connect(self.scenarioChanged)
self.txtAcqTime.textChanged.connect(self.scenarioChanged)
self.txtReplication_2.textChanged.connect(self.scenarioChanged)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
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 __init__(self, rase_gui, id=None):
QDialog.__init__(self)
self.setupUi(self)
self.rase_gui = rase_gui
#save the id if passed
self.id = id
self.settings = RaseSettings()
self.scenarioHasChanged = False
self.groupHasChanged = False
self.session = Session()
self.txtAcqTime.setText('30')
self.txtAcqTime.setToolTip(
"Enter comma-separated values OR range as min-max:step OR range followed by comma-separated values"
)
self.txtReplication_2.setText('100')
int_validator = QIntValidator()
self.txtAcqTime.setValidator(RegExpSetValidator())
self.txtReplication_2.setValidator(int_validator)
# set material table
self.tblMaterial.setColumnWidth(MATERIAL, 120)
self.tblMaterial.setColumnWidth(DOSE, 100)
self.tblMaterial.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.tblMaterial.setHorizontalHeaderItem(
DOSE, QTableWidgetItem('Dose (\u00B5Sv/h)'))
self.tblMaterial.setItemDelegate(
MaterialDoseDelegate(self.tblMaterial,
materialCol=MATERIAL,
doseCol=DOSE))
self.tblMaterial.setRowCount(10)
for row in range(self.tblMaterial.rowCount()):
self.tblMaterial.setItem(row, DOSE, QTableWidgetItem())
self.tblMaterial.setItem(row, MATERIAL, QTableWidgetItem())
self.tblMaterial.item(row, DOSE).setToolTip(
"Enter comma-separated values OR range as min-max:step OR range followed by comma-separated values"
)
self.tblMaterial.setRowHeight(row, 22)
self.tblMaterial.cellChanged.connect(self.updateScenariosList)
# set background table
#self.tblBackground.setEnabled(False)
self.tblBackground.setColumnWidth(MATERIAL, 120)
self.tblBackground.setColumnWidth(DOSE, 100)
self.tblBackground.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.tblBackground.setHorizontalHeaderItem(
DOSE, QTableWidgetItem('Dose (\u00B5Sv/h)'))
self.tblBackground.setItemDelegate(
MaterialDoseDelegate(self.tblBackground,
materialCol=MATERIAL,
doseCol=DOSE))
self.tblBackground.setRowCount(10)
for row in range(self.tblBackground.rowCount()):
self.tblBackground.setItem(row, DOSE, QTableWidgetItem())
self.tblBackground.setItem(row, MATERIAL, QTableWidgetItem())
self.tblBackground.item(row, DOSE).setToolTip(
"Enter comma-separated values OR range as min-max:step OR range followed by comma-separated values"
)
self.tblBackground.setRowHeight(row, 22)
self.tblBackground.cellChanged.connect(self.updateScenariosList)
# link group name and description
self.comboScenarioGroupName.currentIndexChanged.connect(
self.updateScenarioDesc)
self.comboScenarioGroupName.currentTextChanged.connect(
self.txtScenarioGroupDescription.clear)
# fill influence list
for influence in self.session.query(Influence):
self.lstInfluences.addItem(QListWidgetItem(influence.name))
# fill the group name combo box
self.comboScenarioGroupName.addItems(
[s.name for s in self.session.query(ScenarioGroup).all()])
i = self.comboScenarioGroupName.findText(
self.settings.getLastScenarioGroupName())
if i >= 0:
self.comboScenarioGroupName.setCurrentIndex(i)
else:
self.comboScenarioGroupName.setCurrentText(
DEFAULT_SCENARIO_GRPNAME)
self.comboDetectorSelect.addItems(
["all detectors"] +
[s.name for s in self.session.query(Detector).all()])
self.comboDetectorSelect.currentIndexChanged.connect(
self.updateTableDelegate)
# display a previous scenario if defined
if self.id:
self.setWindowTitle("Scenario Edit")
scenario = self.session.query(Scenario).get(id)
materials = scenario.scen_materials
bckg_materials = scenario.scen_bckg_materials
influences = scenario.influences
for rowCount, mat in enumerate(materials):
self.tblMaterial.setItem(rowCount, 0,
QTableWidgetItem(mat.material_name))
self.tblMaterial.setItem(rowCount, 1,
QTableWidgetItem(str(mat.dose)))
for rowCount, mat in enumerate(bckg_materials):
self.tblBackground.setItem(rowCount, 0,
QTableWidgetItem(mat.material_name))
self.tblBackground.setItem(rowCount, 1,
QTableWidgetItem(str(mat.dose)))
self.txtAcqTime.setText(str(scenario.acq_time))
self.txtReplication_2.setText(str(scenario.replication))
scenGrp = self.session.query(ScenarioGroup).get(
scenario.scen_group_id)
i = self.comboScenarioGroupName.findText(scenGrp.name)
self.comboScenarioGroupName.setCurrentIndex(i)
self.txtScenarioGroupDescription.setPlainText(scenGrp.description)
for influence in influences:
lst = self.lstInfluences.findItems(influence.name,
Qt.MatchExactly)[0]
lst.setSelected(True)
# signal/slot connections (this has to be done after_ the previous scenario is loaded)
self.tblMaterial.cellChanged.connect(self.scenarioChanged)
self.tblBackground.cellChanged.connect(self.scenarioChanged)
self.lstInfluences.itemSelectionChanged.connect(self.scenarioChanged)
self.txtAcqTime.textChanged.connect(self.scenarioChanged)
self.txtReplication_2.textChanged.connect(self.scenarioChanged)
self.comboScenarioGroupName.currentIndexChanged.connect(
self.groupChanged)
self.comboScenarioGroupName.currentTextChanged.connect(
self.groupChanged)
self.buttonBox.accepted.connect(self.accept)
self.buttonBox.rejected.connect(self.reject)
def __init__(self, data):
super(ResultsTableModel, self).__init__()
self._data = data.copy()
self.col_settings = RaseSettings().getResultsTableSettings()
self._reformat_data()
def __init__(self, parent, detectorName=None):
QDialog.__init__(self, parent)
self.parent = parent
self.setupUi(self)
self.txtDetector.setText(detectorName)
self.detector = None
self.settings = RaseSettings()
self.newBaseSpectra = []
self.newBackgroundSpectrum = None
self.replay = None
self.internal_secondary = 'None'
self.resultsTranslator = None
self.settingProgramatically = False
self.detectorInfluences = []
# background combo_box
self.back_combo = {'base_spec': 0, 'scenario': 1, 'file': 2}
self.session = session = Session()
self.secondaryIsBackgroundRadio.toggled.connect(
self.setSecondarySpecEnable)
self.combo_typesecondary.currentIndexChanged.connect(
self.enableComboBase)
self.cmbReplay.addItem('')
self.cmbReplay.addItems(
[replay.name for replay in session.query(Replay)])
self.includeSecondarySpectrumCheckBox.setEnabled(False)
self.btnAddInfluences.clicked.connect(
lambda: self.influenceManagement(False))
self.btnModifyInfluences.clicked.connect(
lambda: self.influenceManagement(True))
self.btnDeleteInfluences.clicked.connect(
self.deleteInfluencesFromDetector)
self.manageReplays.clicked.connect(self.replayManagement)
self.lstBaseSpectra.doubleClicked.connect(self.showSpectrum)
# case that this is an edit of an existing detector
if detectorName:
self.setWindowTitle('Edit Detector')
self.detector = detector = session.query(Detector).filter_by(
name=detectorName).first()
# populate details
self.txtDetector.setText(detector.name)
self.txtDetector.setReadOnly(True)
self.txtDetectorDescription.setText(detector.description)
self.txtManufacturer.setText(detector.manufacturer)
self.txtInstrumentId.setText(detector.instr_id)
self.txtHardwareVersion.setText(detector.hardware_version)
self.txtClassCode.setText(detector.class_code)
# populate influences
if self.detector.influences:
self.listInfluences.addItems(
sorted([
influence.name
for influence in self.detector.influences
]))
# populate ecal
self.txtEcal0.setText(
'%E' % Decimal(detector.ecal0) if detector.ecal0 else '0')
self.txtEcal1.setText(
'%E' % Decimal(detector.ecal1) if detector.ecal1 else '0')
self.txtEcal2.setText(
'%E' % Decimal(detector.ecal2) if detector.ecal2 else '0')
self.txtEcal3.setText(
'%E' % Decimal(detector.ecal3) if detector.ecal3 else '0')
self.txtChannelCount.setText(str(detector.chan_count or ''))
# Replay
if detector.replay:
self.cmbReplay.setCurrentText(detector.replay.name)
# populate materials
self.lstBaseSpectra.addItems(
sorted([
baseSpectrum.material_name
for baseSpectrum in detector.base_spectra
]))
if detector.includeSecondarySpectrum:
self.includeSecondarySpectrumCheckBox.setEnabled(True)
# secondary spectrum checkboxes
if detector.secondary_type == secondary_type['internal']:
self.secondaryIsCalibrationRadio.setEnabled(True)
self.secondaryIsCalibrationRadio.setChecked(True)
self.bckgndSpecFileDisplay.setText(
"Secondary Spectrum from: " +
detector.bckg_spectra[0].material_name)
else:
self.secondaryIsCalibrationRadio.setChecked(False)
self.secondaryIsCalibrationRadio.setEnabled(False)
self.bckgndSpecFileDisplay.clear()
if detector.secondary_type != secondary_type['internal']:
self.secondaryIsBackgroundRadio.setChecked(True)
self.combo_typesecondary.setEnabled(True)
for key, val in secondary_type.items():
if val == detector.secondary_type:
self.combo_typesecondary.setCurrentIndex(
self.back_combo[key])
break
self.setBackgroundIsoCombo(
detector.secondary_type == secondary_type['base_spec'])
if self.detector.secondary_type != secondary_type['file']:
self.combo_typesecondary.removeItem(
self.back_combo['file'])
if detector.secondary_type == secondary_type['base_spec']:
self.populateComboBase(
sorted([
baseSpec.material_name
for baseSpec in detector.base_spectra
]))
self.combo_basesecondary.setCurrentText(
detector.bckg_spectra[0].material_name)