[dc5ef15] | 1 | import sys |
---|
| 2 | import os |
---|
| 3 | import numpy |
---|
| 4 | import logging |
---|
| 5 | import time |
---|
| 6 | |
---|
| 7 | from PyQt4 import QtGui |
---|
| 8 | from PyQt4 import QtCore |
---|
| 9 | from twisted.internet import threads |
---|
| 10 | from mpl_toolkits.mplot3d import Axes3D |
---|
| 11 | |
---|
| 12 | import sas.qtgui.Utilities.GuiUtils as GuiUtils |
---|
| 13 | |
---|
| 14 | from sas.qtgui.Utilities.GenericReader import GenReader |
---|
| 15 | |
---|
| 16 | from sas.sascalc.dataloader.data_info import Detector |
---|
| 17 | from sas.sascalc.dataloader.data_info import Source |
---|
| 18 | from sas.sascalc.calculator import sas_gen |
---|
| 19 | |
---|
| 20 | from sas.qtgui.Plotting.Arrow3D import Arrow3D |
---|
| 21 | from sas.qtgui.Plotting.PlotterBase import PlotterBase |
---|
| 22 | from sas.qtgui.Plotting.Plotter2D import Plotter2D |
---|
| 23 | from sas.qtgui.Plotting.Plotter import Plotter |
---|
| 24 | from sas.qtgui.Plotting.PlotterData import Data1D |
---|
| 25 | from sas.qtgui.Plotting.PlotterData import Data2D |
---|
| 26 | |
---|
| 27 | # Local UI |
---|
| 28 | from UI.GenericScatteringCalculator import Ui_GenericScatteringCalculator |
---|
| 29 | |
---|
| 30 | _Q1D_MIN = 0.001 |
---|
| 31 | |
---|
| 32 | |
---|
| 33 | class GenericScatteringCalculator(QtGui.QDialog, Ui_GenericScatteringCalculator): |
---|
| 34 | |
---|
| 35 | trigger_plot_3d = QtCore.pyqtSignal() |
---|
| 36 | |
---|
| 37 | def __init__(self, parent=None): |
---|
| 38 | super(GenericScatteringCalculator, self).__init__() |
---|
| 39 | self.setupUi(self) |
---|
| 40 | self.manager = parent |
---|
| 41 | self.communicator = self.manager.communicator() |
---|
| 42 | self.model = sas_gen.GenSAS() |
---|
| 43 | self.omf_reader = sas_gen.OMFReader() |
---|
| 44 | self.sld_reader = sas_gen.SLDReader() |
---|
| 45 | self.pdb_reader = sas_gen.PDBReader() |
---|
| 46 | self.reader = None |
---|
| 47 | self.sld_data = None |
---|
| 48 | |
---|
| 49 | self.parameters = [] |
---|
| 50 | self.data = None |
---|
| 51 | self.datafile = None |
---|
| 52 | self.file_name = '' |
---|
| 53 | self.ext = None |
---|
| 54 | self.default_shape = str(self.cbShape.currentText()) |
---|
| 55 | self.is_avg = False |
---|
| 56 | self.data_to_plot = None |
---|
| 57 | |
---|
| 58 | # combox box |
---|
| 59 | self.cbOptionsCalc.setVisible(False) |
---|
| 60 | |
---|
| 61 | # push buttons |
---|
| 62 | self.cmdClose.clicked.connect(self.accept) |
---|
| 63 | self.cmdHelp.clicked.connect(self.onHelp) |
---|
| 64 | |
---|
| 65 | self.cmdLoad.clicked.connect(self.loadFile) |
---|
| 66 | self.cmdCompute.clicked.connect(self.onCompute) |
---|
| 67 | self.cmdReset.clicked.connect(self.onReset) |
---|
| 68 | self.cmdSave.clicked.connect(self.onSaveFile) |
---|
| 69 | |
---|
| 70 | self.cmdDraw.clicked.connect(lambda: self.plot3d(has_arrow=True)) |
---|
| 71 | self.cmdDrawpoints.clicked.connect(lambda: self.plot3d(has_arrow=False)) |
---|
| 72 | |
---|
| 73 | # validators |
---|
| 74 | # scale, volume and background must be positive |
---|
| 75 | validat_regex_pos = QtCore.QRegExp('^[+]?([.]\d+|\d+([.]\d+)?)$') |
---|
| 76 | self.txtScale.setValidator(QtGui.QRegExpValidator(validat_regex_pos, |
---|
| 77 | self.txtScale)) |
---|
| 78 | self.txtBackground.setValidator(QtGui.QRegExpValidator( |
---|
| 79 | validat_regex_pos, self.txtBackground)) |
---|
| 80 | self.txtTotalVolume.setValidator(QtGui.QRegExpValidator( |
---|
| 81 | validat_regex_pos, self.txtTotalVolume)) |
---|
| 82 | |
---|
| 83 | # fraction of spin up between 0 and 1 |
---|
| 84 | validat_regexbetween0_1 = QtCore.QRegExp('^(0(\.\d*)*|1(\.0+)?)$') |
---|
| 85 | self.txtUpFracIn.setValidator( |
---|
| 86 | QtGui.QRegExpValidator(validat_regexbetween0_1, self.txtUpFracIn)) |
---|
| 87 | self.txtUpFracOut.setValidator( |
---|
| 88 | QtGui.QRegExpValidator(validat_regexbetween0_1, self.txtUpFracOut)) |
---|
| 89 | |
---|
| 90 | # 0 < Qmax <= 1000 |
---|
| 91 | validat_regex_q = QtCore.QRegExp('^1000$|^[+]?(\d{1,3}([.]\d+)?)$') |
---|
| 92 | self.txtQxMax.setValidator(QtGui.QRegExpValidator(validat_regex_q, |
---|
| 93 | self.txtQxMax)) |
---|
| 94 | self.txtQxMax.textChanged.connect(self.check_value) |
---|
| 95 | |
---|
| 96 | # 2 <= Qbin <= 1000 |
---|
| 97 | self.txtNoQBins.setValidator(QtGui.QRegExpValidator(validat_regex_q, |
---|
| 98 | self.txtNoQBins)) |
---|
| 99 | self.txtNoQBins.textChanged.connect(self.check_value) |
---|
| 100 | |
---|
| 101 | # plots - 3D in real space |
---|
| 102 | self.trigger_plot_3d.connect(lambda: self.plot3d(has_arrow=False)) |
---|
| 103 | |
---|
| 104 | self.graph_num = 1 # index for name of graph |
---|
| 105 | |
---|
| 106 | # TODO the option Ellipsoid has not been implemented |
---|
| 107 | self.cbShape.currentIndexChanged.connect(self.selectedshapechange) |
---|
| 108 | |
---|
| 109 | def selectedshapechange(self): |
---|
| 110 | """ |
---|
| 111 | TODO Temporary solution to display information about option 'Ellipsoid' |
---|
| 112 | """ |
---|
| 113 | print "The option Ellipsoid has not been implemented yet." |
---|
| 114 | self.communicator.statusBarUpdateSignal.emit( |
---|
| 115 | "The option Ellipsoid has not been implemented yet.") |
---|
| 116 | |
---|
| 117 | def loadFile(self): |
---|
| 118 | """ |
---|
| 119 | Open menu to choose the datafile to load |
---|
| 120 | Only extensions .SLD, .PDB, .OMF, .sld, .pdb, .omf |
---|
| 121 | """ |
---|
| 122 | try: |
---|
| 123 | self.datafile = QtGui.QFileDialog.getOpenFileName( |
---|
| 124 | self, "Choose a file", "", "All Gen files (*.OMF *.omf) ;;" |
---|
| 125 | "SLD files (*.SLD *.sld);;PDB files (*.pdb *.PDB);; " |
---|
| 126 | "OMF files (*.OMF *.omf);; " |
---|
| 127 | "All files (*.*)") |
---|
| 128 | if self.datafile: |
---|
| 129 | self.default_shape = str(self.cbShape.currentText()) |
---|
| 130 | self.file_name = os.path.basename(str(self.datafile)) |
---|
| 131 | self.ext = os.path.splitext(str(self.datafile))[1] |
---|
| 132 | if self.ext in self.omf_reader.ext: |
---|
| 133 | loader = self.omf_reader |
---|
| 134 | elif self.ext in self.sld_reader.ext: |
---|
| 135 | loader = self.sld_reader |
---|
| 136 | elif self.ext in self.pdb_reader.ext: |
---|
| 137 | loader = self.pdb_reader |
---|
| 138 | else: |
---|
| 139 | loader = None |
---|
| 140 | # disable some entries depending on type of loaded file |
---|
| 141 | # (according to documentation) |
---|
| 142 | if self.ext.lower() in ['.sld', '.omf', '.pdb']: |
---|
| 143 | self.txtUpFracIn.setEnabled(False) |
---|
| 144 | self.txtUpFracOut.setEnabled(False) |
---|
| 145 | self.txtUpTheta.setEnabled(False) |
---|
| 146 | |
---|
| 147 | if self.reader is not None and self.reader.isrunning(): |
---|
| 148 | self.reader.stop() |
---|
| 149 | self.cmdLoad.setEnabled(False) |
---|
| 150 | self.cmdLoad.setText('Loading...') |
---|
| 151 | self.communicator.statusBarUpdateSignal.emit( |
---|
| 152 | "Loading File {}".format(os.path.basename( |
---|
| 153 | str(self.datafile)))) |
---|
| 154 | self.reader = GenReader(path=str(self.datafile), loader=loader, |
---|
| 155 | completefn=self.complete_loading, |
---|
| 156 | updatefn=self.load_update) |
---|
| 157 | self.reader.queue() |
---|
| 158 | except (RuntimeError, IOError): |
---|
| 159 | log_msg = "Generic SAS Calculator: %s" % sys.exc_value |
---|
| 160 | logging.info(log_msg) |
---|
| 161 | raise |
---|
| 162 | return |
---|
| 163 | |
---|
| 164 | def load_update(self): |
---|
| 165 | """ Legacy function used in GenRead """ |
---|
| 166 | if self.reader.isrunning(): |
---|
| 167 | status_type = "progress" |
---|
| 168 | else: |
---|
| 169 | status_type = "stop" |
---|
| 170 | logging.info(status_type) |
---|
| 171 | |
---|
| 172 | def complete_loading(self, data=None): |
---|
| 173 | """ Function used in GenRead""" |
---|
| 174 | self.cbShape.setEnabled(False) |
---|
| 175 | try: |
---|
| 176 | is_pdbdata = False |
---|
| 177 | self.txtData.setText(os.path.basename(str(self.datafile))) |
---|
| 178 | self.is_avg = False |
---|
| 179 | if self.ext in self.omf_reader.ext: |
---|
| 180 | gen = sas_gen.OMF2SLD() |
---|
| 181 | gen.set_data(data) |
---|
| 182 | self.sld_data = gen.get_magsld() |
---|
| 183 | self.check_units() |
---|
| 184 | elif self.ext in self.sld_reader.ext: |
---|
| 185 | self.sld_data = data |
---|
| 186 | elif self.ext in self.pdb_reader.ext: |
---|
| 187 | self.sld_data = data |
---|
| 188 | is_pdbdata = True |
---|
| 189 | # Display combobox of orientation only for pdb data |
---|
| 190 | self.cbOptionsCalc.setVisible(is_pdbdata) |
---|
| 191 | self.update_gui() |
---|
| 192 | except IOError: |
---|
| 193 | log_msg = "Loading Error: " \ |
---|
| 194 | "This file format is not supported for GenSAS." |
---|
| 195 | logging.info(log_msg) |
---|
| 196 | raise |
---|
| 197 | except ValueError: |
---|
| 198 | log_msg = "Could not find any data" |
---|
| 199 | logging.info(log_msg) |
---|
| 200 | raise |
---|
| 201 | logging.info("Load Complete") |
---|
| 202 | self.cmdLoad.setEnabled(True) |
---|
| 203 | self.cmdLoad.setText('Load') |
---|
| 204 | self.trigger_plot_3d.emit() |
---|
| 205 | |
---|
| 206 | def check_units(self): |
---|
| 207 | """ |
---|
| 208 | Check if the units from the OMF file correspond to the default ones |
---|
| 209 | displayed on the interface. |
---|
| 210 | If not, modify the GUI with the correct unit |
---|
| 211 | """ |
---|
| 212 | # TODO: adopt the convention of font and symbol for the updated values |
---|
| 213 | if sas_gen.OMFData().valueunit != 'A^(-2)': |
---|
| 214 | value_unit = sas_gen.OMFData().valueunit |
---|
| 215 | self.lbl_unitMx.setText(value_unit) |
---|
| 216 | self.lbl_unitMy.setText(value_unit) |
---|
| 217 | self.lbl_unitMz.setText(value_unit) |
---|
| 218 | self.lbl_unitNucl.setText(value_unit) |
---|
| 219 | if sas_gen.OMFData().meshunit != 'A': |
---|
| 220 | mesh_unit = sas_gen.OMFData().meshunit |
---|
| 221 | self.lbl_unitx.setText(mesh_unit) |
---|
| 222 | self.lbl_unity.setText(mesh_unit) |
---|
| 223 | self.lbl_unitz.setText(mesh_unit) |
---|
| 224 | self.lbl_unitVolume.setText(mesh_unit+"^3") |
---|
| 225 | |
---|
| 226 | def check_value(self): |
---|
| 227 | """Check range of text edits for QMax and Number of Qbins """ |
---|
| 228 | text_edit = self.sender() |
---|
| 229 | text_edit.setStyleSheet( |
---|
| 230 | QtCore.QString.fromUtf8('background-color: rgb(255, 255, 255);')) |
---|
| 231 | if text_edit.text(): |
---|
| 232 | value = float(str(text_edit.text())) |
---|
| 233 | if text_edit == self.txtQxMax: |
---|
| 234 | if value <= 0 or value > 1000: |
---|
| 235 | text_edit.setStyleSheet(QtCore.QString.fromUtf8( |
---|
| 236 | 'background-color: rgb(255, 182, 193);')) |
---|
| 237 | else: |
---|
| 238 | text_edit.setStyleSheet(QtCore.QString.fromUtf8( |
---|
| 239 | 'background-color: rgb(255, 255, 255);')) |
---|
| 240 | elif text_edit == self.txtNoQBins: |
---|
| 241 | if value < 2 or value > 1000: |
---|
| 242 | self.txtNoQBins.setStyleSheet(QtCore.QString.fromUtf8( |
---|
| 243 | 'background-color: rgb(255, 182, 193);')) |
---|
| 244 | else: |
---|
| 245 | self.txtNoQBins.setStyleSheet(QtCore.QString.fromUtf8( |
---|
| 246 | 'background-color: rgb(255, 255, 255);')) |
---|
| 247 | |
---|
| 248 | def update_gui(self): |
---|
| 249 | """ Update the interface with values from loaded data """ |
---|
| 250 | self.model.set_is_avg(self.is_avg) |
---|
| 251 | self.model.set_sld_data(self.sld_data) |
---|
| 252 | self.model.params['total_volume'] = len(self.sld_data.sld_n)*self.sld_data.vol_pix[0] |
---|
| 253 | |
---|
| 254 | # add condition for activation of save button |
---|
| 255 | self.cmdSave.setEnabled(True) |
---|
| 256 | |
---|
| 257 | # activation of 3D plots' buttons (with and without arrows) |
---|
| 258 | self.cmdDraw.setEnabled(self.sld_data is not None) |
---|
| 259 | self.cmdDrawpoints.setEnabled(self.sld_data is not None) |
---|
| 260 | |
---|
| 261 | self.txtScale.setText(str(self.model.params['scale'])) |
---|
| 262 | self.txtBackground.setText(str(self.model.params['background'])) |
---|
| 263 | self.txtSolventSLD.setText(str(self.model.params['solvent_SLD'])) |
---|
| 264 | |
---|
| 265 | # Volume to write to interface: npts x volume of first pixel |
---|
| 266 | self.txtTotalVolume.setText(str(len(self.sld_data.sld_n)*self.sld_data.vol_pix[0])) |
---|
| 267 | |
---|
| 268 | self.txtUpFracIn.setText(str(self.model.params['Up_frac_in'])) |
---|
| 269 | self.txtUpFracOut.setText(str(self.model.params['Up_frac_out'])) |
---|
| 270 | self.txtUpTheta.setText(str(self.model.params['Up_theta'])) |
---|
| 271 | |
---|
| 272 | self.txtNoPixels.setText(str(len(self.sld_data.sld_n))) |
---|
| 273 | self.txtNoPixels.setEnabled(False) |
---|
| 274 | |
---|
| 275 | list_parameters = ['sld_mx', 'sld_my', 'sld_mz', 'sld_n', 'xnodes', |
---|
| 276 | 'ynodes', 'znodes', 'xstepsize', 'ystepsize', |
---|
| 277 | 'zstepsize'] |
---|
| 278 | list_gui_button = [self.txtMx, self.txtMy, self.txtMz, self.txtNucl, |
---|
| 279 | self.txtXnodes, self.txtYnodes, self.txtZnodes, |
---|
| 280 | self.txtXstepsize, self.txtYstepsize, |
---|
| 281 | self.txtZstepsize] |
---|
| 282 | |
---|
| 283 | # Fill right hand side of GUI |
---|
| 284 | for indx, item in enumerate(list_parameters): |
---|
| 285 | if getattr(self.sld_data, item) is None: |
---|
| 286 | list_gui_button[indx].setText('NaN') |
---|
| 287 | else: |
---|
| 288 | value = getattr(self.sld_data, item) |
---|
| 289 | if isinstance(value, numpy.ndarray): |
---|
| 290 | item_for_gui = str(GuiUtils.formatNumber(numpy.average(value), True)) |
---|
| 291 | else: |
---|
| 292 | item_for_gui = str(GuiUtils.formatNumber(value, True)) |
---|
| 293 | list_gui_button[indx].setText(item_for_gui) |
---|
| 294 | |
---|
| 295 | # Enable / disable editing of right hand side of GUI |
---|
| 296 | for indx, item in enumerate(list_parameters): |
---|
| 297 | if indx < 4: |
---|
| 298 | # this condition only applies to Mx,y,z and Nucl |
---|
| 299 | value = getattr(self.sld_data, item) |
---|
| 300 | enable = self.sld_data.pix_type == 'pixel' \ |
---|
| 301 | and numpy.min(value) == numpy.max(value) |
---|
| 302 | else: |
---|
| 303 | enable = not self.sld_data.is_data |
---|
| 304 | list_gui_button[indx].setEnabled(enable) |
---|
| 305 | |
---|
| 306 | def write_new_values_from_gui(self): |
---|
| 307 | """ |
---|
| 308 | update parameters using modified inputs from GUI |
---|
| 309 | used before computing |
---|
| 310 | """ |
---|
| 311 | if self.txtScale.isModified(): |
---|
| 312 | self.model.params['scale'] = float(self.txtScale.text()) |
---|
| 313 | |
---|
| 314 | if self.txtBackground.isModified(): |
---|
| 315 | self.model.params['background'] = float(self.txtBackground.text()) |
---|
| 316 | |
---|
| 317 | if self.txtSolventSLD.isModified(): |
---|
| 318 | self.model.params['solvent_SLD'] = float(self.txtSolventSLD.text()) |
---|
| 319 | |
---|
| 320 | # Different condition for total volume to get correct volume after |
---|
| 321 | # applying set_sld_data in compute |
---|
| 322 | if self.txtTotalVolume.isModified() \ |
---|
| 323 | or self.model.params['total_volume'] != float(self.txtTotalVolume.text()): |
---|
| 324 | self.model.params['total_volume'] = float(self.txtTotalVolume.text()) |
---|
| 325 | |
---|
| 326 | if self.txtUpFracIn.isModified(): |
---|
| 327 | self.model.params['Up_frac_in'] = float(self.txtUpFracIn.text()) |
---|
| 328 | |
---|
| 329 | if self.txtUpFracOut.isModified(): |
---|
| 330 | self.model.params['Up_frac_out'] = float(self.txtUpFracOut.text()) |
---|
| 331 | |
---|
| 332 | if self.txtUpTheta.isModified(): |
---|
| 333 | self.model.params['Up_theta'] = float(self.txtUpTheta.text()) |
---|
| 334 | |
---|
| 335 | if self.txtMx.isModified(): |
---|
| 336 | self.sld_data.sld_mx = float(self.txtMx.text())*\ |
---|
| 337 | numpy.ones(len(self.sld_data.sld_mx)) |
---|
| 338 | |
---|
| 339 | if self.txtMy.isModified(): |
---|
| 340 | self.sld_data.sld_my = float(self.txtMy.text())*\ |
---|
| 341 | numpy.ones(len(self.sld_data.sld_my)) |
---|
| 342 | |
---|
| 343 | if self.txtMz.isModified(): |
---|
| 344 | self.sld_data.sld_mz = float(self.txtMz.text())*\ |
---|
| 345 | numpy.ones(len(self.sld_data.sld_mz)) |
---|
| 346 | |
---|
| 347 | if self.txtNucl.isModified(): |
---|
| 348 | self.sld_data.sld_n = float(self.txtNucl.text())*\ |
---|
| 349 | numpy.ones(len(self.sld_data.sld_n)) |
---|
| 350 | |
---|
| 351 | if self.txtXnodes.isModified(): |
---|
| 352 | self.sld_data.xnodes = int(self.txtXnodes.text()) |
---|
| 353 | |
---|
| 354 | if self.txtYnodes.isModified(): |
---|
| 355 | self.sld_data.ynodes = int(self.txtYnodes.text()) |
---|
| 356 | |
---|
| 357 | if self.txtZnodes.isModified(): |
---|
| 358 | self.sld_data.znodes = int(self.txtZnodes.text()) |
---|
| 359 | |
---|
| 360 | if self.txtXstepsize.isModified(): |
---|
| 361 | self.sld_data.xstepsize = float(self.txtXstepsize.text()) |
---|
| 362 | |
---|
| 363 | if self.txtYstepsize.isModified(): |
---|
| 364 | self.sld_data.ystepsize = float(self.txtYstepsize.text()) |
---|
| 365 | |
---|
| 366 | if self.txtZstepsize.isModified(): |
---|
| 367 | self.sld_data.zstepsize = float(self.txtZstepsize.text()) |
---|
| 368 | |
---|
| 369 | if self.cbOptionsCalc.isVisible(): |
---|
| 370 | self.is_avg = (self.cbOptionsCalc.currentIndex() == 1) |
---|
| 371 | |
---|
| 372 | def onHelp(self): |
---|
| 373 | """ |
---|
| 374 | Bring up the Generic Scattering calculator Documentation whenever |
---|
| 375 | the HELP button is clicked. |
---|
| 376 | Calls Documentation Window with the path of the location within the |
---|
| 377 | documentation tree (after /doc/ ....". |
---|
| 378 | """ |
---|
| 379 | try: |
---|
| 380 | location = self.manager.HELP_DIRECTORY_LOCATION + \ |
---|
| 381 | "/user/sasgui/perspectives/calculator/sas_calculator_help.html" |
---|
| 382 | self.manager._helpView.load(QtCore.QUrl(location)) |
---|
| 383 | self.manager._helpView.show() |
---|
| 384 | except AttributeError: |
---|
| 385 | # No manager defined - testing and standalone runs |
---|
| 386 | pass |
---|
| 387 | |
---|
| 388 | def onReset(self): |
---|
| 389 | """ Reset the inputs of textEdit to default values """ |
---|
| 390 | try: |
---|
| 391 | # reset values in textedits |
---|
| 392 | self.txtUpFracIn.setText("1.0") |
---|
| 393 | self.txtUpFracOut.setText("1.0") |
---|
| 394 | self.txtUpTheta.setText("0.0") |
---|
| 395 | self.txtBackground.setText("0.0") |
---|
| 396 | self.txtScale.setText("1.0") |
---|
| 397 | self.txtSolventSLD.setText("0.0") |
---|
| 398 | self.txtTotalVolume.setText("216000.0") |
---|
| 399 | self.txtNoQBins.setText("50") |
---|
| 400 | self.txtQxMax.setText("0.3") |
---|
| 401 | self.txtNoPixels.setText("1000") |
---|
| 402 | self.txtMx.setText("0") |
---|
| 403 | self.txtMy.setText("0") |
---|
| 404 | self.txtMz.setText("0") |
---|
| 405 | self.txtNucl.setText("6.97e-06") |
---|
| 406 | self.txtXnodes.setText("10") |
---|
| 407 | self.txtYnodes.setText("10") |
---|
| 408 | self.txtZnodes.setText("10") |
---|
| 409 | self.txtXstepsize.setText("6") |
---|
| 410 | self.txtYstepsize.setText("6") |
---|
| 411 | self.txtZstepsize.setText("6") |
---|
| 412 | # reset Load button and textedit |
---|
| 413 | self.txtData.setText('Default SLD Profile') |
---|
| 414 | self.cmdLoad.setEnabled(True) |
---|
| 415 | self.cmdLoad.setText('Load') |
---|
| 416 | # reset option for calculation |
---|
| 417 | self.cbOptionsCalc.setCurrentIndex(0) |
---|
| 418 | self.cbOptionsCalc.setVisible(False) |
---|
| 419 | # reset shape button |
---|
| 420 | self.cbShape.setCurrentIndex(0) |
---|
| 421 | self.cbShape.setEnabled(True) |
---|
| 422 | # reset compute button |
---|
| 423 | self.cmdCompute.setText('Compute') |
---|
| 424 | self.cmdCompute.setEnabled(True) |
---|
| 425 | # TODO reload default data set |
---|
| 426 | self._create_default_sld_data() |
---|
| 427 | |
---|
| 428 | finally: |
---|
| 429 | pass |
---|
| 430 | |
---|
| 431 | def _create_default_2d_data(self): |
---|
| 432 | """ |
---|
| 433 | Copied from previous version |
---|
| 434 | Create 2D data by default |
---|
| 435 | :warning: This data is never plotted. |
---|
| 436 | """ |
---|
| 437 | self.qmax_x = float(self.txtQxMax.text()) |
---|
| 438 | self.npts_x = int(self.txtNoQBins.text()) |
---|
| 439 | self.data = Data2D() |
---|
| 440 | self.data.is_data = False |
---|
| 441 | # # Default values |
---|
| 442 | self.data.detector.append(Detector()) |
---|
| 443 | index = len(self.data.detector) - 1 |
---|
| 444 | self.data.detector[index].distance = 8000 # mm |
---|
| 445 | self.data.source.wavelength = 6 # A |
---|
| 446 | self.data.detector[index].pixel_size.x = 5 # mm |
---|
| 447 | self.data.detector[index].pixel_size.y = 5 # mm |
---|
| 448 | self.data.detector[index].beam_center.x = self.qmax_x |
---|
| 449 | self.data.detector[index].beam_center.y = self.qmax_x |
---|
| 450 | xmax = self.qmax_x |
---|
| 451 | xmin = -xmax |
---|
| 452 | ymax = self.qmax_x |
---|
| 453 | ymin = -ymax |
---|
| 454 | qstep = self.npts_x |
---|
| 455 | |
---|
| 456 | x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) |
---|
| 457 | y = numpy.linspace(start=ymin, stop=ymax, num=qstep, endpoint=True) |
---|
| 458 | # use data info instead |
---|
| 459 | new_x = numpy.tile(x, (len(y), 1)) |
---|
| 460 | new_y = numpy.tile(y, (len(x), 1)) |
---|
| 461 | new_y = new_y.swapaxes(0, 1) |
---|
| 462 | # all data require now in 1d array |
---|
| 463 | qx_data = new_x.flatten() |
---|
| 464 | qy_data = new_y.flatten() |
---|
| 465 | q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) |
---|
| 466 | # set all True (standing for unmasked) as default |
---|
| 467 | mask = numpy.ones(len(qx_data), dtype=bool) |
---|
| 468 | self.data.source = Source() |
---|
| 469 | self.data.data = numpy.ones(len(mask)) |
---|
| 470 | self.data.err_data = numpy.ones(len(mask)) |
---|
| 471 | self.data.qx_data = qx_data |
---|
| 472 | self.data.qy_data = qy_data |
---|
| 473 | self.data.q_data = q_data |
---|
| 474 | self.data.mask = mask |
---|
| 475 | # store x and y bin centers in q space |
---|
| 476 | self.data.x_bins = x |
---|
| 477 | self.data.y_bins = y |
---|
| 478 | # max and min taking account of the bin sizes |
---|
| 479 | self.data.xmin = xmin |
---|
| 480 | self.data.xmax = xmax |
---|
| 481 | self.data.ymin = ymin |
---|
| 482 | self.data.ymax = ymax |
---|
| 483 | |
---|
| 484 | def _create_default_sld_data(self): |
---|
| 485 | """ |
---|
| 486 | Copied from previous version |
---|
| 487 | Making default sld-data |
---|
| 488 | """ |
---|
| 489 | sld_n_default = 6.97e-06 # what is this number?? |
---|
| 490 | omfdata = sas_gen.OMFData() |
---|
| 491 | omf2sld = sas_gen.OMF2SLD() |
---|
| 492 | omf2sld.set_data(omfdata, self.default_shape) |
---|
| 493 | self.sld_data = omf2sld.output |
---|
| 494 | self.sld_data.is_data = False |
---|
| 495 | self.sld_data.filename = "Default SLD Profile" |
---|
| 496 | self.sld_data.set_sldn(sld_n_default) |
---|
| 497 | |
---|
| 498 | def _create_default_1d_data(self): |
---|
| 499 | """ |
---|
| 500 | Copied from previous version |
---|
| 501 | Create 1D data by default |
---|
| 502 | :warning: This data is never plotted. |
---|
| 503 | residuals.x = data_copy.x[index] |
---|
| 504 | residuals.dy = numpy.ones(len(residuals.y)) |
---|
| 505 | residuals.dx = None |
---|
| 506 | residuals.dxl = None |
---|
| 507 | residuals.dxw = None |
---|
| 508 | """ |
---|
| 509 | self.qmax_x = float(self.txtQxMax.text()) |
---|
| 510 | self.npts_x = int(self.txtNoQBins.text()) |
---|
| 511 | # Default values |
---|
| 512 | xmax = self.qmax_x |
---|
| 513 | xmin = self.qmax_x * _Q1D_MIN |
---|
| 514 | qstep = self.npts_x |
---|
| 515 | x = numpy.linspace(start=xmin, stop=xmax, num=qstep, endpoint=True) |
---|
| 516 | # store x and y bin centers in q space |
---|
| 517 | y = numpy.ones(len(x)) |
---|
| 518 | dy = numpy.zeros(len(x)) |
---|
| 519 | dx = numpy.zeros(len(x)) |
---|
| 520 | self.data = Data1D(x=x, y=y) |
---|
| 521 | self.data.dx = dx |
---|
| 522 | self.data.dy = dy |
---|
| 523 | |
---|
| 524 | def onCompute(self): |
---|
| 525 | """ |
---|
| 526 | Copied from previous version |
---|
| 527 | Execute the computation of I(qx, qy) |
---|
| 528 | """ |
---|
| 529 | # Set default data when nothing loaded yet |
---|
| 530 | if self.sld_data is None: |
---|
| 531 | self._create_default_sld_data() |
---|
| 532 | try: |
---|
| 533 | self.model.set_sld_data(self.sld_data) |
---|
| 534 | self.write_new_values_from_gui() |
---|
| 535 | if self.is_avg or self.is_avg is None: |
---|
| 536 | self._create_default_1d_data() |
---|
| 537 | i_out = numpy.zeros(len(self.data.y)) |
---|
| 538 | inputs = [self.data.x, [], i_out] |
---|
| 539 | else: |
---|
| 540 | self._create_default_2d_data() |
---|
| 541 | i_out = numpy.zeros(len(self.data.data)) |
---|
| 542 | inputs = [self.data.qx_data, self.data.qy_data, i_out] |
---|
| 543 | logging.info("Computation is in progress...") |
---|
| 544 | self.cmdCompute.setText('Wait...') |
---|
| 545 | self.cmdCompute.setEnabled(False) |
---|
| 546 | d = threads.deferToThread(self.complete, inputs, self._update) |
---|
| 547 | # Add deferred callback for call return |
---|
| 548 | d.addCallback(self.plot_1_2d) |
---|
| 549 | except: |
---|
| 550 | log_msg = "{}. stop".format(sys.exc_value) |
---|
| 551 | logging.info(log_msg) |
---|
| 552 | return |
---|
| 553 | |
---|
| 554 | def _update(self, value): |
---|
| 555 | """ |
---|
| 556 | Copied from previous version |
---|
| 557 | """ |
---|
| 558 | pass |
---|
| 559 | |
---|
| 560 | def complete(self, input, update=None): |
---|
| 561 | """ |
---|
| 562 | Gen compute complete function |
---|
| 563 | :Param input: input list [qx_data, qy_data, i_out] |
---|
| 564 | """ |
---|
| 565 | out = numpy.empty(0) |
---|
| 566 | for ind in range(len(input[0])): |
---|
| 567 | if self.is_avg: |
---|
| 568 | if ind % 1 == 0 and update is not None: |
---|
| 569 | # update() |
---|
| 570 | percentage = int(100.0 * float(ind) / len(input[0])) |
---|
| 571 | update(percentage) |
---|
| 572 | time.sleep(0.001) # 0.1 |
---|
| 573 | inputi = [input[0][ind:ind + 1], [], input[2][ind:ind + 1]] |
---|
| 574 | outi = self.model.run(inputi) |
---|
| 575 | out = numpy.append(out, outi) |
---|
| 576 | else: |
---|
| 577 | if ind % 50 == 0 and update is not None: |
---|
| 578 | percentage = int(100.0 * float(ind) / len(input[0])) |
---|
| 579 | update(percentage) |
---|
| 580 | time.sleep(0.001) |
---|
| 581 | inputi = [input[0][ind:ind + 1], input[1][ind:ind + 1], |
---|
| 582 | input[2][ind:ind + 1]] |
---|
| 583 | outi = self.model.runXY(inputi) |
---|
| 584 | out = numpy.append(out, outi) |
---|
| 585 | self.data_to_plot = out |
---|
| 586 | logging.info('Gen computation completed.') |
---|
| 587 | self.cmdCompute.setText('Compute') |
---|
| 588 | self.cmdCompute.setEnabled(True) |
---|
| 589 | return |
---|
| 590 | |
---|
| 591 | def onSaveFile(self): |
---|
| 592 | """Save data as .sld file""" |
---|
| 593 | path = os.path.dirname(str(self.datafile)) |
---|
| 594 | default_name = os.path.join(path, 'sld_file') |
---|
| 595 | kwargs = { |
---|
| 596 | 'parent': self, |
---|
| 597 | 'directory': default_name, |
---|
| 598 | 'filter': 'SLD file (*.sld)', |
---|
| 599 | 'options': QtGui.QFileDialog.DontUseNativeDialog} |
---|
| 600 | # Query user for filename. |
---|
| 601 | filename = str(QtGui.QFileDialog.getSaveFileName(**kwargs)) |
---|
| 602 | if filename: |
---|
| 603 | try: |
---|
| 604 | if os.path.splitext(filename)[1].lower() == '.sld': |
---|
| 605 | sas_gen.SLDReader().write(filename, self.sld_data) |
---|
| 606 | else: |
---|
| 607 | sas_gen.SLDReader().write('.'.join((filename, 'sld')), |
---|
| 608 | self.sld_data) |
---|
| 609 | except: |
---|
| 610 | raise |
---|
| 611 | |
---|
| 612 | def plot3d(self, has_arrow=False): |
---|
| 613 | """ Generate 3D plot in real space with or without arrows """ |
---|
| 614 | self.write_new_values_from_gui() |
---|
| 615 | graph_title = " Graph {}: {} 3D SLD Profile".format(self.graph_num, |
---|
| 616 | self.file_name) |
---|
| 617 | if has_arrow: |
---|
| 618 | graph_title += ' - Magnetic Vector as Arrow' |
---|
| 619 | |
---|
| 620 | plot3D = Plotter3D(self, graph_title) |
---|
| 621 | plot3D.plot(self.sld_data, has_arrow=has_arrow) |
---|
| 622 | plot3D.show() |
---|
| 623 | self.graph_num += 1 |
---|
| 624 | |
---|
| 625 | def plot_1_2d(self, d): |
---|
| 626 | """ Generate 1D or 2D plot, called in Compute""" |
---|
| 627 | if self.is_avg or self.is_avg is None: |
---|
| 628 | data = Data1D(x=self.data.x, y=self.data_to_plot) |
---|
| 629 | data.title = "GenSAS {} #{} 1D".format(self.file_name, |
---|
| 630 | int(self.graph_num)) |
---|
| 631 | data.xaxis('\\rm{Q_{x}}', '\AA^{-1}') |
---|
| 632 | data.yaxis('\\rm{Intensity}', 'cm^{-1}') |
---|
| 633 | plot1D = Plotter(self) |
---|
| 634 | plot1D.plot(data) |
---|
| 635 | plot1D.show() |
---|
| 636 | self.graph_num += 1 |
---|
| 637 | # TODO |
---|
| 638 | print 'TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED' |
---|
| 639 | return plot1D |
---|
| 640 | else: |
---|
| 641 | numpy.nan_to_num(self.data_to_plot) |
---|
| 642 | data = Data2D(image=self.data_to_plot, |
---|
| 643 | qx_data=self.data.qx_data, |
---|
| 644 | qy_data=self.data.qy_data, |
---|
| 645 | q_data=self.data.q_data, |
---|
| 646 | xmin=self.data.xmin, xmax=self.data.ymax, |
---|
| 647 | ymin=self.data.ymin, ymax=self.data.ymax, |
---|
| 648 | err_image=self.data.err_data) |
---|
| 649 | data.title = "GenSAS {} #{} 2D".format(self.file_name, |
---|
| 650 | int(self.graph_num)) |
---|
| 651 | plot2D = Plotter2D(self) |
---|
| 652 | plot2D.plot(data) |
---|
| 653 | plot2D.show() |
---|
| 654 | self.graph_num += 1 |
---|
| 655 | # TODO |
---|
| 656 | print 'TRANSFER OF DATA TO MAIN PANEL TO BE IMPLEMENTED' |
---|
| 657 | return plot2D |
---|
| 658 | |
---|
| 659 | |
---|
| 660 | class Plotter3DWidget(PlotterBase): |
---|
| 661 | """ |
---|
| 662 | 3D Plot widget for use with a QDialog |
---|
| 663 | """ |
---|
| 664 | def __init__(self, parent=None, manager=None): |
---|
| 665 | super(Plotter3DWidget, self).__init__(parent, manager=manager) |
---|
| 666 | |
---|
| 667 | @property |
---|
| 668 | def data(self): |
---|
| 669 | return self._data |
---|
| 670 | |
---|
| 671 | @data.setter |
---|
| 672 | def data(self, data=None): |
---|
| 673 | """ data setter """ |
---|
| 674 | self._data = data |
---|
| 675 | |
---|
| 676 | def plot(self, data=None, has_arrow=False): |
---|
| 677 | """ |
---|
| 678 | Plot 3D self._data |
---|
| 679 | """ |
---|
| 680 | self.data = data |
---|
| 681 | assert(self._data) |
---|
| 682 | # Prepare and show the plot |
---|
| 683 | self.showPlot(data=self.data, has_arrow=has_arrow) |
---|
| 684 | |
---|
| 685 | def showPlot(self, data, has_arrow=False): |
---|
| 686 | """ |
---|
| 687 | Render and show the current data |
---|
| 688 | """ |
---|
| 689 | # If we don't have any data, skip. |
---|
| 690 | if data is None: |
---|
| 691 | return |
---|
| 692 | color_dic = {'H': 'blue', 'D': 'purple', 'N': 'orange', |
---|
| 693 | 'O': 'red', 'C': 'green', 'P': 'cyan', 'Other': 'k'} |
---|
| 694 | marker = ',' |
---|
| 695 | m_size = 2 |
---|
| 696 | |
---|
| 697 | pos_x = data.pos_x |
---|
| 698 | pos_y = data.pos_y |
---|
| 699 | pos_z = data.pos_z |
---|
| 700 | sld_mx = data.sld_mx |
---|
| 701 | sld_my = data.sld_my |
---|
| 702 | sld_mz = data.sld_mz |
---|
| 703 | pix_symbol = data.pix_symbol |
---|
| 704 | sld_tot = numpy.fabs(sld_mx) + numpy.fabs(sld_my) + \ |
---|
| 705 | numpy.fabs(sld_mz) + numpy.fabs(data.sld_n) |
---|
| 706 | is_nonzero = sld_tot > 0.0 |
---|
| 707 | is_zero = sld_tot == 0.0 |
---|
| 708 | |
---|
| 709 | if data.pix_type == 'atom': |
---|
| 710 | marker = 'o' |
---|
| 711 | m_size = 3.5 |
---|
| 712 | |
---|
| 713 | self.figure.clear() |
---|
| 714 | self.figure.subplots_adjust(left=0.1, right=.8, bottom=.1) |
---|
| 715 | ax = Axes3D(self.figure) |
---|
| 716 | ax.set_xlabel('x ($\A{}$)'.format(data.pos_unit)) |
---|
| 717 | ax.set_ylabel('z ($\A{}$)'.format(data.pos_unit)) |
---|
| 718 | ax.set_zlabel('y ($\A{}$)'.format(data.pos_unit)) |
---|
| 719 | |
---|
| 720 | # I. Plot null points |
---|
| 721 | if is_zero.any(): |
---|
| 722 | im = ax.plot(pos_x[is_zero], pos_z[is_zero], pos_y[is_zero], |
---|
| 723 | marker, c="y", alpha=0.5, markeredgecolor='y', |
---|
| 724 | markersize=m_size) |
---|
| 725 | pos_x = pos_x[is_nonzero] |
---|
| 726 | pos_y = pos_y[is_nonzero] |
---|
| 727 | pos_z = pos_z[is_nonzero] |
---|
| 728 | sld_mx = sld_mx[is_nonzero] |
---|
| 729 | sld_my = sld_my[is_nonzero] |
---|
| 730 | sld_mz = sld_mz[is_nonzero] |
---|
| 731 | pix_symbol = data.pix_symbol[is_nonzero] |
---|
| 732 | # II. Plot selective points in color |
---|
| 733 | other_color = numpy.ones(len(pix_symbol), dtype='bool') |
---|
| 734 | for key in color_dic.keys(): |
---|
| 735 | chosen_color = pix_symbol == key |
---|
| 736 | if numpy.any(chosen_color): |
---|
| 737 | other_color = other_color & (chosen_color!=True) |
---|
| 738 | color = color_dic[key] |
---|
| 739 | im = ax.plot(pos_x[chosen_color], pos_z[chosen_color], |
---|
| 740 | pos_y[chosen_color], marker, c=color, alpha=0.5, |
---|
| 741 | markeredgecolor=color, markersize=m_size, label=key) |
---|
| 742 | # III. Plot All others |
---|
| 743 | if numpy.any(other_color): |
---|
| 744 | a_name = '' |
---|
| 745 | if data.pix_type == 'atom': |
---|
| 746 | # Get atom names not in the list |
---|
| 747 | a_names = [symb for symb in pix_symbol \ |
---|
| 748 | if symb not in color_dic.keys()] |
---|
| 749 | a_name = a_names[0] |
---|
| 750 | for name in a_names: |
---|
| 751 | new_name = ", " + name |
---|
| 752 | if a_name.count(name) == 0: |
---|
| 753 | a_name += new_name |
---|
| 754 | # plot in black |
---|
| 755 | im = ax.plot(pos_x[other_color], pos_z[other_color], |
---|
| 756 | pos_y[other_color], marker, c="k", alpha=0.5, |
---|
| 757 | markeredgecolor="k", markersize=m_size, label=a_name) |
---|
| 758 | if data.pix_type == 'atom': |
---|
| 759 | ax.legend(loc='upper left', prop={'size': 10}) |
---|
| 760 | # IV. Draws atomic bond with grey lines if any |
---|
| 761 | if data.has_conect: |
---|
| 762 | for ind in range(len(data.line_x)): |
---|
| 763 | im = ax.plot(data.line_x[ind], data.line_z[ind], |
---|
| 764 | data.line_y[ind], '-', lw=0.6, c="grey", |
---|
| 765 | alpha=0.3) |
---|
| 766 | # V. Draws magnetic vectors |
---|
| 767 | if has_arrow and len(pos_x) > 0: |
---|
| 768 | def _draw_arrow(input=None, update=None): |
---|
| 769 | """ |
---|
| 770 | draw magnetic vectors w/arrow |
---|
| 771 | """ |
---|
| 772 | max_mx = max(numpy.fabs(sld_mx)) |
---|
| 773 | max_my = max(numpy.fabs(sld_my)) |
---|
| 774 | max_mz = max(numpy.fabs(sld_mz)) |
---|
| 775 | max_m = max(max_mx, max_my, max_mz) |
---|
| 776 | try: |
---|
| 777 | max_step = max(data.xstepsize, data.ystepsize, data.zstepsize) |
---|
| 778 | except: |
---|
| 779 | max_step = 0 |
---|
| 780 | if max_step <= 0: |
---|
| 781 | max_step = 5 |
---|
| 782 | try: |
---|
| 783 | if max_m != 0: |
---|
| 784 | unit_x2 = sld_mx / max_m |
---|
| 785 | unit_y2 = sld_my / max_m |
---|
| 786 | unit_z2 = sld_mz / max_m |
---|
| 787 | # 0.8 is for avoiding the color becomes white=(1,1,1)) |
---|
| 788 | color_x = numpy.fabs(unit_x2 * 0.8) |
---|
| 789 | color_y = numpy.fabs(unit_y2 * 0.8) |
---|
| 790 | color_z = numpy.fabs(unit_z2 * 0.8) |
---|
| 791 | x2 = pos_x + unit_x2 * max_step |
---|
| 792 | y2 = pos_y + unit_y2 * max_step |
---|
| 793 | z2 = pos_z + unit_z2 * max_step |
---|
| 794 | x_arrow = numpy.column_stack((pos_x, x2)) |
---|
| 795 | y_arrow = numpy.column_stack((pos_y, y2)) |
---|
| 796 | z_arrow = numpy.column_stack((pos_z, z2)) |
---|
| 797 | colors = numpy.column_stack((color_x, color_y, color_z)) |
---|
| 798 | arrows = Arrow3D(self.figure, x_arrow, z_arrow, y_arrow, |
---|
| 799 | colors, mutation_scale=10, lw=1, |
---|
| 800 | arrowstyle="->", alpha=0.5) |
---|
| 801 | ax.add_artist(arrows) |
---|
| 802 | except: |
---|
| 803 | pass |
---|
| 804 | log_msg = "Arrow Drawing completed.\n" |
---|
| 805 | logging.info(log_msg) |
---|
| 806 | log_msg = "Arrow Drawing is in progress..." |
---|
| 807 | logging.info(log_msg) |
---|
| 808 | |
---|
| 809 | # Defer the drawing of arrows to another thread |
---|
| 810 | d = threads.deferToThread(_draw_arrow, ax) |
---|
| 811 | |
---|
| 812 | self.figure.canvas.resizing = False |
---|
| 813 | self.figure.canvas.draw() |
---|
| 814 | |
---|
| 815 | |
---|
| 816 | class Plotter3D(QtGui.QDialog, Plotter3DWidget): |
---|
| 817 | def __init__(self, parent=None, graph_title=''): |
---|
| 818 | self.graph_title = graph_title |
---|
| 819 | QtGui.QDialog.__init__(self) |
---|
| 820 | Plotter3DWidget.__init__(self, manager=parent) |
---|
| 821 | self.setWindowTitle(self.graph_title) |
---|
| 822 | |
---|