Ignore:
Timestamp:
Sep 28, 2017 11:29:40 AM (7 years ago)
Author:
celinedurniak <celine.durniak@…>
Branches:
ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc
Children:
7d353af
Parents:
01cda57
Message:

Implemented corrections from review of Resolution Calculator Panel

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/sas/qtgui/Calculators/ResolutionCalculatorPanel.py

    r01cda57 rfc4fec8  
    1717import sys 
    1818import logging 
    19 import math 
    2019import os 
    2120import re 
     
    3231BG_WHITE = "background-color: rgb(255, 255, 255);" 
    3332BG_RED = "background-color: rgb(244, 170, 164);" 
    34  
    35 _INTENSITY = 368428 
    36 _LAMBDA_ARRAY = [[0, 1e+16], [_INTENSITY, _INTENSITY]] 
    3733 
    3834 
     
    8581        # dQ 2d image 
    8682        self.image = None 
    87         # results of sigmas 
    88         self.sigma_strings = ' ' 
    8983        # Source selection dic 
    9084        self.source_mass = _SOURCE_MASS 
     
    237231                text_edit.setStyleSheet(QtCore.QString(BG_RED)) 
    238232                self.cmdCompute.setEnabled(False) 
    239                 logging.info('Qx and Qy are lists of comma-separated numbers.') 
     233                logging.info('Qx and Qy should contain one or more comma-separated numbers.') 
    240234            else: 
    241235                text_edit.setStyleSheet(QtCore.QString(BG_WHITE)) 
     
    256250                    self.cmdCompute.setEnabled(False) 
    257251                    logging.info( 
    258                         'Qx and Qy have the same number of elements.') 
     252                        'Qx and Qy should have the same number of elements.') 
    259253 
    260254                else: 
     
    410404 
    411405        self.image = None 
    412         self.sigma_strings = ' ' 
    413406        self.source_mass = _SOURCE_MASS 
    414407        self.det_coordinate = 'cartesian' 
     
    496489            ymax = max(self.qy) 
    497490            if not self._validate_q_input(self.qx, self.qy): 
    498                 raise 
     491                raise ValueError("Invalid Q input") 
    499492        except: 
    500493            msg = "An error occurred during the resolution computation." 
     
    502495            logging.warning(msg) 
    503496            return 
    504             # raise ValueError, "Invalid Q Input..." 
    505497 
    506498        # Validate the q inputs 
     
    523515        # Compute and get the image plot 
    524516        try: 
    525             self.sigma_strings = '\nResolution: Computation is finished. \n' 
    526             cal_res = threads.deferToThread(self.complete, 
    527                                             map(self._map_func, 
    528                                                 self.qx, 
    529                                                 self.qy, 
    530                                                 qx_min, 
    531                                                 qx_max, 
    532                                                 qy_min, qy_max)[0], 
    533                                             self.image) 
    534  
    535             cal_res.addCallback(self.new2DPlot) 
    536  
    537             logging.info("Computation is in progress...") 
     517            cal_res = threads.deferToThread(self.map_wrapper, 
     518                                            self.calc_func, 
     519                                            self.qx, 
     520                                            self.qy, 
     521                                            qx_min, 
     522                                            qx_max, 
     523                                            qy_min, qy_max) 
     524 
     525            cal_res.addCallback(self.complete) 
     526 
     527            # logging.info("Computation is in progress...") 
    538528            self.cmdCompute.setText('Wait...') 
    539529            self.cmdCompute.setEnabled(False) 
     
    541531            raise 
    542532 
    543     def complete(self, image, elapsed=None): 
     533    def complete(self, image): 
    544534        """ 
    545535        Complete computation 
     
    559549        self.txt1DSigma.setText(str(sigma_1d)) 
    560550 
    561         msg = self.sigma_strings 
    562         logging.info(msg + '\n stop') 
    563551        self.cmdCompute.setText('Compute') 
    564552        self.cmdCompute.setEnabled(True) 
     553 
     554        self.new2DPlot() 
     555 
    565556        return 
    566557 
    567     def _map_func(self, qx, qy, qx_min, qx_max, qy_min, qy_max): 
     558    def map_wrapper(self, func, qx, qy, qx_min, qx_max, qy_min, qy_max): 
    568559        """ 
    569560        Prepare the Mapping for the computation 
     
    571562        : return: image (numpy array) 
    572563        """ 
     564        image = map(func, qx, qy, 
     565                    qx_min, qx_max, 
     566                    qy_min, qy_max)[0] 
     567        return image 
     568 
     569    def calc_func(self, qx, qy, qx_min, qx_max, qy_min, qy_max): 
     570        """ 
     571        Perform the calculation for a given set of Q values. 
     572        : return: image (numpy array) 
     573        """ 
    573574        try: 
    574575            qx_value = float(qx) 
    575576            qy_value = float(qy) 
    576         except: 
    577             raise 
     577        except : 
     578            raise ValueError 
     579 
    578580        # calculate 2D resolution distribution image 
    579581        image = self.resolution.compute_and_plot(qx_value, qy_value, 
     
    581583                                                 qy_max, 
    582584                                                 self.det_coordinate) 
    583         # record sigmas 
    584         self.sigma_strings += " At Qx = %s, Qy = %s; \n" % (qx_value, qy_value) 
    585         self._sigma_strings() 
    586         logging.info(self.sigma_strings) 
    587  
    588585        return image 
    589586 
     
    591588    # Legacy validators 
    592589    # ################################# 
    593     def _sigma_strings(self): 
    594         """ 
    595         Recode sigmas as strings 
    596         """ 
    597         sigma_r = self.formatNumber(self.resolution.sigma_1) 
    598         sigma_phi = self.formatNumber(self.resolution.sigma_2) 
    599         sigma_lamd = self.formatNumber(self.resolution.sigma_lamd) 
    600         sigma_1d = self.formatNumber(self.resolution.sigma_1d) 
    601         # Set output values 
    602         self.sigma_strings += "   sigma_x = %s\n" % sigma_r 
    603         self.sigma_strings += "   sigma_y = %s\n" % sigma_phi 
    604         self.sigma_strings += "   sigma_lamd = %s\n" % sigma_lamd 
    605         self.sigma_strings += "   sigma_1D = %s\n" % sigma_1d 
    606  
    607     def _string2list(self, string): 
     590    def _string2list(self, input_string): 
    608591        """ 
    609592        Change NNN, NNN to list,ie. [NNN, NNN] where NNN is a number 
    610593        """ 
    611         new_string = [] 
     594        new_numbers_list = [] 
    612595        # check the number of floats 
    613596        try: 
    614             strg = float(string) 
    615             new_string.append(strg) 
     597            strg = float(input_string) 
     598            new_numbers_list.append(strg) 
    616599        except: 
    617             string_split = string.split(',') 
     600            string_split = input_string.split(',') 
    618601            if len(string_split) == 2: 
    619602                str_1 = string_split[0] 
    620603                str_2 = string_split[1] 
    621                 new_string.append(float(str_1)) 
    622                 new_string.append(float(str_2)) 
     604                new_numbers_list.append(float(str_1)) 
     605                new_numbers_list.append(float(str_2)) 
    623606            elif len(string_split) == 1: 
    624607                str_1 = string_split[0] 
    625                 new_string.append(float(str_1)) 
     608                new_numbers_list.append(float(str_1)) 
    626609            else: 
    627                 msg = "The numbers must be one or two (separated by ',')..." 
     610                msg = "The numbers must be one or two (separated by ',')" 
    628611                logging.info(msg) 
    629612                raise RuntimeError, msg 
    630613 
    631         return new_string 
    632  
    633     def _string2inputlist(self, string): 
     614        return new_numbers_list 
     615 
     616    def _string2inputlist(self, input_string): 
    634617        """ 
    635618        Change NNN, NNN,... to list,ie. [NNN, NNN,...] where NNN is a number 
    636         : return new_string: string like list 
    637         """ 
    638         new_string = [] 
    639         string_split = string.split(',') 
    640         length = len(string_split) 
    641         for ind in range(length): 
    642             try: 
    643                 value = float(string_split[ind]) 
    644                 new_string.append(value) 
    645             except: 
    646                 logging.error(sys.exc_value) 
    647  
    648         return new_string 
    649  
    650     def _str2longlist(self, string): 
    651         """ 
    652         Change NNN, NNN,... to list, NNN - NNN ; NNN to list, or float to list 
    653         : return new_string: string like list 
    654         """ 
     619        : return new_list: string like list 
     620        """ 
     621        new_list = [] 
     622        string_split = input_string.split(',') 
     623        try: 
     624            new_list = [float(t) for t in string_split] 
     625        except: 
     626            logging.error(sys.exc_value) 
     627        return new_list 
     628 
     629    def _str2longlist(self, input_string): 
     630        """ 
     631          Change NNN, NNN,... to list, NNN - NNN ; NNN to list, or float to list 
     632          : return new_string: string like list 
     633          """ 
    655634        try: 
    656635            # is float 
    657             out = [float(string)] 
     636            out = [float(input_string)] 
    658637            return out 
    659638        except: 
     
    663642                try: 
    664643                    # has a '-' 
    665                     if string.count('-') > 0: 
    666                         value = string.split('-') 
     644                    if input_string.count('-') > 0: 
     645                        value = input_string.split('-') 
    667646                        if value[1].count(';') > 0: 
    668647                            # has a ';' 
    669648                            last_list = value[1].split(';') 
    670                             num = math.ceil(float(last_list[1])) 
     649                            num = numpy.ceil(float(last_list[1])) 
    671650                            max_value = float(last_list[0]) 
    672651                            self.num_wave = num 
     
    677656                        min_value = float(value[0]) 
    678657                        # make a list 
    679                         bin_size = math.fabs(max_value - min_value) / (num - 1) 
     658                        bin_size = numpy.fabs(max_value - min_value) / (num - 1) 
    680659                        out = [min_value + bin_size * bnum for bnum in 
    681660                               range(num)] 
    682661                        return out 
    683                     if string.count(',') > 0: 
    684                         out = self._string2inputlist(string) 
     662                    if input_string.count(',') > 0: 
     663                        out = self._string2inputlist(input_string) 
    685664                        return out 
    686665                except: 
     
    739718        self.plotter = Plotter2DWidget(self, quickplot=True) 
    740719        self.plotter.scale = 'linear' 
     720        self.plotter.cmap = None 
    741721        layout = QtGui.QHBoxLayout() 
    742722        layout.setContentsMargins(0, 0, 0, 0) 
     
    744724        layout.addWidget(self.plotter) 
    745725 
    746     def new2DPlot(self, res_cal): 
     726    def new2DPlot(self): 
    747727        """ 
    748728        Create a new 2D data instance based on computing results 
Note: See TracChangeset for help on using the changeset viewer.