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

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 edd6720 was edd6720, checked in by krzywon, 6 years ago

Fix gui updates when new item selected in P(r) data list.

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