source: sasview/src/sas/qtgui/Perspectives/Inversion/InversionPerspective.py @ 50bfab0

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalc
Last change on this file since 50bfab0 was 50bfab0, checked in by Piotr Rozyczko <rozyczko@…>, 6 years ago

Initial unit tests for inversion - SASVIEW-609
  • Property mode set to 100644
File size: 25.3 KB
Line 
1import sys
2import logging
3import pylab
4import numpy as np
5
6from PyQt5 import QtGui, QtCore, QtWidgets
7
8# sas-global
9import sas.qtgui.Utilities.GuiUtils as GuiUtils
10
11# pr inversion GUI elements
12from .InversionUtils import WIDGETS
13from .UI.TabbedInversionUI import Ui_PrInversion
14from .InversionLogic import InversionLogic
15
16# pr inversion calculation elements
17from sas.sascalc.dataloader.data_info import Data1D
18from sas.sascalc.pr.invertor import Invertor
19
20def is_float(value):
21    """Converts text input values to floats. Empty strings throw ValueError"""
22    try:
23        return float(value)
24    except ValueError:
25        return 0.0
26
27NUMBER_OF_TERMS = 10
28REGULARIZATION = 0.0001
29BACKGROUND_INPUT = 0.0
30MAX_DIST = 140.0
31
32# TODO: Modify plot references, don't just send new
33# TODO: Update help with batch capabilities
34# TODO: Method to export results in some meaningful way
35class InversionWindow(QtWidgets.QDialog, Ui_PrInversion):
36    """
37    The main window for the P(r) Inversion perspective.
38    """
39
40    name = "Inversion"
41    estimateSignal = QtCore.pyqtSignal(tuple)
42    estimateNTSignal = QtCore.pyqtSignal(tuple)
43    calculateSignal = QtCore.pyqtSignal(tuple)
44
45    def __init__(self, parent=None, data=None):
46        super(InversionWindow, self).__init__()
47        self.setupUi(self)
48
49        self.setWindowTitle("P(r) Inversion Perspective")
50
51        self._manager = parent
52        self._model_item = QtGui.QStandardItem()
53        #self._helpView = QtWebKit.QWebView()
54
55        self.communicate = GuiUtils.Communicate()
56
57        self.logic = InversionLogic()
58
59        # Reference to Dmax window
60        self.dmaxWindow = None
61
62        # The window should not close
63        self._allow_close = False
64
65        # current QStandardItem showing on the panel
66        self._data = None
67        # current Data1D as referenced by self._data
68        self._data_set = None
69
70        # p(r) calculator
71        self._calculator = Invertor()
72        self._last_calculator = None
73        self.calc_thread = None
74        self.estimation_thread = None
75
76        # Current data object in view
77        self._data_index = 0
78        # list mapping data to p(r) calculation
79        self._data_list = {}
80        if not isinstance(data, list):
81            data_list = [data]
82        if data is not None:
83            for datum in data_list:
84                self._data_list[datum] = self._calculator.clone()
85
86        # dict of models for quick update after calculation
87        # {item:model}
88        self._models = {}
89
90        self.calculateAllButton.setEnabled(False)
91        self.calculateThisButton.setEnabled(False)
92
93        # plots for current data
94        self.pr_plot = None
95        self.data_plot = None
96        # plot references for all data in perspective
97        self.pr_plot_list = {}
98        self.data_plot_list = {}
99
100        self.model = QtGui.QStandardItemModel(self)
101        self.mapper = QtWidgets.QDataWidgetMapper(self)
102
103        # Add validators
104        self.setupValidators()
105        # Link user interactions with methods
106        self.setupLinks()
107        # Set values
108        self.setupModel()
109        # Set up the Widget Map
110        self.setupMapper()
111        # Set base window state
112        self.setupWindow()
113
114    ######################################################################
115    # Base Perspective Class Definitions
116
117    def communicator(self):
118        return self.communicate
119
120    def allowBatch(self):
121        return True
122
123    def setClosable(self, value=True):
124        """
125        Allow outsiders close this widget
126        """
127        assert isinstance(value, bool)
128        self._allow_close = value
129
130    def closeEvent(self, event):
131        """
132        Overwrite QDialog close method to allow for custom widget close
133        """
134        if self._allow_close:
135            # reset the closability flag
136            self.setClosable(value=False)
137            # Tell the MdiArea to close the container
138            self.parentWidget().close()
139            event.accept()
140        else:
141            event.ignore()
142            # Maybe we should just minimize
143            self.setWindowState(QtCore.Qt.WindowMinimized)
144
145    ######################################################################
146    # Initialization routines
147
148    def setupLinks(self):
149        """Connect the use controls to their appropriate methods"""
150        self.dataList.currentIndexChanged.connect(self.displayChange)
151        self.calculateAllButton.clicked.connect(self.startThreadAll)
152        self.calculateThisButton.clicked.connect(self.startThread)
153        self.removeButton.clicked.connect(self.removeData)
154        self.helpButton.clicked.connect(self.help)
155        self.estimateBgd.toggled.connect(self.toggleBgd)
156        self.manualBgd.toggled.connect(self.toggleBgd)
157        self.regConstantSuggestionButton.clicked.connect(self.acceptAlpha)
158        self.noOfTermsSuggestionButton.clicked.connect(self.acceptNoTerms)
159        self.explorerButton.clicked.connect(self.openExplorerWindow)
160
161        self.backgroundInput.editingFinished.connect(
162            lambda: self._calculator.set_est_bck(int(is_float(self.backgroundInput.text()))))
163        self.minQInput.editingFinished.connect(
164            lambda: self._calculator.set_qmin(is_float(self.minQInput.text())))
165        self.regularizationConstantInput.editingFinished.connect(
166            lambda: self._calculator.set_alpha(is_float(self.regularizationConstantInput.text())))
167        self.maxDistanceInput.editingFinished.connect(
168            lambda: self._calculator.set_dmax(is_float(self.maxDistanceInput.text())))
169        self.maxQInput.editingFinished.connect(
170            lambda: self._calculator.set_qmax(is_float(self.maxQInput.text())))
171        self.slitHeightInput.editingFinished.connect(
172            lambda: self._calculator.set_slit_height(is_float(self.slitHeightInput.text())))
173        self.slitWidthInput.editingFinished.connect(
174            lambda: self._calculator.set_slit_width(is_float(self.slitHeightInput.text())))
175
176        self.model.itemChanged.connect(self.model_changed)
177        self.estimateNTSignal.connect(self._estimateNTUpdate)
178        self.estimateSignal.connect(self._estimateUpdate)
179        self.calculateSignal.connect(self._calculateUpdate)
180
181    def setupMapper(self):
182        # Set up the mapper.
183        self.mapper.setOrientation(QtCore.Qt.Vertical)
184        self.mapper.setModel(self.model)
185
186        # Filename
187        self.mapper.addMapping(self.dataList, WIDGETS.W_FILENAME)
188        # Background
189        self.mapper.addMapping(self.backgroundInput, WIDGETS.W_BACKGROUND_INPUT)
190        self.mapper.addMapping(self.estimateBgd, WIDGETS.W_ESTIMATE)
191        self.mapper.addMapping(self.manualBgd, WIDGETS.W_MANUAL_INPUT)
192
193        # Qmin/Qmax
194        self.mapper.addMapping(self.minQInput, WIDGETS.W_QMIN)
195        self.mapper.addMapping(self.maxQInput, WIDGETS.W_QMAX)
196
197        # Slit Parameter items
198        self.mapper.addMapping(self.slitWidthInput, WIDGETS.W_SLIT_WIDTH)
199        self.mapper.addMapping(self.slitHeightInput, WIDGETS.W_SLIT_HEIGHT)
200
201        # Parameter Items
202        self.mapper.addMapping(self.regularizationConstantInput, WIDGETS.W_REGULARIZATION)
203        self.mapper.addMapping(self.regConstantSuggestionButton, WIDGETS.W_REGULARIZATION_SUGGEST)
204        self.mapper.addMapping(self.explorerButton, WIDGETS.W_EXPLORE)
205        self.mapper.addMapping(self.maxDistanceInput, WIDGETS.W_MAX_DIST)
206        self.mapper.addMapping(self.noOfTermsInput, WIDGETS.W_NO_TERMS)
207        self.mapper.addMapping(self.noOfTermsSuggestionButton, WIDGETS.W_NO_TERMS_SUGGEST)
208
209        # Output
210        self.mapper.addMapping(self.rgValue, WIDGETS.W_RG)
211        self.mapper.addMapping(self.iQ0Value, WIDGETS.W_I_ZERO)
212        self.mapper.addMapping(self.backgroundValue, WIDGETS.W_BACKGROUND_OUTPUT)
213        self.mapper.addMapping(self.computationTimeValue, WIDGETS.W_COMP_TIME)
214        self.mapper.addMapping(self.chiDofValue, WIDGETS.W_CHI_SQUARED)
215        self.mapper.addMapping(self.oscillationValue, WIDGETS.W_OSCILLATION)
216        self.mapper.addMapping(self.posFractionValue, WIDGETS.W_POS_FRACTION)
217        self.mapper.addMapping(self.sigmaPosFractionValue, WIDGETS.W_SIGMA_POS_FRACTION)
218
219        # Main Buttons
220        self.mapper.addMapping(self.removeButton, WIDGETS.W_REMOVE)
221        self.mapper.addMapping(self.calculateAllButton, WIDGETS.W_CALCULATE_ALL)
222        self.mapper.addMapping(self.calculateThisButton, WIDGETS.W_CALCULATE_VISIBLE)
223        self.mapper.addMapping(self.helpButton, WIDGETS.W_HELP)
224
225        self.mapper.toFirst()
226
227    def setupModel(self):
228        """
229        Update boxes with initial values
230        """
231        item = QtGui.QStandardItem("")
232        self.model.setItem(WIDGETS.W_FILENAME, item)
233        item = QtGui.QStandardItem(str(BACKGROUND_INPUT))
234        self.model.setItem(WIDGETS.W_BACKGROUND_INPUT, item)
235        item = QtGui.QStandardItem("")
236        self.model.setItem(WIDGETS.W_QMIN, item)
237        item = QtGui.QStandardItem("")
238        self.model.setItem(WIDGETS.W_QMAX, item)
239        item = QtGui.QStandardItem("")
240        self.model.setItem(WIDGETS.W_SLIT_WIDTH, item)
241        item = QtGui.QStandardItem("")
242        self.model.setItem(WIDGETS.W_SLIT_HEIGHT, item)
243        item = QtGui.QStandardItem(str(NUMBER_OF_TERMS))
244        self.model.setItem(WIDGETS.W_NO_TERMS, item)
245        item = QtGui.QStandardItem(str(REGULARIZATION))
246        self.model.setItem(WIDGETS.W_REGULARIZATION, item)
247        item = QtGui.QStandardItem(str(MAX_DIST))
248        self.model.setItem(WIDGETS.W_MAX_DIST, item)
249        item = QtGui.QStandardItem("")
250        self.model.setItem(WIDGETS.W_RG, item)
251        item = QtGui.QStandardItem("")
252        self.model.setItem(WIDGETS.W_I_ZERO, item)
253        item = QtGui.QStandardItem("")
254        self.model.setItem(WIDGETS.W_BACKGROUND_OUTPUT, item)
255        item = QtGui.QStandardItem("")
256        self.model.setItem(WIDGETS.W_COMP_TIME, item)
257        item = QtGui.QStandardItem("")
258        self.model.setItem(WIDGETS.W_CHI_SQUARED, item)
259        item = QtGui.QStandardItem("")
260        self.model.setItem(WIDGETS.W_OSCILLATION, item)
261        item = QtGui.QStandardItem("")
262        self.model.setItem(WIDGETS.W_POS_FRACTION, item)
263        item = QtGui.QStandardItem("")
264        self.model.setItem(WIDGETS.W_SIGMA_POS_FRACTION, item)
265
266    def setupWindow(self):
267        """Initialize base window state on init"""
268        self.enableButtons()
269        self.estimateBgd.setChecked(True)
270
271    def setupValidators(self):
272        """Apply validators to editable line edits"""
273        self.noOfTermsInput.setValidator(QtGui.QIntValidator())
274        self.regularizationConstantInput.setValidator(GuiUtils.DoubleValidator())
275        self.maxDistanceInput.setValidator(GuiUtils.DoubleValidator())
276        self.minQInput.setValidator(GuiUtils.DoubleValidator())
277        self.maxQInput.setValidator(GuiUtils.DoubleValidator())
278        self.slitHeightInput.setValidator(GuiUtils.DoubleValidator())
279        self.slitWidthInput.setValidator(GuiUtils.DoubleValidator())
280
281    ######################################################################
282    # Methods for updating GUI
283
284    def enableButtons(self):
285        """
286        Enable buttons when data is present, else disable them
287        """
288        self.calculateAllButton.setEnabled(self.logic.data_is_loaded)
289        self.calculateThisButton.setEnabled(self.logic.data_is_loaded)
290        self.removeButton.setEnabled(self.logic.data_is_loaded)
291        self.explorerButton.setEnabled(self.logic.data_is_loaded)
292
293    def populateDataComboBox(self, filename, data_ref):
294        """
295        Append a new file name to the data combobox
296        :param filename: data filename
297        :param data_ref: QStandardItem reference for data set to be added
298        """
299        self.dataList.addItem(filename, data_ref)
300
301    def acceptNoTerms(self):
302        """Send estimated no of terms to input"""
303        self.model.setItem(WIDGETS.W_NO_TERMS, QtGui.QStandardItem(
304            self.noOfTermsSuggestionButton.text()))
305
306    def acceptAlpha(self):
307        """Send estimated alpha to input"""
308        self.model.setItem(WIDGETS.W_REGULARIZATION, QtGui.QStandardItem(
309            self.regConstantSuggestionButton.text()))
310
311    def displayChange(self):
312        ref_item = self.dataList.itemData(self.dataList.currentIndex())
313        self._model_item = ref_item
314        self.setCurrentData(ref_item)
315        self.setCurrentModel(ref_item)
316
317    def removeData(self):
318        """Remove the existing data reference from the P(r) Persepective"""
319        self._data_list.pop(self._data)
320        self.pr_plot_list.pop(self._data)
321        self.data_plot_list.pop(self._data)
322        if self.dmaxWindow is not None:
323            self.dmaxWindow = None
324        self.dataList.removeItem(self.dataList.currentIndex())
325        self.dataList.setCurrentIndex(0)
326        # Last file removed
327        if not self._data_list:
328            self._data = None
329            self.pr_plot = None
330            self._data_set = None
331            self.calculateThisButton.setEnabled(False)
332            self.calculateAllButton.setEnabled(False)
333            self.explorerButton.setEnabled(False)
334
335    ######################################################################
336    # GUI Interaction Events
337
338    def setCurrentModel(self, ref_item):
339        '''update the current model with stored values'''
340        if ref_item in self._models:
341            self.model = self._models[ref_item]
342
343    def update_calculator(self):
344        """Update all p(r) params"""
345        self._calculator.set_x(self._data_set.x)
346        self._calculator.set_y(self._data_set.y)
347        self._calculator.set_err(self._data_set.dy)
348
349    def model_changed(self):
350        """Update the values when user makes changes"""
351        if not self.mapper:
352            msg = "Unable to update P{r}. The connection between the main GUI "
353            msg += "and P(r) was severed. Attempting to restart P(r)."
354            logging.warning(msg)
355            self.setClosable(True)
356            self.close()
357            InversionWindow.__init__(self.parent(), list(self._data_list.keys()))
358            exit(0)
359        # TODO: Only send plot first time - otherwise, update in complete
360        if self.pr_plot is not None:
361            title = self.pr_plot.name
362            GuiUtils.updateModelItemWithPlot(self._data, self.pr_plot, title)
363        if self.data_plot is not None:
364            title = self.data_plot.name
365            GuiUtils.updateModelItemWithPlot(self._data, self.data_plot, title)
366        if self.dmaxWindow is not None:
367             self.dmaxWindow.pr_state = self._calculator
368             self.dmaxWindow.nfunc = self.getNFunc()
369
370        self.mapper.toFirst()
371
372    def help(self):
373        """
374        Open the P(r) Inversion help browser
375        """
376        tree_location = (GuiUtils.HELP_DIRECTORY_LOCATION +
377                         "user/sasgui/perspectives/pr/pr_help.html")
378
379        # Actual file anchor will depend on the combo box index
380        # Note that we can be clusmy here, since bad current_fitter_id
381        # will just make the page displayed from the top
382        #self._helpView.load(QtCore.QUrl(tree_location))
383        #self._helpView.show()
384
385    def toggleBgd(self):
386        """
387        Toggle the background between manual and estimated
388        """
389        sender = self.sender()
390        if sender is self.estimateBgd:
391            self.backgroundInput.setEnabled(False)
392        else:
393            self.backgroundInput.setEnabled(True)
394
395    def openExplorerWindow(self):
396        """
397        Open the Explorer window to see correlations between params and results
398        """
399        from .DMaxExplorerWidget import DmaxWindow
400        self.dmaxWindow = DmaxWindow(self._calculator, self.getNFunc(), self)
401        self.dmaxWindow.show()
402
403    ######################################################################
404    # Response Actions
405
406    def setData(self, data_item=None, is_batch=False):
407        """
408        Assign new data set(s) to the P(r) perspective
409        Obtain a QStandardItem object and parse it to get Data1D/2D
410        Pass it over to the calculator
411        """
412        assert data_item is not None
413
414        if not isinstance(data_item, list):
415            msg = "Incorrect type passed to the P(r) Perspective"
416            raise AttributeError
417
418        for data in data_item:
419            if data in self._data_list.keys():
420                # Don't add data if it's already in
421                return
422            # Create initial internal mappings
423            self._data_list[data] = self._calculator.clone()
424            self._data_set = GuiUtils.dataFromItem(data)
425            self.data_plot_list[data] = self.data_plot
426            self.pr_plot_list[data] = self.pr_plot
427            self.populateDataComboBox(self._data_set.filename, data)
428            self.setCurrentData(data)
429
430            # Estimate initial values from data
431            self.performEstimate()
432            self.logic = InversionLogic(self._data_set)
433
434            # Estimate q range
435            qmin, qmax = self.logic.computeDataRange()
436            self.model.setItem(WIDGETS.W_QMIN, QtGui.QStandardItem("{:.4g}".format(qmin)))
437            self.model.setItem(WIDGETS.W_QMAX, QtGui.QStandardItem("{:.4g}".format(qmax)))
438            self._models[data] = self.model
439            self.model_item = data
440
441        self.enableButtons()
442
443    def getNFunc(self):
444        """Get the n_func value from the GUI object"""
445        try:
446            nfunc = int(self.noOfTermsInput.text())
447        except ValueError:
448            logging.error("Incorrect number of terms specified: %s" %self.noOfTermsInput.text())
449            self.noOfTermsInput.setText(str(NUMBER_OF_TERMS))
450            nfunc = NUMBER_OF_TERMS
451        return nfunc
452
453    def setCurrentData(self, data_ref):
454        """Get the current data and display as necessary"""
455
456        if data_ref is None:
457            return
458
459        if not isinstance(data_ref, QtGui.QStandardItem):
460            msg = "Incorrect type passed to the P(r) Perspective"
461            raise AttributeError
462
463        # Data references
464        self._data = data_ref
465        self._data_set = GuiUtils.dataFromItem(data_ref)
466        self._calculator = self._data_list[data_ref]
467        self.pr_plot = self.pr_plot_list[data_ref]
468        self.data_plot = self.data_plot_list[data_ref]
469
470    ######################################################################
471    # Thread Creators
472    def startThreadAll(self):
473        for data_ref, pr in list(self._data_list.items()):
474            self._data_set = GuiUtils.dataFromItem(data_ref)
475            self._calculator = pr
476            self.startThread()
477
478    def startThread(self):
479        """
480            Start a calculation thread
481        """
482        from .Thread import CalcPr
483
484        # Set data before running the calculations
485        self.update_calculator()
486
487        # If a thread is already started, stop it
488        if self.calc_thread is not None and self.calc_thread.isrunning():
489            self.calc_thread.stop()
490        pr = self._calculator.clone()
491        nfunc = self.getNFunc()
492        self.calc_thread = CalcPr(pr, nfunc,
493                                  error_func=self._threadError,
494                                  completefn=self._calculateCompleted,
495                                  updatefn=None)
496        self.calc_thread.queue()
497        self.calc_thread.ready(2.5)
498
499    def performEstimateNT(self):
500        """
501        Perform parameter estimation
502        """
503        from .Thread import EstimateNT
504
505        # If a thread is already started, stop it
506        if (self.estimation_thread is not None and
507                self.estimation_thread.isrunning()):
508            self.estimation_thread.stop()
509        pr = self._calculator.clone()
510        # Skip the slit settings for the estimation
511        # It slows down the application and it doesn't change the estimates
512        pr.slit_height = 0.0
513        pr.slit_width = 0.0
514        nfunc = self.getNFunc()
515
516        self.estimation_thread = EstimateNT(pr, nfunc,
517                                            error_func=self._threadError,
518                                            completefn=self._estimateNTCompleted,
519                                            updatefn=None)
520        self.estimation_thread.queue()
521        self.estimation_thread.ready(2.5)
522
523    def performEstimate(self):
524        """
525            Perform parameter estimation
526        """
527        from .Thread import EstimatePr
528
529        self.startThread()
530
531        # If a thread is already started, stop it
532        if (self.estimation_thread is not None and
533                self.estimation_thread.isrunning()):
534            self.estimation_thread.stop()
535        pr = self._calculator.clone()
536        nfunc = self.getNFunc()
537        self.estimation_thread = EstimatePr(pr, nfunc,
538                                            error_func=self._threadError,
539                                            completefn=self._estimateCompleted,
540                                            updatefn=None)
541        self.estimation_thread.queue()
542        self.estimation_thread.ready(2.5)
543
544    ######################################################################
545    # Thread Complete
546
547    def _estimateCompleted(self, alpha, message, elapsed):
548        ''' Send a signal to the main thread for model update'''
549        self.estimateSignal.emit((alpha, message, elapsed))
550
551    def _estimateUpdate(self, output_tuple):
552        """
553        Parameter estimation completed,
554        display the results to the user
555
556        :param alpha: estimated best alpha
557        :param elapsed: computation time
558        """
559        alpha, message, elapsed = output_tuple
560        # Save useful info
561        self.model.setItem(WIDGETS.W_COMP_TIME, QtGui.QStandardItem("{:.4g}".format(elapsed)))
562        self.regConstantSuggestionButton.setText("{:-3.2g}".format(alpha))
563        self.regConstantSuggestionButton.setEnabled(True)
564        if message:
565            logging.info(message)
566        self.performEstimateNT()
567
568    def _estimateNTCompleted(self, nterms, alpha, message, elapsed):
569        ''' Send a signal to the main thread for model update'''
570        self.estimateNTSignal.emit((nterms, alpha, message, elapsed))
571
572    def _estimateNTUpdate(self, output_tuple):
573        """
574        Parameter estimation completed,
575        display the results to the user
576
577        :param alpha: estimated best alpha
578        :param nterms: estimated number of terms
579        :param elapsed: computation time
580        """
581        nterms, alpha, message, elapsed = output_tuple
582        # Save useful info
583        self.noOfTermsSuggestionButton.setText("{:n}".format(nterms))
584        self.noOfTermsSuggestionButton.setEnabled(True)
585        self.regConstantSuggestionButton.setText("{:.3g}".format(alpha))
586        self.regConstantSuggestionButton.setEnabled(True)
587        self.model.setItem(WIDGETS.W_COMP_TIME, QtGui.QStandardItem("{:.2g}".format(elapsed)))
588        if message:
589            logging.info(message)
590
591    def _calculateCompleted(self, out, cov, pr, elapsed):
592        ''' Send a signal to the main thread for model update'''
593        self.calculateSignal.emit((out, cov, pr, elapsed))
594
595    def _calculateUpdate(self, output_tuple):
596        """
597        Method called with the results when the inversion is done
598
599        :param out: output coefficient for the base functions
600        :param cov: covariance matrix
601        :param pr: Invertor instance
602        :param elapsed: time spent computing
603        """
604        out, cov, pr, elapsed = output_tuple
605        # Save useful info
606        cov = np.ascontiguousarray(cov)
607        pr.cov = cov
608        pr.out = out
609        pr.elapsed = elapsed
610
611        # Show result on control panel
612        self.model.setItem(WIDGETS.W_RG, QtGui.QStandardItem("{:.3g}".format(pr.rg(out))))
613        self.model.setItem(WIDGETS.W_I_ZERO, QtGui.QStandardItem("{:.3g}".format(pr.iq0(out))))
614        self.model.setItem(WIDGETS.W_BACKGROUND_INPUT,
615                           QtGui.QStandardItem("{:.3f}".format(pr.est_bck)))
616        self.model.setItem(WIDGETS.W_BACKGROUND_OUTPUT, QtGui.QStandardItem("{:.3g}".format(pr.background)))
617        self.model.setItem(WIDGETS.W_CHI_SQUARED, QtGui.QStandardItem("{:.3g}".format(pr.chi2[0])))
618        self.model.setItem(WIDGETS.W_COMP_TIME, QtGui.QStandardItem("{:.2g}".format(elapsed)))
619        self.model.setItem(WIDGETS.W_OSCILLATION, QtGui.QStandardItem("{:.3g}".format(pr.oscillations(out))))
620        self.model.setItem(WIDGETS.W_POS_FRACTION, QtGui.QStandardItem("{:.3g}".format(pr.get_positive(out))))
621        self.model.setItem(WIDGETS.W_SIGMA_POS_FRACTION,
622                           QtGui.QStandardItem("{:.3g}".format(pr.get_pos_err(out, cov))))
623
624        # Save Pr invertor
625        self._calculator = pr
626        # Append data to data list
627        self._data_list[self._data] = self._calculator.clone()
628
629        # Update model dict
630        self._models[self.model_item] = self.model
631
632        # Create new P(r) and fit plots
633        if self.pr_plot is None:
634            self.pr_plot = self.logic.newPRPlot(out, self._calculator, cov)
635            self.pr_plot_list[self._data] = self.pr_plot
636        else:
637            # FIXME: this should update the existing plot, not create a new one
638            self.pr_plot = self.logic.newPRPlot(out, self._calculator, cov)
639            self.pr_plot_list[self._data] = self.pr_plot
640        if self.data_plot is None:
641            self.data_plot = self.logic.new1DPlot(out, self._calculator)
642            self.data_plot_list[self._data] = self.data_plot
643        else:
644            # FIXME: this should update the existing plot, not create a new one
645            self.data_plot = self.logic.new1DPlot(out, self._calculator)
646            self.data_plot_list[self._data] = self.data_plot
647
648    def _threadError(self, error):
649        """
650            Call-back method for calculation errors
651        """
652        logging.warning(error)
Note: See TracBrowser for help on using the repository browser.