Changeset 9258c43c in sasview


Ignore:
Timestamp:
Jun 3, 2018 6:33:35 AM (7 years ago)
Author:
GitHub <noreply@…>
Branches:
master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, unittest-saveload
Children:
316b9c1
Parents:
de43192 (diff), 8b89396 (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@…> (06/03/18 06:33:35)
git-committer:
GitHub <noreply@…> (06/03/18 06:33:35)
Message:

Merge pull request #151 from SasView?/ticket885b

Ticket885b

This reverts to no polydisperse parameters — ticket #885 needs to be updated to be a feature request adding polydispersity … correctly this time.

Files:
6 added
16 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/perspectives/calculator/model_editor.py

    rc6dfb9f r9258c43c  
    663663        Do the layout for parameter related widgets 
    664664        """ 
    665         param_txt = wx.StaticText(self, -1, 'Fit Parameters NOT requiring' + \ 
    666                                   ' polydispersity (if any): ') 
    667  
    668         param_tip = "#Set the parameters NOT requiring polydispersity " + \ 
    669         "and their initial values.\n" 
     665        param_txt = wx.StaticText(self, -1, 'Fit Parameters: ') 
     666 
     667        param_tip = "#Set the parameters and their initial values.\n" 
    670668        param_tip += "#Example:\n" 
    671669        param_tip += "A = 1\nB = 1" 
    … …  
    681679                                  (self.param_tcl, 1, wx.EXPAND | wx.ALL, 10)]) 
    682680 
    683         # Parameters with polydispersity 
    684         pd_param_txt = wx.StaticText(self, -1, 'Fit Parameters requiring ' + \ 
    685                                      'polydispersity (if any): ') 
    686  
    687         pd_param_tip = "#Set the parameters requiring polydispersity and " + \ 
    688         "their initial values.\n" 
    689         pd_param_tip += "#Example:\n" 
    690         pd_param_tip += "C = 2\nD = 2" 
    691         newid = wx.NewId() 
    692         self.pd_param_tcl = EditWindow(self, newid, wx.DefaultPosition, 
    693                                     wx.DefaultSize, 
    694                                     wx.CLIP_CHILDREN | wx.SUNKEN_BORDER) 
    695         self.pd_param_tcl.setDisplayLineNumbers(True) 
    696         self.pd_param_tcl.SetToolTipString(pd_param_tip) 
    697  
    698         self.param_sizer.AddMany([(pd_param_txt, 0, wx.LEFT, 10), 
    699                                   (self.pd_param_tcl, 1, wx.EXPAND | wx.ALL, 10)]) 
    700681 
    701682    def _layout_function(self): 
    … …  
    899880            description = self.desc_tcl.GetValue() 
    900881            param_str = self.param_tcl.GetText() 
    901             pd_param_str = self.pd_param_tcl.GetText() 
    902882            func_str = self.function_tcl.GetText() 
    903883            # No input for the model function 
    … …  
    905885                if func_str.count('return') > 0: 
    906886                    self.write_file(self.fname, name, description, param_str, 
    907                                     pd_param_str, func_str) 
     887                                    func_str) 
    908888                    try: 
    909889                        result, msg = check_model(self.fname), None 
    … …  
    945925        self.warning = msg 
    946926 
    947     def write_file(self, fname, name, desc_str, param_str, pd_param_str, func_str): 
     927    def write_file(self, fname, name, desc_str, param_str, func_str): 
    948928        """ 
    949929        Write content in file 
    … …  
    952932        :param desc_str: content of the description strings 
    953933        :param param_str: content of params; Strings 
    954         :param pd_param_str: content of params requiring polydispersity; Strings 
    955934        :param func_str: content of func; Strings 
    956935        """ 
    … …  
    966945        # Write out parameters 
    967946        param_names = []    # to store parameter names 
    968         pd_params = [] 
    969947        out_f.write('parameters = [ \n') 
    970948        out_f.write('#   ["name", "units", default, [lower, upper], "type", "description"],\n') 
    … …  
    973951            out_f.write("    ['%s', '', %s, [-inf, inf], '', '%s'],\n" 
    974952                        % (pname, pvalue, desc)) 
    975         for pname, pvalue, desc in self.get_param_helper(pd_param_str): 
    976             param_names.append(pname) 
    977             pd_params.append(pname) 
    978             out_f.write("    ['%s', '', %s, [-inf, inf], 'volume', '%s'],\n" 
    979                         % (pname, pvalue, desc)) 
    980953        out_f.write('    ]\n') 
    981954 
    982955        # Write out function definition 
     956        out_f.write('\n') 
    983957        out_f.write('def Iq(%s):\n' % ', '.join(['x'] + param_names)) 
    984958        out_f.write('    """Absolute scattering"""\n') 
    … …  
    990964            out_f.write('    import numpy as np') 
    991965        for func_line in func_str.split('\n'): 
    992             out_f.write('%s%s\n' % (spaces4, func_line)) 
     966            out_f.write('%s%s\n' % ('    ', func_line)) 
    993967        out_f.write('## uncomment the following if Iq works for vector x\n') 
    994968        out_f.write('#Iq.vectorized = True\n') 
    995  
    996         # If polydisperse, create place holders for form_volume, ER and VR 
    997         if pd_params: 
    998             out_f.write('\n') 
    999             out_f.write(CUSTOM_TEMPLATE_PD % {'args': ', '.join(pd_params)}) 
    1000969 
    1001970        # Create place holder for Iqxy 
    … …  
    11281097description = """%(description)s""" 
    11291098 
    1130 ''' 
    1131  
    1132 CUSTOM_TEMPLATE_PD = '''\ 
    1133 def form_volume(%(args)s): 
    1134     """ 
    1135     Volume of the particles used to compute absolute scattering intensity 
    1136     and to weight polydisperse parameter contributions. 
    1137     """ 
    1138     return 0.0 
    1139  
    1140 def ER(%(args)s): 
    1141     """ 
    1142     Effective radius of particles to be used when computing structure factors. 
    1143  
    1144     Input parameters are vectors ranging over the mesh of polydispersity values. 
    1145     """ 
    1146     return 0.0 
    1147  
    1148 def VR(%(args)s): 
    1149     """ 
    1150     Volume ratio of particles to be used when computing structure factors. 
    1151  
    1152     Input parameters are vectors ranging over the mesh of polydispersity values. 
    1153     """ 
    1154     return 1.0 
    11551099''' 
    11561100 

  • src/sas/sasgui/perspectives/fitting/media/fitting_help.rst

    r47ace50 r9258c43c  
    180180*checked*\ . 
    181181 
    182 Also note that the 'Fit Parameters' have been split into two sections: those 
    183 which can be polydisperse (shape and orientation parameters) and those which are 
    184 not (eg, scattering length densities). 
    185  
    186182A model file generated by this option can be viewed and further modified using 
    187183the :ref:`Advanced_Plugin_Editor` . 
    188184 
    189 **SasView version 4.2** made it possible to specify whether a plugin created with 
    190 the *New Plugin Model* dialog is actually a form factor P(Q) or a structure factor 
    191 S(Q). To do this, simply add one or other of the following lines under the *import* 
    192 statements. 
     185Note that the New Plugin Model Feature currently does not allow for parameters 
     186to be polydisperse.  However they can be edited in the Advanced Editor. 
     187 
     188 
     189**SasView version 4.2** made it possible to specify whether a plugin created 
     190with the *New Plugin Model* dialog is actually a form factor P(Q) or a structure 
     191factor S(Q). To do this, simply add one or other of the following lines under 
     192the *import* statements. 
    193193 
    194194For a form factor:: 
    … …  
    200200     structure_factor = True 
    201201 
    202 If the plugin is a structure factor it is *also* necessary to add two variables to 
    203 the parameter list:: 
     202If the plugin is a structure factor it is *also* necessary to add two variables 
     203to the parameter list:: 
    204204 
    205205     parameters = [ 

  • build_tools/requirements.txt

    r36ca21e rc16172d  
    33pylint 
    44unittest-xml-reporting==1.10.0 
    5 pyparsing==1.5.5 
     5pyparsing>=2.0 
    66html5lib==0.95 
    77reportlab==2.5 

  • setup.py

    r1a3602d rc16172d  
    402402 
    403403required = [ 
    404     'bumps>=0.7.5.9', 'periodictable>=1.5.0', 'pyparsing<2.0.0', 
     404    'bumps>=0.7.5.9', 'periodictable>=1.5.0', 'pyparsing>=2.0.0', 
    405405 
    406406    # 'lxml>=2.2.2', 

  • src/sas/sascalc/dataloader/file_reader_base_class.py

    ra58b5a0 r4a8d55c  
    3131FIELDS_2D = ('data', 'qx_data', 'qy_data', 'q_data', 'err_data', 
    3232                 'dqx_data', 'dqy_data', 'mask') 
    33  
     33DEPRECATION_MESSAGE = ("\rThe extension of this file suggests the data set migh" 
     34                       "t not be fully reduced. Support for the reader associat" 
     35                       "ed with this file type has been removed. An attempt to " 
     36                       "load the file was made, but, should it be successful, " 
     37                       "SasView cannot guarantee the accuracy of the data.") 
    3438 
    3539class FileReader(object): 
    … …  
    4044    # List of allowed extensions 
    4145    ext = ['.txt'] 
     46    # Deprecated extensions 
     47    deprecated_extensions = ['.asc', '.nxs'] 
    4248    # Bypass extension check and try to load anyway 
    4349    allow_all = False 
    … …  
    8793                    if not self.f_open.closed: 
    8894                        self.f_open.close() 
     95                    if any(filepath.lower().endswith(ext) for ext in 
     96                           self.deprecated_extensions): 
     97                        self.handle_error_message(DEPRECATION_MESSAGE) 
    8998                    if len(self.output) > 0: 
    9099                        # Sort the data that's been loaded 
    … …  
    146155        else: 
    147156            logger.warning(msg) 
     157            raise NoKnownLoaderException(msg) 
    148158 
    149159    def send_to_output(self): 

  • src/sas/sascalc/dataloader/loader.py

    rdc8d1c2 r4a8d55c  
    9090            ascii_loader = ascii_reader.Reader() 
    9191            return ascii_loader.read(path) 
     92        except NoKnownLoaderException: 
     93            pass  # Try the Cansas XML reader 
    9294        except DefaultReaderException: 
    9395            pass  # Loader specific error to try the cansas XML reader 
    … …  
    100102            cansas_loader = cansas_reader.Reader() 
    101103            return cansas_loader.read(path) 
     104        except NoKnownLoaderException: 
     105            pass  # Try the NXcanSAS reader 
    102106        except DefaultReaderException: 
    103107            pass  # Loader specific error to try the NXcanSAS reader 

  • src/sas/sascalc/fit/pagestate.py

    r9e6aeaf r3b070a0  
    646646                    name = value.split(':', 1)[1].strip() 
    647647                    file_value = "File name:" + name 
     648                    #Truncating string so print doesn't complain of being outside margins 
     649                    if sys.platform != "win32": 
     650                        MAX_STRING_LENGHT = 50 
     651                        if len(file_value) > MAX_STRING_LENGHT: 
     652                            file_value = "File name:.."+file_value[-MAX_STRING_LENGHT+10:] 
    648653                    file_name = CENTRE % file_value 
    649654                    if len(title) == 0: 
    … …  
    721726        html_str, text_str, title = self._get_report_string() 
    722727        # Allow 2 figures to append 
    723         image_links = [FEET_2%fig for fig in fig_urls] 
    724  
     728        #Constraining image width for OSX and linux, so print doesn't complain of being outside margins 
     729        if sys.platform == "win32": 
     730            image_links = [FEET_2%fig for fig in fig_urls] 
     731        else: 
     732            image_links = [FEET_2_unix%fig for fig in fig_urls] 
    725733        # final report html strings 
    726734        report_str = html_str + ELINE.join(image_links) 
    727  
     735        report_str += FEET_3 
    728736        return report_str, text_str 
    729737 
    … …  
    13681376""" 
    13691377FEET_2 = \ 
    1370 """<img src="%s" ></img> 
     1378"""<img src="%s"></img> 
     1379""" 
     1380FEET_2_unix = \ 
     1381"""<img src="%s" width="540"></img> 
    13711382""" 
    13721383FEET_3 = \ 

  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    r20fa5fe r2924532  
    185185            try: 
    186186                message = "Loading {}...\n".format(p_file) 
    187                 self.load_update(output=output, message=message, info="info") 
     187                self.load_update(message=message, info="info") 
    188188                temp = self.loader.load(p_file, format) 
    189189                if not isinstance(temp, list): 
    … …  
    201201                        else: 
    202202                            file_errors[basename] = [error_message] 
    203                         self.load_update(output=output, 
    204                             message=error_message, info="warning") 
    205  
    206                 self.load_update(output=output, 
    207                 message="Loaded {}\n".format(p_file), 
    208                 info="info") 
     203 
     204                self.load_update(message="Loaded {}\n".format(p_file), 
     205                                 info="info") 
    209206 
    210207            except NoKnownLoaderException as e: 
    211208                exception_occurred = True 
    212                 logger.error(e.message) 
    213  
    214209                error_message = "Loading data failed!\n" + e.message 
    215                 self.load_update(output=None, message=e.message, info="warning") 
     210                self.load_complete(output=None, 
     211                                   message=error_message, 
     212                                   info="warning") 
    216213 
    217214            except Exception as e: 
    218215                exception_occurred = True 
    219                 logger.error(e.message) 
    220  
    221216                file_err = "The Data file you selected could not be " 
    222217                file_err += "loaded.\nMake sure the content of your file" 
    … …  
    225220                file_err += " following:\n" 
    226221                file_err += e.message 
    227                 file_errors[basename] = [file_err] 
     222                self.load_complete(output=None, 
     223                                   message=file_err, 
     224                                   info="error") 
    228225 
    229226        if len(file_errors) > 0: 
    230227            error_message = "" 
    231228            for filename, error_array in file_errors.iteritems(): 
    232                 error_message += "The following errors occured whilst " 
     229                error_message += "The following issues were found whilst " 
    233230                error_message += "loading {}:\n".format(filename) 
    234231                for message in error_array: 
    235232                    error_message += message + "\n" 
    236                 error_message += "\n" 
    237             if not exception_occurred: # Some data loaded but with errors 
    238                 self.load_update(output=output, message=error_message, info="error") 
    239  
    240         if not exception_occurred: # Everything loaded as expected 
     233                error_message = error_message[:-1] 
     234            self.load_complete(output=output, 
     235                               message=error_message, 
     236                               info="error") 
     237 
     238        elif not exception_occurred: # Everything loaded as expected 
    241239            self.load_complete(output=output, message="Loading data complete!", 
    242240                               info="info") 
    … …  
    244242            self.load_complete(output=None, message=error_message, info="error") 
    245243 
    246  
    247     def load_update(self, output=None, message="", info="warning"): 
     244    def load_update(self, message="", info="warning"): 
    248245        """ 
    249246        print update on the status bar 
    250247        """ 
    251248        if message != "": 
    252             wx.PostEvent(self.parent, StatusEvent(status=message, info=info, 
     249            wx.PostEvent(self.parent, StatusEvent(status=message, 
     250                                                  info=info, 
    253251                                                  type="progress")) 
    254252 
    … …  
    257255         post message to status bar and return list of data 
    258256        """ 
    259         wx.PostEvent(self.parent, StatusEvent(status=message, info=info, 
     257        wx.PostEvent(self.parent, StatusEvent(status=message, 
     258                                              info=info, 
    260259                                              type="stop")) 
    261260        if output is not None: 

  • src/sas/sasgui/guiframe/report_dialog.py

    r69a6897 r91552b5  
    2727class BaseReportDialog(wx.Dialog): 
    2828 
    29     def __init__(self, report_list, *args, **kwds): 
     29    def __init__(self, report_list, imgRAM, fig_urls, *args, **kwds): 
    3030        """ 
    3131        Initialization. The parameters added to Dialog are: 
    … …  
    3737        kwds["image"] = 'Dynamic Image' 
    3838 
     39        #MemoryFSHandle for storing images 
     40        self.imgRAM = imgRAM 
     41        #Images location in urls 
     42        self.fig_urls = fig_urls 
    3943        # title 
    4044        self.SetTitle("Report") 
    … …  
    7579        hbox.Add(button_print) 
    7680 
    77         button_save = wx.Button(self, wx.NewId(), "Save") 
    78         button_save.SetToolTipString("Save this report.") 
    79         button_save.Bind(wx.EVT_BUTTON, self.onSave, id=button_save.GetId()) 
    80         hbox.Add(button_save) 
     81        if sys.platform != "darwin": 
     82            button_save = wx.Button(self, wx.NewId(), "Save") 
     83            button_save.SetToolTipString("Save this report.") 
     84            button_save.Bind(wx.EVT_BUTTON, self.onSave, id=button_save.GetId()) 
     85            hbox.Add(button_save) 
    8186 
    8287        # panel for report page 
    … …  
    111116        printh.PrintText(self.report_html) 
    112117 
     118 
    113119    def OnClose(self, event=None): 
    114120        """ 
    … …  
    116122        : event: Close button event 
    117123        """ 
     124        for fig in self.fig_urls: 
     125            self.imgRAM.RemoveFile(fig) 
     126 
    118127        self.Close() 
    119128 

  • src/sas/sasgui/perspectives/calculator/resolution_calculator_panel.py

    r7432acb r1cf490b6  
    1818matplotlib.use('WXAgg') 
    1919from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas 
    20 from matplotlib.backends.backend_wxagg import NavigationToolbar2Wx as Toolbar 
     20from matplotlib.backends.backend_wxagg import NavigationToolbar2WxAgg as Toolbar 
    2121from matplotlib.backend_bases import FigureManagerBase 
    2222# Wx-Pylab magic for displaying plots within an application's window. 

  • src/sas/sasgui/perspectives/fitting/basepage.py

    r1f4d708 rc192960  
    641641        # get the strings for report 
    642642        report_str, text_str = self.state.report(fig_urls=refs) 
    643  
    644643        # Show the dialog 
    645644        report_list = [report_str, text_str, images] 
    646         dialog = ReportDialog(report_list, None, wx.ID_ANY, "") 
     645        dialog = ReportDialog(report_list, imgRAM, refs, None, wx.ID_ANY, "") 
    647646        dialog.Show() 
    648647 
    … …  
    677676            refs.append('memory:' + name) 
    678677            imgRAM.AddFile(name, canvas.bitmap, wx.BITMAP_TYPE_PNG) 
    679  
    680678            # append figs 
    681679            images.append(fig) 
    … …  
    14721470            # we need to check here ourselves. 
    14731471            if not is_modified: 
    1474                 is_modified = (self._check_value_enter(self.fittable_param) 
    1475                                or self._check_value_enter(self.fixed_param) 
    1476                                or self._check_value_enter(self.parameters)) 
     1472                is_modified = self._check_value_enter(self.fittable_param) 
     1473                is_modified = self._check_value_enter( 
     1474                    self.fixed_param) or is_modified 
     1475                is_modified = self._check_value_enter( 
     1476                    self.parameters) or is_modified 
    14771477 
    14781478            # Here we should check whether the boundaries have been modified. 
    … …  
    15361536                        data=[self.data]) 
    15371537            # Check the values 
    1538             is_modified = (self._check_value_enter(self.fittable_param) 
    1539                            or self._check_value_enter(self.fixed_param) 
    1540                            or self._check_value_enter(self.parameters)) 
     1538            is_modified = self._check_value_enter(self.fittable_param) 
     1539            is_modified = self._check_value_enter(self.fixed_param) or is_modified 
     1540            is_modified = self._check_value_enter(self.parameters) or is_modified 
    15411541 
    15421542            # If qmin and qmax have been modified, update qmin and qmax and 
    … …  
    23242324 
    23252325            # Update value in model if it has changed 
    2326             if value != self.model.getParam(name): 
     2326            if (value != self.model.getParam(name) or 
     2327                    (np.isnan(value) and np.isnan(self.model.getParam(name)))): 
    23272328                self.model.setParam(name, value) 
    23282329                is_modified = True 

  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rbfeb823 ra7c6f38  
    365365        # StaticText for chi2, N(for fitting), Npts + Log/linear spacing 
    366366        self.tcChi = BGTextCtrl(self, wx.ID_ANY, "-", size=(75, 20), style=0) 
    367         self.tcChi.SetToolTipString("Chi2/Npts(Fit)") 
     367        self.tcChi.SetToolTipString("Chi2/DOF (DOF=Npts-Npar fitted)") 
    368368        self.Npts_fit = BGTextCtrl(self, wx.ID_ANY, "-", size=(75, 20), style=0) 
    369369        self.Npts_fit.SetToolTipString( 
    … …  
    391391        self.points_sizer.Add(self.pointsbox) 
    392392 
    393         box_description_1 = wx.StaticText(self, wx.ID_ANY, '   Chi2/Npts') 
     393        box_description_1 = wx.StaticText(self, wx.ID_ANY, 'Reduced Chi2') 
    394394        box_description_2 = wx.StaticText(self, wx.ID_ANY, 'Npts(Fit)') 
    395395 

  • src/sas/sasgui/perspectives/fitting/media/residuals_help.rst

    r99ded31 r84ac3f1  
    2727 
    2828$\chi^2$ is a statistical parameter that quantifies the differences between 
    29 an observed data set and an expected dataset (or 'theory'). 
    30  
    31 When showing the a model with the data, *SasView* displays this parameter 
    32 normalized to the number of data points, $N_\mathrm{pts}$ such that 
     29an observed data set and an expected dataset (or 'theory') calculated as 
    3330 
    3431.. math:: 
    3532 
    36   \chi^2_N 
    37   =  \sum[(Y_i - \mathrm{theory}_i)^2 / \mathrm{error}_i^2] / N_\mathrm{pts} 
     33  \chi^2 
     34  =  \sum[(Y_i - \mathrm{theory}_i)^2 / \mathrm{error}_i^2] 
    3835 
    39 When performing a fit, *SasView* instead displays the reduced $\chi^2_R$, 
    40 which takes into account the number of fitting parameters $N_\mathrm{par}$ 
    41 (to calculate the number of 'degrees of freedom'). This is computed as 
     36Fitting typically minimizes the value of $\chi^2$.  For assessing the quality of 
     37the model and its "fit" however, *SasView* displays the traditional reduced 
     38$\chi^2_R$ which normalizes this parameter by dividing it by the number of 
     39degrees of freedom (or DOF). The DOF is the number of data points being 
     40considered, $N_\mathrm{pts}$, reduced by the number of free (i.e. fitted) 
     41parameters, $N_\mathrm{par}$. Note that model parameters that are kept fixed do 
     42*not* contribute to the DOF (they are not "free"). This reduced value is then 
     43given as 
    4244 
    4345.. math:: 
    … …  
    4749  / [N_\mathrm{pts} - N_\mathrm{par}] 
    4850 
    49 The normalized $\chi^2_N$ and the reduced $\chi^2_R$ are very close to each 
    50 other when $N_\mathrm{pts} \gg N_\mathrm{par}$. 
     51Note that this means the displayed value will vary depending on the number of 
     52parameters used in the fit. In particular, when doing a calculation without a 
     53fit (e.g. manually changing a parameter) the DOF will now equal $N_\mathrm{pts}$ 
     54and the $\chi^2_R$ will be the smallest possible for that combination of model, 
     55data set, and set of parameter values. 
     56 
     57When $N_\mathrm{pts} \gg N_\mathrm{par}$ as it should for proper fitting, the 
     58value of the reduced $\chi^2_R$ will not change very much. 
    5159 
    5260For a good fit, $\chi^2_R$ tends to 1. 
    … …  
    9098| 2015-06-08 Steve King 
    9199| 2017-09-28 Paul Kienzle 
     100| 2018-03-04 Paul Butler 

  • test/corfunc/test/utest_corfunc.py

    rf53d684 r6ef75fa6  
    7474        while True: 
    7575            time.sleep(0.001) 
    76             if not self.calculator.transform_isrunning(): 
     76            if (not self.calculator.transform_isrunning() and 
     77                self.transformation is not None): 
    7778                break 
    7879 
    79     def transform_callback(self, transforms): 
    80         transform1, transform3, idf = transforms 
     80        transform1, transform3, idf = self.transformation 
    8181        self.assertIsNotNone(transform1) 
    8282        self.assertAlmostEqual(transform1.y[0], 1) 
    8383        self.assertAlmostEqual(transform1.y[-1], 0, 5) 
     84 
     85    def transform_callback(self, transforms): 
    8486        self.transformation = transforms 
    8587 

  • test/sascalculator/test/utest_sas_gen.py

    r5bb05a4 r39a018b  
    6060        Test that the calculator calculates. 
    6161        """ 
    62         f = self.omfloader.read("A_Raw_Example-1.omf") 
     62        f = self.omfloader.read(find("A_Raw_Example-1.omf")) 
    6363        omf2sld = sas_gen.OMF2SLD() 
    6464        omf2sld.set_data(f) 

  • test/sasdataloader/test/utest_generic_file_reader_class.py

    rf53d684 r4a8d55c  
    88import numpy as np 
    99 
    10 from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D 
     10from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D, Data1D 
     11from sas.sascalc.dataloader.loader import Loader 
     12from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException 
    1113from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    1214 
    … …  
    2426        self.bad_file = find("ACB123.txt") 
    2527        self.good_file = find("123ABC.txt") 
     28        self.generic_reader = Loader() 
     29        self.deprecated_file_type = find("FEB18012.ASC") 
    2630 
    2731    def test_bad_file_path(self): 
    28         output = self.reader.read(self.bad_file) 
    29         self.assertEqual(output, []) 
     32        self.assertRaises(NoKnownLoaderException, self.reader.read, 
     33                          self.bad_file) 
    3034 
    3135    def test_good_file_path(self): 
    … …  
    3640        self.assertEqual(len(output), 1) 
    3741        self.assertEqual(output[0].meta_data["blah"], '123ABC exists!') 
     42 
     43    def test_old_file_types(self): 
     44        f = self.generic_reader.load(self.deprecated_file_type) 
     45        last_f = f[0] 
     46        if hasattr(last_f, "errors"): 
     47            self.assertEquals(len(last_f.errors), 1) 
     48        else: 
     49            self.fail("Errors did not propogate to the file properly.") 
     50 
     51    def test_same_file_unknown_extensions(self): 
     52        # Five files, all with the same content, but different file extensions 
     53        no_ext = find("test_data//TestExtensions") 
     54        not_xml = find("test_data//TestExtensions.notxml") 
     55        # Deprecated extensions 
     56        asc_dep = find("test_data//TestExtensions.asc") 
     57        nxs_dep = find("test_data//TestExtensions.nxs") 
     58        # Native extension as a baseline 
     59        xml_native = find("test_data//TestExtensions.xml") 
     60        # Load the files and check contents 
     61        no_ext_load = self.generic_reader.load(no_ext) 
     62        asc_load = self.generic_reader.load(asc_dep) 
     63        nxs_load = self.generic_reader.load(nxs_dep) 
     64        not_xml_load = self.generic_reader.load(not_xml) 
     65        xml_load = self.generic_reader.load(xml_native) 
     66        self.check_unknown_extension(no_ext_load[0]) 
     67        self.check_unknown_extension(asc_load[0]) 
     68        self.check_unknown_extension(nxs_load[0]) 
     69        self.check_unknown_extension(not_xml_load[0]) 
     70        self.check_unknown_extension(xml_load[0]) 
     71        # Be sure the deprecation warning is passed with the file 
     72        self.assertEquals(len(asc_load[0].errors), 1) 
     73        self.assertEquals(len(nxs_load[0].errors), 1) 
     74 
     75    def check_unknown_extension(self, data): 
     76        self.assertTrue(isinstance(data, Data1D)) 
     77        self.assertEquals(len(data.x), 138) 
     78        self.assertEquals(data.sample.ID, "TK49 c10_SANS") 
     79        self.assertEquals(data.meta_data["loader"], "CanSAS XML 1D") 
    3880 
    3981    def tearDown(self): 
Note: See TracChangeset for help on using the changeset viewer.