Changeset 4342fed0 in sasview


Ignore:
Timestamp:
Apr 9, 2017 8:09:12 AM (3 years ago)
Author:
GitHub <noreply@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
fca1f50
Parents:
5b2b04d (diff), 45dffa69 (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.
git-author:
Paul Butler <butlerpd@…> (04/09/17 08:09:12)
git-committer:
GitHub <noreply@…> (04/09/17 08:09:12)
Message:

Merge pull request #67 from andyfaff/is_none

MAINT: use 'is None' instead of '== None'

Files:
88 edited

Legend:

Unmodified
Added
Removed
  • 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/setup_mac.py

    r959eb01 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

    r959eb01 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 
  • 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

    r959eb01 r7432acb  
    806806            # create zero vector 
    807807            dy_other = other.dy 
    808             if other.dy == None or (len(other.dy) != len(other.y)): 
     808            if other.dy is None or (len(other.dy) != len(other.y)): 
    809809                dy_other = np.zeros(len(other.y)) 
    810810 
    811811        # Check that we have errors, otherwise create zero vector 
    812812        dy = self.dy 
    813         if self.dy == None or (len(self.dy) != len(self.y)): 
     813        if self.dy is None or (len(self.dy) != len(self.y)): 
    814814            dy = np.zeros(len(self.y)) 
    815815 
     
    822822        dy, dy_other = self._validity_check(other) 
    823823        result = self.clone_without_data(len(self.x)) 
    824         if self.dxw == None: 
     824        if self.dxw is None: 
    825825            result.dxw = None 
    826826        else: 
    827827            result.dxw = np.zeros(len(self.x)) 
    828         if self.dxl == None: 
     828        if self.dxl is None: 
    829829            result.dxl = None 
    830830        else: 
     
    884884        self._validity_check_union(other) 
    885885        result = self.clone_without_data(len(self.x) + len(other.x)) 
    886         if self.dy == None or other.dy is None: 
     886        if self.dy is None or other.dy is None: 
    887887            result.dy = None 
    888888        else: 
    889889            result.dy = np.zeros(len(self.x) + len(other.x)) 
    890         if self.dx == None or other.dx is None: 
     890        if self.dx is None or other.dx is None: 
    891891            result.dx = None 
    892892        else: 
    893893            result.dx = np.zeros(len(self.x) + len(other.x)) 
    894         if self.dxw == None or other.dxw is None: 
     894        if self.dxw is None or other.dxw is None: 
    895895            result.dxw = None 
    896896        else: 
    897897            result.dxw = np.zeros(len(self.x) + len(other.x)) 
    898         if self.dxl == None or other.dxl is None: 
     898        if self.dxl is None or other.dxl is None: 
    899899            result.dxl = None 
    900900        else: 
     
    907907        result.y = np.append(self.y, other.y) 
    908908        result.y = result.y[ind] 
    909         if result.dy != None: 
     909        if result.dy is not None: 
    910910            result.dy = np.append(self.dy, other.dy) 
    911911            result.dy = result.dy[ind] 
     
    10301030            # Check that the scales match 
    10311031            err_other = other.err_data 
    1032             if other.err_data == None or \ 
     1032            if other.err_data is None or \ 
    10331033                (len(other.err_data) != len(other.data)): 
    10341034                err_other = np.zeros(len(other.data)) 
     
    10361036        # Check that we have errors, otherwise create zero vector 
    10371037        err = self.err_data 
    1038         if self.err_data == None or \ 
     1038        if self.err_data is None or \ 
    10391039            (len(self.err_data) != len(self.data)): 
    10401040            err = np.zeros(len(other.data)) 
     
    10511051        dy, dy_other = self._validity_check(other) 
    10521052        result = self.clone_without_data(np.size(self.data)) 
    1053         if self.dqx_data == None or self.dqy_data == None: 
     1053        if self.dqx_data is None or self.dqy_data is None: 
    10541054            result.dqx_data = None 
    10551055            result.dqy_data = None 
     
    11251125        result.ymin = self.ymin 
    11261126        result.ymax = self.ymax 
    1127         if self.dqx_data == None or self.dqy_data == None or \ 
    1128                 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: 
    11291129            result.dqx_data = None 
    11301130            result.dqy_data = None 
  • src/sas/sascalc/dataloader/manipulations.py

    r959eb01 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

    r959eb01 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_reader.py

    r63d773c r7432acb  
    807807        :param data1d: presumably a Data1D object 
    808808        """ 
    809         if self.current_dataset == None: 
     809        if self.current_dataset is None: 
    810810            x_vals = np.empty(0) 
    811811            y_vals = np.empty(0) 
     
    895895        # Write the file 
    896896        file_ref = open(filename, 'w') 
    897         if self.encoding == None: 
     897        if self.encoding is None: 
    898898            self.encoding = "UTF-8" 
    899899        doc.write(file_ref, encoding=self.encoding, 
     
    10151015        :param entry_node: lxml node ElementTree object to be appended to 
    10161016        """ 
    1017         if datainfo.run == None or datainfo.run == []: 
     1017        if datainfo.run is None or datainfo.run == []: 
    10181018            datainfo.run.append(RUN_NAME_DEFAULT) 
    10191019            datainfo.run_name[RUN_NAME_DEFAULT] = RUN_NAME_DEFAULT 
     
    11331133                self.write_node(point, "T", spectrum.transmission[i], 
    11341134                                {'unit': spectrum.transmission_unit}) 
    1135                 if spectrum.transmission_deviation != None \ 
     1135                if spectrum.transmission_deviation is not None \ 
    11361136                and len(spectrum.transmission_deviation) >= i: 
    11371137                    self.write_node(point, "Tdev", 
     
    12131213                                 str(datainfo.source.name)) 
    12141214        self.append(source, instr) 
    1215         if datainfo.source.radiation == None or datainfo.source.radiation == '': 
     1215        if datainfo.source.radiation is None or datainfo.source.radiation == '': 
    12161216            datainfo.source.radiation = "neutron" 
    12171217        self.write_node(source, "radiation", datainfo.source.radiation) 
     
    12541254        :param instr: lxml node ElementTree object to be appended to 
    12551255        """ 
    1256         if datainfo.collimation == [] or datainfo.collimation == None: 
     1256        if datainfo.collimation == [] or datainfo.collimation is None: 
    12571257            coll = Collimation() 
    12581258            datainfo.collimation.append(coll) 
     
    12991299        :param inst: lxml instrument node to be appended to 
    13001300        """ 
    1301         if datainfo.detector == None or datainfo.detector == []: 
     1301        if datainfo.detector is None or datainfo.detector == []: 
    13021302            det = Detector() 
    13031303            det.name = "" 
     
    14641464                local_unit = None 
    14651465                exec "local_unit = storage.%s_unit" % toks[0] 
    1466                 if local_unit != None and units.lower() != local_unit.lower(): 
     1466                if local_unit is not None and units.lower() != local_unit.lower(): 
    14671467                    if HAS_CONVERTER == True: 
    14681468                        try: 
  • src/sas/sascalc/dataloader/readers/danse_reader.py

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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          
     
    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  
     
    663663        # If this is the first simulation call, we need to generate the 
    664664        # space points 
    665         if self.points == None: 
     665        if self.points is None: 
    666666            self._create_modelObject() 
    667667             
    668668            # Protect against empty model 
    669             if self.points == None: 
     669            if self.points is None: 
    670670                return 0 
    671671                
  • src/sas/sasgui/guiframe/CategoryInstaller.py

    r959eb01 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/dataFitting.py

    r959eb01 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

    re645bbb r7432acb  
    315315        if row > self.max_row_touse: 
    316316            self.max_row_touse = row 
    317         if self.data == None: 
     317        if self.data is None: 
    318318            self.data = {} 
    319319        event.Skip() 
     
    814814        """ 
    815815 
    816         if self.data == None: 
     816        if self.data is None: 
    817817            self.data = {} 
    818         if self.file_name == None: 
     818        if self.file_name is None: 
    819819            self.file_name = 'copied_data' 
    820820        self.Paste() 
     
    10171017                            if index - 1 >= 0: 
    10181018                                new_row, _ = temp_list[index - 1] 
    1019                                 if not new_row == None and new_row != ' ': 
     1019                                if new_row is not None and new_row != ' ': 
    10201020                                    label += create_label(col_name, None, 
    10211021                                                          int(new_row) + 1) 
     
    10251025                            if index + 1 < len(temp_list): 
    10261026                                new_row, _ = temp_list[index + 1] 
    1027                                 if not new_row == None: 
     1027                                if new_row is not None: 
    10281028                                    label += create_label(col_name, 
    10291029                                                          int(new_row) + 1, None) 
    1030                     if row_min != None and row_max != None: 
     1030                    if row_min is not None and row_max is not None: 
    10311031                        if index == 0: 
    10321032                            label += create_label(col_name, 
     
    10851085 
    10861086        # Let's re-order the data from the keys in 'Data' name. 
    1087         if outputs == None: 
     1087        if outputs is None: 
    10881088            return 
    10891089        try: 
     
    13741374            wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error")) 
    13751375            return 
    1376         if dy != None and (len(y) != len(dy)): 
     1376        if dy is not None and (len(y) != len(dy)): 
    13771377            msg = "Need same length for Y and dY axis and both greater than 0" 
    13781378            msg += " to plot.\n" 
     
    13801380            wx.PostEvent(self.parent.parent, StatusEvent(status=msg, info="error")) 
    13811381            return 
    1382         if dy == None: 
     1382        if dy is None: 
    13831383            dy = np.zeros(len(y)) 
    13841384        #plotting 
     
    14411441            col = column_names[col_name] 
    14421442            axis = self.get_plot_axis(col, list) 
    1443             if axis == None: 
     1443            if axis is None: 
    14441444                return None 
    14451445            sentence = sentence.replace(tok, "numpy.array(%s)" % str(axis)) 
     
    15721572        """ 
    15731573 
    1574         if label != None: 
     1574        if label is not None: 
    15751575            tcrtl_label.SetValue(str(label)) 
    1576         if title != None: 
     1576        if title is not None: 
    15771577            tcrtl_title.SetValue(str(title)) 
    15781578 
     
    16851685        # I Believe this is no longer used now that we have removed the  
    16861686        # edit menu from the menubar - PDB July 12, 2015 
    1687         if event != None: 
     1687        if event is not None: 
    16881688            event.Skip() 
    16891689        pos = self.panel.notebook.GetSelection() 
     
    16971697        # I Believe this is no longer used now that we have removed the  
    16981698        # edit menu from the menubar - PDB July 12, 2015 
    1699         if event != None: 
     1699        if event is not None: 
    17001700            event.Skip() 
    17011701        pos = self.panel.notebook.GetSelection() 
     
    17391739            pos = self.panel.notebook.GetSelection() 
    17401740            grid = self.panel.notebook.GetPage(pos) 
    1741             has_data = (grid.data != None and grid.data != {}) 
     1741            has_data = (grid.data is not None and grid.data != {}) 
    17421742            self.open_excel_menu.Enable(has_data) 
    17431743            self.save_menu.Enable(has_data) 
     
    18221822                    path = dlg.GetPath() 
    18231823                dlg.Destroy() 
    1824                 if path != None: 
     1824                if path is not None: 
    18251825                    if self.parent is not None: 
    18261826                        data = grid.get_grid_view() 
     
    20072007                    path = dlg.GetPath() 
    20082008                dlg.Destroy() 
    2009                 if path != None: 
     2009                if path is not None: 
    20102010                    if self.parent is not None and  self.data is not None: 
    20112011                        self.parent.write_batch_tofile(data=self.data, 
  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    rc1d5aea 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 
     
    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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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/panel_base.py

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 r7432acb  
    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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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

    r959eb01 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/inversion_panel.py

    rc1d5aea 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." 
  • src/sas/sasgui/perspectives/pr/inversion_state.py

    r959eb01 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

    r959eb01 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 
     
    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() 
     
    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

    r959eb01 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

    r959eb01 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/PlotPanel.py

    r959eb01 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: 
     1369        if dx is None and dy is None: 
    13701370            self.subplot.plot(x, y, color=self._color(color), 
    13711371                              marker=self._symbol(symbol), 
     
    14431443        c = self._color(color) 
    14441444        # If we don't have any data, skip. 
    1445         if self.data == None: 
     1445        if self.data is None: 
    14461446            return 
    14471447        if self.data.ndim == 1: 
     
    15191519            self.subplot.set_axis_off() 
    15201520 
    1521         if cbax == None: 
     1521        if cbax is None: 
    15221522            ax.set_frame_on(False) 
    15231523            cb = self.subplot.figure.colorbar(im, shrink=0.8, aspect=20) 
     
    15411541        """ 
    15421542        # No qx or qy given in a vector format 
    1543         if self.qx_data == None or self.qy_data == None \ 
     1543        if self.qx_data is None or self.qy_data is None \ 
    15441544                or self.qx_data.ndim != 1 or self.qy_data.ndim != 1: 
    15451545            # do we need deepcopy here? 
     
    16011601        """ 
    16021602        # No qx or qy given in a vector format 
    1603         if self.qx_data == None or self.qy_data == None \ 
     1603        if self.qx_data is None or self.qy_data is None \ 
    16041604                or self.qx_data.ndim != 1 or self.qy_data.ndim != 1: 
    16051605            # do we need deepcopy here? 
     
    16521652        """ 
    16531653        # No image matrix given 
    1654         if image == None or np.ndim(image) != 2 \ 
     1654        if image is None or np.ndim(image) != 2 \ 
    16551655                or np.isfinite(image).all() \ 
    1656                 or weights == None: 
     1656                or weights is None: 
    16571657            return image 
    16581658        # Get bin size in y and x directions 
     
    17721772            # control axis labels from the panel itself 
    17731773            yname, yunits = item.get_yaxis() 
    1774             if self.yaxis_label != None: 
     1774            if self.yaxis_label is not None: 
    17751775                yname = self.yaxis_label 
    17761776                yunits = self.yaxis_unit 
     
    17791779                self.yaxis_unit = yunits 
    17801780            xname, xunits = item.get_xaxis() 
    1781             if self.xaxis_label != None: 
     1781            if self.xaxis_label is not None: 
    17821782                xname = self.xaxis_label 
    17831783                xunits = self.xaxis_unit 
     
    19401940        """ 
    19411941        """ 
    1942         if self.parent == None: 
     1942        if self.parent is None: 
    19431943            return 
    19441944        # get current caption 
  • src/sas/sasgui/plottools/TextDialog.py

    r959eb01 r7432acb  
    4141        style_box = wx.BoxSizer(wx.HORIZONTAL) 
    4242        # tcA 
    43         if unit != None: 
     43        if unit is not None: 
    4444            styles = wx.TAB_TRAVERSAL 
    4545            height = -1 
     
    130130                       0, wx.TOP, 5) 
    131131        family_box.Add(self.font_size, 0, 0) 
    132         if unit_box != None: 
     132        if unit_box is not None: 
    133133            family_box.Add((_BOX_WIDTH / 2, -1)) 
    134134            family_box.Add(tick_label_text, 0, 0) 
     
    159159        text_box.Add(self.text_string) 
    160160        vbox.Add(text_box, 0, wx.EXPAND, 15) 
    161         if unit_box != None: 
     161        if unit_box is not None: 
    162162            unit_box.Add(unit_text, 0, 0) 
    163163            unit_box.Add(self.unit_ctrl, 0, 0) 
  • src/sas/sasgui/plottools/arrow3d.py

    r959eb01 r7432acb  
    2929        self.base = base 
    3030 
    31         if base != None: 
     31        if base is not None: 
    3232            # To turn the updating off during dragging 
    3333            base.canvas.mpl_connect('button_press_event', self.on_left_down) 
  • src/sas/sasgui/plottools/canvas.py

    r463e7ffc r7432acb  
    153153        """ 
    154154        self.panel.subplot.grid(self.panel.grid_on) 
    155         if self.panel.legend != None and self.panel.legend_pos_loc: 
     155        if self.panel.legend is not None and self.panel.legend_pos_loc: 
    156156            self.panel.legend._loc = self.panel.legend_pos_loc 
    157157        self.idletimer.Restart(5, *args, **kwargs)  # Delay by 5 ms 
  • src/sas/sasgui/plottools/fitDialog.py

    r959eb01 r7432acb  
    9595 
    9696        # Set default value of parameter in the dialog panel 
    97         if self.Avalue == None: 
     97        if self.Avalue is None: 
    9898            self.tcA.SetValue(format_number(self.default_A)) 
    9999        else: 
    100100            self.tcA.SetLabel(format_number(self.Avalue)) 
    101         if self.Bvalue == None: 
     101        if self.Bvalue is None: 
    102102            self.tcB.SetValue(format_number(self.default_B)) 
    103103        else: 
    104104            self.tcB.SetLabel(format_number(self.Bvalue)) 
    105         if self.ErrAvalue == None: 
     105        if self.ErrAvalue is None: 
    106106            self.tcErrA.SetLabel(format_number(0.0)) 
    107107        else: 
    108108            self.tcErrA.SetLabel(format_number(self.ErrAvalue)) 
    109         if self.ErrBvalue == None: 
     109        if self.ErrBvalue is None: 
    110110            self.tcErrB.SetLabel(format_number(0.0)) 
    111111        else: 
    112112            self.tcErrB.SetLabel(format_number(self.ErrBvalue)) 
    113         if self.Chivalue == None: 
     113        if self.Chivalue is None: 
    114114            self.tcChi.SetLabel(format_number(0.0)) 
    115115        else: 
     
    502502 
    503503                # Check that cov and out are iterable before displaying them 
    504                 if cov == None: 
     504                if cov is None: 
    505505                    errA = 0.0 
    506506                    errB = 0.0 
     
    508508                    errA = math.sqrt(cov[0][0]) 
    509509                    errB = math.sqrt(cov[1][1]) 
    510                 if out == None: 
     510                if out is None: 
    511511                    cstA = 0.0 
    512512                    cstB = 0.0 
     
    579579                    self.I0_tctr.SetValue(format_number(val)) 
    580580            if self.Rgerr_tctr.IsShown(): 
    581                 if rg != None and rg != 0: 
     581                if rg is not None and rg != 0: 
    582582                    value = format_number(3 * float(errA) / (2 * rg)) 
    583583                else: 
     
    593593                self.Diameter_tctr.SetValue(value) 
    594594            if self.Diametererr_tctr.IsShown(): 
    595                 if rg != None and rg != 0: 
     595                if rg is not None and rg != 0: 
    596596                    value = format_number(8 * float(errA) / _diam) 
    597597                else: 
  • src/sas/sasgui/plottools/fittings.py

    r959eb01 rac07a3a  
    2525        self.model = model 
    2626        self.name = name 
    27         if not value == None: 
     27        if value is not None: 
    2828            self.model.setParam(self.name, value) 
    2929 
  • src/sas/sasgui/plottools/plottable_interactor.py

    r959eb01 r45dffa69  
    5050            l_width = markersize * 0.4 
    5151            return self.step(x=x, y=y, color=color, label=label, width=l_width) 
    52         if not self.marker == None: 
    53             self.base.connect.clear([self.marker]) 
    54         self.color = self._color(color) 
    55         if self.markersize != None: 
     52        if self.marker is not None: 
     53            self.base.connect.clear([self.marker]) 
     54        self.color = self._color(color) 
     55        if self.markersize is not None: 
    5656            markersize = self.markersize 
    5757        # Convert tuple (lo,hi) to array [(x-lo),(hi-x)] 
    58         if dx != None and type(dx) == type(()): 
     58        if dx is not None and type(dx) == type(()): 
    5959            dx = nx.vstack((x - dx[0], dx[1] - x)).transpose() 
    60         if dy != None and type(dy) == type(()): 
     60        if dy is not None and type(dy) == type(()): 
    6161            dy = nx.vstack((y - dy[0], dy[1] - y)).transpose() 
    6262 
    63         if dx == None and dy == None: 
     63        if dx is None and dy is None: 
    6464            # zorder = 1 
    6565            self.marker = self.axes.plot(x, y, color=self.color, 
     
    100100        """ 
    101101        """ 
    102         if not self.marker == None: 
     102        if self.marker is not None: 
    103103            self.base.connect.clear([self.marker]) 
    104104        self.color = self._color(color) 
     
    115115        """ 
    116116        """ 
    117         if not self.marker == None: 
     117        if self.marker is not None: 
    118118            self.base.connect.clear([self.marker]) 
    119119        self.color = self._color(color) 
     
    133133        """ 
    134134        """ 
    135         if not self.marker == None: 
     135        if self.marker is not None: 
    136136            self.base.connect.clear([self.marker]) 
    137137        self.color = self._color(color) 
  • src/sas/sasgui/plottools/plottables.py

    r9c0f3c17 r45dffa69  
    229229            if p.hidden == True: 
    230230                continue 
    231             if not p.x == None: 
     231            if p.x is not None: 
    232232                for x_i in p.x: 
    233                     if min_value == None or x_i < min_value: 
     233                    if min_value is None or x_i < min_value: 
    234234                        min_value = x_i 
    235                     if max_value == None or x_i > max_value: 
     235                    if max_value is None or x_i > max_value: 
    236236                        max_value = x_i 
    237237        return min_value, max_value 
     
    562562        Returns True if there is no data stored in the plottable 
    563563        """ 
    564         if not self.x == None and len(self.x) == 0 \ 
    565             and not self.y == None and len(self.y) == 0: 
     564        if (self.x is not None and len(self.x) == 0 
     565            and self.y is not None and len(self.y) == 0): 
    566566            return True 
    567567        return False 
     
    679679        # Sanity check 
    680680        # Do the transofrmation only when x and y are empty 
    681         has_err_x = not (dx == None or len(dx) == 0) 
    682         has_err_y = not (dy == None or len(dy) == 0) 
    683  
    684         if(x != None) and (y != None): 
    685             if not dx == None and not len(dx) == 0 and not len(x) == len(dx): 
     681        has_err_x = not (dx is None or len(dx) == 0) 
     682        has_err_y = not (dy is None or len(dy) == 0) 
     683 
     684        if(x is not None) and (y is not None): 
     685            if dx is not None and not len(dx) == 0 and not len(x) == len(dx): 
    686686                msg = "Plottable.View: Given x and dx are not" 
    687687                msg += " of the same length" 
     
    693693                raise ValueError, msg 
    694694 
    695             if not dy == None and not len(dy) == 0 and not len(y) == len(dy): 
     695            if dy is not None and not len(dy) == 0 and not len(y) == len(dy): 
    696696                msg = "Plottable.View: Given y and dy are not of the same " 
    697697                msg += "length: len(y)=%s, len(dy)=%s" % (len(y), len(dy)) 
     
    797797        tempy = [] 
    798798        tempdy = [] 
    799         if self.dx == None: 
     799        if self.dx is None: 
    800800            self.dx = np.zeros(len(self.x)) 
    801         if self.dy == None: 
     801        if self.dy is None: 
    802802            self.dy = np.zeros(len(self.y)) 
    803803        if self.xLabel == "log10(x)": 
     
    827827        tempy = [] 
    828828        tempdy = [] 
    829         if self.dx == None: 
     829        if self.dx is None: 
    830830            self.dx = np.zeros(len(self.x)) 
    831         if self.dy == None: 
     831        if self.dy is None: 
    832832            self.dy = np.zeros(len(self.y)) 
    833833        if self.yLabel == "log10(y)": 
     
    860860        tempy = [] 
    861861        tempdy = [] 
    862         if self.dx == None: 
     862        if self.dx is None: 
    863863            self.dx = np.zeros(len(self.x)) 
    864         if self.dy == None: 
     864        if self.dy is None: 
    865865            self.dy = np.zeros(len(self.y)) 
    866         if xmin != None and xmax != None: 
     866        if xmin is not None and xmax is not None: 
    867867            for i in range(len(self.x)): 
    868868                if self.x[i] >= xmin and self.x[i] <= xmax: 
     
    12061206        """ 
    12071207        """ 
    1208         if  self._chisq == None: 
     1208        if  self._chisq is None: 
    12091209            chisqTxt = r'$\chi^2=$' 
    12101210        else: 
  • src/sas/sasgui/plottools/transform.py

    r959eb01 r7432acb  
    162162 
    163163    """ 
    164     if dx == None: 
     164    if dx is None: 
    165165        dx = 0 
    166166    return dx 
     
    175175 
    176176    """ 
    177     if dx == None: 
     177    if dx is None: 
    178178        dx = 0 
    179179    return dx 
     
    188188 
    189189    """ 
    190     if  dx != None: 
     190    if  dx is not None: 
    191191        err = 2 * x * dx 
    192192        return math.fabs(err) 
     
    204204    """ 
    205205    if x > 0: 
    206         if dx != None: 
     206        if dx is not None: 
    207207            err = dx / (2 * math.sqrt(x)) 
    208208        else: 
     
    222222 
    223223    """ 
    224     if dx != None: 
     224    if dx is not None: 
    225225        err = 4 * math.pow(x, 3) * dx 
    226226        return math.fabs(err) 
     
    238238    """ 
    239239    if x > 0: 
    240         if dx != None: 
     240        if dx is not None: 
    241241            err = dx / (4 * math.pow(x, 3 / 4)) 
    242242        else: 
     
    256256 
    257257    """ 
    258     if dx == None: 
     258    if dx is None: 
    259259        dx = 0 
    260260 
     
    280280 
    281281    """ 
    282     if dx == None: 
     282    if dx is None: 
    283283        dx = 0 
    284284 
     
    294294    """ 
    295295    """ 
    296     if dx == None: 
    297         dx = 0 
    298     if dy == None: 
     296    if dx is None: 
     297        dx = 0 
     298    if dy is None: 
    299299        dy = 0 
    300300    err = math.sqrt((2 * x * y * dx) ** 2 + ((x ** 2) * dy) ** 2) 
     
    314314        raise ValueError, msg 
    315315    if x != 0 and y != 0: 
    316         if dx == None: 
     316        if dx is None: 
    317317            dx = 0 
    318         if dy == None: 
     318        if dy is None: 
    319319            dy = 0 
    320320        err = (dx / x) ** 2 + (dy / y) ** 2 
     
    337337        raise ValueError, msg 
    338338    if x > 0 and y > 0: 
    339         if dx == None: 
     339        if dx is None: 
    340340            dx = 0 
    341         if dy == None: 
     341        if dy is None: 
    342342            dy = 0 
    343343        err = (2.0 * dx / x) ** 2 + (dy / y) ** 2 
     
    353353    """ 
    354354    if x != 0: 
    355         if dx == None: 
     355        if dx is None: 
    356356            dx = 0 
    357357        err = dx / x ** 2 
     
    367367    """ 
    368368    if x > 0: 
    369         if dx == None: 
     369        if dx is None: 
    370370            dx = 0 
    371371        err = -1 / 2 * math.pow(x, -3.0 / 2.0) * dx 
     
    388388        msg += " that are consistent with zero." 
    389389        raise ValueError, msg 
    390     if dx == None: 
    391         dx = 0 
    392     if dy == None: 
     390    if dx is None: 
     391        dx = 0 
     392    if dy is None: 
    393393        dy = 0 
    394394    err = math.sqrt((4.0 * dx / x) ** 2 + (dy / y) ** 2) 
     
    406406    # within errors 
    407407 
    408     if dx == None: 
    409         dx = 0 
    410     if dy == None: 
     408    if dx is None: 
     409        dx = 0 
     410    if dy is None: 
    411411        dy = 0 
    412412    err = math.sqrt((dy * pow(x, 4)) ** 2 + (4 * y * dx * math.pow(x, 3)) ** 2) 
  • test/pr_inversion/test/utest_invertor.py

    r959eb01 rac07a3a  
    576576    data_err = np.zeros(0) 
    577577    scale    = None 
    578     if not path == None: 
     578    if path is not None: 
    579579        input_f = open(path,'r') 
    580580        buff    = input_f.read() 
  • test/sasdataloader/test/utest_cansas.py

    r959eb01 r7432acb  
    103103        self.assertAlmostEqual(data.detector[1].distance, 4145.02) 
    104104        self.assertTrue(data.process[0].name == "Mantid generated CanSAS1D XML") 
    105         self.assertTrue(data.meta_data["xmlpreprocess"] != None) 
     105        self.assertTrue(data.meta_data["xmlpreprocess"] is not None) 
    106106 
    107107 
  • test/sasrealspace/test/sim_validation.py

    r959eb01 rac07a3a  
    3232            #return: mean, error 
    3333        """ 
    34         if not density == None: 
     34        if density is not None: 
    3535            self.density = density 
    3636            self.create() 
     
    4545            #return: mean, error 
    4646        """ 
    47         if not density == None: 
     47        if density is not None: 
    4848            self.density = density 
    4949            self.create() 
  • test/sasrealspace/test/utest_realspace.py

    r959eb01 r45dffa69  
    326326        self.canvas.setParam('%s.radius' % handle, self.outer_radius) 
    327327        self.canvas.setParam('%s.contrast' % handle, self.shell_sld) 
    328         if not order1 == None: 
     328        if order1 is not None: 
    329329            self.canvas.setParam('%s.order' % handle, order1) 
    330330        
     
    332332