Changeset 8fbf8d6 in sasview


Ignore:
Timestamp:
Apr 10, 2017 10:59:31 AM (2 years ago)
Author:
gonzalezm
Branches:
master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
56e377c
Parents:
80a49c2 (diff), d26f025 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of https://github.com/SasView/sasview

Files:
3 added
101 edited

Legend:

Unmodified
Added
Removed
  • .gitattributes

    r600bea1 rfd5d8747  
    33Make.mm linguist-language=Makefile 
    44sasview/test/* linguist-language=Other 
    5 * test=auto 
     5*.py text eol=lf 
     6*.c text eol=lf 
     7*.h text eol=lf 
     8*.cpp text eol=lf 
     9*.rst text eol=lf 
  • check_packages.py

    rf433e6a r235f514  
    5757    try: 
    5858        i = __import__(test_vals['import_name'], fromlist=['']) 
    59         if test_vals['test'] == None: 
     59        if test_vals['test'] is None: 
    6060            print("%s Installed (Unknown version)" % package_name) 
    6161        elif package_name == 'lxml': 
  • sasview/local_config.py

    r9c0f3c17 rea45bfe  
    4848 
    4949_acknowledgement =  \ 
    50 '''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: https://github.com/orgs/SasView/people 
     50'''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: http://www.sasview.org/contact.html 
    5151''' 
    5252 
  • sasview/media/README.txt

    r7202894 r643dcd93  
    22in the menu bar. 
    33 
    4 The source files are in: /SasViewLocalTrunk/docs/sasview 
     4The source files are in: /sasview/docs/sasview 
  • sasview/setup_mac.py

    rb58654c r235f514  
    5858    if os.path.isfile(libxml_path_test): 
    5959        libxml_path = libxml_path_test 
    60 if libxml_path == None: 
     60if libxml_path is None: 
    6161    raise RuntimeError, "Could not find libxml2 on the system" 
    6262 
  • sasview/welcome_panel.py

    rd85c194 r7432acb  
    6969        """ 
    7070        self.frame = frame 
    71         if frame != None: 
     71        if frame is not None: 
    7272            self.frame.Bind(wx.EVT_CLOSE, self.on_close_page) 
    7373 
  • setup.py

    red2276f rf3bf622  
    5353    #             os.remove(file_path) 
    5454    if os.path.exists(SASVIEW_BUILD): 
    55         print "Removing existing build directory", SASVIEW_BUILD, "for a clean build" 
     55        print("Removing existing build directory", SASVIEW_BUILD, "for a clean build") 
    5656        shutil.rmtree(SASVIEW_BUILD) 
    5757 
     
    7474                enable_openmp = False 
    7575        except: 
    76             print "PROBLEM determining Darwin version" 
     76            print("PROBLEM determining Darwin version") 
    7777 
    7878# Options to enable OpenMP 
     
    9595            platform_copt = {'unix' : ['-Wno-error=unused-command-line-argument-hard-error-in-future']} 
    9696    except: 
    97         print "PROBLEM determining Darwin version" 
     97        print("PROBLEM determining Darwin version") 
    9898 
    9999class DisableOpenMPCommand(Command): 
     
    118118        # Get 64-bitness 
    119119        c = self.compiler.compiler_type 
    120         print "Compiling with %s (64bit=%s)" % (c, str(is_64bits)) 
     120        print("Compiling with %s (64bit=%s)" % (c, str(is_64bits))) 
    121121 
    122122        # OpenMP build options 
    123123        if enable_openmp: 
    124             if copt.has_key(c): 
     124            if c in copt: 
    125125                for e in self.extensions: 
    126126                    e.extra_compile_args = copt[ c ] 
    127             if lopt.has_key(c): 
     127            if c in lopt: 
    128128                for e in self.extensions: 
    129129                    e.extra_link_args = lopt[ c ] 
    130130 
    131131        # Platform-specific build options 
    132         if platform_lopt.has_key(c): 
     132        if c in platform_lopt: 
    133133            for e in self.extensions: 
    134134                e.extra_link_args = platform_lopt[ c ] 
    135135 
    136         if platform_copt.has_key(c): 
     136        if c in platform_copt: 
    137137            for e in self.extensions: 
    138138                e.extra_compile_args = platform_copt[ c ] 
  • src/sas/sascalc/calculator/kiessig_calculator.py

    rb699768 r235f514  
    4949            return None 
    5050        # check if delta_q is zero 
    51         if dq == 0.0 or dq == None: 
     51        if dq == 0.0 or dq is None: 
    5252            return None 
    5353        else: 
  • src/sas/sascalc/calculator/resolution_calculator.py

    r9c0f3c17 r7432acb  
    608608        a_value *= 1.0E-16 
    609609        # if lamda is give (broad meanning of A)  return 2* lamda^2 * A 
    610         if lamda != None: 
     610        if lamda is not None: 
    611611            a_value *= (4 * lamda * lamda) 
    612612        return a_value 
  • src/sas/sascalc/calculator/sas_gen.py

    r9c0f3c17 r7432acb  
    9797        :Param volume: pixel volume [float] 
    9898        """ 
    99         if self.data_vol == None: 
     99        if self.data_vol is None: 
    100100            raise 
    101101        self.data_vol = volume 
     
    119119        pos_z = self.data_z 
    120120        len_x = len(pos_x) 
    121         if self.is_avg == None: 
     121        if self.is_avg is None: 
    122122            len_x *= -1 
    123123            pos_x, pos_y, pos_z = transform_center(pos_x, pos_y, pos_z) 
     
    257257        self.sld_n = np.zeros(length) 
    258258 
    259         if omfdata.mx == None: 
     259        if omfdata.mx is None: 
    260260            self.mx = np.zeros(length) 
    261         if omfdata.my == None: 
     261        if omfdata.my is None: 
    262262            self.my = np.zeros(length) 
    263         if omfdata.mz == None: 
     263        if omfdata.mz is None: 
    264264            self.mz = np.zeros(length) 
    265265 
     
    691691            output.set_pix_type('pixel') 
    692692            output.set_pixel_symbols('pixel') 
    693             if vol_pix != None: 
     693            if vol_pix is not None: 
    694694                output.set_pixel_volumes(vol_pix) 
    695695            return output 
     
    703703        :Param data: MagSLD data object 
    704704        """ 
    705         if path == None: 
     705        if path is None: 
    706706            raise ValueError, "Missing the file path." 
    707         if data == None: 
     707        if data is None: 
    708708            raise ValueError, "Missing the data to save." 
    709709        x_val = data.pos_x 
     
    713713        length = len(x_val) 
    714714        sld_n = data.sld_n 
    715         if sld_n == None: 
     715        if sld_n is None: 
    716716            sld_n = np.zeros(length) 
    717717        sld_mx = data.sld_mx 
    718         if sld_mx == None: 
     718        if sld_mx is None: 
    719719            sld_mx = np.zeros(length) 
    720720            sld_my = np.zeros(length) 
     
    867867        self.sld_theta = None 
    868868        self.pix_symbol = None 
    869         if sld_mx != None and sld_my != None and sld_mz != None: 
     869        if sld_mx is not None and sld_my is not None and sld_mz is not None: 
    870870            self.set_sldms(sld_mx, sld_my, sld_mz) 
    871871        self.set_nodes() 
     
    935935        :Params pixel: str; pixel or atomic symbol, or array of strings 
    936936        """ 
    937         if self.sld_n == None: 
     937        if self.sld_n is None: 
    938938            return 
    939939        if symbol.__class__.__name__ == 'str': 
     
    947947        :Params pixel: str; pixel or atomic symbol, or array of strings 
    948948        """ 
    949         if self.sld_n == None: 
     949        if self.sld_n is None: 
    950950            return 
    951951        if vol.__class__.__name__ == 'ndarray': 
  • src/sas/sascalc/data_util/calcthread.py

    r64ca561 r7432acb  
    205205    def update(self, **kwargs): 
    206206        """Update GUI with the lastest results from the current work unit.""" 
    207         if self.updatefn != None and clock() > self._time_for_update: 
     207        if self.updatefn is not None and clock() > self._time_for_update: 
    208208            self._lock.acquire() 
    209209            self._time_for_update = clock() + self._delay 
     
    221221    def complete(self, **kwargs): 
    222222        """Update the GUI with the completed results from a work unit.""" 
    223         if self.completefn != None: 
     223        if self.completefn is not None: 
    224224            self.completefn(**kwargs) 
    225225            sleep(self.yieldtime) 
  • src/sas/sascalc/data_util/qsmearing.py

    r9a5097c r235f514  
    4242    # This checks for 2D data (does not throw exception because fail is common) 
    4343    if  data.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    44         if data == None: 
     44        if data is None: 
    4545            return None 
    46         elif data.dqx_data == None or data.dqy_data == None: 
     46        elif data.dqx_data is None or data.dqy_data is None: 
    4747            return None 
    4848        return PySmear2D(data) 
  • src/sas/sascalc/dataloader/data_info.py

    r9a5097c r7432acb  
    353353    details = None 
    354354    ## SESANS zacceptance 
    355     zacceptance = None 
     355    zacceptance = (0,"") 
     356    yacceptance = (0,"") 
    356357 
    357358    def __init__(self): 
     
    805806            # create zero vector 
    806807            dy_other = other.dy 
    807             if other.dy == None or (len(other.dy) != len(other.y)): 
     808            if other.dy is None or (len(other.dy) != len(other.y)): 
    808809                dy_other = np.zeros(len(other.y)) 
    809810 
    810811        # Check that we have errors, otherwise create zero vector 
    811812        dy = self.dy 
    812         if self.dy == None or (len(self.dy) != len(self.y)): 
     813        if self.dy is None or (len(self.dy) != len(self.y)): 
    813814            dy = np.zeros(len(self.y)) 
    814815 
     
    821822        dy, dy_other = self._validity_check(other) 
    822823        result = self.clone_without_data(len(self.x)) 
    823         if self.dxw == None: 
     824        if self.dxw is None: 
    824825            result.dxw = None 
    825826        else: 
    826827            result.dxw = np.zeros(len(self.x)) 
    827         if self.dxl == None: 
     828        if self.dxl is None: 
    828829            result.dxl = None 
    829830        else: 
     
    883884        self._validity_check_union(other) 
    884885        result = self.clone_without_data(len(self.x) + len(other.x)) 
    885         if self.dy == None or other.dy is None: 
     886        if self.dy is None or other.dy is None: 
    886887            result.dy = None 
    887888        else: 
    888889            result.dy = np.zeros(len(self.x) + len(other.x)) 
    889         if self.dx == None or other.dx is None: 
     890        if self.dx is None or other.dx is None: 
    890891            result.dx = None 
    891892        else: 
    892893            result.dx = np.zeros(len(self.x) + len(other.x)) 
    893         if self.dxw == None or other.dxw is None: 
     894        if self.dxw is None or other.dxw is None: 
    894895            result.dxw = None 
    895896        else: 
    896897            result.dxw = np.zeros(len(self.x) + len(other.x)) 
    897         if self.dxl == None or other.dxl is None: 
     898        if self.dxl is None or other.dxl is None: 
    898899            result.dxl = None 
    899900        else: 
     
    906907        result.y = np.append(self.y, other.y) 
    907908        result.y = result.y[ind] 
    908         if result.dy != None: 
     909        if result.dy is not None: 
    909910            result.dy = np.append(self.dy, other.dy) 
    910911            result.dy = result.dy[ind] 
     
    10291030            # Check that the scales match 
    10301031            err_other = other.err_data 
    1031             if other.err_data == None or \ 
     1032            if other.err_data is None or \ 
    10321033                (len(other.err_data) != len(other.data)): 
    10331034                err_other = np.zeros(len(other.data)) 
     
    10351036        # Check that we have errors, otherwise create zero vector 
    10361037        err = self.err_data 
    1037         if self.err_data == None or \ 
     1038        if self.err_data is None or \ 
    10381039            (len(self.err_data) != len(self.data)): 
    10391040            err = np.zeros(len(other.data)) 
     
    10501051        dy, dy_other = self._validity_check(other) 
    10511052        result = self.clone_without_data(np.size(self.data)) 
    1052         if self.dqx_data == None or self.dqy_data == None: 
     1053        if self.dqx_data is None or self.dqy_data is None: 
    10531054            result.dqx_data = None 
    10541055            result.dqy_data = None 
     
    11241125        result.ymin = self.ymin 
    11251126        result.ymax = self.ymax 
    1126         if self.dqx_data == None or self.dqy_data == None or \ 
    1127                 other.dqx_data == None or other.dqy_data == None: 
     1127        if self.dqx_data is None or self.dqy_data is None or \ 
     1128                other.dqx_data is None or other.dqy_data is None: 
    11281129            result.dqx_data = None 
    11291130            result.dqy_data = None 
  • src/sas/sascalc/dataloader/manipulations.py

    rdd11014 r7432acb  
    210210            y[i_q] += frac * data[npts] 
    211211 
    212             if err_data == None or err_data[npts] == 0.0: 
     212            if err_data is None or err_data[npts] == 0.0: 
    213213                if data[npts] < 0: 
    214214                    data[npts] = -data[npts] 
     
    333333                continue 
    334334            y += frac * data[npts] 
    335             if err_data == None or err_data[npts] == 0.0: 
     335            if err_data is None or err_data[npts] == 0.0: 
    336336                if data[npts] < 0: 
    337337                    data[npts] = -data[npts] 
     
    422422 
    423423        # Get the dq for resolution averaging 
    424         if data2D.dqx_data != None and data2D.dqy_data != None: 
     424        if data2D.dqx_data is not None and data2D.dqy_data is not None: 
    425425            # The pinholes and det. pix contribution present 
    426426            # in both direction of the 2D which must be subtracted when 
     
    462462 
    463463        #q_data_max = numpy.max(q_data) 
    464         if len(data2D.q_data) == None: 
     464        if len(data2D.q_data) is None: 
    465465            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data 
    466466            raise RuntimeError, msg 
     
    502502            # Take dqs from data to get the q_average 
    503503            x[i_q] += frac * q_value 
    504             if err_data == None or err_data[npt] == 0.0: 
     504            if err_data is None or err_data[npt] == 0.0: 
    505505                if data_n < 0: 
    506506                    data_n = -data_n 
     
    508508            else: 
    509509                err_y[i_q] += frac * frac * err_data[npt] * err_data[npt] 
    510             if dq_data != None: 
     510            if dq_data is not None: 
    511511                # To be consistent with dq calculation in 1d reduction, 
    512512                # we need just the averages (not quadratures) because 
     
    523523                err_y[n] = -err_y[n] 
    524524            err_y[n] = math.sqrt(err_y[n]) 
    525             #if err_x != None: 
     525            #if err_x is not None: 
    526526            #    err_x[n] = math.sqrt(err_x[n]) 
    527527 
     
    532532        idx = (numpy.isfinite(y)) & (numpy.isfinite(x)) 
    533533 
    534         if err_x != None: 
     534        if err_x is not None: 
    535535            d_x = err_x[idx] / y_counts[idx] 
    536536        else: 
     
    623623            phi_bins[i_phi] += frac * data[npt] 
    624624 
    625             if err_data == None or err_data[npt] == 0.0: 
     625            if err_data is None or err_data[npt] == 0.0: 
    626626                if data_n < 0: 
    627627                    data_n = -data_n 
     
    777777 
    778778        # Get the dq for resolution averaging 
    779         if data2D.dqx_data != None and data2D.dqy_data != None: 
     779        if data2D.dqx_data is not None and data2D.dqy_data is not None: 
    780780            # The pinholes and det. pix contribution present 
    781781            # in both direction of the 2D which must be subtracted when 
     
    888888            y[i_bin] += frac * data_n 
    889889            x[i_bin] += frac * q_value 
    890             if err_data[n] == None or err_data[n] == 0.0: 
     890            if err_data[n] is None or err_data[n] == 0.0: 
    891891                if data_n < 0: 
    892892                    data_n = -data_n 
     
    895895                y_err[i_bin] += frac * frac * err_data[n] * err_data[n] 
    896896 
    897             if dq_data != None: 
     897            if dq_data is not None: 
    898898                # To be consistent with dq calculation in 1d reduction, 
    899899                # we need just the averages (not quadratures) because 
     
    925925        y_err[y_err == 0] = numpy.average(y_err) 
    926926        idx = (numpy.isfinite(y) & numpy.isfinite(y_err)) 
    927         if x_err != None: 
     927        if x_err is not None: 
    928928            d_x = x_err[idx] / y_counts[idx] 
    929929        else: 
  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    r9a5097c r235f514  
    128128                        if new_lentoks > 2: 
    129129                            _dy = float(toks[2]) 
    130                         has_error_dy = False if _dy == None else True 
     130                        has_error_dy = False if _dy is None else True 
    131131 
    132132                        # If a 4th row is present, consider it dx 
    133133                        if new_lentoks > 3: 
    134134                            _dx = float(toks[3]) 
    135                         has_error_dx = False if _dx == None else True 
     135                        has_error_dx = False if _dx is None else True 
    136136 
    137137                        # Delete the previously stored lines of data candidates if 
  • src/sas/sascalc/dataloader/readers/cansas_constants.py

    rad4632c r63d773c  
    135135                             "Sesans": {"storeas": "content"}, 
    136136                             "zacceptance": {"storeas": "float"}, 
     137                             "yacceptance": {"storeas": "float"}, 
    137138                             "<any>" : ANY 
    138139                            } 
  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r463e7ffc r7432acb  
    292292                elif tagname == 'Sesans': 
    293293                    self.current_datainfo.isSesans = bool(data_point) 
     294                elif tagname == 'yacceptance': 
     295                    self.current_datainfo.sample.yacceptance = (data_point, unit) 
    294296                elif tagname == 'zacceptance': 
    295297                    self.current_datainfo.sample.zacceptance = (data_point, unit) 
     
    805807        :param data1d: presumably a Data1D object 
    806808        """ 
    807         if self.current_dataset == None: 
     809        if self.current_dataset is None: 
    808810            x_vals = np.empty(0) 
    809811            y_vals = np.empty(0) 
     
    893895        # Write the file 
    894896        file_ref = open(filename, 'w') 
    895         if self.encoding == None: 
     897        if self.encoding is None: 
    896898            self.encoding = "UTF-8" 
    897899        doc.write(file_ref, encoding=self.encoding, 
     
    10131015        :param entry_node: lxml node ElementTree object to be appended to 
    10141016        """ 
    1015         if datainfo.run == None or datainfo.run == []: 
     1017        if datainfo.run is None or datainfo.run == []: 
    10161018            datainfo.run.append(RUN_NAME_DEFAULT) 
    10171019            datainfo.run_name[RUN_NAME_DEFAULT] = RUN_NAME_DEFAULT 
     
    10571059            sesans.text = str(datainfo.isSesans) 
    10581060            node.append(sesans) 
     1061            self.write_node(node, "yacceptance", datainfo.sample.yacceptance[0], 
     1062                             {'unit': datainfo.sample.yacceptance[1]}) 
    10591063            self.write_node(node, "zacceptance", datainfo.sample.zacceptance[0], 
    10601064                             {'unit': datainfo.sample.zacceptance[1]}) 
     
    11291133                self.write_node(point, "T", spectrum.transmission[i], 
    11301134                                {'unit': spectrum.transmission_unit}) 
    1131                 if spectrum.transmission_deviation != None \ 
     1135                if spectrum.transmission_deviation is not None \ 
    11321136                and len(spectrum.transmission_deviation) >= i: 
    11331137                    self.write_node(point, "Tdev", 
     
    12091213                                 str(datainfo.source.name)) 
    12101214        self.append(source, instr) 
    1211         if datainfo.source.radiation == None or datainfo.source.radiation == '': 
     1215        if datainfo.source.radiation is None or datainfo.source.radiation == '': 
    12121216            datainfo.source.radiation = "neutron" 
    12131217        self.write_node(source, "radiation", datainfo.source.radiation) 
     
    12501254        :param instr: lxml node ElementTree object to be appended to 
    12511255        """ 
    1252         if datainfo.collimation == [] or datainfo.collimation == None: 
     1256        if datainfo.collimation == [] or datainfo.collimation is None: 
    12531257            coll = Collimation() 
    12541258            datainfo.collimation.append(coll) 
     
    12951299        :param inst: lxml instrument node to be appended to 
    12961300        """ 
    1297         if datainfo.detector == None or datainfo.detector == []: 
     1301        if datainfo.detector is None or datainfo.detector == []: 
    12981302            det = Detector() 
    12991303            det.name = "" 
     
    14601464                local_unit = None 
    14611465                exec "local_unit = storage.%s_unit" % toks[0] 
    1462                 if local_unit != None and units.lower() != local_unit.lower(): 
     1466                if local_unit is not None and units.lower() != local_unit.lower(): 
    14631467                    if HAS_CONVERTER == True: 
    14641468                        try: 
  • src/sas/sascalc/dataloader/readers/danse_reader.py

    r9c0f3c17 r235f514  
    166166                 
    167167                x_vals.append(qx) 
    168                 if xmin == None or qx < xmin: 
     168                if xmin is None or qx < xmin: 
    169169                    xmin = qx 
    170                 if xmax == None or qx > xmax: 
     170                if xmax is None or qx > xmax: 
    171171                    xmax = qx 
    172172             
     
    181181                 
    182182                y_vals.append(qy) 
    183                 if ymin == None or qy < ymin: 
     183                if ymin is None or qy < ymin: 
    184184                    ymin = qy 
    185                 if ymax == None or qy > ymax: 
     185                if ymax is None or qy > ymax: 
    186186                    ymax = qy 
    187187             
  • src/sas/sascalc/dataloader/readers/xml_reader.py

    r463e7ffc r235f514  
    240240        :param name: The name of the element to be created 
    241241        """ 
    242         if attrib == None: 
     242        if attrib is None: 
    243243            attrib = {} 
    244244        return etree.Element(name, attrib, nsmap) 
     
    299299        """ 
    300300        text = str(text) 
    301         if attrib == None: 
     301        if attrib is None: 
    302302            attrib = {} 
    303303        elem = E(elementname, attrib, text) 
  • src/sas/sascalc/file_converter/cansas_writer.py

    r0b1a677 r7432acb  
    1717        # Write the file 
    1818        file_ref = open(filename, 'w') 
    19         if self.encoding == None: 
     19        if self.encoding is None: 
    2020            self.encoding = "UTF-8" 
    2121        doc.write(file_ref, encoding=self.encoding, 
     
    9696                self.write_node(point, "I", datainfo.y[i], 
    9797                                {'unit': datainfo.y_unit}) 
    98             if datainfo.dy != None and len(datainfo.dy) > i: 
     98            if datainfo.dy is not None and len(datainfo.dy) > i: 
    9999                self.write_node(point, "Idev", datainfo.dy[i], 
    100100                                {'unit': datainfo.y_unit}) 
    101             if datainfo.dx != None and len(datainfo.dx) > i: 
     101            if datainfo.dx is not None and len(datainfo.dx) > i: 
    102102                self.write_node(point, "Qdev", datainfo.dx[i], 
    103103                                {'unit': datainfo.x_unit}) 
    104             if datainfo.dxw != None and len(datainfo.dxw) > i: 
     104            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    105105                self.write_node(point, "dQw", datainfo.dxw[i], 
    106106                                {'unit': datainfo.x_unit}) 
    107             if datainfo.dxl != None and len(datainfo.dxl) > i: 
     107            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    108108                self.write_node(point, "dQl", datainfo.dxl[i], 
    109109                                {'unit': datainfo.x_unit}) 
  • src/sas/sascalc/fit/AbstractFitEngine.py

    r9a5097c r7432acb  
    190190        if qmin == 0.0 and not np.isfinite(self.y[qmin]): 
    191191            self.qmin = min(self.x[self.x != 0]) 
    192         elif qmin != None: 
     192        elif qmin is not None: 
    193193            self.qmin = qmin 
    194         if qmax != None: 
     194        if qmax is not None: 
    195195            self.qmax = qmax 
    196196        # Determine the range needed in unsmeared-Q to cover 
     
    202202        self._last_unsmeared_bin = len(self.x) - 1 
    203203         
    204         if self.smearer != None: 
     204        if self.smearer is not None: 
    205205            self._first_unsmeared_bin, self._last_unsmeared_bin = \ 
    206206                    self.smearer.get_bin_range(self.qmin, self.qmax) 
     
    294294         
    295295        ## fitting range 
    296         if qmin == None: 
     296        if qmin is None: 
    297297            self.qmin = 1e-16 
    298         if qmax == None: 
     298        if qmax is None: 
    299299            self.qmax = math.sqrt(x_max * x_max + y_max * y_max) 
    300300        ## new error image for fitting purpose 
    301         if self.err_data == None or self.err_data == []: 
     301        if self.err_data is None or self.err_data == []: 
    302302            self.res_err_data = np.ones(len(self.data)) 
    303303        else: 
     
    318318            Set smearer 
    319319        """ 
    320         if smearer == None: 
     320        if smearer is None: 
    321321            return 
    322322        self.smearer = smearer 
     
    330330        if qmin == 0.0: 
    331331            self.qmin = 1e-16 
    332         elif qmin != None: 
     332        elif qmin is not None: 
    333333            self.qmin = qmin 
    334         if qmax != None: 
     334        if qmax is not None: 
    335335            self.qmax = qmax 
    336336        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2) 
     
    357357        return the residuals 
    358358        """ 
    359         if self.smearer != None: 
     359        if self.smearer is not None: 
    360360            fn.set_index(self.idx) 
    361361            gn = fn.get_value() 
     
    612612        """ 
    613613        """ 
    614         if self.pvec == None and self.model is None and self.param_list is None: 
     614        if self.pvec is None and self.model is None and self.param_list is None: 
    615615            return "No results" 
    616616 
  • src/sas/sascalc/fit/Loader.py

    r9a5097c rac07a3a  
    3434    def set_values(self): 
    3535        """ Store the values loaded from file in local variables""" 
    36         if not self.filename == None: 
     36        if self.filename is not None: 
    3737            input_f =  open(self.filename, 'r') 
    3838            buff = input_f.read() 
  • src/sas/sascalc/fit/MultiplicationModel.py

    r9a5097c r7432acb  
    178178        """ 
    179179        value = self.params['volfraction'] 
    180         if value != None: 
     180        if value is not None: 
    181181            factor = self.p_model.calculate_VR() 
    182             if factor == None or factor == NotImplemented or factor == 0.0: 
     182            if factor is None or factor == NotImplemented or factor == 0.0: 
    183183                val = value 
    184184            else: 
     
    195195        effective_radius = self.p_model.calculate_ER() 
    196196        #Reset the effective_radius of s_model just before the run 
    197         if effective_radius != None and effective_radius != NotImplemented: 
     197        if effective_radius is not None and effective_radius != NotImplemented: 
    198198            self.s_model.setParam('radius_effective', effective_radius) 
    199199 
  • src/sas/sascalc/invariant/invariant.py

    r9a5097c r7432acb  
    329329 
    330330        ##power is given only for function = power_law 
    331         if power != None: 
     331        if power is not None: 
    332332            sigma2 = linearized_data.dy * linearized_data.dy 
    333333            a = -(power) 
     
    389389        self._data = self._get_data(data) 
    390390        # get the dxl if the data is smeared: This is done only once on init. 
    391         if self._data.dxl != None and self._data.dxl.all() > 0: 
     391        if self._data.dxl is not None and self._data.dxl.all() > 0: 
    392392            # assumes constant dxl 
    393393            self._smeared = self._data.dxl[0] 
     
    579579 
    580580        result_data = LoaderData1D(x=q, y=iq, dy=diq) 
    581         if self._smeared != None: 
     581        if self._smeared is not None: 
    582582            result_data.dxl = self._smeared * np.ones(len(q)) 
    583583        return result_data 
  • src/sas/sascalc/pr/fit/AbstractFitEngine.py

    r9a5097c r7432acb  
    190190        if qmin == 0.0 and not np.isfinite(self.y[qmin]): 
    191191            self.qmin = min(self.x[self.x != 0]) 
    192         elif qmin != None: 
     192        elif qmin is not None: 
    193193            self.qmin = qmin 
    194         if qmax != None: 
     194        if qmax is not None: 
    195195            self.qmax = qmax 
    196196        # Determine the range needed in unsmeared-Q to cover 
     
    202202        self._last_unsmeared_bin = len(self.x) - 1 
    203203         
    204         if self.smearer != None: 
     204        if self.smearer is not None: 
    205205            self._first_unsmeared_bin, self._last_unsmeared_bin = \ 
    206206                    self.smearer.get_bin_range(self.qmin, self.qmax) 
     
    294294         
    295295        ## fitting range 
    296         if qmin == None: 
     296        if qmin is None: 
    297297            self.qmin = 1e-16 
    298         if qmax == None: 
     298        if qmax is None: 
    299299            self.qmax = math.sqrt(x_max * x_max + y_max * y_max) 
    300300        ## new error image for fitting purpose 
    301         if self.err_data == None or self.err_data == []: 
     301        if self.err_data is None or self.err_data == []: 
    302302            self.res_err_data = np.ones(len(self.data)) 
    303303        else: 
     
    318318            Set smearer 
    319319        """ 
    320         if smearer == None: 
     320        if smearer is None: 
    321321            return 
    322322        self.smearer = smearer 
     
    330330        if qmin == 0.0: 
    331331            self.qmin = 1e-16 
    332         elif qmin != None: 
     332        elif qmin is not None: 
    333333            self.qmin = qmin 
    334         if qmax != None: 
     334        if qmax is not None: 
    335335            self.qmax = qmax 
    336336        self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2) 
     
    357357        return the residuals 
    358358        """ 
    359         if self.smearer != None: 
     359        if self.smearer is not None: 
    360360            fn.set_index(self.idx) 
    361361            # Get necessary data from self.data and set the data for smearing 
     
    615615        """ 
    616616        """ 
    617         if self.pvec == None and self.model is None and self.param_list is None: 
     617        if self.pvec is None and self.model is None and self.param_list is None: 
    618618            return "No results" 
    619619 
  • src/sas/sascalc/pr/fit/Loader.py

    r9a5097c rac07a3a  
    3434    def set_values(self): 
    3535        """ Store the values loaded from file in local variables""" 
    36         if not self.filename == None: 
     36        if self.filename is not None: 
    3737            input_f =  open(self.filename, 'r') 
    3838            buff = input_f.read() 
  • src/sas/sascalc/pr/invertor.py

    r9c0f3c17 r45dffa69  
    162162            return self.set_dmax(value) 
    163163        elif name == 'q_min': 
    164             if value == None: 
     164            if value is None: 
    165165                return self.set_qmin(-1.0) 
    166166            return self.set_qmin(value) 
    167167        elif name == 'q_max': 
    168             if value == None: 
     168            if value is None: 
    169169                return self.set_qmax(-1.0) 
    170170            return self.set_qmax(value) 
     
    395395        Check q-value against user-defined range 
    396396        """ 
    397         if not self.q_min == None and q < self.q_min: 
     397        if self.q_min is not None and q < self.q_min: 
    398398            return False 
    399         if not self.q_max == None and q > self.q_max: 
     399        if self.q_max is not None and q > self.q_max: 
    400400            return False 
    401401        return True 
     
    658658            file.write("#has_bck=0\n") 
    659659        file.write("#alpha_estimate=%g\n" % self.suggested_alpha) 
    660         if not self.out == None: 
     660        if self.out is not None: 
    661661            if len(self.out) == len(self.cov): 
    662662                for i in range(len(self.out)): 
  • src/sas/sascalc/pr/num_term.py

    r9c0f3c17 r7432acb  
    6767        self.alpha_list = [] 
    6868        for k in range(self.nterm_min, self.nterm_max, 1): 
    69             if self.isquit_func != None: 
     69            if self.isquit_func is not None: 
    7070                self.isquit_func() 
    7171            best_alpha, message, _ = inver.estimate_alpha(k) 
     
    159159    scale = None 
    160160    min_err = 0.0 
    161     if not path == None: 
     161    if path is not None: 
    162162        input_f = open(path, 'r') 
    163163        buff = input_f.read() 
     
    171171                    err = float(toks[2]) 
    172172                else: 
    173                     if scale == None: 
     173                    if scale is None: 
    174174                        scale = 0.05 * math.sqrt(test_y) 
    175175                        #scale = 0.05/math.sqrt(y) 
  • src/sas/sascalc/realspace/VolumeCanvas.py

    rd85c194 r235f514  
    293293        """ 
    294294        # If the handle is not provided, create one 
    295         if id == None: 
     295        if id is None: 
    296296            id = shapeDesc.params["type"]+str(self.shapecount) 
    297297          
     
    303303        self.shapecount += 1 
    304304 
    305         #model changed, need to recalculate P(r) 
     305        # model changed, need to recalculate P(r) 
    306306        self._model_changed() 
    307307 
     
    325325        """ 
    326326        # If the handle is not provided, create one 
    327         if id == None: 
     327        if id is None: 
    328328            id = "shape"+str(self.shapecount) 
    329329  
    330         #shapeDesc = ShapeDescriptor(shape.lower()) 
     330        # shapeDesc = ShapeDescriptor(shape.lower()) 
    331331        if shape.lower() in shape_dict: 
    332332            shapeDesc = shape_dict[shape.lower()]() 
     
    335335            shapeDesc = PDBDescriptor(shape) 
    336336        else: 
    337             raise ValueError, "VolumeCanvas.add: Unknown shape %s" % shape 
     337            raise ValueError("VolumeCanvas.add: Unknown shape %s" % shape) 
    338338         
    339339        return self.addObject(shapeDesc, id) 
     
    345345        """ 
    346346 
    347         if self.shapes.has_key(id): 
     347        if id in self.shapes: 
    348348            del self.shapes[id] 
    349349        else: 
    350             raise KeyError, "VolumeCanvas.delete: could not find shape ID" 
    351  
    352         #model changed, need to recalculate P(r) 
     350            raise KeyError("VolumeCanvas.delete: could not find shape ID") 
     351 
     352        # model changed, need to recalculate P(r) 
    353353        self._model_changed() 
    354354 
     
    379379        # If a shape identifier was given, look the shape up 
    380380        # in the dictionary 
    381         if len(toks)>1: 
    382             if toks[0] in self.shapes.keys(): 
     381        if len(toks): 
     382            if toks[0] in self.shapes: 
    383383                # The shape was found, now look for the parameter 
    384384                if toks[1] in self.shapes[toks[0]].params: 
     
    387387                    self._model_changed() 
    388388                else: 
    389                     raise ValueError, "Could not find parameter %s" % name 
     389                    raise ValueError("Could not find parameter %s" % name) 
    390390            else: 
    391                 raise ValueError, "Could not find shape %s" % toks[0] 
     391                raise ValueError("Could not find shape %s" % toks[0]) 
    392392         
    393393        else: 
     
    410410        if len(toks) == 1: 
    411411            try: 
    412                 self.params.has_key(toks[0]) 
     412                value = self.params[toks[0]] 
    413413            except KeyError: 
    414                 raise ValueError, \ 
    415                     "VolumeCanvas.getParam: Could not find %s" % name 
    416  
    417             value = self.params[toks[0]] 
     414                raise ValueError("VolumeCanvas.getParam: Could not find" 
     415                                 " %s" % name) 
    418416            if isinstance(value, ShapeDescriptor): 
    419                 raise ValueError, \ 
    420                     "VolumeCanvas.getParam: Cannot get parameter value."  
     417                raise ValueError("VolumeCanvas.getParam: Cannot get parameter" 
     418                                 " value.") 
    421419            else: 
    422420                return value 
     
    424422        elif len(toks) == 2: 
    425423            try: 
    426                 self.shapes.has_key(toks[0]) 
     424                shapeinstance = self.shapes[toks[0]] 
    427425            except KeyError: 
    428                 raise ValueError, \ 
    429                     "VolumeCanvas.getParam: Could not find %s" % name 
    430  
    431             shapeinstance = self.shapes[toks[0]] 
    432  
    433             try: 
    434                 shapeinstance.params.has_key(toks[1]) 
    435             except KeyError: 
    436                 raise ValueError, \ 
    437                     "VolumeCanvas.getParam: Could not find %s" % name 
     426                raise ValueError("VolumeCanvas.getParam: Could not find " 
     427                                 "%s" % name) 
     428 
     429            if not toks[1] in shapeinstance.params: 
     430                raise ValueError("VolumeCanvas.getParam: Could not find " 
     431                                 "%s" % name) 
    438432 
    439433            return shapeinstance.params[toks[1]] 
    440434 
    441435        else: 
    442             raise ValueError, \ 
    443                 "VolumeCanvas.getParam: Could not find %s" % name 
    444              
    445     def getParamList(self, shapeid = None): 
     436            raise ValueError("VolumeCanvas.getParam: Could not find %s" % name) 
     437             
     438    def getParamList(self, shapeid=None): 
    446439        """ 
    447440               return a full list of all available parameters from  
     
    455448 
    456449        param_list = [] 
    457         if shapeid == None:         
    458             for key1 in self.params.keys(): 
     450        if shapeid is None: 
     451            for key1 in self.params: 
    459452                #value1 = self.params[key1] 
    460453                param_list.append(key1) 
    461             for key2 in self.shapes.keys(): 
     454            for key2 in self.shapes: 
    462455                value2 = self.shapes[key2] 
    463456                header = key2 + '.' 
    464                 for key3 in value2.params.keys():    
     457                for key3 in value2.params: 
    465458                    fullname = header + key3                  
    466459                    param_list.append(fullname) 
    467460      
    468461        else: 
    469             try: 
    470                 self.shapes.has_key(shapeid) 
    471             except KeyError: 
    472                 raise ValueError, \ 
    473                     "VolumeCanvas: getParamList: Could not find %s" % shapeid 
     462            if not shapeid in self.shapes: 
     463                raise ValueError("VolumeCanvas: getParamList: Could not find " 
     464                                 "%s" % shapeid) 
     465 
    474466            header = shapeid + '.' 
    475             param_list = self.shapes[shapeid].params.keys()   
    476             for i in range(len(param_list)): 
    477                 param_list[i] = header + param_list[i] 
    478  
     467            param_list = [header + param for param in self.shapes[shapeid].params] 
    479468        return param_list 
    480469 
     
    490479            @param shapeDesc: shape description 
    491480        """ 
    492         #Create the object model 
     481        # Create the object model 
    493482        shapeDesc.create() 
    494483                     
     
    605594        # type we recognize 
    606595        else: 
    607             raise ValueError, "run(q): bad type for q" 
     596            raise ValueError("run(q): bad type for q") 
    608597     
    609598    def runXY(self, q = 0): 
     
    625614        # type we recognize 
    626615        else: 
    627             raise ValueError, "runXY(q): bad type for q" 
     616            raise ValueError("runXY(q): bad type for q") 
    628617     
    629618    def _create_modelObject(self): 
     
    674663        # If this is the first simulation call, we need to generate the 
    675664        # space points 
    676         if self.points == None: 
     665        if self.points is None: 
    677666            self._create_modelObject() 
    678667             
    679668            # Protect against empty model 
    680             if self.points == None: 
     669            if self.points is None: 
    681670                return 0 
    682671                
  • src/sas/sasgui/guiframe/CategoryInstaller.py

    r463e7ffc r235f514  
    132132 
    133133        serialized_file = None 
    134         if homedir == None: 
     134        if homedir is None: 
    135135            serialized_file = CategoryInstaller.get_user_file() 
    136136        else: 
  • src/sas/sasgui/guiframe/config.py

    r64ca561 rea45bfe  
    4949 
    5050_acknowledgement =  \ 
    51 '''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: https://github.com/orgs/SasView/people 
     51'''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO, TU Delft, DLS, and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: http://www.sasview.org/contact.html 
    5252''' 
    5353 
  • src/sas/sasgui/guiframe/dataFitting.py

    r9a5097c r7432acb  
    7878        result.clone_without_data(length=len(self.x), clone=self) 
    7979        result.copy_from_datainfo(data1d=self) 
    80         if self.dxw == None: 
     80        if self.dxw is None: 
    8181            result.dxw = None 
    8282        else: 
    8383            result.dxw = np.zeros(len(self.x)) 
    84         if self.dxl == None: 
     84        if self.dxl is None: 
    8585            result.dxl = None 
    8686        else: 
     
    125125        tot_length = len(self.x) + len(other.x) 
    126126        result = self.clone_without_data(length=tot_length, clone=result) 
    127         if self.dlam == None or other.dlam is None: 
     127        if self.dlam is None or other.dlam is None: 
    128128            result.dlam = None 
    129129        else: 
    130130            result.dlam = np.zeros(tot_length) 
    131         if self.dy == None or other.dy is None: 
     131        if self.dy is None or other.dy is None: 
    132132            result.dy = None 
    133133        else: 
    134134            result.dy = np.zeros(tot_length) 
    135         if self.dx == None or other.dx is None: 
     135        if self.dx is None or other.dx is None: 
    136136            result.dx = None 
    137137        else: 
    138138            result.dx = np.zeros(tot_length) 
    139         if self.dxw == None or other.dxw is None: 
     139        if self.dxw is None or other.dxw is None: 
    140140            result.dxw = None 
    141141        else: 
    142142            result.dxw = np.zeros(tot_length) 
    143         if self.dxl == None or other.dxl is None: 
     143        if self.dxl is None or other.dxl is None: 
    144144            result.dxl = None 
    145145        else: 
     
    154154        result.lam = np.append(self.lam, other.lam) 
    155155        result.lam = result.lam[ind] 
    156         if result.dlam != None: 
     156        if result.dlam is not None: 
    157157            result.dlam = np.append(self.dlam, other.dlam) 
    158158            result.dlam = result.dlam[ind] 
    159         if result.dy != None: 
     159        if result.dy is not None: 
    160160            result.dy = np.append(self.dy, other.dy) 
    161161            result.dy = result.dy[ind] 
     
    227227        result = self.clone_without_data(len(self.x)) 
    228228        result.copy_from_datainfo(data1d=self) 
    229         if self.dxw == None: 
     229        if self.dxw is None: 
    230230            result.dxw = None 
    231231        else: 
    232232            result.dxw = np.zeros(len(self.x)) 
    233         if self.dxl == None: 
     233        if self.dxl is None: 
    234234            result.dxl = None 
    235235        else: 
     
    279279        tot_length = len(self.x)+len(other.x) 
    280280        result.clone_without_data(length=tot_length, clone=self) 
    281         if self.dlam == None or other.dlam is None: 
     281        if self.dlam is None or other.dlam is None: 
    282282            result.dlam = None 
    283283        else: 
    284284            result.dlam = np.zeros(tot_length) 
    285         if self.dy == None or other.dy is None: 
     285        if self.dy is None or other.dy is None: 
    286286            result.dy = None 
    287287        else: 
    288288            result.dy = np.zeros(tot_length) 
    289         if self.dx == None or other.dx is None: 
     289        if self.dx is None or other.dx is None: 
    290290            result.dx = None 
    291291        else: 
    292292            result.dx = np.zeros(tot_length) 
    293         if self.dxw == None or other.dxw is None: 
     293        if self.dxw is None or other.dxw is None: 
    294294            result.dxw = None 
    295295        else: 
    296296            result.dxw = np.zeros(tot_length) 
    297         if self.dxl == None or other.dxl is None: 
     297        if self.dxl is None or other.dxl is None: 
    298298            result.dxl = None 
    299299        else: 
     
    307307        result.lam = np.append(self.lam, other.lam) 
    308308        result.lam = result.lam[ind] 
    309         if result.dy != None: 
     309        if result.dy is not None: 
    310310            result.dy = np.append(self.dy, other.dy) 
    311311            result.dy = result.dy[ind] 
     
    405405        result.ymin = self.ymin 
    406406        result.ymax = self.ymax 
    407         if self.dqx_data == None or self.dqy_data == None: 
     407        if self.dqx_data is None or self.dqy_data is None: 
    408408            result.dqx_data = None 
    409409            result.dqy_data = None 
     
    468468        result.ymin = self.ymin 
    469469        result.ymax = self.ymax 
    470         if self.dqx_data == None or self.dqy_data == None or \ 
    471                 other.dqx_data == None or other.dqy_data == None : 
     470        if self.dqx_data is None or self.dqy_data is None or \ 
     471                other.dqx_data is None or other.dqy_data is None : 
    472472            result.dqx_data = None 
    473473            result.dqy_data = None 
  • src/sas/sasgui/guiframe/data_processor.py

    r9a5097c r7432acb  
    1818 
    1919""" 
    20 import wx 
    21 import numpy 
    22 import math 
    23 import re 
    2420import os 
    2521import sys 
    2622import copy 
    27 from wx.lib.scrolledpanel import ScrolledPanel 
     23import math 
     24import re 
     25import wx 
     26import numpy as np 
     27 
    2828import wx.aui 
    2929from wx.aui import AuiNotebook as nb 
    3030import wx.lib.sheet as sheet 
     31from wx.lib.scrolledpanel import ScrolledPanel 
     32 
    3133from sas.sasgui.guiframe.panel_base import PanelBase 
    3234from sas.sasgui.guiframe.events import NewPlotEvent 
     
    313315        if row > self.max_row_touse: 
    314316            self.max_row_touse = row 
    315         if self.data == None: 
     317        if self.data is None: 
    316318            self.data = {} 
    317319        event.Skip() 
     
    812814        """ 
    813815 
    814         if self.data == None: 
     816        if self.data is None: 
    815817            self.data = {} 
    816         if self.file_name == None: 
     818        if self.file_name is None: 
    817819            self.file_name = 'copied_data' 
    818820        self.Paste() 
     
    10151017                            if index - 1 >= 0: 
    10161018                                new_row, _ = temp_list[index - 1] 
    1017                                 if not new_row == None and new_row != ' ': 
     1019                                if new_row is not None and new_row != ' ': 
    10181020                                    label += create_label(col_name, None, 
    10191021                                                          int(new_row) + 1) 
     
    10231025                            if index + 1 < len(temp_list): 
    10241026                                new_row, _ = temp_list[index + 1] 
    1025                                 if not new_row == None: 
     1027                                if new_row is not None: 
    10261028                                    label += create_label(col_name, 
    10271029                                                          int(new_row) + 1, None) 
    1028                     if row_min != None and row_max != None: 
     1030                    if row_min is not None and row_max is not None: 
    10291031                        if index == 0: 
    10301032                            label += create_label(col_name, 
     
    10831085 
    10841086        # Let's re-order the data from the keys in 'Data' name. 
    1085         if outputs == None: 
     1087        if outputs is None: 
    10861088            return 
    10871089        try: 
     
    13721374            wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error")) 
    13731375            return 
    1374         if dy != None and (len(y) != len(dy)): 
     1376        if dy is not None and (len(y) != len(dy)): 
    13751377            msg = "Need same length for Y and dY axis and both greater than 0" 
    13761378            msg += " to plot.\n" 
     
    13781380            wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error")) 
    13791381            return 
    1380         if dy == None: 
     1382        if dy is None: 
    13811383            dy = np.zeros(len(y)) 
    13821384        #plotting 
     
    14391441            col = column_names[col_name] 
    14401442            axis = self.get_plot_axis(col, list) 
    1441             if axis == None: 
     1443            if axis is None: 
    14421444                return None 
    14431445            sentence = sentence.replace(tok, "numpy.array(%s)" % str(axis)) 
     
    15701572        """ 
    15711573 
    1572         if label != None: 
     1574        if label is not None: 
    15731575            tcrtl_label.SetValue(str(label)) 
    1574         if title != None: 
     1576        if title is not None: 
    15751577            tcrtl_title.SetValue(str(title)) 
    15761578 
     
    16831685        # I Believe this is no longer used now that we have removed the  
    16841686        # edit menu from the menubar - PDB July 12, 2015 
    1685         if event != None: 
     1687        if event is not None: 
    16861688            event.Skip() 
    16871689        pos = self.panel.notebook.GetSelection() 
     
    16951697        # I Believe this is no longer used now that we have removed the  
    16961698        # edit menu from the menubar - PDB July 12, 2015 
    1697         if event != None: 
     1699        if event is not None: 
    16981700            event.Skip() 
    16991701        pos = self.panel.notebook.GetSelection() 
     
    17371739            pos = self.panel.notebook.GetSelection() 
    17381740            grid = self.panel.notebook.GetPage(pos) 
    1739             has_data = (grid.data != None and grid.data != {}) 
     1741            has_data = (grid.data is not None and grid.data != {}) 
    17401742            self.open_excel_menu.Enable(has_data) 
    17411743            self.save_menu.Enable(has_data) 
     
    18201822                    path = dlg.GetPath() 
    18211823                dlg.Destroy() 
    1822                 if path != None: 
     1824                if path is not None: 
    18231825                    if self.parent is not None: 
    18241826                        data = grid.get_grid_view() 
     
    20052007                    path = dlg.GetPath() 
    20062008                dlg.Destroy() 
    2007                 if path != None: 
     2009                if path is not None: 
    20082010                    if self.parent is not None and  self.data is not None: 
    20092011                        self.parent.write_batch_tofile(data=self.data, 
  • src/sas/sasgui/guiframe/gui_manager.py

    r64ca561 r49165488  
    21222122        """ 
    21232123        if custom_config is not None: 
    2124             sas_opencl = os.environ.get("SAS_OPENCL",None) 
     2124            sas_opencl = os.environ.get("SAS_OPENCL") 
    21252125            new_config_lines = [] 
    21262126            config_file = open(custom_config.__file__) 
  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    r463e7ffc r235f514  
    7575        path = None 
    7676        self._default_save_location = self.parent._default_save_location 
    77         if self._default_save_location == None: 
     77        if self._default_save_location is None: 
    7878            self._default_save_location = os.getcwd() 
    7979 
     
    9292        if dlg.ShowModal() == wx.ID_OK: 
    9393            file_list = dlg.GetPaths() 
    94             if len(file_list) >= 0 and not file_list[0] is None: 
     94            if len(file_list) >= 0 and file_list[0] is not None: 
    9595                self._default_save_location = os.path.dirname(file_list[0]) 
    9696                path = self._default_save_location 
     
    116116        path = None 
    117117        self._default_save_location = self.parent._default_save_location 
    118         if self._default_save_location == None: 
     118        if self._default_save_location is None: 
    119119            self._default_save_location = os.getcwd() 
    120120        dlg = wx.DirDialog(self.parent, "Choose a directory", 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/AnnulusSlicer.py

    rd85c194 r7432acb  
    122122        data = self.base.data2D 
    123123        # If we have no data, just return 
    124         if data == None: 
     124        if data is None: 
    125125            return 
    126126 
     
    132132        # if the user does not specify the numbers of points to plot 
    133133        # the default number will be nbins= 36 
    134         if nbins == None: 
     134        if nbins is None: 
    135135            self.nbins = 36 
    136136        else: 
     
    498498        # Update locations 
    499499        self.outer_circle.update() 
    500         # if self.is_inside != None: 
     500        # if self.is_inside is not None: 
    501501        out = self._post_data() 
    502502        return out 
     
    521521 
    522522        # If we have no data, just return 
    523         if data == None: 
     523        if data is None: 
    524524            return 
    525525        mask = data.mask 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/Arc.py

    rd85c194 r7432acb  
    7171        x = [] 
    7272        y = [] 
    73         if theta1 != None: 
     73        if theta1 is not None: 
    7474            self.theta1 = theta1 
    75         if theta2 != None: 
     75        if theta2 is not None: 
    7676            self.theta2 = theta2 
    7777        while self.theta2 < self.theta1: 
     
    8181        npts = int((self.theta2 - self.theta1) / (math.pi / 120)) 
    8282 
    83         if r == None: 
     83        if r is None: 
    8484            self.radius = math.sqrt(math.pow(self._mouse_x, 2) + \ 
    8585                                     math.pow(self._mouse_y, 2)) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/Edge.py

    rd85c194 r7432acb  
    6363        Draw the new roughness on the graph. 
    6464        """ 
    65         if r1 != None: 
     65        if r1 is not None: 
    6666            self.r1 = r1 
    67         if r2 != None: 
     67        if r2 is not None: 
    6868            self.r2 = r2 
    69         if theta != None: 
     69        if theta is not None: 
    7070            self.theta = theta 
    7171        x1 = self.r1 * math.cos(self.theta) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter1D.py

    r9c0f3c17 r7432acb  
    183183        # So manually recode the size (=x_size) and compare here. 
    184184        # Massy code to work around:< 
    185         if self.parent._mgr != None: 
     185        if self.parent._mgr is not None: 
    186186            max_panel = self.parent._mgr.GetPane(self) 
    187187            if max_panel.IsMaximized(): 
    188188                self.parent._mgr.RestorePane(max_panel) 
    189189                max_panel.Maximize() 
    190         if self.x_size != None: 
     190        if self.x_size is not None: 
    191191            if self.x_size == self.GetSize(): 
    192192                self.resizing = False 
     
    212212        On Qmin Qmax vertical line event 
    213213        """ 
    214         if event == None: 
     214        if event is None: 
    215215            return 
    216216        event.Skip() 
    217217        active_ctrl = event.active 
    218         if active_ctrl == None: 
     218        if active_ctrl is None: 
    219219            return 
    220220        if hasattr(event, 'is_corfunc'): 
     
    231231                colors.append('purple') 
    232232                values.append(min(x_data.max(), float(ctrl[2].GetValue()))) 
    233             if self.ly == None: 
     233            if self.ly is None: 
    234234                self.ly = [] 
    235235                for c, v in zip(colors, values): 
     
    241241                xval = float(active_ctrl.GetValue()) 
    242242                position = self.get_data_xy_vals(xval) 
    243                 if position != None and not self.is_corfunc: 
     243                if position is not None and not self.is_corfunc: 
    244244                    wx.PostEvent(self.parent, StatusEvent(status=position)) 
    245245            except: 
     
    336336        if hasattr(event, "action"): 
    337337            dclick = event.action == 'dclick' 
    338             if ax == None or dclick: 
     338            if ax is None or dclick: 
    339339                # remove the vline 
    340340                self._check_zoom_plot() 
     
    342342                self.q_ctrl = None 
    343343                return 
    344         if self.ly != None and event.xdata != None: 
     344        if self.ly is not None and event.xdata is not None: 
    345345            # Selecting a new line if cursor lines are displayed already 
    346346            dqmin = math.fabs(event.xdata - self.ly[0].get_xdata()) 
     
    361361        Move the cursor line to write Q range 
    362362        """ 
    363         if self.q_ctrl == None: 
     363        if self.q_ctrl is None: 
    364364            return 
    365365        # release a q range vline 
    366         if self.ly != None and not self.leftdown: 
     366        if self.ly is not None and not self.leftdown: 
    367367            for ly in self.ly: 
    368368                ly.set_alpha(0.7) 
     
    370370            return 
    371371        ax = event.inaxes 
    372         if ax == None or not hasattr(event, 'action'): 
     372        if ax is None or not hasattr(event, 'action'): 
    373373            return 
    374         end_drag = event.action != 'drag' and event.xdata != None 
     374        end_drag = event.action != 'drag' and event.xdata is not None 
    375375        nop = len(self.plots) 
    376376        pos_x, _ = float(event.xdata), float(event.ydata) 
     
    514514        ax = event.inaxes 
    515515        PlotPanel.onLeftDown(self, event) 
    516         if ax != None: 
     516        if ax is not None: 
    517517            try: 
    518518                pos_x = float(event.xdata)  # / size_x 
     
    618618            # add menu of other plugins 
    619619            item_list = self.parent.get_current_context_menu(self) 
    620             if (not item_list == None) and (not len(item_list) == 0): 
     620            if (item_list is not None) and (len(item_list)): 
    621621                for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]): 
    622  
    623622                    try: 
    624623                        plot_menu.Append(wx_id, item[0], name) 
     
    684683 
    685684 
    686         if self.position != None: 
     685        if self.position is not None: 
    687686            wx_id = ids.next() 
    688687            self._slicerpop.Append(wx_id, '&Add Text') 
     
    761760            default_name = default_name.split('.')[0] 
    762761        default_name += "_out" 
    763         if self.parent != None: 
     762        if self.parent is not None: 
    764763            self.parent.save_data1d(data, default_name) 
    765764 
     
    779778            default_name = default_name.split('.')[0] 
    780779        # default_name += "_out" 
    781         if self.parent != None: 
     780        if self.parent is not None: 
    782781            self.parent.show_data1d(data, default_name) 
    783782 
     
    811810        curr_label = self.appearance_selected_plot.label 
    812811 
    813         if curr_color == None: 
     812        if curr_color is None: 
    814813            curr_color = self._color_labels['Blue'] 
    815814            curr_symbol = 13 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/Plotter2D.py

    r9c0f3c17 r7432acb  
    144144        """ 
    145145        # Not implemented 
    146         if event == None: 
     146        if event is None: 
    147147            return 
    148148        event.Skip() 
     
    156156        PlotPanel.onLeftDown(self, event) 
    157157        ax = event.inaxes 
    158         if ax != None: 
     158        if ax is not None: 
    159159            # data coordinate position 
    160160            pos_x = "%8.3g" % event.xdata 
     
    227227        if self._is_changed_legend_label: 
    228228            data.label = self.title_label 
    229         if data.label == None: 
     229        if data.label is None: 
    230230            data.label = data.name 
    231231        if not self.title_font: 
     
    264264        # control axis labels from the panel itself 
    265265        yname, yunits = data.get_yaxis() 
    266         if self.yaxis_label != None: 
     266        if self.yaxis_label is not None: 
    267267            yname = self.yaxis_label 
    268268            yunits = self.yaxis_unit 
     
    271271            self.yaxis_unit = yunits 
    272272        xname, xunits = data.get_xaxis() 
    273         if self.xaxis_label != None: 
     273        if self.xaxis_label is not None: 
    274274            xname = self.xaxis_label 
    275275            xunits = self.xaxis_unit 
     
    320320        if len(self.data2D.detector) <= 1: 
    321321            item_list = self.parent.get_current_context_menu(self) 
    322             if (not item_list == None) and (not len(item_list) == 0) and\ 
    323                 self.data2D.name.split(" ")[0] != 'Residuals': 
     322            if ((item_list is not None) and len(item_list) and 
     323                self.data2D.name.split(" ")[0] != 'Residuals'): 
    324324                for item, wx_id in zip(item_list, [ids.next() for i in range(len(item_list))]): 
    325325                    try: 
     
    355355            slicerpop.Append(wx_id, '&Box Averaging in Qy') 
    356356            wx.EVT_MENU(self, wx_id, self.onBoxavgY) 
    357             if self.slicer != None: 
     357            if self.slicer is not None: 
    358358                wx_id = ids.next() 
    359359                slicerpop.Append(wx_id, '&Clear Slicer') 
     
    435435                msg = "Add Text: Error. Check your property values..." 
    436436                logger.error(msg) 
    437                 if self.parent != None: 
     437                if self.parent is not None: 
    438438                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    439439        dial.Destroy() 
     
    533533        """ 
    534534        ## Clear current slicer 
    535         if not self.slicer == None: 
     535        if self.slicer is not None: 
    536536            self.slicer.clear() 
    537537        ## Create a new slicer 
     
    629629 
    630630        """ 
    631         if self.slicer != None: 
     631        if self.slicer is not None: 
    632632            from SlicerParameters import SlicerParameterPanel 
    633633            dialog = SlicerParameterPanel(self, -1, "Slicer Parameters") 
     
    719719        Clear the slicer on the plot 
    720720        """ 
    721         if not self.slicer == None: 
     721        if self.slicer is not None: 
    722722            self.slicer.clear() 
    723723            self.subplot.figure.canvas.draw() 
     
    735735        """ 
    736736        event_id = str(evt.GetId()) 
    737         if self.parent != None: 
     737        if self.parent is not None: 
    738738            self._default_save_location = self.parent._default_save_location 
    739739        default_name = self.plots[self.graph.selected_plottable].label 
     
    759759            default_name = default_name.split('.')[0] 
    760760        #default_name += "_out" 
    761         if self.parent != None: 
     761        if self.parent is not None: 
    762762            self.parent.show_data2d(data, default_name) 
    763763 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/SectorSlicer.py

    rd85c194 r7432acb  
    144144        data = self.base.data2D 
    145145        # If we have no data, just return 
    146         if data == None: 
     146        if data is None: 
    147147            return 
    148148        ## Averaging 
     
    151151        phimin = -self.left_line.phi + self.main_line.theta 
    152152        phimax = self.left_line.phi + self.main_line.theta 
    153         if nbins == None: 
     153        if nbins is None: 
    154154            nbins = 20 
    155155        sect = SectorQ(r_min=0.0, r_max=radius, 
     
    362362        self.left_moving = left 
    363363        theta3 = 0 
    364         if phi != None: 
     364        if phi is not None: 
    365365            self.phi = phi 
    366         if delta == None: 
     366        if delta is None: 
    367367            delta = 0 
    368368        if  right: 
     
    374374            self.theta = mline.theta + self.phi 
    375375 
    376         if mline != None: 
     376        if mline is not None: 
    377377            if delta != 0: 
    378378                self.theta2 = mline + delta 
     
    538538        """ 
    539539 
    540         if theta != None: 
     540        if theta is not None: 
    541541            self.theta = theta 
    542542        x1 = self.radius * math.cos(self.theta) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/SimplePlot.py

    r25b9707a r7432acb  
    8787            pos = (pos_x, pos_y + 5) 
    8888        self.PopupMenu(slicerpop, pos) 
    89         if self.scale != None: 
     89        if self.scale is not None: 
    9090            self.parent.scale2d = self.scale 
    9191 
     
    106106            self.leftdown = True 
    107107            ax = event.inaxes 
    108             if ax != None: 
     108            if ax is not None: 
    109109                self.xInit, self.yInit = event.xdata, event.ydata 
    110110                try: 
     
    123123        """ 
    124124        self.resizing = False 
    125         if self.x_size != None: 
     125        if self.x_size is not None: 
    126126            if self.x_size == self.GetSize(): 
    127127                self.canvas.set_resizing(self.resizing) 
     
    161161        self.plots[plot.name] = plot 
    162162        # Axis scales 
    163         if plot.xtransform != None: 
     163        if plot.xtransform is not None: 
    164164            self.xLabel = plot.xtransform 
    165         if plot.ytransform != None: 
     165        if plot.ytransform is not None: 
    166166            self.yLabel = plot.ytransform 
    167167        # Init graph 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/SlicerParameters.py

    rd85c194 r235f514  
    4646        """ 
    4747        event.Skip() 
    48         if event.obj_class == None: 
     48        if event.obj_class is None: 
    4949            self.set_slicer(None, None) 
    5050        else: 
     
    5757        self.bck.Clear(True) 
    5858        self.type = type 
    59         if type == None: 
     59        if type is None: 
    6060            label = "Right-click on 2D plot for slicer options" 
    6161            title = wx.StaticText(self, -1, label, style=wx.ALIGN_LEFT) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxMask.py

    rd85c194 r7432acb  
    123123                                         x2=self.vertical_lines.x2, 
    124124                                         width=self.vertical_lines.half_width) 
    125         # if self.is_inside != None: 
     125        # if self.is_inside is not None: 
    126126        out = self._post_data() 
    127127        return out 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxSlicer.py

    r9a5097c r7432acb  
    139139 
    140140        """ 
    141         if self.direction == None: 
     141        if self.direction is None: 
    142142            self.direction = direction 
    143143 
     
    147147        y_max = math.fabs(self.horizontal_lines.y) 
    148148 
    149         if nbins != None: 
     149        if nbins is not None: 
    150150            self.nbins = nbins 
    151         if self.averager == None: 
    152             if new_slab == None: 
     151        if self.averager is None: 
     152            if new_slab is None: 
    153153                msg = "post data:cannot average , averager is empty" 
    154154                raise ValueError, msg 
     
    357357        """ 
    358358        # # Reset x, y- coordinates if send as parameters 
    359         if x != None: 
     359        if x is not None: 
    360360            self.x = np.sign(self.x) * math.fabs(x) 
    361         if y != None: 
     361        if y is not None: 
    362362            self.y = np.sign(self.y) * math.fabs(y) 
    363363        # # Draw lines and markers 
     
    464464        """ 
    465465        # # reset x, y -coordinates if given as parameters 
    466         if x != None: 
     466        if x is not None: 
    467467            self.x = np.sign(self.x) * math.fabs(x) 
    468         if y != None: 
     468        if y is not None: 
    469469            self.y = np.sign(self.y) * math.fabs(y) 
    470470        # # draw lines and markers 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/boxSum.py

    rd85c194 r7432acb  
    353353            Draw the new roughness on the graph. 
    354354        """ 
    355         if center_x != None: 
     355        if center_x is not None: 
    356356            self.x = center_x 
    357         if center_y != None: 
     357        if center_y is not None: 
    358358            self.y = center_y 
    359359        self.center_marker.set(xdata=[self.x], ydata=[self.y]) 
     
    490490        """ 
    491491        # # save the new height, witdh of the rectangle if given as a param 
    492         if width != None: 
     492        if width is not None: 
    493493            self.half_width = width 
    494         if height != None: 
     494        if height is not None: 
    495495            self.half_height = height 
    496496        # # If new  center coordinates are given draw the rectangle 
    497497        # #given these value 
    498         if center != None: 
     498        if center is not None: 
    499499            self.center_x = center.x 
    500500            self.center_y = center.y 
     
    511511            return 
    512512        # # if x1, y1, y2, y3 are given draw the rectangle with this value 
    513         if x1 != None: 
     513        if x1 is not None: 
    514514            self.x1 = x1 
    515         if x2 != None: 
     515        if x2 is not None: 
    516516            self.x2 = x2 
    517         if y1 != None: 
     517        if y1 is not None: 
    518518            self.y1 = y1 
    519         if y2 != None: 
     519        if y2 is not None: 
    520520            self.y2 = y2 
    521521        # # Draw 2 vertical lines and a marker 
     
    657657        """ 
    658658        # # save the new height, witdh of the rectangle if given as a param 
    659         if width != None: 
     659        if width is not None: 
    660660            self.half_width = width 
    661         if height != None: 
     661        if height is not None: 
    662662            self.half_height = height 
    663663        # # If new  center coordinates are given draw the rectangle 
    664664        # #given these value 
    665         if center != None: 
     665        if center is not None: 
    666666            self.center_x = center.x 
    667667            self.center_y = center.y 
     
    679679            return 
    680680        # # if x1, y1, y2, y3 are given draw the rectangle with this value 
    681         if x1 != None: 
     681        if x1 is not None: 
    682682            self.x1 = x1 
    683         if x2 != None: 
     683        if x2 is not None: 
    684684            self.x2 = x2 
    685         if y1 != None: 
     685        if y1 is not None: 
    686686            self.y1 = y1 
    687         if y2 != None: 
     687        if y2 is not None: 
    688688            self.y2 = y2 
    689689        # # Draw 2 vertical lines and a marker 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/detector_dialog.py

    r8416a02 r7432acb  
    9090            zmin = self.reset_zmin_ctl 
    9191            zmax = self.reset_zmax_ctl 
    92             if zmin == None: 
     92            if zmin is None: 
    9393                zmin = "" 
    94             if zmax == None: 
     94            if zmax is None: 
    9595                zmax = "" 
    9696            self.zmin_ctl.SetValue(str(zmin)) 
     
    155155        self.qmax_ctl.SetLabel(str(format_number(qmax))) 
    156156        self.beam_ctl.SetLabel(str(format_number(beam))) 
    157         if zmin != None: 
     157        if zmin is not None: 
    158158            self.zmin_ctl.SetValue(str(format_number(zmin))) 
    159         if zmax != None: 
     159        if zmax is not None: 
    160160            self.zmax_ctl.SetValue(str(format_number(zmax))) 
    161161 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/masking.py

    r9a5097c r45dffa69  
    100100        wx.Dialog.__init__(self, parent, id=id, *args, **kwds) 
    101101 
    102         if data != None: 
     102        if data is not None: 
    103103            # Font size 
    104104            kwds = [] 
     
    235235        event.Skip() 
    236236        # from boxMask import BoxMask 
    237         if event != None: 
     237        if event is not None: 
    238238            self._on_clear_slicer(event) 
    239239        self.slicer_z += 1 
     
    249249        Add new mask to old mask 
    250250        """ 
    251         if not self.slicer == None: 
     251        if self.slicer is not None: 
    252252            data = Data2D() 
    253253            data = self.data 
     
    269269        Erase new mask from old mask 
    270270        """ 
    271         if not self.slicer == None: 
     271        if self.slicer is not None: 
    272272            self.slicer_mask = self.slicer.update() 
    273273            mask = self.data.mask 
     
    307307        Clear the slicer on the plot 
    308308        """ 
    309         if not self.slicer == None: 
     309        if self.slicer is not None: 
    310310            self.slicer.clear() 
    311311            self.subplot.figure.canvas.draw() 
     
    336336        """ 
    337337        # the case of liitle numbers of True points 
    338         if len(mask[mask]) < 10 and self.data != None: 
     338        if len(mask[mask]) < 10 and self.data is not None: 
    339339            self.ShowMessage() 
    340340            mask = copy.deepcopy(self.mask) 
     
    355355        temp_data.data[mask == False] = temp_mask[mask == False] 
    356356        self.plotpanel.clear() 
    357         if self.slicer != None: 
     357        if self.slicer is not None: 
    358358            self.slicer.clear() 
    359359            self.slicer = None 
     
    460460        wx.Dialog.__init__(self, parent, id=id, *args, **kwds) 
    461461 
    462         if data != None: 
     462        if data is not None: 
    463463            # Font size 
    464464            kwds = [] 
     
    710710        Status msg 
    711711        """ 
    712         if self.parent.parent.parent != None: 
     712        if self.parent.parent.parent is not None: 
    713713            wx.PostEvent(self.parent.parent.parent, 
    714714                         StatusEvent(status=msg, type=type)) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/plotting.py

    rca224b1 r235f514  
    8888        On Qmin Qmax vertical line event 
    8989        """ 
    90         if event == None: 
     90        if event is None: 
    9191            return 
    9292        if event.id in self.plot_panels.keys(): 
     
    9999 
    100100    def _on_plot_lim(self, event=None): 
    101         if event == None: 
     101        if event is None: 
    102102            return 
    103103        if event.id in self.plot_panels.keys(): 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/profile_dialog.py

    rd85c194 r7432acb  
    4444        wx.Dialog.__init__(self, parent, id=id, *args, **kwds) 
    4545 
    46         if data != None: 
     46        if data is not None: 
    4747            #Font size 
    4848            kwds = [] 
     
    284284            default_name = default_name.split('.')[0] 
    285285        default_name += "_out" 
    286         if self.parent != None: 
     286        if self.parent is not None: 
    287287            # What an ancestor! 
    288288            fit_panel = self.parent.parent.parent 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/sector_mask.py

    rd85c194 r7432acb  
    9696            self.left_line.update(phi=self.right_line.phi, delta=None, 
    9797                                  mline=self.main_line, side=True, left=False) 
    98         #if self.is_inside != None: 
     98        #if self.is_inside is not None: 
    9999        out = self._post_data() 
    100100        return out 
     
    117117        data = self.base.data 
    118118        # If we have no data, just return 
    119         if data == None: 
     119        if data is None: 
    120120            return 
    121121        ## Averaging 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/slicerpanel.py

    rd85c194 r7432acb  
    3737        self.bck = wx.GridBagSizer(5, 5) 
    3838        self.SetSizer(self.bck) 
    39         if type == None and params == None: 
     39        if type is None and params is None: 
    4040            label = "Right-click on 2D plot for slicer options" 
    4141            title = wx.StaticText(self, -1, label, style=wx.ALIGN_LEFT) 
     
    5757        """ 
    5858        event.Skip() 
    59         if event.obj_class == None: 
     59        if event.obj_class is None: 
    6060            self.set_slicer(None, None) 
    6161        else: 
     
    6868        self.bck.Clear(True) 
    6969        self.type = type 
    70         if type == None: 
     70        if type is None: 
    7171            label = "Right-click on 2D plot for slicer options" 
    7272            title = wx.StaticText(self, -1, label, style=wx.ALIGN_LEFT) 
     
    114114        self.Layout() 
    115115        psizer = self.parent.GetSizer() 
    116         if psizer != None: 
     116        if psizer is not None: 
    117117            psizer.Layout() 
    118118 
  • src/sas/sasgui/guiframe/media/data_formats_help.rst

    r98c44f3 r959eb01  
    8686 
    8787- Spin echo length (z, in Angstroms) 
    88 - depolarization (:math:`log(P/P_0)/(lambda^2 * thickness)`, in Angstrom^-1 cm^-1) 
     88- depolarization (:math:`log(P/P_0)/(lambda^2 * thickness)`, in Angstrom :sup:`-1` cm :sup:`-1`\ ) 
    8989- depolarization error in the same unit) (measurement error) 
    9090- Spin echo length error (:math:`\Delta`\ z, in Angstroms) (experimental resolution) 
  • src/sas/sasgui/guiframe/panel_base.py

    r18b7ecb9 r235f514  
    441441        """ 
    442442        """ 
    443         if self._manager == None: 
     443        if self._manager is None: 
    444444            return None 
    445445        return self._manager.frame 
  • src/sas/sasgui/guiframe/plugin_base.py

    rd85c194 r7432acb  
    161161        Sets default frame config 
    162162        """ 
    163         if self.frame != None: 
     163        if self.frame is not None: 
    164164            self.frame.EnableCloseButton(False) 
    165165            self.frame.Show(False) 
     
    230230        old_frame = None 
    231231        old_persp = self.parent.get_current_perspective() 
    232         if old_persp != None: 
     232        if old_persp is not None: 
    233233            old_frame = old_persp.get_frame() 
    234234        self.parent.check_multimode(self) 
     
    236236        self.parent.set_perspective(self.perspective) 
    237237 
    238         if self.frame != None: 
    239             if old_frame != None: 
     238        if self.frame is not None: 
     239            if old_frame is not None: 
    240240                pos_x, pos_y = old_frame.GetPositionTuple() 
    241241                self.frame.SetPosition((pos_x, pos_y)) 
  • src/sas/sasgui/guiframe/startup_configuration.py

    r73cbeec r7432acb  
    129129                width, _ = panel.frame.GetSizeTuple() 
    130130                if panel.frame.IsShown(): 
    131                     if p_size == None or width > p_size: 
     131                    if p_size is None or width > p_size: 
    132132                        p_size = width 
    133             if p_size == None: 
     133            if p_size is None: 
    134134                p_size = CURRENT_STRINGS['PLOPANEL_WIDTH'] 
    135135            self.current_string['PLOPANEL_WIDTH'] = p_size 
     
    145145                 
    146146            data_pw, _ = self.parent.panels["data_panel"].frame.GetSizeTuple() 
    147             if data_pw == None: 
     147            if data_pw is None: 
    148148                data_pw = CURRENT_STRINGS['DATAPANEL_WIDTH'] 
    149149            self.current_string['DATAPANEL_WIDTH'] = data_pw 
     
    208208        for key, item in strings.iteritems(): 
    209209            if (key == 'DEFAULT_PERSPECTIVE') or \ 
    210                 (key == 'DEFAULT_OPEN_FOLDER' and item != None): 
     210                (key == 'DEFAULT_OPEN_FOLDER' and item is not None): 
    211211                out_f.write("%s = \"%s\"\n" % (key,str(item))) 
    212212            else: 
  • src/sas/sasgui/guiframe/utils.py

    ra0373d5 r7432acb  
    8989    list = [] 
    9090    for item in mylist: 
    91         if re.search(separator,item)!= None: 
     91        if re.search(separator,item)is not None: 
    9292            if n > 0: 
    9393                word = re.split(separator, item, int(n)) 
  • src/sas/sasgui/perspectives/calculator/calculator.py

    r463e7ffc r235f514  
    9393        Edit meta data 
    9494        """ 
    95         if self.data_edit_frame == None: 
     95        if self.data_edit_frame is None: 
    9696            self.data_edit_frame = DataEditorWindow(parent=self.parent, 
    9797                                                    manager=self, data=[], 
     
    106106        Data operation 
    107107        """ 
    108         if self.data_operator_frame == None: 
     108        if self.data_operator_frame is None: 
    109109            # Use one frame all the time 
    110110            self.data_operator_frame = DataOperatorWindow(parent=self.parent, 
     
    121121        Compute the Kiessig thickness 
    122122        """ 
    123         if self.kiessig_frame == None: 
     123        if self.kiessig_frame is None: 
    124124            frame = KiessigWindow(parent=self.parent, manager=self) 
    125125            self.put_icon(frame) 
     
    133133        Compute the scattering length density of molecula 
    134134        """ 
    135         if self.sld_frame == None: 
     135        if self.sld_frame is None: 
    136136            frame = SldWindow(parent=self.parent, 
    137137                                  base=self.parent, manager=self) 
     
    146146        Compute the mass density or molar voulme 
    147147        """ 
    148         if self.cal_md_frame == None: 
     148        if self.cal_md_frame is None: 
    149149            frame = DensityWindow(parent=self.parent, 
    150150                                  base=self.parent, manager=self) 
     
    159159        Compute the slit size a given data 
    160160        """ 
    161         if self.cal_slit_frame == None: 
     161        if self.cal_slit_frame is None: 
    162162            frame = SlitLengthCalculatorWindow(parent=self.parent, manager=self) 
    163163            self.put_icon(frame) 
     
    171171        Estimate the instrumental resolution 
    172172        """ 
    173         if self.cal_res_frame == None: 
     173        if self.cal_res_frame is None: 
    174174            frame = ResolutionWindow(parent=self.parent, manager=self) 
    175175            self.put_icon(frame) 
     
    183183        On Generic model menu event 
    184184        """ 
    185         if self.gen_frame == None: 
     185        if self.gen_frame is None: 
    186186            frame = SasGenWindow(parent=self.parent, manager=self) 
    187187            self.put_icon(frame) 
     
    214214        :param filename: file name to open in editor 
    215215        """ 
    216         if self.py_frame == None: 
     216        if self.py_frame is None: 
    217217            frame = PyConsole(parent=self.parent, base=self, 
    218218                              filename=filename) 
  • src/sas/sasgui/perspectives/calculator/data_editor.py

    rd85c194 r235f514  
    419419        """ 
    420420        path = None 
    421         if location == None: 
     421        if location is None: 
    422422            location = os.getcwd() 
    423423 
  • src/sas/sasgui/perspectives/calculator/data_operator.py

    r9a5097c r7432acb  
    182182        On data name typing 
    183183        """ 
    184         if event != None: 
     184        if event is not None: 
    185185            event.Skip() 
    186186        item = event.GetEventObject() 
     
    198198        self.send_warnings('') 
    199199        msg = '' 
    200         if name == None: 
     200        if name is None: 
    201201            text = self.data_namectr.GetValue().strip() 
    202202        else: 
     
    205205        name_list = [] 
    206206        for state in state_list: 
    207             if state.data == None: 
     207            if state.data is None: 
    208208                theory_list = state.get_theory() 
    209209                theory, _ = theory_list.values()[0] 
     
    264264        self.put_text_pic(self.data2_pic, content=str(val)) 
    265265        self.check_data_inputs() 
    266         if self.output != None: 
     266        if self.output is not None: 
    267267            self.output.name = str(self.data_namectr.GetValue()) 
    268268        self.draw_output(self.output) 
     
    278278        pos = item.GetCurrentSelection() 
    279279        data = item.GetClientData(pos) 
    280         if data == None: 
     280        if data is None: 
    281281            content = "?" 
    282282            self.put_text_pic(self.data1_pic, content) 
     
    284284            self.data1_pic.add_image(data) 
    285285        self.check_data_inputs() 
    286         if self.output != None: 
     286        if self.output is not None: 
    287287            self.output.name = str(self.data_namectr.GetValue()) 
    288288        self.draw_output(self.output) 
     
    297297        self.put_text_pic(self.operator_pic, content=text) 
    298298        self.check_data_inputs() 
    299         if self.output != None: 
     299        if self.output is not None: 
    300300            self.output.name = str(self.data_namectr.GetValue()) 
    301301        self.draw_output(self.output) 
     
    313313        content = "?" 
    314314        if not (self.numberctr.IsShown() and self.numberctr.IsEnabled()): 
    315             if data == None: 
     315            if data is None: 
    316316                content = "?" 
    317317                self.put_text_pic(self.data2_pic, content) 
     
    329329                data = None 
    330330            item.SetClientData(pos, data) 
    331             if data != None: 
     331            if data is not None: 
    332332                self.check_data_inputs() 
    333333 
    334334            self.put_text_pic(self.data2_pic, content) 
    335335 
    336         if self.output != None: 
     336        if self.output is not None: 
    337337            self.output.name = str(self.data_namectr.GetValue()) 
    338338        self.draw_output(self.output) 
     
    355355        pos1 = self.data1_cbox.GetCurrentSelection() 
    356356        data1 = self.data1_cbox.GetClientData(pos1) 
    357         if data1 == None: 
     357        if data1 is None: 
    358358            self.output = None 
    359359            return flag 
     
    361361        data2 = self.data2_cbox.GetClientData(pos2) 
    362362 
    363         if data2 == None: 
     363        if data2 is None: 
    364364            self.output = None 
    365365            return flag 
     
    422422        """ 
    423423        out = self.out_pic 
    424         if output == None: 
     424        if output is None: 
    425425            content = "?" 
    426426            self.put_text_pic(out, content) 
     
    472472        On Focus at this window 
    473473        """ 
    474         if event != None: 
     474        if event is not None: 
    475475            event.Skip() 
    476476        self._data = self.get_datalist() 
     
    534534        ids = self._data.keys() 
    535535        for id in ids: 
    536             if id != None: 
    537                 if self._data[id].data != None: 
     536            if id is not None: 
     537                if self._data[id].data is not None: 
    538538                    dnames.append(self._data[id].data.name) 
    539539                else: 
     
    546546            for datastate in val_list: 
    547547                data = datastate.data 
    548                 if data != None: 
     548                if data is not None: 
    549549                    name = data.name 
    550550                    pos1 = self.data1_cbox.Append(str(name)) 
     
    577577        """ 
    578578        data_manager = self.parent.parent.get_data_manager() 
    579         if data_manager != None: 
     579        if data_manager is not None: 
    580580            return  data_manager.get_all_data() 
    581581        else: 
     
    592592        name_list = [] 
    593593        for state in state_list: 
    594             if state.data == None: 
     594            if state.data is None: 
    595595                theory_list = state.get_theory() 
    596596                theory, _ = theory_list.values()[0] 
     
    609609            wx.MessageBox(msg, 'Error') 
    610610            return 
    611         if self.output == None: 
     611        if self.output is None: 
    612612            msg = "No Output Data has been generated...   " 
    613613            wx.MessageBox(msg, 'Error') 
     
    983983        On close event 
    984984        """ 
    985         if self.manager != None: 
     985        if self.manager is not None: 
    986986            self.manager.data_operator_frame = None 
    987987        self.panel.disconnect_panels() 
  • src/sas/sasgui/perspectives/calculator/density_panel.py

    r02b4d10 r7432acb  
    239239        update units and output combobox 
    240240        """ 
    241         if event == None: 
     241        if event is None: 
    242242            return 
    243243        event.Skip() 
     
    257257        update units and input combobox 
    258258        """ 
    259         if event == None: 
     259        if event is None: 
    260260            return 
    261261        event.Skip() 
     
    438438        On close event 
    439439        """ 
    440         if self.manager != None: 
     440        if self.manager is not None: 
    441441            self.manager.cal_md_frame = None 
    442442        self.Destroy() 
  • src/sas/sasgui/perspectives/calculator/gen_scatter_panel.py

    r9c0f3c17 r7432acb  
    6161    Add icon in the frame 
    6262    """ 
    63     if parent != None: 
     63    if parent is not None: 
    6464        if hasattr(frame, "IsIconized"): 
    6565            if not frame.IsIconized(): 
     
    7474    Set_error dialog 
    7575    """ 
    76     if item != None: 
     76    if item is not None: 
    7777        item.SetBackgroundColour("pink") 
    7878        item.Refresh() 
    7979    if show_msg: 
    8080        msg = "Error: wrong (or out of range) value entered." 
    81         if panel.parent.parent != None: 
     81        if panel.parent.parent is not None: 
    8282            wx.PostEvent(panel.parent.parent, 
    8383                     StatusEvent(status=msg, info='Error')) 
     
    425425        """ 
    426426        unit = 'sec' 
    427         if self.time_text != None: 
     427        if self.time_text is not None: 
    428428            self.time_text.SetForegroundColour('black') 
    429429            etime = self.estimate_ctime() 
     
    487487        path = None 
    488488        filename = '' 
    489         if location == None: 
     489        if location is None: 
    490490            location = os.getcwd() 
    491491 
     
    633633        self.model.set_sld_data(self.sld_data) 
    634634 
    635         self.draw_button.Enable(self.sld_data != None) 
     635        self.draw_button.Enable(self.sld_data is not None) 
    636636        wx.CallAfter(self.parent.set_sld_data, self.sld_data) 
    637637        self._update_model_params() 
     
    855855        """ 
    856856        flag = self.parent.check_omfpanel_inputs() 
    857         if not flag and self.parent.parent != None: 
     857        if not flag and self.parent.parent is not None: 
    858858            infor = 'Error' 
    859859            msg = 'Error: Wrong inputs in the SLD info panel.' 
     
    864864            return 
    865865        self.sld_data = self.parent.get_sld_from_omf() 
    866         if self.sld_data == None: 
    867             if self.parent.parent != None: 
     866        if self.sld_data is None: 
     867            if self.parent.parent is not None: 
    868868                infor = 'Error' 
    869869                msg = 'Error: No data has been selected.' 
     
    880880            self.model.set_sld_data(self.sld_data) 
    881881            self.set_input_params() 
    882             if self.is_avg or self.is_avg == None: 
     882            if self.is_avg or self.is_avg is None: 
    883883                self._create_default_1d_data() 
    884884                i_out = np.zeros(len(self.data.y)) 
     
    971971        self.bt_compute.SetLabel(label) 
    972972        self.bt_compute.SetToolTipString(label) 
    973         if self.parent.parent != None: 
     973        if self.parent.parent is not None: 
    974974            wx.PostEvent(self.parent.parent, 
    975975                             StatusEvent(status=msg, type=type)) 
     
    979979        Update the progress bar 
    980980        """ 
    981         if self.parent.parent == None: 
     981        if self.parent.parent is None: 
    982982            return 
    983983        type = "progress" 
     
    995995        for ind in range(len(input[0])): 
    996996            if self.is_avg: 
    997                 if ind % 1 == 0 and update != None: 
     997                if ind % 1 == 0 and update is not None: 
    998998                    update() 
    999999                    time.sleep(0.1) 
     
    10021002                out = np.append(out, outi) 
    10031003            else: 
    1004                 if ind % 50 == 0  and update != None: 
     1004                if ind % 50 == 0  and update is not None: 
    10051005                    update() 
    10061006                    time.sleep(0.001) 
     
    10101010                out = np.append(out, outi) 
    10111011        #print time.time() - s 
    1012         if self.is_avg or self.is_avg == None: 
     1012        if self.is_avg or self.is_avg is None: 
    10131013            self._draw1D(out) 
    10141014        else: 
     
    11511151        new_plot.label = new_plot.id 
    11521152        #theory_data = deepcopy(new_plot) 
    1153         if self.parent.parent != None: 
     1153        if self.parent.parent is not None: 
    11541154            self.parent.parent.update_theory(data_id=new_plot.id, 
    11551155                                           theory=new_plot, 
     
    12101210        new_plot.label = new_plot.id 
    12111211        #theory_data = deepcopy(new_plot) 
    1212         if self.parent.parent != None: 
     1212        if self.parent.parent is not None: 
    12131213            self.parent.parent.update_theory(data_id=data.id, 
    12141214                                           theory=new_plot, 
     
    12871287            key_low = key.lower() 
    12881288            if key_low.count('mx') > 0: 
    1289                 if sld_sets[key] == None: 
     1289                if sld_sets[key] is None: 
    12901290                    sld_sets[key] = self.sld_data.sld_mx 
    12911291                mx = sld_sets[key] 
    12921292            elif key_low.count('my') > 0: 
    1293                 if sld_sets[key] == None: 
     1293                if sld_sets[key] is None: 
    12941294                    sld_sets[key] = self.sld_data.sld_my 
    12951295                my = sld_sets[key] 
    12961296            elif key_low.count('mz') > 0: 
    1297                 if sld_sets[key] == None: 
     1297                if sld_sets[key] is None: 
    12981298                    sld_sets[key] = self.sld_data.sld_mz 
    12991299                mz = sld_sets[key] 
    13001300            else: 
    1301                 if sld_sets[key] != None: 
     1301                if sld_sets[key] is not None: 
    13021302                    self.sld_data.set_sldn(sld_sets[key]) 
    13031303        self.sld_data.set_sldms(mx, my, mz) 
     
    13471347            infor = 'Error' 
    13481348            #logger.error(msg) 
    1349             if self.parent.parent != None: 
     1349            if self.parent.parent is not None: 
    13501350                # inform msg to wx 
    13511351                wx.PostEvent(self.parent.parent, 
     
    13681368        """ 
    13691369 
    1370         if omfdata == None: 
     1370        if omfdata is None: 
    13711371            self._set_none_text() 
    13721372            return 
     
    14371437        self.slds = [] 
    14381438        omfdata = self.sld_data 
    1439         if omfdata == None: 
     1439        if omfdata is None: 
    14401440            raise 
    14411441        sld_key_list = self._get_slds_key_list(omfdata) 
     
    14771477        self.nodes = [] 
    14781478        omfdata = self.sld_data 
    1479         if omfdata == None: 
     1479        if omfdata is None: 
    14801480            raise 
    14811481        key_list = self._get_nodes_key_list(omfdata) 
     
    15121512        self.stepsize = [] 
    15131513        omfdata = self.sld_data 
    1514         if omfdata == None: 
     1514        if omfdata is None: 
    15151515            raise 
    15161516        key_list = self._get_step_key_list(omfdata) 
     
    16311631        Set sld textctrls 
    16321632        """ 
    1633         if sld_data == None: 
     1633        if sld_data is None: 
    16341634            for ctr_list in self.slds: 
    16351635                ctr_list[1].Enable(False) 
     
    16901690            data = self.parent.get_sld_data() 
    16911691            fName = os.path.splitext(path)[0] + '.' + extension.split('.')[-1] 
    1692             if data != None: 
     1692            if data is not None: 
    16931693                try: 
    16941694                    reader.write(fName, data) 
     
    16991699                infor = 'Error' 
    17001700                #logger.error(msg) 
    1701                 if self.parent.parent != None: 
     1701                if self.parent.parent is not None: 
    17021702                    # inform msg to wx 
    17031703                    wx.PostEvent(self.parent.parent, 
     
    17081708            msg = "Error occurred while saving. " 
    17091709            infor = 'Error' 
    1710             if self.parent.parent != None: 
     1710            if self.parent.parent is not None: 
    17111711                # inform msg to wx 
    17121712                wx.PostEvent(self.parent.parent, 
     
    17181718        """ 
    17191719        flag = True 
    1720         if event != None: 
     1720        if event is not None: 
    17211721            event.Skip() 
    17221722            ctl = event.GetEventObject() 
     
    17391739            if npts > 0: 
    17401740                nop = self.set_npts_from_slddata() 
    1741                 if nop == None: 
     1741                if nop is None: 
    17421742                    nop = npts 
    17431743                self.display_npts(nop) 
     
    17581758        """ 
    17591759        flag = True 
    1760         if event != None: 
     1760        if event is not None: 
    17611761            event.Skip() 
    17621762            ctl = event.GetEventObject() 
     
    19111911        Set omfdata 
    19121912        """ 
    1913         if data == None: 
     1913        if data is None: 
    19141914            return 
    19151915        self.sld_data = data 
    1916         enable = (not data == None) 
     1916        enable = (data is not None) 
    19171917        self._set_omfpanel_sld_data(self.sld_data) 
    19181918        self.omfpanel.bt_save.Enable(enable) 
     
    19741974        Send full draw to gui frame 
    19751975        """ 
    1976         if self.parent != None: 
     1976        if self.parent is not None: 
    19771977            self.parent.set_schedule_full_draw(panel, func) 
    19781978 
     
    20502050        Close 
    20512051        """ 
    2052         if self.base != None: 
     2052        if self.base is not None: 
    20532053            self.base.gen_frame = None 
    20542054        self.Destroy() 
  • src/sas/sasgui/perspectives/calculator/image_viewer.py

    r25b9707a r7432acb  
    4242        """ 
    4343        parent = self.parent 
    44         if parent == None: 
     44        if parent is None: 
    4545            location = os.getcwd() 
    4646        else: 
    4747            location = parent._default_save_location 
    4848        path_list = self.choose_data_file(location=location) 
    49         if path_list == None: 
     49        if path_list is None: 
    5050            return 
    51         if len(path_list) >= 0 and not(path_list[0]is None): 
    52             if parent != None: 
     51        if len(path_list) >= 0 and path_list[0] is not None: 
     52            if parent is not None: 
    5353                parent._default_save_location = os.path.dirname(path_list[0]) 
    5454        err_msg = '' 
     
    7070                plot_frame.SetTitle('Picture -- %s --' % basename) 
    7171                plot_frame.Show(True) 
    72                 if parent != None: 
     72                if parent is not None: 
    7373                    parent.put_icon(plot_frame) 
    7474            except: 
     
    8585        """ 
    8686        path = None 
    87         if location == None: 
     87        if location is None: 
    8888            location = os.getcwd() 
    8989        dlg = wx.FileDialog(self.parent, "Image Viewer: Choose a image file", 
     
    403403        output.is_data = True 
    404404        output = reader2D_converter(output) 
    405         if self.base != None: 
     405        if self.base is not None: 
    406406            data = self.base.create_gui_data(output, self.title) 
    407407            self.base.add_data({data.id:data}) 
  • src/sas/sasgui/perspectives/calculator/kiessig_calculator_panel.py

    rd0248bd r7432acb  
    190190        """ 
    191191        # skip for another event 
    192         if event != None: 
     192        if event is not None: 
    193193            event.Skip() 
    194194        dq = self.dq_name_tcl.GetValue() 
     
    237237        Close event 
    238238        """ 
    239         if self.manager != None: 
     239        if self.manager is not None: 
    240240            self.manager.kiessig_frame = None 
    241241        self.Destroy() 
  • src/sas/sasgui/perspectives/calculator/model_editor.py

    r463e7ffc r7432acb  
    387387        self._msg_box.SetLabel(msg) 
    388388        self._msg_box.SetForegroundColour(color) 
    389         if self.parent.parent != None: 
     389        if self.parent.parent is not None: 
    390390            from sas.sasgui.guiframe.events import StatusEvent 
    391391            wx.PostEvent(self.parent.parent, StatusEvent(status=msg, 
     
    478478        """ 
    479479        # For Mac 
    480         if event != None: 
     480        if event is not None: 
    481481            event.Skip() 
    482482        item = event.GetEventObject() 
     
    979979 
    980980        # Prepare the messagebox 
    981         if self.base != None and not msg: 
     981        if self.base is not None and not msg: 
    982982            self.base.update_custom_combo() 
    983983            # Passed exception in import test as it will fail for sasmodels.sasview_model class 
     
    10021002        self._msg_box.SetForegroundColour(color) 
    10031003        # Send msg to the top window 
    1004         if self.base != None: 
     1004        if self.base is not None: 
    10051005            from sas.sasgui.guiframe.events import StatusEvent 
    10061006            wx.PostEvent(self.base.parent, 
     
    11901190        """ 
    11911191        self.Show(False) 
    1192         #if self.parent != None: 
     1192        #if self.parent is not None: 
    11931193        #    self.parent.new_model_frame = None 
    11941194        #self.Destroy() 
     
    13881388 
    13891389    def _get_upper_name(self, name=None): 
    1390         if name == None: 
     1390        if name is None: 
    13911391            return "" 
    13921392        upper_name = "" 
  • src/sas/sasgui/perspectives/calculator/pyconsole.py

    rddbac66 r7432acb  
    118118        self.panel = panel 
    119119        self._add_menu() 
    120         if filename != None: 
     120        if filename is not None: 
    121121            dataDir = os.path.dirname(filename) 
    122         elif self.parent != None: 
     122        elif self.parent is not None: 
    123123            dataDir = self.parent._default_save_location 
    124124        else: 
     
    128128 
    129129        # See if there is a corresponding C file 
    130         if filename != None: 
     130        if filename is not None: 
    131131            c_filename = os.path.splitext(filename)[0] + ".c" 
    132132            if os.path.isfile(c_filename): 
     
    244244 
    245245        # See if there is a corresponding C file 
    246         if result.path != None: 
     246        if result.path is not None: 
    247247            c_filename = os.path.splitext(result.path)[0] + ".c" 
    248248            if os.path.isfile(c_filename): 
     
    303303 
    304304        # Update plugin model list in fitpage combobox 
    305         if success and self._manager != None and self.panel != None: 
     305        if success and self._manager is not None and self.panel is not None: 
    306306            self._manager.set_edit_menu_helper(self.parent) 
    307307            wx.CallAfter(self._manager.update_custom_combo) 
     
    337337        Close event 
    338338        """ 
    339         if self.base != None: 
     339        if self.base is not None: 
    340340            self.base.py_frame = None 
    341341        self.Destroy() 
  • src/sas/sasgui/perspectives/calculator/resolution_calculator_panel.py

    r463e7ffc r7432acb  
    656656            event.Skip() 
    657657        # Clear the plot 
    658         if self.image != None: 
     658        if self.image is not None: 
    659659            self.image.clf() 
    660660            # reset image 
     
    674674        """ 
    675675        # Skip event for next event 
    676         if event != None: 
     676        if event is not None: 
    677677            event.Skip() 
    678678            msg = "Please Check your input values " 
     
    708708            # Validate the wave inputs 
    709709            wave_input = self._validate_q_input(wavelength, wavelength_spread) 
    710             if wave_input != None: 
     710            if wave_input is not None: 
    711711                wavelength, wavelength_spread = wave_input 
    712712 
     
    757757        # Validate the q inputs 
    758758        q_input = self._validate_q_input(self.qx, self.qy) 
    759         if q_input != None: 
     759        if q_input is not None: 
    760760            self.qx, self.qy = q_input 
    761761 
     
    769769 
    770770        # Compute the resolution 
    771         if self.image != None: 
     771        if self.image is not None: 
    772772            #_pylab_helpers.Gcf.set_active(self.fm) 
    773773            _pylab_helpers.Gcf.figs = {} 
     
    839839        : Param image: pylab object 
    840840        """ 
    841         if image == None: 
     841        if image is None: 
    842842            return 
    843843        if color == 'g': 
     
    973973        if len(qx) != len(qy): 
    974974            return None 
    975         if qx == None or qy == None: 
     975        if qx is None or qy is None: 
    976976            return None 
    977977        return qx, qy 
     
    982982        """ 
    983983        # skip for another event 
    984         if event != None: 
     984        if event is not None: 
    985985            event.Skip() 
    986986        # init resolution_calculator 
     
    11481148        Set the detector coordinate for sigmas to x-y coordinate 
    11491149        """ 
    1150         if event != None: 
     1150        if event is not None: 
    11511151            event.Skip() 
    11521152        # Set the coordinate in Cartesian 
     
    11601160        Set the detector coordinate for sigmas to polar coordinate 
    11611161        """ 
    1162         if event != None: 
     1162        if event is not None: 
    11631163            event.Skip() 
    11641164        # Set the coordinate in polar 
     
    11811181        self.compute_button.SetLabel(label) 
    11821182        self.compute_button.SetToolTipString(label) 
    1183         if self.parent.parent != None: 
     1183        if self.parent.parent is not None: 
    11841184            wx.PostEvent(self.parent.parent, 
    11851185                         StatusEvent(status=msg, type=type)) 
     
    11961196        On source combobox selection 
    11971197        """ 
    1198         if event != None: 
     1198        if event is not None: 
    11991199            combo = event.GetEventObject() 
    12001200            event.Skip() 
     
    12151215        On source color combobox selection 
    12161216        """ 
    1217         if event != None: 
     1217        if event is not None: 
    12181218            #combo = event.GetEventObject() 
    12191219            event.Skip() 
     
    12531253        On spectrum ComboBox event 
    12541254        """ 
    1255         if event != None: 
     1255        if event is not None: 
    12561256            #combo = event.GetEventObject() 
    12571257            event.Skip() 
     
    12611261        if selection == 'Add new': 
    12621262            path = self._selectDlg() 
    1263             if path == None: 
     1263            if path is None: 
    12641264                self.spectrum_cb.SetValue('Flat') 
    12651265                self.resolution.set_spectrum(self.spectrum_dic['Flat']) 
     
    13011301        """ 
    13021302        try: 
    1303             if path == None: 
     1303            if path is None: 
    13041304                wx.PostEvent(self.parent.parent, StatusEvent(status=\ 
    13051305                            " Selected Distribution was not loaded: %s" % path)) 
     
    13481348        """ 
    13491349        _pylab_helpers.Gcf.figs = {} 
    1350         if self.manager != None: 
     1350        if self.manager is not None: 
    13511351            self.manager.cal_res_frame = None 
    13521352        self.Destroy() 
  • src/sas/sasgui/perspectives/calculator/sld_panel.py

    rd0248bd r7432acb  
    504504        On close event 
    505505        """ 
    506         if self.manager != None: 
     506        if self.manager is not None: 
    507507            self.manager.sld_frame = None 
    508508        self.Destroy() 
  • src/sas/sasgui/perspectives/calculator/slit_length_calculator_panel.py

    rd0248bd r7432acb  
    157157        path = None 
    158158        filename = '' 
    159         if location == None: 
     159        if location is None: 
    160160            location = os.getcwd() 
    161161 
     
    303303        Close event 
    304304        """ 
    305         if self.manager != None: 
     305        if self.manager is not None: 
    306306            self.manager.cal_slit_frame = None 
    307307        self.Destroy() 
  • src/sas/sasgui/perspectives/corfunc/corfunc_panel.py

    r1dc8ec9 r7432acb  
    320320        path = None 
    321321        default_save_location = os.getcwd() 
    322         if self._manager.parent != None: 
     322        if self._manager.parent is not None: 
    323323            default_save_location = self._manager.parent.get_save_location() 
    324324 
     
    329329            path = dlg.GetPath() 
    330330            default_save_location = os.path.dirname(path) 
    331             if self._manager.parent != None: 
     331            if self._manager.parent is not None: 
    332332                self._manager.parent._default_save_location = default_save_location 
    333333        else: 
  • src/sas/sasgui/perspectives/corfunc/corfunc_state.py

    r463e7ffc r7432acb  
    293293                corstate = self._parse_state(entry) 
    294294 
    295                 if corstate != None: 
     295                if corstate is not None: 
    296296                    sas_entry.meta_data['corstate'] = corstate 
    297297                    sas_entry.filename = corstate.file 
     
    327327        if datainfo.title is None or datainfo.title == '': 
    328328            datainfo.title = datainfo.name 
    329         if datainfo.run_name == None or datainfo.run_name == '': 
     329        if datainfo.run_name is None or datainfo.run_name == '': 
    330330            datainfo.run = [str(datainfo.name)] 
    331331            datainfo.run_name[0] = datainfo.name 
  • src/sas/sasgui/perspectives/fitting/batchfitpage.py

    ree4b3cb r7432acb  
    200200#         self.state.formfactorcombobox = self.formfactorbox.GetCurrentSelection() 
    201201#        
    202 #         if self.model != None: 
     202#         if self.model is not None: 
    203203#             self._set_copy_flag(True) 
    204204#             self._set_paste_flag(True) 
    205 #             if self.data != None: 
     205#             if self.data is not None: 
    206206#                 self._set_bookmark_flag(False) 
    207207#                 self._keep.Enable(False) 
     
    225225#  
    226226#              
    227 #         if event != None: 
     227#         if event is not None: 
    228228#             ## post state to fit panel 
    229229#             new_event = PageInfoEvent(page = self) 
     
    254254#         is_modified = False 
    255255#  
    256 #         if self.model != None:            
     256#         if self.model is not None: 
    257257#             ##Check the values 
    258258#             self._check_value_enter( self.fittable_param) 
     
    291291#         else: 
    292292#             #self.btFit.Enable(True) 
    293 #             if self._is_2D() and  self.data != None: 
     293#             if self._is_2D() and  self.data is not None: 
    294294#                 self.btEditMask.Enable(True) 
    295295#  
     
    335335#             self._set_save_flag(False) 
    336336#         else: 
    337 #             if self.model != None: 
     337#             if self.model is not None: 
    338338#                 self._set_bookmark_flag(False) 
    339339#                 self._keep.Enable(False) 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    r9c0f3c17 r7432acb  
    302302        Make new model 
    303303        """ 
    304         if self.new_model_frame != None: 
     304        if self.new_model_frame is not None: 
    305305            self.new_model_frame.Show(False) 
    306306            self.new_model_frame.Show(True) 
     
    386386        help for setting list of the edit model menu labels 
    387387        """ 
    388         if menu == None: 
     388        if menu is None: 
    389389            menu = self.edit_custom_model 
    390390        list_fnames = os.listdir(models.find_plugins_dir()) 
     
    441441            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    442442 
    443         if page != None: 
     443        if page is not None: 
    444444            return set_focus_page(page) 
    445445        if caption == "Const & Simul Fit": 
     
    634634            state = self.temp_state[self.state_index] 
    635635            #panel state should have model selection to set_state 
    636             if state.formfactorcombobox != None: 
     636            if state.formfactorcombobox is not None: 
    637637                #set state 
    638638                data = self.parent.create_gui_data(state.data) 
     
    10161016                return False 
    10171017        ## If a thread is already started, stop it 
    1018         #if self.calc_fit!= None and self.calc_fit.isrunning(): 
     1018        #if self.calc_fitis not None and self.calc_fit.isrunning(): 
    10191019        #    self.calc_fit.stop() 
    10201020        msg = "Fitting is in progress..." 
     
    11061106            page = self.fit_panel.add_empty_page() 
    11071107            # add data associated to the page created 
    1108             if page != None: 
     1108            if page is not None: 
    11091109                evt = StatusEvent(status="Page Created", info="info") 
    11101110                wx.PostEvent(self.parent, evt) 
     
    11251125        page = self.fit_panel.set_data(data) 
    11261126        # page could be None when loading state files 
    1127         if page == None: 
     1127        if page is None: 
    11281128            return page 
    11291129        #append Data1D to the panel containing its theory 
     
    11931193        """ 
    11941194        # case that uid is not specified 
    1195         if uid == None: 
     1195        if uid is None: 
    11961196            for page_id in self.page_finder.keys(): 
    11971197                self.page_finder[page_id].schedule_tofit(value) 
     
    12161216            for item in param: 
    12171217                ## check if constraint 
    1218                 if item[0] != None and item[1] != None: 
     1218                if item[0] is not None and item[1] is not None: 
    12191219                    listOfConstraint.append((item[0], item[1])) 
    12201220        new_model = model 
     
    12311231        """ 
    12321232        panel = self.plot_panel 
    1233         if panel == None: 
     1233        if panel is None: 
    12341234            raise ValueError, "Fitting:_onSelect: NonType panel" 
    12351235        Plugin.on_perspective(self, event=event) 
     
    13351335                if not correct_result or res.fitness is None or \ 
    13361336                    not np.isfinite(res.fitness) or \ 
    1337                         np.any(res.pvec == None) or not \ 
     1337                        np.any(res.pvec is None) or not \ 
    13381338                        np.all(np.isfinite(res.pvec)): 
    13391339                    data_name = str(None) 
     
    14571457        cell.value = index 
    14581458 
    1459         if theory_data != None: 
     1459        if theory_data is not None: 
    14601460            #Suucessful fit 
    14611461            theory_data.id = wx.NewId() 
     
    15261526                if res.fitness is None or \ 
    15271527                    not np.isfinite(res.fitness) or \ 
    1528                         np.any(res.pvec == None) or \ 
     1528                        np.any(res.pvec is None) or \ 
    15291529                    not np.all(np.isfinite(res.pvec)): 
    15301530                    fit_msg += "\nFitting did not converge!!!" 
     
    15441544                    #(CallAfter is important to MAC) 
    15451545                    try: 
    1546                         #if res != None: 
     1546                        #if res is not None: 
    15471547                        wx.CallAfter(cpage.onsetValues, res.fitness, 
    15481548                                     res.param_list, 
     
    15871587        """ 
    15881588        event.Skip() 
    1589         if self.menu1 == None: 
     1589        if self.menu1 is None: 
    15901590            return 
    15911591        menu_item = self.menu1.FindItemById(self.id_reset_flag) 
     
    16461646        caption = evt.caption 
    16471647        enable_smearer = evt.enable_smearer 
    1648         if model == None: 
     1648        if model is None: 
    16491649            return 
    16501650        if uid not in self.page_finder.keys(): 
     
    16981698        new_plot.title = data.name 
    16991699        new_plot.group_id = data.group_id 
    1700         if new_plot.group_id == None: 
     1700        if new_plot.group_id is None: 
    17011701            new_plot.group_id = data.group_id 
    17021702        new_plot.id = data_id 
     
    20022002        chisqr = None 
    20032003        #to compute chisq make sure data has valid data 
    2004         # return None if data == None 
    2005         if not check_data_validity(data_copy) or data_copy == None: 
     2004        # return None if data is None 
     2005        if not check_data_validity(data_copy) or data_copy is None: 
    20062006            return chisqr 
    20072007 
    20082008        # Get data: data I, theory I, and data dI in order 
    20092009        if data_copy.__class__.__name__ == "Data2D": 
    2010             if index == None: 
     2010            if index is None: 
    20112011                index = np.ones(len(data_copy.data), dtype=bool) 
    2012             if weight != None: 
     2012            if weight is not None: 
    20132013                data_copy.err_data = weight 
    20142014            # get rid of zero error points 
     
    20172017            fn = data_copy.data[index] 
    20182018            theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id) 
    2019             if theory_data == None: 
     2019            if theory_data is None: 
    20202020                return chisqr 
    20212021            gn = theory_data.data[index] 
     
    20232023        else: 
    20242024            # 1 d theory from model_thread is only in the range of index 
    2025             if index == None: 
     2025            if index is None: 
    20262026                index = np.ones(len(data_copy.y), dtype=bool) 
    2027             if weight != None: 
     2027            if weight is not None: 
    20282028                data_copy.dy = weight 
    2029             if data_copy.dy == None or data_copy.dy == []: 
     2029            if data_copy.dy is None or data_copy.dy == []: 
    20302030                dy = np.ones(len(data_copy.y)) 
    20312031            else: 
     
    20372037 
    20382038            theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id) 
    2039             if theory_data == None: 
     2039            if theory_data is None: 
    20402040                return chisqr 
    20412041            gn = theory_data.y 
     
    20802080            theory_data = self.page_finder[page_id].get_theory_data(fid=data_copy.id) 
    20812081            gn = theory_data.data 
    2082             if weight == None: 
     2082            if weight is None: 
    20832083                en = data_copy.err_data 
    20842084            else: 
     
    21012101        else: 
    21022102            # 1 d theory from model_thread is only in the range of index 
    2103             if data_copy.dy == None or data_copy.dy == []: 
     2103            if data_copy.dy is None or data_copy.dy == []: 
    21042104                dy = np.ones(len(data_copy.y)) 
    21052105            else: 
    2106                 if weight == None: 
     2106                if weight is None: 
    21072107                    dy = np.ones(len(data_copy.y)) 
    21082108                ## Set consitently w/AbstractFitengine: 
     
    21422142        ##group_id specify on which panel to plot this data 
    21432143        group_id = self.page_finder[page_id].get_graph_id() 
    2144         if group_id == None: 
     2144        if group_id is None: 
    21452145            group_id = data.group_id 
    21462146        new_plot.group_id = "res" + str(group_id) 
  • src/sas/sasgui/perspectives/fitting/model_thread.py

    r9a5097c r7432acb  
    5353        self.starttime = time.time() 
    5454        # Determine appropriate q range 
    55         if self.qmin == None: 
     55        if self.qmin is None: 
    5656            self.qmin = 0 
    57         if self.qmax == None: 
    58             if self.data != None: 
     57        if self.qmax is None: 
     58            if self.data is not None: 
    5959                newx = math.pow(max(math.fabs(self.data.xmax), 
    6060                                   math.fabs(self.data.xmin)), 2) 
  • src/sas/sasgui/perspectives/fitting/report_dialog.py

    rd85c194 r7432acb  
    3939        self.nimages = len(self.report_list[2]) 
    4040 
    41         if self.report_list[2] != None: 
     41        if self.report_list[2] is not None: 
    4242            # put image path in the report string 
    4343            if len(self.report_list[2]) == 1: 
  • src/sas/sasgui/perspectives/invariant/invariant.py

    r463e7ffc r7432acb  
    331331        new_plot.title = self.__data.title 
    332332        # Save theory_data in a state 
    333         if data != None: 
     333        if data is not None: 
    334334            name_head = name.split('-') 
    335335            if name_head[0] == 'Low': 
     
    353353 
    354354        # Save data in a state: but seems to never happen 
    355         if new_plot != None: 
     355        if new_plot is not None: 
    356356            self.invariant_panel.state.data = copy.deepcopy(new_plot) 
    357357        wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
  • src/sas/sasgui/perspectives/invariant/invariant_panel.py

    r463e7ffc r7432acb  
    240240        """ 
    241241 
    242         if state == None and data == None: 
     242        if state is None and data is None: 
    243243            self.state = IState() 
    244         elif state == None or data == None: 
     244        elif state is None or data is None: 
    245245            return 
    246246        else: 
     
    604604        compute invariant 
    605605        """ 
    606         if self._data == None: 
     606        if self._data is None: 
    607607            msg = "\n\nData must be loaded first in order" 
    608608            msg += " to perform a compution..." 
    609609            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    610610        # set a state for this computation for saving 
    611         elif event != None: 
     611        elif event is not None: 
    612612            self._set_compute_state(state='compute') 
    613613            self._set_bookmark_flag(True) 
     
    718718        self._set_preview_flag(True) 
    719719 
    720         if event != None: 
     720        if event is not None: 
    721721            self._set_preview_flag(True) 
    722722            self._set_save_flag(True) 
     
    792792        : param state_num: the given state number 
    793793        """ 
    794         if state_num == None: 
     794        if state_num is None: 
    795795            return 
    796796 
     
    924924        :param event: rb/cb event 
    925925        """ 
    926         if event == None: 
     926        if event is None: 
    927927            return 
    928928        obj = event.GetEventObject() 
     
    934934 
    935935        try: 
    936             if value == None or value.lstrip().rstrip() == '': 
     936            if value is None or value.lstrip().rstrip() == '': 
    937937                value = 'None' 
    938938            setattr(self.state, name, str(value)) 
     
    10131013        Used in 'set_current_data()' 
    10141014        """ 
    1015         #if data == None: return 
     1015        #if data is None: return 
    10161016        #temp_state = self.state.clone_state() 
    10171017        #copy.deepcopy(self.state.saved_state) 
     
    10221022        self.state.saved_state['state_num'] = 0 
    10231023        self.state.saved_state['compute_num'] = 0 
    1024         if self._data != None: 
     1024        if self._data is not None: 
    10251025            self.state.saved_state['file'] = str(self._data.name) 
    10261026        else: 
     
    10491049 
    10501050        """ 
    1051         if self._data == None: 
     1051        if self._data is None: 
    10521052            return 
    10531053        # check if this event is from do/undo button 
     
    10721072        # try to add new state of the text changes in the state_list 
    10731073        try: 
    1074             if value.strip() == None: 
     1074            if value.strip() is None: 
    10751075                value = '' 
    10761076            setattr(self.state, name, str(value)) 
     
    11401140        the popup menu on bookmark context menu event 
    11411141        """ 
    1142         if self._data == None: 
     1142        if self._data is None: 
    11431143            return 
    1144         if event == None: 
     1144        if event is None: 
    11451145            return 
    11461146        self.bookmark_num += 1 
     
    12061206        : event: popUpMenu event 
    12071207        """ 
    1208         if event == None: 
     1208        if event is None: 
    12091209            return 
    12101210        # get the object 
     
    12441244        # Ask the user the location of the file to write to. 
    12451245        path = None 
    1246         if self.parent != None: 
     1246        if self.parent is not None: 
    12471247            self._default_save_location = self.parent.get_save_location() 
    1248         if self._default_save_location == None: 
     1248        if self._default_save_location is None: 
    12491249            self._default_save_location = os.getcwd() 
    12501250        dlg = wx.FileDialog(self, "Choose a file", 
     
    12541254            path = dlg.GetPath() 
    12551255            self._default_save_location = os.path.dirname(path) 
    1256             if self.parent != None: 
     1256            if self.parent is not None: 
    12571257                self.parent._default_save_location = \ 
    12581258                    self._default_save_location 
     
    13931393        Enable and disable the power value editing 
    13941394        """ 
    1395         if event != None: 
     1395        if event is not None: 
    13961396            self._set_bookmark_flag(True) 
    13971397            self._set_preview_flag(False) 
     
    14111411        Disable or enable some button if the user enable low q extrapolation 
    14121412        """ 
    1413         if event != None: 
     1413        if event is not None: 
    14141414            self._set_bookmark_flag(True) 
    14151415            self._set_preview_flag(False) 
     
    14381438        Enable editing power law section at low q range 
    14391439        """ 
    1440         if event != None: 
     1440        if event is not None: 
    14411441            self._set_bookmark_flag(True) 
    14421442            self._set_preview_flag(False) 
     
    15371537        Enable and disable the power value editing 
    15381538        """ 
    1539         if event != None: 
     1539        if event is not None: 
    15401540            self._set_bookmark_flag(True) 
    15411541 
     
    15541554        Disable or enable some button if the user enable high q extrapolation 
    15551555        """ 
    1556         if event != None: 
     1556        if event is not None: 
    15571557            self._set_bookmark_flag(True) 
    15581558            self._set_preview_flag(False) 
  • src/sas/sasgui/perspectives/invariant/invariant_state.py

    r463e7ffc r7432acb  
    281281        # File name 
    282282        element = newdoc.createElement("filename") 
    283         if self.file != None and self.file != '': 
     283        if self.file is not None and self.file != '': 
    284284            element.appendChild(newdoc.createTextNode(str(self.file))) 
    285285        else: 
     
    734734                    # invstate could be None when .svs file is loaded 
    735735                    # in this case, skip appending to output 
    736                     if invstate != None: 
     736                    if invstate is not None: 
    737737                        sas_entry.meta_data['invstate'] = invstate 
    738738                        sas_entry.filename = invstate.file 
     
    787787            raise RuntimeError, msg 
    788788        # make sure title and data run is filled up. 
    789         if datainfo.title == None or datainfo.title == '': 
     789        if datainfo.title is None or datainfo.title == '': 
    790790            datainfo.title = datainfo.name 
    791         if datainfo.run_name == None or datainfo.run_name == {}: 
     791        if datainfo.run_name is None or datainfo.run_name == {}: 
    792792            datainfo.run = [str(datainfo.name)] 
    793793            datainfo.run_name[0] = datainfo.name 
  • src/sas/sasgui/perspectives/pr/explore_dialog.py

    r9c0f3c17 r959eb01  
    269269        # Note: by design, the output type should always be part of the 
    270270        #       results object. 
    271         if self.results.outputs.has_key(output_type): 
     271        if output_type in self.results.outputs: 
    272272            self.plotpanel.plot.x = self.results.d_max 
    273273            self.plotpanel.plot.y = self.results.outputs[output_type][2] 
  • src/sas/sasgui/perspectives/pr/inversion_panel.py

    r463e7ffc r7432acb  
    271271        # Ask the user the location of the file to write to. 
    272272        path = None 
    273         if self.parent != None: 
     273        if self.parent is not None: 
    274274            self._default_save_location = self.parent._default_save_location 
    275275        dlg = wx.FileDialog(self, "Choose a file", 
     
    279279            path = dlg.GetPath() 
    280280            self._default_save_location = os.path.dirname(path) 
    281             if self.parent != None: 
     281            if self.parent is not None: 
    282282                self.parent._default_save_location = self._default_save_location 
    283283        else: 
     
    920920        if flag: 
    921921            dataset = self.plot_data.GetValue() 
    922             if dataset == None or len(dataset.strip()) == 0: 
     922            if dataset is None or len(dataset.strip()) == 0: 
    923923                message = "No data to invert. Select a data set before" 
    924924                message += " proceeding with P(r) inversion." 
     
    940940        Choose a new input file for I(q) 
    941941        """ 
    942         if not self._manager is None: 
     942        if self._manager is not None: 
    943943            self.plot_data.SetValue(str(data.name)) 
    944944            try: 
  • src/sas/sasgui/perspectives/pr/inversion_state.py

    r463e7ffc r7432acb  
    473473                    #prstate could be None when .svs file is loaded 
    474474                    #in this case, skip appending to output 
    475                     if prstate != None: 
     475                    if prstate is not None: 
    476476                        sas_entry.meta_data['prstate'] = prstate 
    477477                        sas_entry.filename = prstate.file 
  • src/sas/sasgui/perspectives/pr/pr.py

    r9c0f3c17 r7432acb  
    291291        """ 
    292292        qtemp = pr.x 
    293         if not q == None: 
     293        if q is not None: 
    294294            qtemp = q 
    295295 
     
    303303 
    304304        # Check for user min/max 
    305         if not pr.q_min == None: 
     305        if pr.q_min is not None: 
    306306            minq = pr.q_min 
    307         if not pr.q_max == None: 
     307        if pr.q_max is not None: 
    308308            maxq = pr.q_max 
    309309 
     
    329329 
    330330        # If we have a group ID, use it 
    331         if pr.info.has_key("plot_group_id"): 
     331        if 'plot_group_id' in pr.info: 
    332332            new_plot.group_id = pr.info["plot_group_id"] 
    333333        new_plot.id = IQ_FIT_LABEL 
     
    348348                except: 
    349349                    err[i] = 1.0 
    350                     print "Error getting error", value, x[i] 
     350                    print("Error getting error", value, x[i]) 
    351351 
    352352            new_plot = Data1D(x, y) 
     
    356356            new_plot.yaxis("\\rm{Intensity} ", "cm^{-1}") 
    357357            # If we have a group ID, use it 
    358             if pr.info.has_key("plot_group_id"): 
     358            if 'plot_group_id' in pr.info: 
    359359                new_plot.group_id = pr.info["plot_group_id"] 
    360360            new_plot.id = IQ_SMEARED_LABEL 
     
    393393 
    394394        for i in range(len(x)): 
    395             if cov2 == None: 
     395            if cov2 is None: 
    396396                value = pr.pr(out, x[i]) 
    397397            else: 
     
    412412            dy = dy / pmax 
    413413 
    414         if cov2 == None: 
     414        if cov2 is None: 
    415415            new_plot = Data1D(x, y) 
    416416            new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM 
     
    487487        scale = None 
    488488        min_err = 0.0 
    489         if not path == None: 
     489        if path is not None: 
    490490            input_f = open(path, 'r') 
    491491            buff = input_f.read() 
     
    499499                        err = float(toks[2]) 
    500500                    else: 
    501                         if scale == None: 
     501                        if scale is None: 
    502502                            scale = 0.05 * math.sqrt(y) 
    503503                            #scale = 0.05/math.sqrt(y) 
     
    512512                    logger.error(sys.exc_value) 
    513513 
    514         if not scale == None: 
     514        if scale is not None: 
    515515            message = "The loaded file had no error bars, statistical errors are assumed." 
    516516            wx.PostEvent(self.parent, StatusEvent(status=message)) 
     
    537537 
    538538        data_started = False 
    539         if not path == None: 
     539        if path is not None: 
    540540            input_f = open(path, 'r') 
    541541            buff = input_f.read() 
     
    550550                            err = float(toks[2]) 
    551551                        else: 
    552                             if scale == None: 
     552                            if scale is None: 
    553553                                scale = 0.05 * math.sqrt(y) 
    554554                                #scale = 0.05/math.sqrt(y) 
     
    565565                    data_started = True 
    566566 
    567         if not scale == None: 
     567        if scale is not None: 
    568568            message = "The loaded file had no error bars, statistical errors are assumed." 
    569569            wx.PostEvent(self.parent, StatusEvent(status=message)) 
     
    721721 
    722722        # If a thread is already started, stop it 
    723         if self.calc_thread != None and self.calc_thread.isrunning(): 
     723        if self.calc_thread is not None and self.calc_thread.isrunning(): 
    724724            self.calc_thread.stop() 
    725725            ## stop just raises the flag -- the thread is supposed to 
     
    761761        self.elapsed = elapsed 
    762762        self.control_panel.alpha_estimate = alpha 
    763         if not message == None: 
     763        if message is not None: 
    764764            wx.PostEvent(self.parent, StatusEvent(status=str(message))) 
    765765        self.perform_estimateNT() 
     
    779779        self.control_panel.nterms_estimate = nterms 
    780780        self.control_panel.alpha_estimate = alpha 
    781         if not message == None: 
     781        if message is not None: 
    782782            wx.PostEvent(self.parent, StatusEvent(status=str(message))) 
    783783 
     
    858858 
    859859        # Make a plot of I(q) data 
    860         if self.pr.err == None: 
     860        if self.pr.err is None: 
    861861            new_plot = Data1D(self.pr.x, self.pr.y) 
    862862            new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM 
     
    921921        try: 
    922922            pr = self._create_plot_pr() 
    923             if not pr == None: 
     923            if pr is not None: 
    924924                self.pr = pr 
    925925                self.perform_inversion() 
     
    944944        try: 
    945945            pr = self._create_plot_pr() 
    946             if not pr == None: 
     946            if pr is not None: 
    947947                self.pr = pr 
    948948                self.perform_estimate() 
     
    983983        err = self.current_plottable.dy 
    984984        all_zeros = True 
    985         if err == None: 
     985        if err is None: 
    986986            err = np.zeros(len(pr.y)) 
    987987        else: 
     
    995995            for i in range(len(pr.y)): 
    996996                # Scale the error so that we can fit over several decades of Q 
    997                 if scale == None: 
     997                if scale is None: 
    998998                    scale = 0.05 * math.sqrt(pr.y[i]) 
    999999                    min_err = 0.01 * pr.y[i] 
     
    10241024        try: 
    10251025            pr = self._create_file_pr(data) 
    1026             if not pr == None: 
     1026            if pr is not None: 
    10271027                self.pr = pr 
    10281028                self.perform_inversion() 
     
    10471047        try: 
    10481048            pr = self._create_file_pr(data) 
    1049             if not pr is None: 
     1049            if pr is not None: 
    10501050                self.pr = pr 
    10511051                self.perform_estimate() 
     
    10901090        # If we have not errors, add statistical errors 
    10911091        if y is not None: 
    1092             if err == None or np.all(err) == 0: 
     1092            if err is None or np.all(err) == 0: 
    10931093                err = np.zeros(len(y)) 
    10941094                scale = None 
     
    10961096                for i in range(len(y)): 
    10971097                    # Scale the error so that we can fit over several decades of Q 
    1098                     if scale == None: 
     1098                    if scale is None: 
    10991099                        scale = 0.05 * math.sqrt(y[i]) 
    11001100                        min_err = 0.01 * y[i] 
     
    11291129 
    11301130        # If a thread is already started, stop it 
    1131         if self.estimation_thread != None and \ 
     1131        if self.estimation_thread is not None and \ 
    11321132            self.estimation_thread.isrunning(): 
    11331133            self.estimation_thread.stop() 
     
    11591159 
    11601160        # If a thread is already started, stop it 
    1161         if self.estimation_thread != None and self.estimation_thread.isrunning(): 
     1161        if self.estimation_thread is not None and self.estimation_thread.isrunning(): 
    11621162            self.estimation_thread.stop() 
    11631163            ## stop just raises the flag -- the thread is supposed to 
  • src/sas/sasgui/perspectives/pr/pr_thread.py

    rd85c194 rac07a3a  
    4242            pass 
    4343        except: 
    44             if not self.error_func == None: 
     44            if self.error_func is not None: 
    4545                self.error_func("CalcPr.compute: %s" % sys.exc_value) 
    4646 
     
    7070            pass 
    7171        except: 
    72             if not self.error_func == None: 
     72            if self.error_func is not None: 
    7373                self.error_func("EstimatePr.compute: %s" % sys.exc_value) 
    7474 
     
    110110            pass 
    111111        except: 
    112             if not self.error_func == None: 
     112            if self.error_func is not None: 
    113113                self.error_func("EstimatePr2.compute: %s" % sys.exc_value) 
  • src/sas/sasgui/perspectives/simulation/simulation.py

    r9c0f3c17 r7432acb  
    213213         
    214214        # If a computation thread is running, stop it 
    215         if self.calc_thread_1D != None and self.calc_thread_1D.isrunning(): 
     215        if self.calc_thread_1D is not None and self.calc_thread_1D.isrunning(): 
    216216            self.calc_thread_1D.stop() 
    217217            ## stop just raises the flag -- the thread is supposed to  
  • src/sas/sasgui/plottools/LineModel.py

    rdd5bf63 r959eb01  
    88function should disappear in a future iteration (see notes in fitDialog) 
    99 
    10                 -PDB   July 10, 2016 
     10PDB   July 10, 2016 
     11 
    1112""" 
    1213 
     
    7071        runXY is when the if statement is true. I however cannot see what that 
    7172        function is for.  It needs to be documented here or removed. 
    72         -PDB 7/10/16  
     73        PDB 7/10/16  
    7374 
    7475        :param x: simple value 
     
    9293        but the only difference between this and run is when the if  
    9394        statement is true. I however cannot see what that function 
    94         is for.  It needs to be documented here or removed. -PDB 7/10/16  
     95        is for.  It needs to be documented here or removed. PDB 7/10/16  
    9596 
    9697        :param x: simple value 
  • src/sas/sasgui/plottools/PlotPanel.py

    r9c0f3c17 r7432acb  
    154154        self.selectedText = None 
    155155        #User scale 
    156         if xtransform != None: 
     156        if xtransform is not None: 
    157157            self.xLabel = xtransform 
    158158        else: 
    159159            self.xLabel = "log10(x)" 
    160         if ytransform != None: 
     160        if ytransform is not None: 
    161161            self.yLabel = ytransform 
    162162        else: 
     
    360360                    return 
    361361 
    362             if ax != None: 
     362            if ax is not None: 
    363363                self.xInit, self.yInit = event.xdata, event.ydata 
    364364                try: 
     
    392392        Set legend alpha 
    393393        """ 
    394         if self.legend != None: 
     394        if self.legend is not None: 
    395395            self.legend.legendPatch.set_alpha(alpha) 
    396396 
     
    418418        """ 
    419419        ax = event.inaxes 
    420         if ax == None: 
     420        if ax is None: 
    421421            return 
    422422        # Event occurred inside a plotting area 
     
    461461            # User has clicked on text and is dragging 
    462462            ax = event.inaxes 
    463             if ax != None: 
     463            if ax is not None: 
    464464                # Only move text if mouse is within axes 
    465465                self.selectedText.set_position((event.xdata, event.ydata)) 
     
    476476        if self.leftdown == True and self.mousemotion == True: 
    477477            ax = event.inaxes 
    478             if ax != None:  # the dragging is perform inside the figure 
     478            if ax is not None:  # the dragging is perform inside the figure 
    479479                self.xFinal, self.yFinal = event.xdata, event.ydata 
    480480                # Check whether this is the first point 
    481                 if self.xInit == None: 
     481                if self.xInit is None: 
    482482                    self.xInit = self.xFinal 
    483483                    self.yInit = self.yFinal 
     
    576576        step = event.step 
    577577 
    578         if ax != None: 
     578        if ax is not None: 
    579579            # Event occurred inside a plotting area 
    580580            lo, hi = ax.get_xlim() 
     
    935935        # reset postion 
    936936        self.position = None 
    937         if self.graph.selected_plottable != None: 
     937        if self.graph.selected_plottable is not None: 
    938938            self.graph.selected_plottable = None 
    939939 
     
    959959                                              prop=FontProperties(size=10), 
    960960                                              loc=self.legendLoc) 
    961             if self.legend != None: 
     961            if self.legend is not None: 
    962962                self.legend.set_picker(self.legend_picker) 
    963963                self.legend.set_axes(self.subplot) 
     
    989989                                          prop=FontProperties(size=10), 
    990990                                          loc=self.legendLoc) 
    991         if self.legend != None: 
     991        if self.legend is not None: 
    992992            self.legend.set_picker(self.legend_picker) 
    993993            self.legend.set_axes(self.subplot) 
     
    10101010        pos_x = 0 
    10111011        pos_y = 0 
    1012         if self.position != None: 
     1012        if self.position is not None: 
    10131013            pos_x, pos_y = self.position 
    10141014        else: 
     
    10351035                    self.subplot.figure.canvas.draw_idle() 
    10361036            except: 
    1037                 if self.parent != None: 
     1037                if self.parent is not None: 
    10381038                    msg = "Add Text: Error. Check your property values..." 
    10391039                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     
    10691069            self.xaxis_tick = xaxis_font 
    10701070 
    1071         if self.data != None: 
     1071        if self.data is not None: 
    10721072            # 2D 
    10731073            self.xaxis(self.xaxis_label, self.xaxis_unit, \ 
     
    11161116            self.yaxis_tick = yaxis_font 
    11171117 
    1118         if self.data != None: 
     1118        if self.data is not None: 
    11191119            # 2D 
    11201120            self.yaxis(self.yaxis_label, self.yaxis_unit, \ 
     
    11551155                label_temp = textdial.getText() 
    11561156                if label_temp.count("\%s" % "\\") > 0: 
    1157                     if self.parent != None: 
     1157                    if self.parent is not None: 
    11581158                        msg = "Add Label: Error. Can not use double '\\' " 
    11591159                        msg += "characters..." 
     
    11621162                    label = label_temp 
    11631163            except: 
    1164                 if self.parent != None: 
     1164                if self.parent is not None: 
    11651165                    msg = "Add Label: Error. Check your property values..." 
    11661166                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     
    11801180        num_text = len(self.textList) 
    11811181        if num_text < 1: 
    1182             if self.parent != None: 
     1182            if self.parent is not None: 
    11831183                msg = "Remove Text: Nothing to remove.  " 
    11841184                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     
    11901190            text_remove = txt.get_text() 
    11911191            txt.remove() 
    1192             if self.parent != None: 
     1192            if self.parent is not None: 
    11931193                msg = "Removed Text: '%s'. " % text_remove 
    11941194                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    11951195        except: 
    1196             if self.parent != None: 
     1196            if self.parent is not None: 
    11971197                msg = "Remove Text: Error occurred. " 
    11981198                wx.PostEvent(self.parent, StatusEvent(status=msg)) 
     
    12501250                                        prop=FontProperties(size=10), 
    12511251                                        loc=self.legendLoc) 
    1252                 if self.legend != None: 
     1252                if self.legend is not None: 
    12531253                    self.legend.set_picker(self.legend_picker) 
    12541254                    self.legend.set_axes(self.subplot) 
     
    12791279        if font: 
    12801280            self.subplot.set_xlabel(label, fontproperties=font, color=color) 
    1281             if t_font != None: 
     1281            if t_font is not None: 
    12821282                for tick in self.subplot.xaxis.get_major_ticks(): 
    12831283                    tick.label.set_fontproperties(t_font) 
     
    13001300        if font: 
    13011301            self.subplot.set_ylabel(label, fontproperties=font, color=color) 
    1302             if t_font != None: 
     1302            if t_font is not None: 
    13031303                for tick_label in self.subplot.get_yticklabels(): 
    13041304                    tick_label.set_fontproperties(t_font) 
     
    13271327        from plottable_interactor import PointInteractor 
    13281328        p = PointInteractor(self, self.subplot, zorder=zorder, id=id) 
    1329         if p.markersize != None: 
     1329        if p.markersize is not None: 
    13301330            markersize = p.markersize 
    13311331        p.points(x, y, dx=dx, dy=dy, color=color, symbol=symbol, zorder=zorder, 
     
    13631363 
    13641364        # Convert tuple (lo,hi) to array [(x-lo),(hi-x)] 
    1365         if dx != None and type(dx) == type(()): 
     1365        if dx is not None and type(dx) == type(()): 
    13661366            dx = nx.vstack((x - dx[0], dx[1] - x)).transpose() 
    1367         if dy != None and type(dy) == type(()): 
     1367        if dy is not None and type(dy) == type(()): 
    13681368            dy = nx.vstack((y - dy[0], dy[1] - y)).transpose() 
    1369         if dx == None and dy == None: