Changes in / [855e7ad:4b7d322] in sasview


Ignore:
Location:
src/sas
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • src/sas/qtgui/Perspectives/Inversion/DMaxExplorerWidget.py

    rb0ba43e re908916  
    4242        self.parent = parent 
    4343 
    44         self.setWindowTitle("Dₐₓ Explorer") 
     44        self.setWindowTitle("Dmax Explorer") 
    4545 
    4646        self.pr_state = pr_state 
     
    116116        bck = [] 
    117117        chi2 = [] 
    118  
     118        plotable_xs = [] #Introducing this to make sure size of x and y for plotting is the same.8 
    119119        try: 
    120120            dmin = float(self.model.item(W.DMIN).text()) 
     
    128128 
    129129        original = self.pr_state.d_max 
     130 
    130131        for x in xs: 
    131132            self.pr_state.d_max = x 
     
    140141                bck.append(self.pr_state.background) 
    141142                chi2.append(self.pr_state.chi2) 
     143                plotable_xs.append(x) 
    142144            except Exception as ex: 
    143145                # This inversion failed, skip this D_max value 
     
    188190            y_unit = "a.u." 
    189191 
    190         data = Data1D(xs, ys) 
     192        data = Data1D(plotable_xs, ys) 
    191193        if self.hasPlot: 
    192194            self.plot.removePlot(None) 
  • src/sas/qtgui/Perspectives/Inversion/InversionPerspective.py

    r855e7ad r855e7ad  
    4444    estimateSignal = QtCore.pyqtSignal(tuple) 
    4545    estimateNTSignal = QtCore.pyqtSignal(tuple) 
     46    estimateDynamicNTSignal = QtCore.pyqtSignal(tuple) 
     47    estimateDynamicSignal = QtCore.pyqtSignal(tuple) 
    4648    calculateSignal = QtCore.pyqtSignal(tuple) 
    4749 
     
    195197        self.model.itemChanged.connect(self.model_changed) 
    196198        self.estimateNTSignal.connect(self._estimateNTUpdate) 
     199        self.estimateDynamicNTSignal.connect(self._estimateDynamicNTUpdate) 
     200        self.estimateDynamicSignal.connect(self._estimateDynamicUpdate) 
    197201        self.estimateSignal.connect(self._estimateUpdate) 
    198202        self.calculateSignal.connect(self._calculateUpdate) 
     203 
     204        self.maxDistanceInput.textEdited.connect(self.performEstimateDynamic) 
    199205 
    200206    def setupMapper(self): 
     
    310316                                            and not self.isCalculating) 
    311317        self.removeButton.setEnabled(self.logic.data_is_loaded) 
    312         self.explorerButton.setEnabled(self.logic.data_is_loaded 
    313                                        and np.all(self.logic.data.dy != 0)) 
     318        self.explorerButton.setEnabled(self.logic.data_is_loaded) 
    314319        self.stopButton.setVisible(self.isCalculating) 
    315320        self.regConstantSuggestionButton.setEnabled( 
     
    458463            self._calculator.set_qmin(qmin) 
    459464            self._calculator.set_qmax(qmax) 
     465            if np.size(self.logic.data.dy) == 0 or np.all(self.logic.data.dy) == 0: 
     466                self.logic.data.dy = self._calculator.add_errors(self.logic.data.y) 
    460467            self.updateDataList(data) 
    461468            self.populateDataComboBox(self.logic.data.filename, data) 
     
    502509        self.dataPlot = self._dataList[data_ref].get(DICT_KEYS[2]) 
    503510        self.performEstimate() 
     511 
     512    def updateDynamicGuiValues(self): 
     513        pr = self._calculator 
     514        alpha = self._calculator.suggested_alpha 
     515        self.model.setItem(WIDGETS.W_MAX_DIST, 
     516                            QtGui.QStandardItem("{:.4g}".format(pr.get_dmax()))) 
     517        self.regConstantSuggestionButton.setText("{:-3.2g}".format(alpha)) 
     518        self.noOfTermsSuggestionButton.setText( 
     519             "{:n}".format(self.nTermsSuggested)) 
     520 
     521        self.enableButtons() 
    504522 
    505523    def updateGuiValues(self): 
     
    521539        self.model.setItem(WIDGETS.W_MAX_DIST, 
    522540                           QtGui.QStandardItem("{:.4g}".format(pr.get_dmax()))) 
    523         self.regConstantSuggestionButton.setText("{:-3.2g}".format(alpha)) 
    524         self.noOfTermsSuggestionButton.setText( 
    525             "{:n}".format(self.nTermsSuggested)) 
    526541 
    527542        if isinstance(pr.chi2, np.ndarray): 
     
    674689        self.estimationThreadNT.ready(2.5) 
    675690 
     691    def performEstimateDynamicNT(self): 
     692        """ 
     693        Perform parameter estimation 
     694        """ 
     695        from .Thread import EstimateNT 
     696 
     697        self.updateCalculator() 
     698 
     699        # If a thread is already started, stop it 
     700        self.stopEstimateNTThread() 
     701 
     702        pr = self._calculator.clone() 
     703        # Skip the slit settings for the estimation 
     704        # It slows down the application and it doesn't change the estimates 
     705        pr.slit_height = 0.0 
     706        pr.slit_width = 0.0 
     707        nfunc = self.getNFunc() 
     708 
     709        self.estimationThreadNT = EstimateNT(pr, nfunc, 
     710                                             error_func=self._threadError, 
     711                                             completefn=self._estimateDynamicNTCompleted, 
     712                                             updatefn=None) 
     713        self.estimationThreadNT.queue() 
     714        self.estimationThreadNT.ready(2.5) 
     715 
    676716    def stopEstimateNTThread(self): 
    677717        if (self.estimationThreadNT is not None and 
     
    696736        self.estimationThread.ready(2.5) 
    697737 
     738    def performEstimateDynamic(self): 
     739        """ 
     740            Perform parameter estimation 
     741        """ 
     742        from .Thread import EstimatePr 
     743 
     744        # If a thread is already started, stop it 
     745        self.stopEstimationThread() 
     746 
     747        self.estimationThread = EstimatePr(self._calculator.clone(), 
     748                                           self.getNFunc(), 
     749                                           error_func=self._threadError, 
     750                                           completefn=self._estimateDynamicCompleted, 
     751                                           updatefn=None) 
     752        self.estimationThread.queue() 
     753        self.estimationThread.ready(2.5) 
     754 
    698755    def stopEstimationThread(self): 
    699756        """ Stop the estimation thread if it exists and is running """ 
     
    708765        ''' Send a signal to the main thread for model update''' 
    709766        self.estimateSignal.emit((alpha, message, elapsed)) 
     767 
     768    def _estimateDynamicCompleted(self, alpha, message, elapsed): 
     769        ''' Send a signal to the main thread for model update''' 
     770        self.estimateDynamicSignal.emit((alpha, message, elapsed)) 
    710771 
    711772    def _estimateUpdate(self, output_tuple): 
     
    723784            logger.info(message) 
    724785        self.performEstimateNT() 
     786        self.performEstimateDynamicNT() 
     787 
     788    def _estimateDynamicUpdate(self, output_tuple): 
     789        """ 
     790        Parameter estimation completed, 
     791        display the results to the user 
     792 
     793        :param alpha: estimated best alpha 
     794        :param elapsed: computation time 
     795        """ 
     796        alpha, message, elapsed = output_tuple 
     797        self._calculator.alpha = alpha 
     798        self._calculator.elapsed += self._calculator.elapsed 
     799        if message: 
     800            logger.info(message) 
     801        self.performEstimateDynamicNT() 
    725802 
    726803    def _estimateNTCompleted(self, nterms, alpha, message, elapsed): 
    727804        ''' Send a signal to the main thread for model update''' 
    728805        self.estimateNTSignal.emit((nterms, alpha, message, elapsed)) 
     806 
     807    def _estimateDynamicNTCompleted(self, nterms, alpha, message, elapsed): 
     808        ''' Send a signal to the main thread for model update''' 
     809        self.estimateDynamicNTSignal.emit((nterms, alpha, message, elapsed)) 
    729810 
    730811    def _estimateNTUpdate(self, output_tuple): 
     
    750831            self.startThread() 
    751832 
     833    def _estimateDynamicNTUpdate(self, output_tuple): 
     834        """ 
     835        Parameter estimation completed, 
     836        display the results to the user 
     837 
     838        :param alpha: estimated best alpha 
     839        :param nterms: estimated number of terms 
     840        :param elapsed: computation time 
     841        """ 
     842        nterms, alpha, message, elapsed = output_tuple 
     843        self._calculator.elapsed += elapsed 
     844        self._calculator.suggested_alpha = alpha 
     845        self.nTermsSuggested = nterms 
     846        # Save useful info 
     847        self.updateDynamicGuiValues() 
     848        if message: 
     849            logger.info(message) 
     850        if self.isBatch: 
     851            self.acceptAlpha() 
     852            self.acceptNoTerms() 
     853            self.startThread() 
     854 
    752855    def _calculateCompleted(self, out, cov, pr, elapsed): 
    753856        ''' Send a signal to the main thread for model update''' 
  • src/sas/sascalc/pr/invertor.py

    rb8080e1 reeea6a3  
    7171        A[j][i] = (Fourier transformed base function for point j) 
    7272 
    73     We them choose a number of r-points, n_r, to evaluate the second 
     73    We then choose a number of r-points, n_r, to evaluate the second 
    7474    derivative of P(r) at. This is used as our regularization term. 
    7575    For a vector r of length n_r, the following n_r rows are set to :: 
     
    144144        x, y, err, d_max, q_min, q_max and alpha 
    145145        """ 
    146         if   name == 'x': 
     146        if name == 'x': 
    147147            if 0.0 in value: 
    148148                msg = "Invertor: one of your q-values is zero. " 
     
    227227        return None 
    228228 
     229    def add_errors(self, yvalues): 
     230        """ 
     231        Adds errors to data set is they are not avaialble 
     232        :return: 
     233        """ 
     234        stats_errors = np.zeros(len(yvalues)) 
     235        for i in range(len(yvalues)): 
     236            # Scale the error so that we can fit over several decades of Q 
     237            scale = 0.05 * np.sqrt(yvalues[i]) 
     238            min_err = 0.01 * yvalues[i] 
     239            stats_errors[i] = scale * np.sqrt(np.fabs(yvalues[i])) + min_err 
     240        logger.warning("Simulated errors have been added to the data set\n") 
     241        return stats_errors 
     242 
    229243    def clone(self): 
    230244        """ 
     
    268282            A[i][j] = (Fourier transformed base function for point j) 
    269283 
    270         We them choose a number of r-points, n_r, to evaluate the second 
     284        We then choose a number of r-points, n_r, to evaluate the second 
    271285        derivative of P(r) at. This is used as our regularization term. 
    272286        For a vector r of length n_r, the following n_r rows are set to :: 
Note: See TracChangeset for help on using the changeset viewer.