def __init__(self, parent=None, sample_model=None, selected=None, *args):
QtWidgets.QWidget.__init__(self, parent=parent, *args)
Ui_LayerProperties.__init__(self)
self.setupUi(self)
self.sample_model = SampleModel()
self.layer_list = []
self.selection = []
self.ties_nsld_real = []
self.ties_nsld_imaginary = []
self.ties_msld_rho = []
self.ties_msld_theta = []
self.ties_msld_phi = []
self.ties_roughness = []
self.ties_thickness = []
self.show_hide_roughness_extras(0)
if isinstance(sample_model, SampleModel):
self.set_layer_list(sample_model)
if selected is not None:
self.set_selection(selected)
self.Name_lineEdit.setFocus()
self.buttonBox.button(
QtWidgets.QDialogButtonBox.Reset).clicked.connect(self.reset)
self.buttonBox.button(
QtWidgets.QDialogButtonBox.Apply).clicked.connect(self.apply)
self.sublayers_spinBox.setSpecialValueText('Unchanged')
self.roughness_model_comboBox.addItem('Unchanged')
self.roughness_model_comboBox.addItems(
[r.name for r in RoughnessModel])
def __init__(self, sample_model=SampleModel(), *args):
QtWidgets.QWidget.__init__(self, *args)
Ui_layerselector.__init__(self)
self.setupUi(self)
self.sample_model = SampleModel()
self.set_sample_model(sample_model)
self.listView.selectionModel().selectionChanged.connect(
self.selectionChanged)
self.invalidSelection[str].connect(self.module_logger)
def test_iterate(self):
sm = SampleModel()
sm.addItem(Layer(name='0'))
sm.addItem(Layer(name='1'))
sm.addItem(Layer(name='2', thickness=3.14))
sm.addItem(Layer(name='3'))
expected_names = ['0', '1', '2', '3']
self.assertEqual([s.name for s in sm], expected_names)
expected_thickness = [0, 0, 3.14, 0]
self.assertEqual([s.thickness.value for s in sm], expected_thickness)
for i, layer in enumerate(sm):
layer.nsld = 3 * i + 4j
for i in range(4):
self.assertEqual(sm.layers[i].nsld_real.value, 3 * i)
self.assertEqual(sm.layers[i].nsld_imaginary.value, 4)
class layerselector(QtWidgets.QWidget, Ui_layerselector):
invalidSelection = QtCore.pyqtSignal(str)
sampleModelChanged = QtCore.pyqtSignal(SampleModel)
def __init__(self, sample_model=SampleModel(), *args):
QtWidgets.QWidget.__init__(self, *args)
Ui_layerselector.__init__(self)
self.setupUi(self)
self.sample_model = SampleModel()
self.set_sample_model(sample_model)
self.listView.selectionModel().selectionChanged.connect(
self.selectionChanged)
self.invalidSelection[str].connect(self.module_logger)
def set_sample_model(self, sample_model):
self.sample_model.set_model(sample_model)
self.sample_model.setParent(self)
self.listView.setModel(self.sample_model)
def module_logger(self, message):
print('[layerselector]: ' + message)
def addClicked(self):
selected = self.listView.selectionModel().selectedRows()
inds = sorted([s.row() for s in selected])
selected = []
if inds:
for i, j in enumerate(inds):
if j in [0, self.sample_model.rowCount() - 1]:
self.invalidSelection.emit(
'Cannot add another substrate or incoming media')
else:
self.sample_model.addItem(
copy.deepcopy(self.sample_model.layers[i - 1 + j]),
i + j)
selected.append(i + j)
else:
self.sample_model.addItem(Layer())
self.sampleModelChanged.emit(self.sample_model)
self.listView.selectionModel().clear()
for selection in selected:
self.listView.selectionModel().select(
self.sample_model.index(selection),
QtCore.QItemSelectionModel.Select)
def delClicked(self):
inds = sorted(
[s.row() for s in self.listView.selectionModel().selectedRows()],
reverse=True)
if inds:
if inds in [[0], [self.sample_model.rowCount() - 1]]:
self.invalidSelection.emit(
'Cannot delete substrate or incoming media')
else:
for i in inds:
self.sample_model.delItem(i - 1)
else:
self.invalidSelection.emit("nothing selected")
self.sampleModelChanged.emit(self.sample_model)
def selectionEntered(self):
selection_string = str(self.select_lineEdit.text())
slice_parts = selection_string.split(':')
if len(slice_parts) > 3:
self.invalidSelection.emit(selection_string +
" has more than three arguments")
return
if len(slice_parts) == 1:
try:
index = int(slice_parts[0])
selection_slice = slice(index, index + 1)
except ValueError:
self.invalidSelection.emit(selection_string +
' cannot be converted to a slice')
return
else:
try:
s = [int(x) if x.strip() != '' else None for x in slice_parts]
try: # first layer is 1
s[0] -= 1
except TypeError:
pass
selection_slice = slice(*s)
except ValueError:
self.invalidSelection.emit(selection_string +
' cannot be converted to a slice')
return
self.listView.selectionModel().clear()
all_layers = range(1, self.sample_model.rowCount() - 1)
new_selection = all_layers[selection_slice]
for i in new_selection:
layer_index = self.sample_model.index(i)
self.listView.selectionModel().select(
layer_index, QtCore.QItemSelectionModel.Select)
def selectionChanged(self, selected, deselected):
incoming_media_index = self.sample_model.index(0)
substrate_index = self.sample_model.index(
self.sample_model.rowCount() - 1)
all_rows = self.listView.selectionModel().selectedRows()
if (substrate_index in all_rows) and len(all_rows) > 1:
if substrate_index in selected:
if len(selected) > 1:
self.listView.selectionModel().select(
substrate_index, QtCore.QItemSelectionModel.Deselect)
else:
self.listView.selectionModel().clear()
self.listView.selectionModel().select(
substrate_index, QtCore.QItemSelectionModel.Select)
else:
self.listView.selectionModel().select(
substrate_index, QtCore.QItemSelectionModel.Deselect)
if (incoming_media_index in all_rows) and len(all_rows) > 1:
if incoming_media_index in selected:
if len(selected) > 1:
self.listView.selectionModel().select(
incoming_media_index,
QtCore.QItemSelectionModel.Deselect)
else:
self.listView.selectionModel().clear()
self.listView.selectionModel().select(
incoming_media_index,
QtCore.QItemSelectionModel.Select)
else:
self.listView.selectionModel().select(
incoming_media_index, QtCore.QItemSelectionModel.Deselect)
substrate_index, QtCore.QItemSelectionModel.Select)
else:
self.listView.selectionModel().select(
substrate_index, QtCore.QItemSelectionModel.Deselect)
if (incoming_media_index in all_rows) and len(all_rows) > 1:
if incoming_media_index in selected:
if len(selected) > 1:
self.listView.selectionModel().select(
incoming_media_index,
QtCore.QItemSelectionModel.Deselect)
else:
self.listView.selectionModel().clear()
self.listView.selectionModel().select(
incoming_media_index,
QtCore.QItemSelectionModel.Select)
else:
self.listView.selectionModel().select(
incoming_media_index, QtCore.QItemSelectionModel.Deselect)
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
sm = SampleModel()
sm.addItem(Layer(name='L0'))
sm.addItem(Layer(name='L1', thickness=2))
sm.addItem(Layer(name='L2'))
sm.addItem(Layer(name='L3'))
window = layerselector(sm)
window.show()
sys.exit(app.exec_())
def test_move_down_1(self):
sm = SampleModel()
sm.addItem(Layer(name='0'))
sm.addItem(Layer(name='1'))
sm.addItem(Layer(name='2'))
sm.addItem(Layer(name='3'))
sm.move_down_1([3]) #cannot move down more
expected_names = ['incoming media', '0', '1', '2', '3', 'substrate']
self.assertEqual(
[s.name for s in [sm.incoming_media] + sm.layers + [sm.substrate]],
expected_names)
sm.move_down_1([1])
expected_names = ['incoming media', '0', '2', '1', '3', 'substrate']
self.assertEqual(
[s.name for s in [sm.incoming_media] + sm.layers + [sm.substrate]],
expected_names)
sm.move_down_1([0, 2])
expected_names = ['incoming media', '2', '0', '3', '1', 'substrate']
self.assertEqual(
[s.name for s in [sm.incoming_media] + sm.layers + [sm.substrate]],
expected_names)
sm.move_up_1([1, 2, 4]) #no effect
expected_names = ['incoming media', '2', '0', '3', '1', 'substrate']
self.assertEqual(
[s.name for s in [sm.incoming_media] + sm.layers + [sm.substrate]],
expected_names)
def test_creation_addition_deletion(self):
sm = SampleModel()
sm.addItem(Layer(name='0'))
sm.addItem(Layer(name='1'))
sm.addItem(Layer(name='2'))
sm.addItem(Layer(name='3'))
sm.addItem('4') #should have no effect
expected_names = ['incoming media', '0', '1', '2', '3', 'substrate']
self.assertEqual(
[s.name for s in [sm.incoming_media] + sm.layers + [sm.substrate]],
expected_names)
sm.delItem(0)
expected_names = ['incoming media', '1', '2', '3', 'substrate']
self.assertEqual(
[s.name for s in [sm.incoming_media] + sm.layers + [sm.substrate]],
expected_names)
sm.delItem(3)
expected_names = ['incoming media', '1', '2', '3', 'substrate']
self.assertEqual(
[s.name for s in [sm.incoming_media] + sm.layers + [sm.substrate]],
expected_names)
class LayerPropertiesWidget(QtWidgets.QWidget, Ui_LayerProperties):
sampleModelChanged = QtCore.pyqtSignal(SampleModel)
def __init__(self, parent=None, sample_model=None, selected=None, *args):
QtWidgets.QWidget.__init__(self, parent=parent, *args)
Ui_LayerProperties.__init__(self)
self.setupUi(self)
self.sample_model = SampleModel()
self.layer_list = []
self.selection = []
self.ties_nsld_real = []
self.ties_nsld_imaginary = []
self.ties_msld_rho = []
self.ties_msld_theta = []
self.ties_msld_phi = []
self.ties_roughness = []
self.ties_thickness = []
self.show_hide_roughness_extras(0)
if isinstance(sample_model, SampleModel):
self.set_layer_list(sample_model)
if selected is not None:
self.set_selection(selected)
self.Name_lineEdit.setFocus()
self.buttonBox.button(
QtWidgets.QDialogButtonBox.Reset).clicked.connect(self.reset)
self.buttonBox.button(
QtWidgets.QDialogButtonBox.Apply).clicked.connect(self.apply)
self.sublayers_spinBox.setSpecialValueText('Unchanged')
self.roughness_model_comboBox.addItem('Unchanged')
self.roughness_model_comboBox.addItems(
[r.name for r in RoughnessModel])
def set_layer_list(self, new_sample_model):
self.sample_model.set_model(new_sample_model)
self.layer_list = [l for l in self.sample_model.layers]
self.layer_list.insert(0, self.sample_model.incoming_media)
self.layer_list.append(self.sample_model.substrate)
self.selection = []
self.ties_nsld_real, self.ties_nsld_imaginary, self.ties_msld_rho, \
self.ties_msld_theta, self.ties_msld_phi, self.ties_roughness, self.ties_thickness = \
generate_available_ties(self.layer_list[1:-1], self.layer_list[0], self.layer_list[-1])
def set_selection(self, selected):
self.selection = selected
if not self.selection:
return # TODO: clear input
name = self.layer_list[np.min(self.selection)].name
if len(self.selection) > 1 and name != '':
name += ' multiple'
self.Name_lineEdit.setText(name)
if selected == [0]:
prefix = 'Incoming_media.'
self.Name_lineEdit.setPlaceholderText('Incoming Media')
elif selected == [len(self.layer_list) - 1]:
prefix = 'Substrate.'
self.Name_lineEdit.setPlaceholderText('Substrate')
else:
prefix = 'Layer{0}.'.format(np.min(selected) - 1)
if len(selected) == 1:
self.Name_lineEdit.setPlaceholderText(
'Layer{0}'.format(np.min(selected) - 1))
else:
self.Name_lineEdit.setPlaceholderText(
'Layer{0} multiple'.format(np.min(selected) - 1))
self.Thickness.updateUiFromParameter(
[self.layer_list[x].thickness for x in self.selection],
self.ties_thickness, prefix)
self.NSLDR.updateUiFromParameter(
[self.layer_list[x].nsld_real for x in self.selection],
self.ties_nsld_real, prefix)
self.NSLDI.updateUiFromParameter(
[self.layer_list[x].nsld_imaginary for x in self.selection],
self.ties_nsld_imaginary, prefix)
self.MSLD_rho.updateUiFromParameter(
[self.layer_list[x].msld.rho for x in self.selection],
self.ties_msld_rho, prefix)
self.MSLD_theta.updateUiFromParameter(
[self.layer_list[x].msld.theta for x in self.selection],
self.ties_msld_theta, prefix)
self.MSLD_phi.updateUiFromParameter(
[self.layer_list[x].msld.phi for x in self.selection],
self.ties_msld_phi, prefix)
self.MSLD_rho.updateUiFromParameter(
[self.layer_list[x].msld.rho for x in self.selection],
self.ties_msld_rho, prefix)
self.Roughness.updateUiFromParameter(
[self.layer_list[x].roughness for x in self.selection],
self.ties_roughness, prefix)
self.update_UI_roughness_model(
[self.layer_list[x].roughness_model for x in self.selection],
[self.layer_list[x].sublayers for x in self.selection])
def reset(self):
self.set_selection(self.selection)
def update_UI_roughness_model(self, roughness_model_list, sublayers_list):
if len(set(sublayers_list)) == 1:
self.sublayers_spinBox.setValue(sublayers_list[0])
else:
self.sublayers_spinBox.setValue(-1)
if len(set(roughness_model_list)) == 1:
self.roughness_model_comboBox.setCurrentIndex(
self.roughness_model_comboBox.findText(
roughness_model_list[0].name))
else:
self.roughness_model_comboBox.setCurrentIndex(
0) # select the 'Unchanged'
def update_roughness_model(self):
if self.roughness_model_comboBox.currentIndex(
) != 0: # not the 'Unchanged'
for x in self.selection:
self.layer_list[x].roughness_model = RoughnessModel[
self.roughness_model_comboBox.currentText()]
if self.sublayers_spinBox.value() != -1: # not the 'Unchanged'
for x in self.selection:
self.layer_list[x].sublayers = self.sublayers_spinBox.value()
def apply(self):
if self.Name_lineEdit.text().strip() != '':
for x in self.selection:
self.layer_list[x].name = self.Name_lineEdit.text().strip()
self.Thickness.update_parameter()
self.NSLDR.update_parameter()
self.NSLDI.update_parameter()
self.MSLD_rho.update_parameter()
self.MSLD_theta.update_parameter()
self.MSLD_phi.update_parameter()
self.Roughness.update_parameter()
self.update_roughness_model()
self.sampleModelChanged.emit(self.sample_model)
def show_hide_roughness_extras(self, selected_tab):
if selected_tab == 5: # roughness tab selected
self.roughness_model_label.show()
self.roughness_model_comboBox.show()
self.sublayers_label.show()
self.sublayers_spinBox.show()
else:
self.roughness_model_label.hide()
self.roughness_model_comboBox.hide()
self.sublayers_label.hide()
self.sublayers_spinBox.hide()
else:
layer = self.sample_model.layers[i//7-1]
layer.name=name.split('.')[0]
property_name = name.split(layer.name+'.')[1]
if 'msld' in property_name:
msld_property_name = property_name.split('.')[1]
layer.msld.__getattribute__(msld_property_name).name=msld_property_name
layer.msld.__getattribute__(msld_property_name).value=params[p].value
layer.msld.__getattribute__(msld_property_name).minimum=params[p].min
layer.msld.__getattribute__(msld_property_name).maximum=params[p].max
layer.msld.__getattribute__(msld_property_name).vary=params[p].vary
layer.msld.__getattribute__(msld_property_name).expr=params[p].expr
else:
layer.__getattribute__(property_name).name=property_name
layer.__getattribute__(property_name).value=params[p].value
layer.__getattribute__(property_name).minimum=params[p].min
layer.__getattribute__(property_name).maximum=params[p].max
layer.__getattribute__(property_name).vary=params[p].vary
layer.__getattribute__(property_name).expr=params[p].expr
if __name__ == "__main__":
from licorne.SampleModel import SampleModel
sm = SampleModel()
ma = ModelAdapter(sm)
ps = ma.params_from_model()
ps['substrate___nsld_real'].value=42.
ps['substrate___msld___rho'].min=42.5
ma.update_model_from_params(ps)
print(sm.substrate)
ax.stem(depth, val, linefmt='--')
ax.set_xlim(xmin, xmax)
ax.axhline(y=0)
ax.set_xlabel('Depth')
ax.set_ylabel(parameter.replace('_', ' '))
return sublayers, corresponding
if __name__ == '__main__':
# This is for testing purposes only
import sys
app = QtWidgets.QApplication(sys.argv)
mainForm = layerplot()
from licorne.layer import RoughnessModel
from licorne.SampleModel import SampleModel
newSample = SampleModel()
newSample.incoming_media = Layer(thickness=np.inf, nsld_real=1.5)
newSample.layers = [
Layer(thickness=20., nsld_real=1.),
Layer(thickness=25.,
nsld_real=3.,
roughness=5,
roughness_model=RoughnessModel.TANH,
sublayers=7),
Layer(thickness=30.,
nsld_real=5.,
msld_rho=7e-7,
roughness=3,
roughness_model=RoughnessModel.TANH,
sublayers=7)
]