Changeset 44daa56 in sasview for src/sas


Ignore:
Timestamp:
Aug 21, 2017 4:51:20 AM (7 years ago)
Author:
lewis
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:
dcb91cf
Parents:
ce8c7bd (diff), a06ee7e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ticket-876

Location:
src/sas
Files:
3 added
4 deleted
30 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/pr/c_extensions/Cinvertor.c

    r959eb01 rcb62bd5  
    294294} 
    295295 
    296 const char set_has_bck_doc[] = 
     296const char set_est_bck_doc[] = 
    297297        "Sets background flag\n"; 
    298298 
     
    300300 * Sets the maximum distance 
    301301 */ 
    302 static PyObject * set_has_bck(Cinvertor *self, PyObject *args) { 
    303         int has_bck; 
    304  
    305         if (!PyArg_ParseTuple(args, "i", &has_bck)) return NULL; 
    306         self->params.has_bck = has_bck; 
    307         return Py_BuildValue("i", self->params.has_bck); 
    308 } 
    309  
    310 const char get_has_bck_doc[] = 
     302static PyObject * set_est_bck(Cinvertor *self, PyObject *args) { 
     303        int est_bck; 
     304 
     305        if (!PyArg_ParseTuple(args, "i", &est_bck)) return NULL; 
     306        self->params.est_bck = est_bck; 
     307        return Py_BuildValue("i", self->params.est_bck); 
     308} 
     309 
     310const char get_est_bck_doc[] = 
    311311        "Gets background flag\n"; 
    312312 
     
    314314 * Gets the maximum distance 
    315315 */ 
    316 static PyObject * get_has_bck(Cinvertor *self, PyObject *args) { 
    317         return Py_BuildValue("i", self->params.has_bck); 
     316static PyObject * get_est_bck(Cinvertor *self, PyObject *args) { 
     317        return Py_BuildValue("i", self->params.est_bck); 
    318318} 
    319319 
     
    882882        sqrt_alpha = sqrt(self->params.alpha); 
    883883        pi = acos(-1.0); 
    884         offset = (self->params.has_bck==1) ? 0 : 1; 
     884        offset = (self->params.est_bck==1) ? 0 : 1; 
    885885 
    886886    for (j=0; j<nfunc; j++) { 
     
    892892            } 
    893893            if (accept_q(self, self->params.x[i])){ 
    894                 if (self->params.has_bck==1 && j==0) { 
     894                if (self->params.est_bck==1 && j==0) { 
    895895                    a[i*nfunc+j] = 1.0/self->params.err[i]; 
    896896                } else { 
     
    906906        } 
    907907        for (i_r=0; i_r<nr; i_r++){ 
    908             if (self->params.has_bck==1 && j==0) { 
     908            if (self->params.est_bck==1 && j==0) { 
    909909                a[(i_r+self->params.npoints)*nfunc+j] = 0.0; 
    910910            } else { 
     
    10291029                   {"set_slit_height", (PyCFunction)set_slit_height, METH_VARARGS, set_slit_height_doc}, 
    10301030                   {"get_slit_height", (PyCFunction)get_slit_height, METH_VARARGS, get_slit_height_doc}, 
    1031                    {"set_has_bck", (PyCFunction)set_has_bck, METH_VARARGS, set_has_bck_doc}, 
    1032                    {"get_has_bck", (PyCFunction)get_has_bck, METH_VARARGS, get_has_bck_doc}, 
     1031                   {"set_est_bck", (PyCFunction)set_est_bck, METH_VARARGS, set_est_bck_doc}, 
     1032                   {"get_est_bck", (PyCFunction)get_est_bck, METH_VARARGS, get_est_bck_doc}, 
    10331033                   {"get_nx", (PyCFunction)get_nx, METH_VARARGS, get_nx_doc}, 
    10341034                   {"get_ny", (PyCFunction)get_ny, METH_VARARGS, get_ny_doc}, 
  • src/sas/sascalc/pr/c_extensions/invertor.c

    r959eb01 rcb62bd5  
    2020        pars->q_min = -1.0; 
    2121        pars->q_max = -1.0; 
    22         pars->has_bck = 0; 
     22        pars->est_bck = 0; 
    2323} 
    2424 
     
    313313    return sqrt(sum_r2/(2.0*sum)); 
    314314} 
    315  
  • src/sas/sascalc/pr/c_extensions/invertor.h

    r959eb01 rcb62bd5  
    2727    double q_max; 
    2828    /// Flag for whether or not to evalute a constant background while inverting 
    29     int has_bck; 
     29    int est_bck; 
    3030    /// Slit height in units of q [A-1] 
    3131    double slit_height; 
  • src/sas/sascalc/pr/invertor.py

    r45dffa69 rcb62bd5  
    121121         self.q_min, self.q_max, 
    122122         self.x, self.y, 
    123          self.err, self.has_bck, 
     123         self.err, self.est_bck, 
    124124         self.slit_height, self.slit_width) = state 
    125125 
     
    133133                 self.q_min, self.q_max, 
    134134                 self.x, self.y, 
    135                  self.err, self.has_bck, 
     135                 self.err, self.est_bck, 
    136136                 self.slit_height, self.slit_width, 
    137137                ) 
     
    175175        elif name == 'slit_width': 
    176176            return self.set_slit_width(value) 
    177         elif name == 'has_bck': 
     177        elif name == 'est_bck': 
    178178            if value == True: 
    179                 return self.set_has_bck(1) 
     179                return self.set_est_bck(1) 
    180180            elif value == False: 
    181                 return self.set_has_bck(0) 
     181                return self.set_est_bck(0) 
    182182            else: 
    183                 raise ValueError, "Invertor: has_bck can only be True or False" 
     183                raise ValueError, "Invertor: est_bck can only be True or False" 
    184184 
    185185        return Cinvertor.__setattr__(self, name, value) 
     
    220220        elif name == 'slit_width': 
    221221            return self.get_slit_width() 
    222         elif name == 'has_bck': 
    223             value = self.get_has_bck() 
     222        elif name == 'est_bck': 
     223            value = self.get_est_bck() 
    224224            if value == 1: 
    225225                return True 
     
    248248        invertor.y = self.y 
    249249        invertor.err = self.err 
    250         invertor.has_bck = self.has_bck 
     250        invertor.est_bck = self.est_bck 
     251        invertor.background = self.background 
    251252        invertor.slit_height = self.slit_height 
    252253        invertor.slit_width = self.slit_width 
     
    290291        """ 
    291292        # Reset the background value before proceeding 
    292         self.background = 0.0 
    293         return self.lstsq(nfunc, nr=nr) 
     293        # self.background = 0.0 
     294        if not self.est_bck: 
     295            self.y -= self.background 
     296        out, cov = self.lstsq(nfunc, nr=nr) 
     297        if not self.est_bck: 
     298            self.y += self.background 
     299        return out, cov 
    294300 
    295301    def iq(self, out, q): 
     
    454460 
    455461        # If we need to fit the background, add a term 
    456         if self.has_bck == True: 
     462        if self.est_bck == True: 
    457463            nfunc_0 = nfunc 
    458464            nfunc += 1 
     
    500506 
    501507        # Keep a copy of the last output 
    502         if self.has_bck == False: 
    503             self.background = 0 
     508        if self.est_bck == False: 
    504509            self.out = c 
    505510            self.cov = err 
     
    653658        file.write("#slit_width=%g\n" % self.slit_width) 
    654659        file.write("#background=%g\n" % self.background) 
    655         if self.has_bck == True: 
     660        if self.est_bck == True: 
    656661            file.write("#has_bck=1\n") 
    657662        else: 
     
    734739                        toks = line.split('=') 
    735740                        if int(toks[1]) == 1: 
    736                             self.has_bck = True 
     741                            self.est_bck = True 
    737742                        else: 
    738                             self.has_bck = False 
     743                            self.est_bck = False 
    739744 
    740745                    # Now read in the parameters 
  • src/sas/sasgui/perspectives/calculator/model_editor.py

    ra1b8fee r07ec714  
    643643        self.name_hsizer = None 
    644644        self.name_tcl = None 
     645        self.overwrite_cb = None 
    645646        self.desc_sizer = None 
    646647        self.desc_tcl = None 
     
    657658        self.warning = "" 
    658659        #This does not seem to be used anywhere so commenting out for now 
    659         #    -- PDB 2/26/17  
     660        #    -- PDB 2/26/17 
    660661        #self._description = "New Plugin Model" 
    661662        self.function_tcl = None 
     
    689690        #title name [string] 
    690691        name_txt = wx.StaticText(self, -1, 'Function Name : ') 
    691         overwrite_cb = wx.CheckBox(self, -1, "Overwrite existing plugin model of this name?", (10, 10)) 
    692         overwrite_cb.SetValue(False) 
    693         overwrite_cb.SetToolTipString("Overwrite it if already exists?") 
    694         wx.EVT_CHECKBOX(self, overwrite_cb.GetId(), self.on_over_cb) 
     692        self.overwrite_cb = wx.CheckBox(self, -1, "Overwrite existing plugin model of this name?", (10, 10)) 
     693        self.overwrite_cb.SetValue(False) 
     694        self.overwrite_cb.SetToolTipString("Overwrite it if already exists?") 
     695        wx.EVT_CHECKBOX(self, self.overwrite_cb.GetId(), self.on_over_cb) 
    695696        self.name_tcl = wx.TextCtrl(self, -1, size=(PANEL_WIDTH * 3 / 5, -1)) 
    696697        self.name_tcl.Bind(wx.EVT_TEXT_ENTER, self.on_change_name) 
     
    700701        self.name_tcl.SetToolTipString(hint_name) 
    701702        self.name_hsizer.AddMany([(self.name_tcl, 0, wx.LEFT | wx.TOP, 0), 
    702                                   (overwrite_cb, 0, wx.LEFT, 20)]) 
     703                                  (self.overwrite_cb, 0, wx.LEFT, 20)]) 
    703704        self.name_sizer.AddMany([(name_txt, 0, wx.LEFT | wx.TOP, 10), 
    704705                                 (self.name_hsizer, 0, 
     
    740741        self.param_sizer.AddMany([(param_txt, 0, wx.LEFT, 10), 
    741742                                  (self.param_tcl, 1, wx.EXPAND | wx.ALL, 10)]) 
    742          
     743 
    743744        # Parameters with polydispersity 
    744745        pd_param_txt = wx.StaticText(self, -1, 'Fit Parameters requiring ' + \ 
     
    755756        self.pd_param_tcl.setDisplayLineNumbers(True) 
    756757        self.pd_param_tcl.SetToolTipString(pd_param_tip) 
    757          
     758 
    758759        self.param_sizer.AddMany([(pd_param_txt, 0, wx.LEFT, 10), 
    759760                                  (self.pd_param_tcl, 1, wx.EXPAND | wx.ALL, 10)]) 
     
    995996            info = 'Error' 
    996997            color = 'red' 
     998            self.overwrite_cb.SetValue(True) 
     999            self.overwrite_name = True 
    9971000        else: 
    9981001            self._notes = result 
     
    10301033        if has_scipy: 
    10311034            lines.insert(0, 'import scipy') 
    1032          
    1033         # Think about 2D later         
     1035 
     1036        # Think about 2D later 
    10341037        #self.is_2d = func_str.count("#self.ndim = 2") 
    10351038        #line_2d = '' 
    10361039        #if self.is_2d: 
    10371040        #    line_2d = CUSTOM_2D_TEMP.split('\n') 
    1038          
    1039         # Also think about test later         
     1041 
     1042        # Also think about test later 
    10401043        #line_test = TEST_TEMPLATE.split('\n') 
    10411044        #local_params = '' 
     
    10431046        spaces4  = ' '*4 
    10441047        spaces13 = ' '*13 
    1045         spaces16 = ' '*16      
     1048        spaces16 = ' '*16 
    10461049        param_names = []    # to store parameter names 
    10471050        has_scipy = func_str.count("scipy.") 
     
    10551058            out_f.write(line + '\n') 
    10561059            if line.count('#name'): 
    1057                 out_f.write('name = "%s" \n' % name)                
     1060                out_f.write('name = "%s" \n' % name) 
    10581061            elif line.count('#title'): 
    1059                 out_f.write('title = "User model for %s"\n' % name)                
     1062                out_f.write('title = "User model for %s"\n' % name) 
    10601063            elif line.count('#description'): 
    1061                 out_f.write('description = "%s"\n' % desc_str)                
     1064                out_f.write('description = "%s"\n' % desc_str) 
    10621065            elif line.count('#parameters'): 
    10631066                out_f.write('parameters = [ \n') 
     
    10651068                    p_line = param_line.lstrip().rstrip() 
    10661069                    if p_line: 
    1067                         pname, pvalue = self.get_param_helper(p_line) 
     1070                        pname, pvalue, desc = self.get_param_helper(p_line) 
    10681071                        param_names.append(pname) 
    1069                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', ''],\n" % (spaces16, pname, pvalue)) 
     1072                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', '%s'],\n" % (spaces16, pname, pvalue, desc)) 
    10701073                for param_line in pd_param_str.split('\n'): 
    10711074                    p_line = param_line.lstrip().rstrip() 
    10721075                    if p_line: 
    1073                         pname, pvalue = self.get_param_helper(p_line) 
     1076                        pname, pvalue, desc = self.get_param_helper(p_line) 
    10741077                        param_names.append(pname) 
    1075                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', ''],\n" % (spaces16, pname, pvalue)) 
     1078                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', '%s'],\n" % (spaces16, pname, pvalue, desc)) 
    10761079                out_f.write('%s]\n' % spaces13) 
    1077              
     1080 
    10781081        # No form_volume or ER available in simple model editor 
    10791082        out_f.write('def form_volume(*arg): \n') 
     
    10821085        out_f.write('def ER(*arg): \n') 
    10831086        out_f.write('    return 1.0 \n') 
    1084          
     1087 
    10851088        # function to compute 
    10861089        out_f.write('\n') 
     
    10911094        for func_line in func_str.split('\n'): 
    10921095            out_f.write('%s%s\n' % (spaces4, func_line)) 
    1093          
     1096 
    10941097        Iqxy_string = 'return Iq(numpy.sqrt(x**2+y**2) ' 
    1095              
     1098 
    10961099        out_f.write('\n') 
    10971100        out_f.write('def Iqxy(x, y ') 
     
    11131116        items = line.split(";") 
    11141117        for item in items: 
    1115             name = item.split("=")[0].lstrip().rstrip() 
     1118            name = item.split("=")[0].strip() 
     1119            description = "" 
    11161120            try: 
    1117                 value = item.split("=")[1].lstrip().rstrip() 
     1121                value = item.split("=")[1].strip() 
     1122                if value.count("#"): 
     1123                    # If line ends in a comment, remove it before parsing float 
     1124                    index = value.index("#") 
     1125                    description = value[(index + 1):].strip() 
     1126                    value = value[:value.index("#")].strip() 
    11181127                float(value) 
    1119             except: 
     1128            except ValueError: 
    11201129                value = 1.0 # default 
    11211130 
    1122         return name, value 
     1131        return name, value, description 
    11231132 
    11241133    def set_function_helper(self, line): 
     
    12041213import numpy 
    12051214 
    1206 #name  
     1215#name 
    12071216 
    12081217#title 
     
    12101219#description 
    12111220 
    1212 #parameters  
     1221#parameters 
    12131222 
    12141223""" 
  • src/sas/sasgui/perspectives/calculator/pyconsole.py

    r7432acb r4627657  
    3737    Iqxy = model.evalDistribution([qx, qy]) 
    3838 
    39     result = """ 
    40     Iq(%s) = %s 
    41     Iqxy(%s, %s) = %s 
    42     """%(q, Iq, qx, qy, Iqxy) 
     39    # check the model's unit tests run 
     40    from sasmodels.model_test import run_one 
     41    result = run_one(path) 
    4342 
    4443    return result 
     
    8988        ok = wx.Button(self, wx.ID_OK, "OK") 
    9089 
    91         # Mysterious constraint layouts from  
     90        # Mysterious constraint layouts from 
    9291        # https://www.wxpython.org/docs/api/wx.lib.layoutf.Layoutf-class.html 
    9392        lc = layoutf.Layoutf('t=t5#1;b=t5#2;l=l5#1;r=r5#1', (self,ok)) 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    ra534432 r489f53a  
    257257        toks = os.path.splitext(label) 
    258258        path = os.path.join(models.find_plugins_dir(), toks[0]) 
     259        message = "Are you sure you want to delete the file {}?".format(path) 
     260        dlg = wx.MessageDialog(self.frame, message, '', wx.YES_NO | wx.ICON_QUESTION) 
     261        if not dlg.ShowModal() == wx.ID_YES: 
     262            return 
    259263        try: 
    260264            for ext in ['.py', '.pyc']: 
    261265                p_path = path + ext 
     266                if ext == '.pyc' and not os.path.isfile(path + ext): 
     267                    # If model is invalid, .pyc file may not exist as model has 
     268                    # never been compiled. Don't try and delete it 
     269                    continue 
    262270                os.remove(p_path) 
    263271            self.update_custom_combo() 
     
    361369                                   'Add a new model function') 
    362370        wx.EVT_MENU(owner, wx_id, self.make_new_model) 
    363          
     371 
    364372        wx_id = wx.NewId() 
    365373        self.edit_model_menu.Append(wx_id, 'Sum|Multi(p1, p2)', 
     
    383391          '(Re)Load all models present in user plugin_models folder') 
    384392        wx.EVT_MENU(owner, wx_id, self.load_plugin_models) 
    385                  
     393 
    386394    def set_edit_menu_helper(self, owner=None, menu=None): 
    387395        """ 
     
    17341742            @param unsmeared_error: data error, rescaled to unsmeared model 
    17351743        """ 
    1736              
    1737         number_finite = np.count_nonzero(np.isfinite(y))  
     1744 
     1745        number_finite = np.count_nonzero(np.isfinite(y)) 
    17381746        np.nan_to_num(y) 
    17391747        new_plot = self.create_theory_1D(x, y, page_id, model, data, state, 
     
    17941802            msg = "Computing Error: Model did not return any finite value." 
    17951803            wx.PostEvent(self.parent, StatusEvent(status = msg, info="error")) 
    1796         else:                  
     1804        else: 
    17971805            msg = "Computation  completed!" 
    17981806            if number_finite != y.size: 
     
    18241832        that can be plot. 
    18251833        """ 
    1826         number_finite = np.count_nonzero(np.isfinite(image))  
     1834        number_finite = np.count_nonzero(np.isfinite(image)) 
    18271835        np.nan_to_num(image) 
    18281836        new_plot = Data2D(image=image, err_image=data.err_data) 
     
    19271935                ## and may be the cause of other noted instabilities 
    19281936                ## 
    1929                 ##    -PDB August 12, 2014  
     1937                ##    -PDB August 12, 2014 
    19301938                while self.calc_2D.isrunning(): 
    19311939                    time.sleep(0.1) 
     
    19691977            if (self.calc_1D is not None) and self.calc_1D.isrunning(): 
    19701978                self.calc_1D.stop() 
    1971                 ## stop just raises the flag -- the thread is supposed to  
     1979                ## stop just raises the flag -- the thread is supposed to 
    19721980                ## then kill itself but cannot.  Paul Kienzle came up with 
    19731981                ## this fix to prevent threads from stepping on each other 
     
    19811989                ## a request to stop the computation. 
    19821990                ## It seems thus that the whole thread approach used here 
    1983                 ## May need rethinking   
     1991                ## May need rethinking 
    19841992                ## 
    19851993                ##    -PDB August 12, 2014 
     
    21462154            residuals.dxw = None 
    21472155            residuals.ytransform = 'y' 
    2148             # For latter scale changes  
     2156            # For latter scale changes 
    21492157            residuals.xaxis('\\rm{Q} ', 'A^{-1}') 
    21502158            residuals.yaxis('\\rm{Residuals} ', 'normalized') 
  • src/sas/sasgui/perspectives/fitting/models.py

    r8cec26b rb1c2011  
    186186            try: 
    187187                model = load_custom_model(path) 
    188                 model.name = PLUGIN_NAME_BASE + model.name 
     188                if not model.name.count(PLUGIN_NAME_BASE): 
     189                    model.name = PLUGIN_NAME_BASE + model.name 
    189190                plugins[model.name] = model 
    190191            except Exception: 
     
    297298        for name, plug in self.stored_plugins.iteritems(): 
    298299            self.model_dictionary[name] = plug 
    299          
     300 
    300301        self._get_multifunc_models() 
    301302 
  • src/sas/sasgui/perspectives/pr/inversion_panel.py

    r7432acb rcb62bd5  
    7070        self.rg_ctl = None 
    7171        self.iq0_ctl = None 
    72         self.bck_chk = None 
     72        self.bck_value = None 
     73        self.bck_est_ctl = None 
     74        self.bck_man_ctl = None 
     75        self.est_bck = True 
     76        self.bck_input = None 
    7377        self.bck_ctl = None 
    7478 
     
    312316        # Read the panel's parameters 
    313317        flag, alpha, dmax, nfunc, qmin, \ 
    314         qmax, height, width = self._read_pars() 
     318        qmax, height, width, bck = self._read_pars() 
    315319 
    316320        state.nfunc = nfunc 
     
    326330 
    327331        # Background evaluation checkbox 
    328         state.estimate_bck = self.bck_chk.IsChecked() 
     332        state.estimate_bck = self.est_bck 
     333        state.bck_value = bck 
    329334 
    330335        # Estimates 
     
    371376        self.plot_data.SetValue(str(state.file)) 
    372377 
    373         # Background evaluation checkbox 
    374         self.bck_chk.SetValue(state.estimate_bck) 
     378        # Background value 
     379        self.bck_est_ctl.SetValue(state.estimate_bck) 
     380        self.bck_man_ctl.SetValue(not state.estimate_bck) 
     381        if not state.estimate_bck: 
     382            self.bck_input.Enable() 
     383            self.bck_input.SetValue(str(state.bck_value)) 
     384        self.est_bck = state.estimate_bck 
     385        self.bck_value = state.bck_value 
    375386 
    376387        # Estimates 
     
    431442                       wx.EXPAND | wx.LEFT | wx.RIGHT | wx.ADJUST_MINSIZE, 15) 
    432443 
    433         self.bck_chk = wx.CheckBox(self, -1, "Estimate background level") 
    434         hint_msg = "Check box to let the fit estimate " 
    435         hint_msg += "the constant background level." 
    436         self.bck_chk.SetToolTipString(hint_msg) 
    437         self.bck_chk.Bind(wx.EVT_CHECKBOX, self._on_pars_changed) 
     444        radio_sizer = wx.GridBagSizer(5, 5) 
     445 
     446        self.bck_est_ctl = wx.RadioButton(self, -1, "Estimate background level", 
     447            name="estimate_bck", style=wx.RB_GROUP) 
     448        self.bck_man_ctl = wx.RadioButton(self, -1, "Input manual background level", 
     449            name="manual_bck") 
     450 
     451        self.bck_est_ctl.Bind(wx.EVT_RADIOBUTTON, self._on_bck_changed) 
     452        self.bck_man_ctl.Bind(wx.EVT_RADIOBUTTON, self._on_bck_changed) 
     453 
     454        radio_sizer.Add(self.bck_est_ctl, (0,0), (1,1), wx.LEFT | wx.EXPAND) 
     455        radio_sizer.Add(self.bck_man_ctl, (0,1), (1,1), wx.RIGHT | wx.EXPAND) 
     456 
    438457        iy += 1 
    439         pars_sizer.Add(self.bck_chk, (iy, 0), (1, 2), 
     458        pars_sizer.Add(radio_sizer, (iy, 0), (1, 2), 
    440459                       wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
     460 
     461        background_label = wx.StaticText(self, -1, "Background: ") 
     462        self.bck_input = PrTextCtrl(self, -1, style=wx.TE_PROCESS_ENTER, 
     463            size=(60, 20), value="0.0") 
     464        self.bck_input.Disable() 
     465        self.bck_input.Bind(wx.EVT_TEXT, self._read_pars) 
     466        background_units = wx.StaticText(self, -1, "[A^(-1)]", size=(55, 20)) 
     467        iy += 1 
     468 
     469        background_sizer = wx.GridBagSizer(5, 5) 
     470 
     471        background_sizer.Add(background_label, (0, 0), (1,1), 
     472            wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 23) 
     473        background_sizer.Add(self.bck_input, (0, 1), (1,1), 
     474            wx.LEFT | wx.ADJUST_MINSIZE, 5) 
     475        background_sizer.Add(background_units, (0, 2), (1,1), 
     476            wx.LEFT | wx.ADJUST_MINSIZE, 5) 
     477        pars_sizer.Add(background_sizer, (iy, 0), (1, 2), 
     478            wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
     479 
    441480        boxsizer1.Add(pars_sizer, 0, wx.EXPAND) 
    442481        vbox.Add(boxsizer1, (iy_vb, 0), (1, 1), 
     
    764803        self._on_pars_changed() 
    765804 
     805    def _on_bck_changed(self, evt=None): 
     806        self.est_bck = self.bck_est_ctl.GetValue() 
     807        if self.est_bck: 
     808            self.bck_input.Disable() 
     809        else: 
     810            self.bck_input.Enable() 
     811 
    766812    def _on_pars_changed(self, evt=None): 
    767813        """ 
     
    770816        scenes. 
    771817        """ 
    772         flag, alpha, dmax, nfunc, qmin, qmax, height, width = self._read_pars() 
    773         has_bck = self.bck_chk.IsChecked() 
     818        flag, alpha, dmax, nfunc, qmin, qmax, height, width, bck = self._read_pars() 
    774819 
    775820        # If the pars are valid, estimate alpha 
     
    783828                                                      d_max=dmax, 
    784829                                                      q_min=qmin, q_max=qmax, 
    785                                                       bck=has_bck, 
     830                                                      est_bck=self.est_bck, 
     831                                                      bck_val=bck, 
    786832                                                      height=height, 
    787833                                                      width=width) 
     
    797843        height = 0 
    798844        width = 0 
     845        background = 0 
    799846        flag = True 
    800847        # Read slit height 
     
    890937            self.qmax_ctl.Refresh() 
    891938 
    892         return flag, alpha, dmax, nfunc, qmin, qmax, height, width 
     939        # Read background 
     940        if not self.est_bck: 
     941            try: 
     942                bck_str = self.bck_input.GetValue() 
     943                if len(bck_str.strip()) == 0: 
     944                    background = 0.0 
     945                else: 
     946                    background = float(bck_str) 
     947                    self.bck_input.SetBackgroundColour(wx.WHITE) 
     948            except ValueError: 
     949                background = 0.0 
     950                self.bck_input.SetBackgroundColour("pink") 
     951            self.bck_input.Refresh() 
     952 
     953        return flag, alpha, dmax, nfunc, qmin, qmax, height, width, background 
    893954 
    894955    def _on_explore(self, evt): 
     
    915976        # Push it to the manager 
    916977 
    917         flag, alpha, dmax, nfunc, qmin, qmax, height, width = self._read_pars() 
    918         has_bck = self.bck_chk.IsChecked() 
     978        flag, alpha, dmax, nfunc, qmin, qmax, height, width, bck = self._read_pars() 
    919979 
    920980        if flag: 
     
    928988                                                   d_max=dmax, 
    929989                                                   q_min=qmin, q_max=qmax, 
    930                                                    bck=has_bck, 
     990                                                   est_bck=self.est_bck, 
     991                                                   bck_val = bck, 
    931992                                                   height=height, 
    932993                                                   width=width) 
  • src/sas/sasgui/perspectives/pr/inversion_state.py

    r7432acb ra0e6b1b  
    3636           ["qmin", "qmin"], 
    3737           ["qmax", "qmax"], 
    38            ["estimate_bck", "estimate_bck"]] 
     38           ["estimate_bck", "estimate_bck"], 
     39           ["bck_value", "bck_value"]] 
    3940 
    4041## List of P(r) inversion outputs 
     
    6263        self.estimate_bck = False 
    6364        self.timestamp = time.time() 
     65        self.bck_value = 0.0 
    6466 
    6567        # Inversion parameters 
     
    109111        state += "Timestamp:    %s\n" % self.timestamp 
    110112        state += "Estimate bck: %s\n" % str(self.estimate_bck) 
     113        state += "Bck Value:    %s\n" % str(self.bck_value) 
    111114        state += "No. terms:    %s\n" % str(self.nfunc) 
    112115        state += "D_max:        %s\n" % str(self.d_max) 
     
    296299                            self.coefficients.append(float(c)) 
    297300                        except: 
    298                             # Bad data, skip. We will count the number of  
    299                             # coefficients at the very end and deal with  
     301                            # Bad data, skip. We will count the number of 
     302                            # coefficients at the very end and deal with 
    300303                            # inconsistencies then. 
    301304                            pass 
     
    329332                                cov_row.append(float(c)) 
    330333                            except: 
    331                                 # Bad data, skip. We will count the number of  
    332                                 # coefficients at the very end and deal with  
     334                                # Bad data, skip. We will count the number of 
     335                                # coefficients at the very end and deal with 
    333336                                # inconsistencies then. 
    334337                                pass 
     
    461464                tree = etree.parse(path, parser=etree.ETCompatXMLParser()) 
    462465                # Check the format version number 
    463                 # Specifying the namespace will take care of the file  
    464                 #format version  
     466                # Specifying the namespace will take care of the file 
     467                #format version 
    465468                root = tree.getroot() 
    466469 
  • src/sas/sasgui/perspectives/pr/media/pr_help.rst

    r1221196 r1abd19c  
    4949P(r) inversion requires that the background be perfectly subtracted.  This is 
    5050often difficult to do well and thus many data sets will include a background. 
    51 For those cases, the user should check the "estimate background" box and the 
    52 module will do its best to estimate it. 
     51For those cases, the user should check the "Estimate background level" option 
     52and the module will do its best to estimate it. If you know the background value 
     53for your data, select the "Input manual background level" option. Note that 
     54this value will be treated as having 0 error. 
    5355 
    5456The P(r) module is constantly computing in the background what the optimum 
  • src/sas/sasgui/perspectives/pr/pr.py

    ra1b8fee rcb62bd5  
    6868        self.q_min = None 
    6969        self.q_max = None 
    70         self.has_bck = False 
     70        self.est_bck = False 
     71        self.bck_val = 0 
    7172        self.slit_height = 0 
    7273        self.slit_width = 0 
     
    828829        self.control_panel.iq0 = pr.iq0(out) 
    829830        self.control_panel.bck = pr.background 
     831        self.control_panel.bck_input.SetValue("{:.2g}".format(pr.background)) 
    830832 
    831833        # Show I(q) fit 
     
    907909 
    908910    def setup_plot_inversion(self, alpha, nfunc, d_max, q_min=None, q_max=None, 
    909                              bck=False, height=0, width=0): 
     911                             est_bck=False, bck_val=0, height=0, width=0): 
    910912        """ 
    911913            Set up inversion from plotted data 
     
    916918        self.q_min = q_min 
    917919        self.q_max = q_max 
    918         self.has_bck = bck 
     920        self.est_bck = est_bck 
     921        self.bck_val = bck_val 
    919922        self.slit_height = height 
    920923        self.slit_width = width 
     
    930933    def estimate_plot_inversion(self, alpha, nfunc, d_max, 
    931934                                q_min=None, q_max=None, 
    932                                 bck=False, height=0, width=0): 
     935                                est_bck=False, bck_val=0, height=0, width=0): 
    933936        """ 
    934937            Estimate parameters from plotted data 
     
    939942        self.q_min = q_min 
    940943        self.q_max = q_max 
    941         self.has_bck = bck 
     944        self.est_bck = est_bck 
     945        self.bck_val = bck_val 
    942946        self.slit_height = height 
    943947        self.slit_width = width 
     
    973977        pr.x = self.current_plottable.x 
    974978        pr.y = self.current_plottable.y 
    975         pr.has_bck = self.has_bck 
     979        pr.est_bck = self.est_bck 
    976980        pr.slit_height = self.slit_height 
    977981        pr.slit_width = self.slit_width 
     982        pr.background = self.bck_val 
    978983 
    979984        # Keep track of the plot window title to ensure that 
     
    10191024        self.q_min = q_min 
    10201025        self.q_max = q_max 
    1021         self.has_bck = bck 
     1026        self.est_bck = bck 
    10221027        self.slit_height = height 
    10231028        self.slit_width = width 
     
    10421047        self.q_min = q_min 
    10431048        self.q_max = q_max 
    1044         self.has_bck = bck 
     1049        self.est_bck = bck 
    10451050        self.slit_height = height 
    10461051        self.slit_width = width 
     
    11151120            pr.y = y 
    11161121            pr.err = err 
    1117             pr.has_bck = self.has_bck 
     1122            pr.est_bck = self.est_bck 
    11181123            pr.slit_height = self.slit_height 
    11191124            pr.slit_width = self.slit_width 
  • src/sas/sascalc/data_util/registry.py

    ra1b8fee r5a8cdbb  
    1 # This program is public domain 
    21""" 
    32File extension registry. 
     
    87from __future__ import print_function 
    98 
    10 import os.path 
     9from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException 
     10 
    1111 
    1212class ExtensionRegistry(object): 
     
    2222        # Add an association by setting an element 
    2323        registry['.zip'] = unzip 
    24          
     24 
    2525        # Multiple extensions for one loader 
    2626        registry['.tgz'] = untar 
    2727        registry['.tar.gz'] = untar 
    2828 
    29         # Generic extensions to use after trying more specific extensions;  
     29        # Generic extensions to use after trying more specific extensions; 
    3030        # these will be checked after the more specific extensions fail. 
    3131        registry['.gz'] = gunzip 
     
    3838        # Show registered extensions 
    3939        print registry.extensions() 
    40          
     40 
    4141        # Can also register a format name for explicit control from caller 
    4242        registry['cx3'] = cx3 
     
    6262    def __init__(self, **kw): 
    6363        self.loaders = {} 
     64 
    6465    def __setitem__(self, ext, loader): 
    6566        if ext not in self.loaders: 
    6667            self.loaders[ext] = [] 
    6768        self.loaders[ext].insert(0,loader) 
     69 
    6870    def __getitem__(self, ext): 
    6971        return self.loaders[ext] 
     72 
    7073    def __contains__(self, ext): 
    7174        return ext in self.loaders 
     75 
    7276    def formats(self): 
    7377        """ 
     
    7781        names.sort() 
    7882        return names 
     83 
    7984    def extensions(self): 
    8085        """ 
     
    8489        exts.sort() 
    8590        return exts 
     91 
    8692    def lookup(self, path): 
    8793        """ 
    8894        Return the loader associated with the file type of path. 
    89          
    90         Raises ValueError if file type is not known. 
    91         """         
     95 
     96        :param path: Data file path 
     97        :raises ValueError: When no loaders are found for the file. 
     98        :return: List of available readers for the file extension 
     99        """ 
    92100        # Find matching extensions 
    93101        extlist = [ext for ext in self.extensions() if path.endswith(ext)] 
     
    106114        # Raise an error if there are no matching extensions 
    107115        if len(loaders) == 0: 
    108             raise ValueError, "Unknown file type for "+path 
    109         # All done 
     116            raise ValueError("Unknown file type for "+path) 
    110117        return loaders 
     118 
    111119    def load(self, path, format=None): 
    112120        """ 
    113121        Call the loader for the file type of path. 
    114122 
    115         Raises ValueError if no loader is available. 
    116         Raises KeyError if format is not available. 
    117         May raise a loader-defined exception if loader fails.         
     123        :raise ValueError: if no loader is available. 
     124        :raise KeyError: if format is not available. 
     125        May raise a loader-defined exception if loader fails. 
    118126        """ 
     127        loaders = [] 
    119128        if format is None: 
    120             loaders = self.lookup(path) 
     129            try: 
     130                loaders = self.lookup(path) 
     131            except ValueError as e: 
     132                pass 
    121133        else: 
    122             loaders = self.loaders[format] 
     134            try: 
     135                loaders = self.loaders[format] 
     136            except KeyError as e: 
     137                pass 
     138        last_exc = None 
    123139        for fn in loaders: 
    124140            try: 
    125141                return fn(path) 
    126             except: 
    127                 pass # give other loaders a chance to succeed 
     142            except Exception as e: 
     143                last_exc = e 
     144                pass  # give other loaders a chance to succeed 
    128145        # If we get here it is because all loaders failed 
    129         raise # reraises last exception 
    130  
    131 def test(): 
    132     reg = ExtensionRegistry() 
    133     class CxError(Exception): pass 
    134     def cx(file): return 'cx' 
    135     def new_cx(file): return 'new_cx' 
    136     def fail_cx(file): raise CxError 
    137     def cat(file): return 'cat' 
    138     def gunzip(file): return 'gunzip' 
    139     reg['.cx'] = cx 
    140     reg['.cx1'] = cx 
    141     reg['.cx'] = new_cx 
    142     reg['.gz'] = gunzip 
    143     reg['.cx.gz'] = new_cx 
    144     reg['.cx1.gz'] = fail_cx 
    145     reg['.cx1'] = fail_cx 
    146     reg['.cx2'] = fail_cx 
    147     reg['new_cx'] = new_cx 
    148  
    149     # Two loaders associated with .cx 
    150     assert reg.lookup('hello.cx') == [new_cx,cx] 
    151     # Make sure the last loader applies first 
    152     assert reg.load('hello.cx') == 'new_cx' 
    153     # Make sure the next loader applies if the first fails 
    154     assert reg.load('hello.cx1') == 'cx' 
    155     # Make sure the format override works 
    156     assert reg.load('hello.cx1',format='.cx.gz') == 'new_cx' 
    157     # Make sure the format override works 
    158     assert reg.load('hello.cx1',format='new_cx') == 'new_cx' 
    159     # Make sure the case of all loaders failing is correct 
    160     try:  reg.load('hello.cx2') 
    161     except CxError: pass # correct failure 
    162     else: raise AssertError,"Incorrect error on load failure" 
    163     # Make sure the case of no loaders fails correctly 
    164     try: reg.load('hello.missing') 
    165     except ValueError,msg: 
    166         assert str(msg)=="Unknown file type for hello.missing",'Message: <%s>'%(msg) 
    167     else: raise AssertError,"No error raised for missing extension" 
    168     assert reg.formats() == ['new_cx'] 
    169     assert reg.extensions() == ['.cx','.cx.gz','.cx1','.cx1.gz','.cx2','.gz'] 
    170     # make sure that it supports multiple '.' in filename 
    171     assert reg.load('hello.extra.cx1') == 'cx' 
    172     assert reg.load('hello.gz') == 'gunzip' 
    173     assert reg.load('hello.cx1.gz') == 'gunzip' # Since .cx1.gz fails 
    174  
    175 if __name__ == "__main__": test() 
     146        if last_exc is not None and len(loaders) != 0: 
     147            # If file has associated loader(s) and they;ve failed 
     148            raise last_exc 
     149        raise NoKnownLoaderException(e.message)  # raise generic exception 
  • src/sas/sascalc/dataloader/data_info.py

    ra1b8fee r5a8cdbb  
    11811181        return return_string 
    11821182 
    1183     final_dataset.xmax = data.xmax 
    1184     final_dataset.ymax = data.ymax 
    1185     final_dataset.xmin = data.xmin 
    1186     final_dataset.ymin = data.ymin 
     1183    if hasattr(data, "xmax"): 
     1184        final_dataset.xmax = data.xmax 
     1185    if hasattr(data, "ymax"): 
     1186        final_dataset.ymax = data.ymax 
     1187    if hasattr(data, "xmin"): 
     1188        final_dataset.xmin = data.xmin 
     1189    if hasattr(data, "ymin"): 
     1190        final_dataset.ymin = data.ymin 
    11871191    final_dataset.isSesans = datainfo.isSesans 
    11881192    final_dataset.title = datainfo.title 
  • src/sas/sascalc/dataloader/loader.py

    r463e7ffc r3a81cd9  
    11""" 
    22    File handler to support different file extensions. 
    3     Uses reflectometry's registry utility. 
     3    Uses reflectometer registry utility. 
    44 
    55    The default readers are found in the 'readers' sub-module 
     
    1414""" 
    1515##################################################################### 
    16 #This software was developed by the University of Tennessee as part of the 
    17 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    18 #project funded by the US National Science Foundation. 
    19 #See the license text in license.txt 
    20 #copyright 2008, University of Tennessee 
     16# This software was developed by the University of Tennessee as part of the 
     17# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     18# project funded by the US National Science Foundation. 
     19# See the license text in license.txt 
     20# copyright 2008, University of Tennessee 
    2121###################################################################### 
    2222 
     
    2929# Default readers are defined in the readers sub-module 
    3030import readers 
     31from loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
     32    DefaultReaderException 
    3133from readers import ascii_reader 
    3234from readers import cansas_reader 
     35from readers import cansas_reader_HDF5 
    3336 
    3437logger = logging.getLogger(__name__) 
     38 
    3539 
    3640class Registry(ExtensionRegistry): 
     
    3943    Readers and writers are supported. 
    4044    """ 
    41  
    4245    def __init__(self): 
    4346        super(Registry, self).__init__() 
    4447 
    45         ## Writers 
     48        # Writers 
    4649        self.writers = {} 
    4750 
    48         ## List of wildcards 
     51        # List of wildcards 
    4952        self.wildcards = ['All (*.*)|*.*'] 
    5053 
    51         ## Creation time, for testing 
     54        # Creation time, for testing 
    5255        self._created = time.time() 
    5356 
     
    6366            of a particular reader 
    6467 
    65         Defaults to the ascii (multi-column) reader 
    66         if no reader was registered for the file's 
    67         extension. 
     68        Defaults to the ascii (multi-column), cansas XML, and cansas NeXuS 
     69        readers if no reader was registered for the file's extension. 
    6870        """ 
    6971        try: 
    7072            return super(Registry, self).load(path, format=format) 
    71         except: 
    72             try: 
    73                 # No reader was found. Default to the ascii reader. 
    74                 ascii_loader = ascii_reader.Reader() 
    75                 return ascii_loader.read(path) 
    76             except: 
    77                 cansas_loader = cansas_reader.Reader() 
    78                 return cansas_loader.read(path) 
     73        except NoKnownLoaderException as nkl_e: 
     74            pass  # try the ASCII reader 
     75        except FileContentsException as fc_exc: 
     76            # File has an associated reader but it failed 
     77            raise RuntimeError(fc_exc.message) 
     78        except Exception: 
     79            pass 
     80 
     81        # File has no associated reader - try the ASCII reader 
     82        try: 
     83            ascii_loader = ascii_reader.Reader() 
     84            return ascii_loader.read(path) 
     85        except DefaultReaderException: 
     86            pass  # Loader specific error to try the cansas XML reader 
     87        except FileContentsException as e: 
     88            raise RuntimeError(e.message) 
     89 
     90        # ASCII reader failed - try CanSAS xML reader 
     91        try: 
     92            cansas_loader = cansas_reader.Reader() 
     93            return cansas_loader.read(path) 
     94        except DefaultReaderException: 
     95            pass  # Loader specific error to try the NXcanSAS reader 
     96        except FileContentsException as e: 
     97            raise RuntimeError(e.message) 
     98        except Exception as csr: 
     99            pass 
     100 
     101        # CanSAS XML reader failed - try NXcanSAS reader 
     102        try: 
     103            cansas_nexus_loader = cansas_reader_HDF5.Reader() 
     104            return cansas_nexus_loader.read(path) 
     105        except DefaultReaderException as e: 
     106            logging.error("No default loader can load the data") 
     107            # No known reader available. Give up and throw an error 
     108            msg = "\n\tUnknown data format: %s.\n\tThe file is not a " % path 
     109            msg += "known format that can be loaded by SasView.\n" 
     110            raise NoKnownLoaderException(msg) 
     111        except FileContentsException as e: 
     112            raise RuntimeError(e.message) 
    79113 
    80114    def find_plugins(self, dir): 
  • src/sas/sascalc/dataloader/readers/__init__.py

    r959eb01 r7a5d066  
    1 # Backward compatibility with the previous implementation of the default readers 
    2 from associations import register_readers 
     1# Method to associate extensions to default readers 
     2from associations import read_associations 
    33 
    4 # Method to associate extensions to default readers  
    5 from associations import read_associations 
    64 
    75# Method to return the location of the XML settings file 
  • src/sas/sascalc/dataloader/readers/abs_reader.py

    r959eb01 rad92c5a  
    11""" 
     2    IGOR 1D data reader 
    23""" 
    34##################################################################### 
    4 #This software was developed by the University of Tennessee as part of the 
    5 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    6 #project funded by the US National Science Foundation. 
    7 #See the license text in license.txt 
    8 #copyright 2008, University of Tennessee 
     5# This software was developed by the University of Tennessee as part of the 
     6# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     7# project funded by the US National Science Foundation. 
     8# See the license text in license.txt 
     9# copyright 2008, University of Tennessee 
    910###################################################################### 
    1011 
     12import logging 
    1113import numpy as np 
    12 import os 
    13 from sas.sascalc.dataloader.data_info import Data1D 
    14 from sas.sascalc.dataloader.data_info import Detector 
    15  
    16 has_converter = True 
    17 try: 
    18     from sas.sascalc.data_util.nxsunit import Converter 
    19 except: 
    20     has_converter = False 
    21      
    22      
    23 class Reader: 
     14from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     15from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D, Data1D,\ 
     16    Detector 
     17from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
     18    DefaultReaderException 
     19 
     20logger = logging.getLogger(__name__) 
     21 
     22 
     23class Reader(FileReader): 
    2424    """ 
    2525    Class to load IGOR reduced .ABS files 
    2626    """ 
    27     ## File type 
     27    # File type 
    2828    type_name = "IGOR 1D" 
    29     ## Wildcards 
     29    # Wildcards 
    3030    type = ["IGOR 1D files (*.abs)|*.abs"] 
    31     ## List of allowed extensions 
    32     ext = ['.abs', '.ABS'] 
     31    # List of allowed extensions 
     32    ext = ['.abs'] 
    3333     
    34     def read(self, path): 
     34    def get_file_contents(self): 
    3535        """  
    36         Load data file. 
    37          
    38         :param path: file path 
    39          
    40         :return: Data1D object, or None 
     36        Get the contents of the file 
    4137         
    4238        :raise RuntimeError: when the file can't be opened 
    4339        :raise ValueError: when the length of the data vectors are inconsistent 
    4440        """ 
    45         if os.path.isfile(path): 
    46             basename = os.path.basename(path) 
    47             root, extension = os.path.splitext(basename) 
    48             if extension.lower() in self.ext: 
    49                 try: 
    50                     input_f = open(path,'r') 
     41        buff = self.f_open.read() 
     42        filepath = self.f_open.name 
     43        lines = buff.splitlines() 
     44        self.has_converter = True 
     45        try: 
     46            from sas.sascalc.data_util.nxsunit import Converter 
     47        except: 
     48            self.has_converter = False 
     49        self.output = [] 
     50        self.current_datainfo = DataInfo() 
     51        self.current_datainfo.filename = filepath 
     52        self.reset_data_list(len(lines)) 
     53        detector = Detector() 
     54        data_line = 0 
     55        self.reset_data_list(len(lines)) 
     56        self.current_datainfo.detector.append(detector) 
     57        self.current_datainfo.filename = filepath 
     58 
     59        is_info = False 
     60        is_center = False 
     61        is_data_started = False 
     62 
     63        base_q_unit = '1/A' 
     64        base_i_unit = '1/cm' 
     65        data_conv_q = Converter(base_q_unit) 
     66        data_conv_i = Converter(base_i_unit) 
     67 
     68        for line in lines: 
     69            # Information line 1 
     70            if is_info: 
     71                is_info = False 
     72                line_toks = line.split() 
     73 
     74                # Wavelength in Angstrom 
     75                try: 
     76                    value = float(line_toks[1]) 
     77                    if self.has_converter and \ 
     78                            self.current_datainfo.source.wavelength_unit != 'A': 
     79                        conv = Converter('A') 
     80                        self.current_datainfo.source.wavelength = conv(value, 
     81                            units=self.current_datainfo.source.wavelength_unit) 
     82                    else: 
     83                        self.current_datainfo.source.wavelength = value 
     84                except KeyError: 
     85                    msg = "ABSReader cannot read wavelength from %s" % filepath 
     86                    self.current_datainfo.errors.append(msg) 
     87 
     88                # Detector distance in meters 
     89                try: 
     90                    value = float(line_toks[3]) 
     91                    if self.has_converter and detector.distance_unit != 'm': 
     92                        conv = Converter('m') 
     93                        detector.distance = conv(value, 
     94                                        units=detector.distance_unit) 
     95                    else: 
     96                        detector.distance = value 
    5197                except: 
    52                     raise  RuntimeError, "abs_reader: cannot open %s" % path 
    53                 buff = input_f.read() 
    54                 lines = buff.split('\n') 
    55                 x  = np.zeros(0) 
    56                 y  = np.zeros(0) 
    57                 dy = np.zeros(0) 
    58                 dx = np.zeros(0) 
    59                 output = Data1D(x, y, dy=dy, dx=dx) 
    60                 detector = Detector() 
    61                 output.detector.append(detector) 
    62                 output.filename = basename 
    63                  
    64                 is_info = False 
     98                    msg = "ABSReader cannot read SDD from %s" % filepath 
     99                    self.current_datainfo.errors.append(msg) 
     100 
     101                # Transmission 
     102                try: 
     103                    self.current_datainfo.sample.transmission = \ 
     104                        float(line_toks[4]) 
     105                except ValueError: 
     106                    # Transmission isn't always in the header 
     107                    pass 
     108 
     109                # Sample thickness in mm 
     110                try: 
     111                    value = float(line_toks[5]) 
     112                    if self.has_converter and \ 
     113                            self.current_datainfo.sample.thickness_unit != 'cm': 
     114                        conv = Converter('cm') 
     115                        self.current_datainfo.sample.thickness = conv(value, 
     116                            units=self.current_datainfo.sample.thickness_unit) 
     117                    else: 
     118                        self.current_datainfo.sample.thickness = value 
     119                except ValueError: 
     120                    # Thickness is not a mandatory entry 
     121                    pass 
     122 
     123            # MON CNT  LAMBDA  DET ANG  DET DIST  TRANS  THICK  AVE   STEP 
     124            if line.count("LAMBDA") > 0: 
     125                is_info = True 
     126 
     127            # Find center info line 
     128            if is_center: 
    65129                is_center = False 
    66                 is_data_started = False 
    67                  
    68                 data_conv_q = None 
    69                 data_conv_i = None 
    70                  
    71                 if has_converter == True and output.x_unit != '1/A': 
    72                     data_conv_q = Converter('1/A') 
    73                     # Test it 
    74                     data_conv_q(1.0, output.x_unit) 
    75                      
    76                 if has_converter == True and output.y_unit != '1/cm': 
    77                     data_conv_i = Converter('1/cm') 
    78                     # Test it 
    79                     data_conv_i(1.0, output.y_unit) 
    80                  
    81                 for line in lines: 
    82                      
    83                     # Information line 1 
    84                     if is_info == True: 
    85                         is_info = False 
    86                         line_toks = line.split() 
    87                          
    88                         # Wavelength in Angstrom 
    89                         try: 
    90                             value = float(line_toks[1]) 
    91                             if has_converter == True and \ 
    92                                 output.source.wavelength_unit != 'A': 
    93                                 conv = Converter('A') 
    94                                 output.source.wavelength = conv(value, 
    95                                         units=output.source.wavelength_unit) 
    96                             else: 
    97                                 output.source.wavelength = value 
    98                         except: 
    99                             #goes to ASC reader 
    100                             msg = "abs_reader: cannot open %s" % path 
    101                             raise  RuntimeError, msg 
    102                          
    103                         # Distance in meters 
    104                         try: 
    105                             value = float(line_toks[3]) 
    106                             if has_converter == True and \ 
    107                                 detector.distance_unit != 'm': 
    108                                 conv = Converter('m') 
    109                                 detector.distance = conv(value, 
    110                                                 units=detector.distance_unit) 
    111                             else: 
    112                                 detector.distance = value 
    113                         except: 
    114                             #goes to ASC reader 
    115                             msg = "abs_reader: cannot open %s" % path 
    116                             raise  RuntimeError, msg 
    117                         # Transmission 
    118                         try: 
    119                             output.sample.transmission = float(line_toks[4]) 
    120                         except: 
    121                             # Transmission is not a mandatory entry 
    122                             pass 
    123                      
    124                         # Thickness in mm 
    125                         try: 
    126                             value = float(line_toks[5]) 
    127                             if has_converter == True and \ 
    128                                 output.sample.thickness_unit != 'cm': 
    129                                 conv = Converter('cm') 
    130                                 output.sample.thickness = conv(value, 
    131                                             units=output.sample.thickness_unit) 
    132                             else: 
    133                                 output.sample.thickness = value 
    134                         except: 
    135                             # Thickness is not a mandatory entry 
    136                             pass 
    137                      
    138                     #MON CNT   LAMBDA   DET ANG   DET DIST   TRANS   THICK  
    139                     #  AVE   STEP 
    140                     if line.count("LAMBDA") > 0: 
    141                         is_info = True 
    142                          
    143                     # Find center info line 
    144                     if is_center == True: 
    145                         is_center = False 
    146                         line_toks = line.split() 
    147                         # Center in bin number 
    148                         center_x = float(line_toks[0]) 
    149                         center_y = float(line_toks[1]) 
    150                          
    151                         # Bin size 
    152                         if has_converter == True and \ 
    153                             detector.pixel_size_unit != 'mm': 
    154                             conv = Converter('mm') 
    155                             detector.pixel_size.x = conv(5.0, 
    156                                                 units=detector.pixel_size_unit) 
    157                             detector.pixel_size.y = conv(5.0, 
    158                                                 units=detector.pixel_size_unit) 
    159                         else: 
    160                             detector.pixel_size.x = 5.0 
    161                             detector.pixel_size.y = 5.0 
    162                          
    163                         # Store beam center in distance units 
    164                         # Det 640 x 640 mm 
    165                         if has_converter == True and \ 
    166                             detector.beam_center_unit != 'mm': 
    167                             conv = Converter('mm') 
    168                             detector.beam_center.x = conv(center_x * 5.0, 
    169                                              units=detector.beam_center_unit) 
    170                             detector.beam_center.y = conv(center_y * 5.0, 
    171                                             units=detector.beam_center_unit) 
    172                         else: 
    173                             detector.beam_center.x = center_x * 5.0 
    174                             detector.beam_center.y = center_y * 5.0 
    175                          
    176                         # Detector type 
    177                         try: 
    178                             detector.name = line_toks[7] 
    179                         except: 
    180                             # Detector name is not a mandatory entry 
    181                             pass 
    182                      
    183                     #BCENT(X,Y)   A1(mm)   A2(mm)   A1A2DIST(m)   DL/L 
    184                     #  BSTOP(mm)   DET_TYP 
    185                     if line.count("BCENT") > 0: 
    186                         is_center = True 
    187                          
    188                     # Parse the data 
    189                     if is_data_started == True: 
    190                         toks = line.split() 
    191  
    192                         try: 
    193                             _x  = float(toks[0]) 
    194                             _y  = float(toks[1]) 
    195                             _dy = float(toks[2]) 
    196                             _dx = float(toks[3]) 
    197                              
    198                             if data_conv_q is not None: 
    199                                 _x = data_conv_q(_x, units=output.x_unit) 
    200                                 _dx = data_conv_i(_dx, units=output.x_unit) 
    201                                  
    202                             if data_conv_i is not None: 
    203                                 _y = data_conv_i(_y, units=output.y_unit) 
    204                                 _dy = data_conv_i(_dy, units=output.y_unit) 
    205                             
    206                             x = np.append(x, _x) 
    207                             y = np.append(y, _y) 
    208                             dy = np.append(dy, _dy) 
    209                             dx = np.append(dx, _dx) 
    210                              
    211                         except: 
    212                             # Could not read this data line. If we are here 
    213                             # it is because we are in the data section. Just 
    214                             # skip it. 
    215                             pass 
    216                              
    217                     #The 6 columns are | Q (1/A) | I(Q) (1/cm) | std. dev. 
    218                     # I(Q) (1/cm) | sigmaQ | meanQ | ShadowFactor| 
    219                     if line.count("The 6 columns") > 0: 
    220                         is_data_started = True 
    221              
    222                 # Sanity check 
    223                 if not len(y) == len(dy): 
    224                     msg = "abs_reader: y and dy have different length" 
    225                     raise ValueError, msg 
    226                 # If the data length is zero, consider this as 
    227                 # though we were not able to read the file. 
    228                 if len(x) == 0: 
    229                     raise ValueError, "ascii_reader: could not load file" 
    230                  
    231                 output.x = x[x != 0] 
    232                 output.y = y[x != 0] 
    233                 output.dy = dy[x != 0] 
    234                 output.dx = dx[x != 0] 
    235                 if data_conv_q is not None: 
    236                     output.xaxis("\\rm{Q}", output.x_unit) 
     130                line_toks = line.split() 
     131                # Center in bin number 
     132                center_x = float(line_toks[0]) 
     133                center_y = float(line_toks[1]) 
     134 
     135                # Bin size 
     136                if self.has_converter and detector.pixel_size_unit != 'mm': 
     137                    conv = Converter('mm') 
     138                    detector.pixel_size.x = conv(5.08, 
     139                                        units=detector.pixel_size_unit) 
     140                    detector.pixel_size.y = conv(5.08, 
     141                                        units=detector.pixel_size_unit) 
    237142                else: 
    238                     output.xaxis("\\rm{Q}", 'A^{-1}') 
    239                 if data_conv_i is not None: 
    240                     output.yaxis("\\rm{Intensity}", output.y_unit) 
     143                    detector.pixel_size.x = 5.08 
     144                    detector.pixel_size.y = 5.08 
     145 
     146                # Store beam center in distance units 
     147                # Det 640 x 640 mm 
     148                if self.has_converter and detector.beam_center_unit != 'mm': 
     149                    conv = Converter('mm') 
     150                    detector.beam_center.x = conv(center_x * 5.08, 
     151                                     units=detector.beam_center_unit) 
     152                    detector.beam_center.y = conv(center_y * 5.08, 
     153                                    units=detector.beam_center_unit) 
    241154                else: 
    242                     output.yaxis("\\rm{Intensity}", "cm^{-1}") 
    243                      
    244                 # Store loading process information 
    245                 output.meta_data['loader'] = self.type_name 
    246                 return output 
     155                    detector.beam_center.x = center_x * 5.08 
     156                    detector.beam_center.y = center_y * 5.08 
     157 
     158                # Detector type 
     159                try: 
     160                    detector.name = line_toks[7] 
     161                except: 
     162                    # Detector name is not a mandatory entry 
     163                    pass 
     164 
     165            # BCENT(X,Y)  A1(mm)  A2(mm)  A1A2DIST(m)  DL/L  BSTOP(mm)  DET_TYP 
     166            if line.count("BCENT") > 0: 
     167                is_center = True 
     168 
     169            # Parse the data 
     170            if is_data_started: 
     171                toks = line.split() 
     172 
     173                try: 
     174                    _x = float(toks[0]) 
     175                    _y = float(toks[1]) 
     176                    _dy = float(toks[2]) 
     177                    _dx = float(toks[3]) 
     178 
     179                    if data_conv_q is not None: 
     180                        _x = data_conv_q(_x, units=base_q_unit) 
     181                        _dx = data_conv_q(_dx, units=base_q_unit) 
     182 
     183                    if data_conv_i is not None: 
     184                        _y = data_conv_i(_y, units=base_i_unit) 
     185                        _dy = data_conv_i(_dy, units=base_i_unit) 
     186 
     187                    self.current_dataset.x[data_line] = _x 
     188                    self.current_dataset.y[data_line] = _y 
     189                    self.current_dataset.dy[data_line] = _dy 
     190                    self.current_dataset.dx[data_line] = _dx 
     191                    data_line += 1 
     192 
     193                except ValueError: 
     194                    # Could not read this data line. If we are here 
     195                    # it is because we are in the data section. Just 
     196                    # skip it. 
     197                    pass 
     198 
     199            # The 6 columns are | Q (1/A) | I(Q) (1/cm) | std. dev. 
     200            # I(Q) (1/cm) | sigmaQ | meanQ | ShadowFactor| 
     201            if line.count("The 6 columns") > 0: 
     202                is_data_started = True 
     203 
     204        self.remove_empty_q_values(True, True) 
     205 
     206        # Sanity check 
     207        if not len(self.current_dataset.y) == len(self.current_dataset.dy): 
     208            self.set_all_to_none() 
     209            msg = "abs_reader: y and dy have different length" 
     210            raise ValueError(msg) 
     211        # If the data length is zero, consider this as 
     212        # though we were not able to read the file. 
     213        if len(self.current_dataset.x) == 0: 
     214            self.set_all_to_none() 
     215            raise ValueError("ascii_reader: could not load file") 
     216 
     217        if data_conv_q is not None: 
     218            self.current_dataset.xaxis("\\rm{Q}", base_q_unit) 
    247219        else: 
    248             raise RuntimeError, "%s is not a file" % path 
    249         return None 
     220            self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
     221        if data_conv_i is not None: 
     222            self.current_dataset.yaxis("\\rm{Intensity}", base_i_unit) 
     223        else: 
     224            self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
     225 
     226        # Store loading process information 
     227        self.current_datainfo.meta_data['loader'] = self.type_name 
     228        self.send_to_output() 
  • src/sas/sascalc/dataloader/readers/anton_paar_saxs_reader.py

    ra235f715 rfafe52a  
    99 
    1010from sas.sascalc.dataloader.readers.xml_reader import XMLreader 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, Data1D, Sample, Source 
     11from sas.sascalc.dataloader.data_info import plottable_1D, Data1D, DataInfo, Sample, Source 
    1212from sas.sascalc.dataloader.data_info import Process, Aperture, Collimation, TransmissionSpectrum, Detector 
    13  
     13from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
    1414 
    1515class Reader(XMLreader): 
    1616    """ 
    17     A class for reading in CanSAS v2.0 data files. The existing iteration opens Mantid generated HDF5 formatted files 
    18     with file extension .h5/.H5. Any number of data sets may be present within the file and any dimensionality of data 
    19     may be used. Currently 1D and 2D SAS data sets are supported, but future implementations will include 1D and 2D 
    20     SESANS data. This class assumes a single data set for each sasentry. 
    21  
    22     :Dependencies: 
    23         The CanSAS HDF5 reader requires h5py v2.5.0 or later. 
     17    A class for reading in Anton Paar .pdh files 
    2418    """ 
    2519 
     
    3024    ## Raw file contents to be processed 
    3125    raw_data = None 
    32     ## Data set being modified 
    33     current_dataset = None 
    3426    ## For recursion and saving purposes, remember parent objects 
    3527    parent_list = None 
     
    4234    ## Flag to bypass extension check 
    4335    allow_all = False 
    44     ## List of files to return 
    45     output = None 
    4636 
    4737    def reset_state(self): 
    48         self.current_dataset = Data1D(np.empty(0), np.empty(0), 
    49                                             np.empty(0), np.empty(0)) 
     38        self.current_dataset = plottable_1D(np.empty(0), np.empty(0), np.empty(0), np.empty(0)) 
     39        self.current_datainfo = DataInfo() 
    5040        self.datasets = [] 
    5141        self.raw_data = None 
     
    6353        self.lower = 5 
    6454 
    65     def read(self, filename): 
     55    def get_file_contents(self): 
    6656        """ 
    6757            This is the general read method that all SasView data_loaders must have. 
     
    7363        ## Reinitialize the class when loading a new data file to reset all class variables 
    7464        self.reset_state() 
    75         ## Check that the file exists 
    76         if os.path.isfile(filename): 
    77             basename = os.path.basename(filename) 
    78             _, extension = os.path.splitext(basename) 
    79             # If the file type is not allowed, return empty list 
    80             if extension in self.ext or self.allow_all: 
    81                 ## Load the data file 
    82                 input_f = open(filename, 'r') 
    83                 buff = input_f.read() 
    84                 self.raw_data = buff.splitlines() 
    85                 self.read_data() 
    86         return self.output 
     65        buff = self.f_open.read() 
     66        self.raw_data = buff.splitlines() 
     67        self.read_data() 
    8768 
    8869    def read_data(self): 
     70        correctly_loaded = True 
     71        error_message = "" 
     72 
    8973        q_unit = "1/nm" 
    9074        i_unit = "1/um^2" 
    91         self.current_dataset.title = self.raw_data[0] 
    92         self.current_dataset.meta_data["Keywords"] = self.raw_data[1] 
    93         line3 = self.raw_data[2].split() 
    94         line4 = self.raw_data[3].split() 
    95         line5 = self.raw_data[4].split() 
    96         self.data_points = int(line3[0]) 
    97         self.lower = 5 
    98         self.upper = self.lower + self.data_points 
    99         self.source.radiation = 'x-ray' 
    100         normal = float(line4[3]) 
    101         self.current_dataset.source.radiation = "x-ray" 
    102         self.current_dataset.source.name = "Anton Paar SAXSess Instrument" 
    103         self.current_dataset.source.wavelength = float(line4[4]) 
    104         xvals = [] 
    105         yvals = [] 
    106         dyvals = [] 
    107         for i in range(self.lower, self.upper): 
    108             index = i - self.lower 
    109             data = self.raw_data[i].split() 
    110             xvals.insert(index, normal * float(data[0])) 
    111             yvals.insert(index, normal * float(data[1])) 
    112             dyvals.insert(index, normal * float(data[2])) 
     75        try: 
     76            self.current_datainfo.title = self.raw_data[0] 
     77            self.current_datainfo.meta_data["Keywords"] = self.raw_data[1] 
     78            line3 = self.raw_data[2].split() 
     79            line4 = self.raw_data[3].split() 
     80            line5 = self.raw_data[4].split() 
     81            self.data_points = int(line3[0]) 
     82            self.lower = 5 
     83            self.upper = self.lower + self.data_points 
     84            self.source.radiation = 'x-ray' 
     85            normal = float(line4[3]) 
     86            self.current_datainfo.source.radiation = "x-ray" 
     87            self.current_datainfo.source.name = "Anton Paar SAXSess Instrument" 
     88            self.current_datainfo.source.wavelength = float(line4[4]) 
     89            xvals = [] 
     90            yvals = [] 
     91            dyvals = [] 
     92            for i in range(self.lower, self.upper): 
     93                index = i - self.lower 
     94                data = self.raw_data[i].split() 
     95                xvals.insert(index, normal * float(data[0])) 
     96                yvals.insert(index, normal * float(data[1])) 
     97                dyvals.insert(index, normal * float(data[2])) 
     98        except Exception as e: 
     99            error_message = "Couldn't load {}.\n".format(self.f_open.name) 
     100            error_message += e.message 
     101            raise FileContentsException(error_message) 
    113102        self.current_dataset.x = np.append(self.current_dataset.x, xvals) 
    114103        self.current_dataset.y = np.append(self.current_dataset.y, yvals) 
    115104        self.current_dataset.dy = np.append(self.current_dataset.dy, dyvals) 
    116105        if self.data_points != self.current_dataset.x.size: 
    117             self.errors.add("Not all data was loaded properly.") 
    118         if self.current_dataset.dx.size != self.current_dataset.x.size: 
    119             dxvals = np.zeros(self.current_dataset.x.size) 
    120             self.current_dataset.dx = dxvals 
     106            error_message += "Not all data points could be loaded.\n" 
     107            correctly_loaded = False 
    121108        if self.current_dataset.x.size != self.current_dataset.y.size: 
    122             self.errors.add("The x and y data sets are not the same size.") 
     109            error_message += "The x and y data sets are not the same size.\n" 
     110            correctly_loaded = False 
    123111        if self.current_dataset.y.size != self.current_dataset.dy.size: 
    124             self.errors.add("The y and dy datasets are not the same size.") 
    125         self.current_dataset.errors = self.errors 
     112            error_message += "The y and dy datasets are not the same size.\n" 
     113            correctly_loaded = False 
     114 
    126115        self.current_dataset.xaxis("Q", q_unit) 
    127116        self.current_dataset.yaxis("Intensity", i_unit) 
    128117        xml_intermediate = self.raw_data[self.upper:] 
    129118        xml = ''.join(xml_intermediate) 
    130         self.set_xml_string(xml) 
    131         dom = self.xmlroot.xpath('/fileinfo') 
    132         self._parse_child(dom) 
    133         self.output.append(self.current_dataset) 
     119        try: 
     120            self.set_xml_string(xml) 
     121            dom = self.xmlroot.xpath('/fileinfo') 
     122            self._parse_child(dom) 
     123        except Exception as e: 
     124            # Data loaded but XML metadata has an error 
     125            error_message += "Data points have been loaded but there was an " 
     126            error_message += "error reading XML metadata: " + e.message 
     127            correctly_loaded = False 
     128        self.send_to_output() 
     129        if not correctly_loaded: 
     130            raise DataReaderException(error_message) 
    134131 
    135132    def _parse_child(self, dom, parent=''): 
     
    146143                self._parse_child(node, key) 
    147144                if key == "SampleDetector": 
    148                     self.current_dataset.detector.append(self.detector) 
     145                    self.current_datainfo.detector.append(self.detector) 
    149146                    self.detector = Detector() 
    150147            else: 
    151148                if key == "value": 
    152149                    if parent == "Wavelength": 
    153                         self.current_dataset.source.wavelength = value 
     150                        self.current_datainfo.source.wavelength = value 
    154151                    elif parent == "SampleDetector": 
    155152                        self.detector.distance = value 
    156153                    elif parent == "Temperature": 
    157                         self.current_dataset.sample.temperature = value 
     154                        self.current_datainfo.sample.temperature = value 
    158155                    elif parent == "CounterSlitLength": 
    159156                        self.detector.slit_length = value 
     
    161158                    value = value.replace("_", "") 
    162159                    if parent == "Wavelength": 
    163                         self.current_dataset.source.wavelength_unit = value 
     160                        self.current_datainfo.source.wavelength_unit = value 
    164161                    elif parent == "SampleDetector": 
    165162                        self.detector.distance_unit = value 
     
    169166                        self.current_dataset.yaxis(self.current_dataset._yaxis, value) 
    170167                    elif parent == "Temperature": 
    171                         self.current_dataset.sample.temperature_unit = value 
     168                        self.current_datainfo.sample.temperature_unit = value 
    172169                    elif parent == "CounterSlitLength": 
    173170                        self.detector.slit_length_unit = value 
  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    r235f514 rf994e8b1  
    11""" 
    2     ASCII reader 
     2    Generic multi-column ASCII data reader 
    33""" 
    44############################################################################ 
    5 #This software was developed by the University of Tennessee as part of the 
    6 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation.  
    8 #If you use DANSE applications to do scientific research that leads to 
    9 #publication, we ask that you acknowledge the use of the software with the 
    10 #following sentence: 
    11 #This work benefited from DANSE software developed under NSF award DMR-0520547. 
    12 #copyright 2008, University of Tennessee 
     5# This software was developed by the University of Tennessee as part of the 
     6# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     7# project funded by the US National Science Foundation. 
     8# If you use DANSE applications to do scientific research that leads to 
     9# publication, we ask that you acknowledge the use of the software with the 
     10# following sentence: 
     11# This work benefited from DANSE software developed under NSF award DMR-0520547. 
     12# copyright 2008, University of Tennessee 
    1313############################################################################# 
    1414 
     15import logging 
     16from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     17from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D 
     18from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
     19    DefaultReaderException 
    1520 
    16 import numpy as np 
    17 import os 
    18 from sas.sascalc.dataloader.data_info import Data1D 
    19  
    20 # Check whether we have a converter available 
    21 has_converter = True 
    22 try: 
    23     from sas.sascalc.data_util.nxsunit import Converter 
    24 except: 
    25     has_converter = False 
    26 _ZERO = 1e-16 
     21logger = logging.getLogger(__name__) 
    2722 
    2823 
    29 class Reader: 
     24class Reader(FileReader): 
    3025    """ 
    3126    Class to load ascii files (2, 3 or 4 columns). 
    3227    """ 
    33     ## File type 
     28    # File type 
    3429    type_name = "ASCII" 
    35  
    36     ## Wildcards 
     30    # Wildcards 
    3731    type = ["ASCII files (*.txt)|*.txt", 
    3832            "ASCII files (*.dat)|*.dat", 
    3933            "ASCII files (*.abs)|*.abs", 
    4034            "CSV files (*.csv)|*.csv"] 
    41     ## List of allowed extensions 
    42     ext = ['.txt', '.TXT', '.dat', '.DAT', '.abs', '.ABS', 'csv', 'CSV'] 
     35    # List of allowed extensions 
     36    ext = ['.txt', '.dat', '.abs', '.csv'] 
     37    # Flag to bypass extension check 
     38    allow_all = True 
     39    # data unless that is the only data 
     40    min_data_pts = 5 
    4341 
    44     ## Flag to bypass extension check 
    45     allow_all = True 
     42    def get_file_contents(self): 
     43        """ 
     44        Get the contents of the file 
     45        """ 
    4646 
    47     def read(self, path): 
    48         """ 
    49         Load data file 
     47        buff = self.f_open.read() 
     48        filepath = self.f_open.name 
     49        lines = buff.splitlines() 
     50        self.output = [] 
     51        self.current_datainfo = DataInfo() 
     52        self.current_datainfo.filename = filepath 
     53        self.reset_data_list(len(lines)) 
    5054 
    51         :param path: file path 
    52         :return: Data1D object, or None 
     55        # The first good line of data will define whether 
     56        # we have 2-column or 3-column ascii 
     57        has_error_dx = None 
     58        has_error_dy = None 
    5359 
    54         :raise RuntimeError: when the file can't be opened 
    55         :raise ValueError: when the length of the data vectors are inconsistent 
    56         """ 
    57         if os.path.isfile(path): 
    58             basename = os.path.basename(path) 
    59             _, extension = os.path.splitext(basename) 
    60             if self.allow_all or extension.lower() in self.ext: 
    61                 try: 
    62                     # Read in binary mode since GRASP frequently has no-ascii 
    63                     # characters that breaks the open operation 
    64                     input_f = open(path,'rb') 
    65                 except: 
    66                     raise  RuntimeError, "ascii_reader: cannot open %s" % path 
    67                 buff = input_f.read() 
    68                 lines = buff.splitlines() 
     60        # Initialize counters for data lines and header lines. 
     61        is_data = False 
     62        # More than "5" lines of data is considered as actual 
     63        # To count # of current data candidate lines 
     64        candidate_lines = 0 
     65        # To count total # of previous data candidate lines 
     66        candidate_lines_previous = 0 
     67        # Current line number 
     68        line_no = 0 
     69        # minimum required number of columns of data 
     70        lentoks = 2 
     71        for line in lines: 
     72            toks = self.splitline(line.strip()) 
     73            # To remember the number of columns in the current line of data 
     74            new_lentoks = len(toks) 
     75            try: 
     76                if new_lentoks == 0: 
     77                    # If the line is blank, skip and continue on 
     78                    # In case of breaks within data sets. 
     79                    continue 
     80                elif new_lentoks != lentoks and is_data: 
     81                    # If a footer is found, break the loop and save the data 
     82                    break 
     83                elif new_lentoks != lentoks and not is_data: 
     84                    # If header lines are numerical 
     85                    candidate_lines = 0 
     86                    self.reset_data_list(len(lines) - line_no) 
    6987 
    70                 # Arrays for data storage 
    71                 tx = np.zeros(0) 
    72                 ty = np.zeros(0) 
    73                 tdy = np.zeros(0) 
    74                 tdx = np.zeros(0) 
     88                self.current_dataset.x[candidate_lines] = float(toks[0]) 
    7589 
    76                 # The first good line of data will define whether 
    77                 # we have 2-column or 3-column ascii 
     90                if new_lentoks > 1: 
     91                    self.current_dataset.y[candidate_lines] = float(toks[1]) 
     92 
     93                # If a 3rd row is present, consider it dy 
     94                if new_lentoks > 2: 
     95                    self.current_dataset.dy[candidate_lines] = \ 
     96                        float(toks[2]) 
     97                    has_error_dy = True 
     98 
     99                # If a 4th row is present, consider it dx 
     100                if new_lentoks > 3: 
     101                    self.current_dataset.dx[candidate_lines] = \ 
     102                        float(toks[3]) 
     103                    has_error_dx = True 
     104 
     105                candidate_lines += 1 
     106                # If 5 or more lines, this is considering the set data 
     107                if candidate_lines >= self.min_data_pts: 
     108                    is_data = True 
     109 
     110                if is_data and new_lentoks >= 8: 
     111                    msg = "This data looks like 2D ASCII data. Use the file " 
     112                    msg += "converter tool to convert it to NXcanSAS." 
     113                    raise FileContentsException(msg) 
     114 
     115                # To remember the # of columns on the current line 
     116                # for the next line of data 
     117                lentoks = new_lentoks 
     118                line_no += 1 
     119            except ValueError: 
     120                # ValueError is raised when non numeric strings conv. to float 
     121                # It is data and meet non - number, then stop reading 
     122                if is_data: 
     123                    break 
     124                # Delete the previously stored lines of data candidates if 
     125                # the list is not data 
     126                self.reset_data_list(len(lines) - line_no) 
     127                lentoks = 2 
    78128                has_error_dx = None 
    79129                has_error_dy = None 
     130                # Reset # of lines of data candidates 
     131                candidate_lines = 0 
     132         
     133        if not is_data: 
     134            self.set_all_to_none() 
     135            if self.extension in self.ext: 
     136                msg = "ASCII Reader error: Fewer than five Q data points found " 
     137                msg += "in {}.".format(filepath) 
     138                raise FileContentsException(msg) 
     139            else: 
     140                msg = "ASCII Reader could not load the file {}".format(filepath) 
     141                raise DefaultReaderException(msg) 
     142        # Sanity check 
     143        if has_error_dy and not len(self.current_dataset.y) == \ 
     144                len(self.current_dataset.dy): 
     145            msg = "ASCII Reader error: Number of I and dI data points are" 
     146            msg += " different in {}.".format(filepath) 
     147            # TODO: Add error to self.current_datainfo.errors instead? 
     148            self.set_all_to_none() 
     149            raise FileContentsException(msg) 
     150        if has_error_dx and not len(self.current_dataset.x) == \ 
     151                len(self.current_dataset.dx): 
     152            msg = "ASCII Reader error: Number of Q and dQ data points are" 
     153            msg += " different in {}.".format(filepath) 
     154            # TODO: Add error to self.current_datainfo.errors instead? 
     155            self.set_all_to_none() 
     156            raise FileContentsException(msg) 
    80157 
    81                 #Initialize counters for data lines and header lines. 
    82                 is_data = False 
    83                 # More than "5" lines of data is considered as actual 
    84                 # data unless that is the only data 
    85                 min_data_pts = 5 
    86                 # To count # of current data candidate lines 
    87                 candidate_lines = 0 
    88                 # To count total # of previous data candidate lines 
    89                 candidate_lines_previous = 0 
    90                 #minimum required number of columns of data 
    91                 lentoks = 2 
    92                 for line in lines: 
    93                     toks = self.splitline(line) 
    94                     # To remember the # of columns in the current line of data 
    95                     new_lentoks = len(toks) 
    96                     try: 
    97                         if new_lentoks == 1 and not is_data: 
    98                             ## If only one item in list, no longer data 
    99                             raise ValueError 
    100                         elif new_lentoks == 0: 
    101                             ## If the line is blank, skip and continue on 
    102                             ## In case of breaks within data sets. 
    103                             continue 
    104                         elif new_lentoks != lentoks and is_data: 
    105                             ## If a footer is found, break the loop and save the data 
    106                             break 
    107                         elif new_lentoks != lentoks and not is_data: 
    108                             ## If header lines are numerical 
    109                             candidate_lines = 0 
    110                             candidate_lines_previous = 0 
     158        self.remove_empty_q_values(has_error_dx, has_error_dy) 
     159        self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
     160        self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
    111161 
    112                         #Make sure that all columns are numbers. 
    113                         for colnum in range(len(toks)): 
    114                             # Any non-floating point values throw ValueError 
    115                             float(toks[colnum]) 
    116  
    117                         candidate_lines += 1 
    118                         _x = float(toks[0]) 
    119                         _y = float(toks[1]) 
    120                         _dx = None 
    121                         _dy = None 
    122  
    123                         #If 5 or more lines, this is considering the set data 
    124                         if candidate_lines >= min_data_pts: 
    125                             is_data = True 
    126  
    127                         # If a 3rd row is present, consider it dy 
    128                         if new_lentoks > 2: 
    129                             _dy = float(toks[2]) 
    130                         has_error_dy = False if _dy is None else True 
    131  
    132                         # If a 4th row is present, consider it dx 
    133                         if new_lentoks > 3: 
    134                             _dx = float(toks[3]) 
    135                         has_error_dx = False if _dx is None else True 
    136  
    137                         # Delete the previously stored lines of data candidates if 
    138                         # the list is not data 
    139                         if candidate_lines == 1 and -1 < candidate_lines_previous < min_data_pts and \ 
    140                             is_data == False: 
    141                             try: 
    142                                 tx = np.zeros(0) 
    143                                 ty = np.zeros(0) 
    144                                 tdy = np.zeros(0) 
    145                                 tdx = np.zeros(0) 
    146                             except: 
    147                                 pass 
    148  
    149                         if has_error_dy == True: 
    150                             tdy = np.append(tdy, _dy) 
    151                         if has_error_dx == True: 
    152                             tdx = np.append(tdx, _dx) 
    153                         tx = np.append(tx, _x) 
    154                         ty = np.append(ty, _y) 
    155  
    156                         #To remember the # of columns on the current line 
    157                         # for the next line of data 
    158                         lentoks = new_lentoks 
    159                         candidate_lines_previous = candidate_lines 
    160                     except ValueError: 
    161                         # It is data and meet non - number, then stop reading 
    162                         if is_data == True: 
    163                             break 
    164                         lentoks = 2 
    165                         has_error_dx = None 
    166                         has_error_dy = None 
    167                         #Reset # of lines of data candidates 
    168                         candidate_lines = 0 
    169                     except: 
    170                         pass 
    171  
    172                 input_f.close() 
    173                 if not is_data: 
    174                     msg = "ascii_reader: x has no data" 
    175                     raise RuntimeError, msg 
    176                 # Sanity check 
    177                 if has_error_dy == True and not len(ty) == len(tdy): 
    178                     msg = "ascii_reader: y and dy have different length" 
    179                     raise RuntimeError, msg 
    180                 if has_error_dx == True and not len(tx) == len(tdx): 
    181                     msg = "ascii_reader: y and dy have different length" 
    182                     raise RuntimeError, msg 
    183                 # If the data length is zero, consider this as 
    184                 # though we were not able to read the file. 
    185                 if len(tx) == 0: 
    186                     raise RuntimeError, "ascii_reader: could not load file" 
    187  
    188                 #Let's re-order the data to make cal. 
    189                 # curve look better some cases 
    190                 ind = np.lexsort((ty, tx)) 
    191                 x = np.zeros(len(tx)) 
    192                 y = np.zeros(len(ty)) 
    193                 dy = np.zeros(len(tdy)) 
    194                 dx = np.zeros(len(tdx)) 
    195                 output = Data1D(x, y, dy=dy, dx=dx) 
    196                 self.filename = output.filename = basename 
    197  
    198                 for i in ind: 
    199                     x[i] = tx[ind[i]] 
    200                     y[i] = ty[ind[i]] 
    201                     if has_error_dy == True: 
    202                         dy[i] = tdy[ind[i]] 
    203                     if has_error_dx == True: 
    204                         dx[i] = tdx[ind[i]] 
    205                 # Zeros in dx, dy 
    206                 if has_error_dx: 
    207                     dx[dx == 0] = _ZERO 
    208                 if has_error_dy: 
    209                     dy[dy == 0] = _ZERO 
    210                 #Data 
    211                 output.x = x[x != 0] 
    212                 output.y = y[x != 0] 
    213                 output.dy = dy[x != 0] if has_error_dy == True\ 
    214                     else np.zeros(len(output.y)) 
    215                 output.dx = dx[x != 0] if has_error_dx == True\ 
    216                     else np.zeros(len(output.x)) 
    217  
    218                 output.xaxis("\\rm{Q}", 'A^{-1}') 
    219                 output.yaxis("\\rm{Intensity}", "cm^{-1}") 
    220  
    221                 # Store loading process information 
    222                 output.meta_data['loader'] = self.type_name 
    223                 if len(output.x) < 1: 
    224                     raise RuntimeError, "%s is empty" % path 
    225                 return output 
    226  
    227         else: 
    228             raise RuntimeError, "%s is not a file" % path 
    229         return None 
    230  
    231     def splitline(self, line): 
    232         """ 
    233         Splits a line into pieces based on common delimeters 
    234         :param line: A single line of text 
    235         :return: list of values 
    236         """ 
    237         # Initial try for CSV (split on ,) 
    238         toks = line.split(',') 
    239         # Now try SCSV (split on ;) 
    240         if len(toks) < 2: 
    241             toks = line.split(';') 
    242         # Now go for whitespace 
    243         if len(toks) < 2: 
    244             toks = line.split() 
    245         return toks 
     162        # Store loading process information 
     163        self.current_datainfo.meta_data['loader'] = self.type_name 
     164        self.send_to_output() 
  • src/sas/sascalc/dataloader/readers/associations.py

    ra1b8fee rce8c7bd  
    1414#copyright 2009, University of Tennessee 
    1515############################################################################# 
    16 from __future__ import print_function 
    17  
    18 import os 
    1916import sys 
    2017import logging 
    21 import json 
    2218 
    2319logger = logging.getLogger(__name__) 
    2420 
    25 FILE_NAME = 'defaults.json' 
     21FILE_ASSOCIATIONS = { 
     22    ".xml": "cansas_reader", 
     23    ".ses": "sesans_reader", 
     24    ".h5": "cansas_reader_HDF5", 
     25    ".txt": "ascii_reader", 
     26    ".dat": "red2d_reader", 
     27    ".abs": "abs_reader", 
     28    ".sans": "danse_reader", 
     29    ".pdh": "anton_paar_saxs_reader" 
     30} 
    2631 
    27 def read_associations(loader, settings=FILE_NAME): 
     32 
     33def read_associations(loader, settings=FILE_ASSOCIATIONS): 
    2834    """ 
    2935    Read the specified settings file to associate 
    3036    default readers to file extension. 
    31      
     37 
    3238    :param loader: Loader object 
    3339    :param settings: path to the json settings file [string] 
    3440    """ 
    35     reader_dir = os.path.dirname(__file__) 
    36     path = os.path.join(reader_dir, settings) 
    37      
    38     # If we can't find the file in the installation 
    39     # directory, look into the execution directory. 
    40     if not os.path.isfile(path): 
    41         path = os.path.join(os.getcwd(), settings) 
    42     if not os.path.isfile(path): 
    43         path = os.path.join(sys.path[0], settings) 
    44     if not os.path.isfile(path): 
    45         path = settings 
    46     if not os.path.isfile(path): 
    47         path = "./%s" % settings 
    48     if os.path.isfile(path): 
    49         with open(path) as fh: 
    50             json_tree = json.load(fh) 
    51          
    52         # Read in the file extension associations 
    53         entry_list = json_tree['SasLoader']['FileType'] 
    54  
    55         # For each FileType entry, get the associated reader and extension 
    56         for entry in entry_list: 
    57             reader = entry['-reader'] 
    58             ext = entry['-extension'] 
    59              
    60             if reader is not None and ext is not None: 
    61                 # Associate the extension with a particular reader 
    62                 # TODO: Modify the Register code to be case-insensitive 
    63                 # and remove the extra line below. 
    64                 try: 
    65                     exec "import %s" % reader 
    66                     exec "loader.associate_file_type('%s', %s)" % (ext.lower(), 
    67                                                                     reader) 
    68                     exec "loader.associate_file_type('%s', %s)" % (ext.upper(), 
    69                                                                     reader) 
    70                 except: 
    71                     msg = "read_associations: skipping association" 
    72                     msg += " for %s\n  %s" % (ext.lower(), sys.exc_value) 
    73                     logger.error(msg) 
    74     else: 
    75         print("Could not find reader association settings\n  %s [%s]" % (__file__, os.getcwd())) 
    76           
    77           
    78 def register_readers(registry_function): 
    79     """ 
    80     Function called by the registry/loader object to register 
    81     all default readers using a call back function. 
    82      
    83     :WARNING: this method is now obsolete 
    84  
    85     :param registry_function: function to be called to register each reader 
    86     """ 
    87     logger.info("register_readers is now obsolete: use read_associations()") 
    88     import abs_reader 
    89     import ascii_reader 
    90     import cansas_reader 
    91     import danse_reader 
    92     import hfir1d_reader 
    93     import IgorReader 
    94     import red2d_reader 
    95     #import tiff_reader 
    96     import nexus_reader 
    97     import sesans_reader 
    98     import cansas_reader_HDF5 
    99     import anton_paar_saxs_reader 
    100     registry_function(sesans_reader) 
    101     registry_function(abs_reader) 
    102     registry_function(ascii_reader) 
    103     registry_function(cansas_reader) 
    104     registry_function(danse_reader) 
    105     registry_function(hfir1d_reader) 
    106     registry_function(IgorReader) 
    107     registry_function(red2d_reader) 
    108     #registry_function(tiff_reader) 
    109     registry_function(nexus_reader) 
    110     registry_function(cansas_reader_HDF5) 
    111     registry_function(anton_paar_saxs_reader) 
    112     return True 
     41    # For each FileType entry, get the associated reader and extension 
     42    for ext, reader in settings.iteritems(): 
     43        if reader is not None and ext is not None: 
     44            # Associate the extension with a particular reader 
     45            # TODO: Modify the Register code to be case-insensitive 
     46            # FIXME: Remove exec statements 
     47            # and remove the extra line below. 
     48            try: 
     49                exec "import %s" % reader 
     50                exec "loader.associate_file_type('%s', %s)" % (ext.lower(), 
     51                                                                reader) 
     52                exec "loader.associate_file_type('%s', %s)" % (ext.upper(), 
     53                                                                reader) 
     54            except: 
     55                msg = "read_associations: skipping association" 
     56                msg += " for %s\n  %s" % (ext.lower(), sys.exc_value) 
     57                logger.error(msg) 
  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r7432acb r248ff73  
    1 """ 
    2     CanSAS data reader - new recursive cansas_version. 
    3 """ 
    4 ############################################################################ 
    5 #This software was developed by the University of Tennessee as part of the 
    6 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation. 
    8 #If you use DANSE applications to do scientific research that leads to 
    9 #publication, we ask that you acknowledge the use of the software with the 
    10 #following sentence: 
    11 #This work benefited from DANSE software developed under NSF award DMR-0520547. 
    12 #copyright 2008,2009 University of Tennessee 
    13 ############################################################################# 
    14  
    151import logging 
    162import numpy as np 
     
    2915from sas.sascalc.dataloader.readers.xml_reader import XMLreader 
    3016from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants, CurrentLevel 
     17from sas.sascalc.dataloader.loader_exceptions import FileContentsException, \ 
     18    DefaultReaderException, DataReaderException 
    3119 
    3220# The following 2 imports *ARE* used. Do not remove either. 
    3321import xml.dom.minidom 
    3422from xml.dom.minidom import parseString 
     23 
     24from lxml import etree 
    3525 
    3626logger = logging.getLogger(__name__) 
     
    5545 
    5646class Reader(XMLreader): 
    57     """ 
    58     Class to load cansas 1D XML files 
    59  
    60     :Dependencies: 
    61         The CanSAS reader requires PyXML 0.8.4 or later. 
    62     """ 
    63     # CanSAS version - defaults to version 1.0 
    6447    cansas_version = "1.0" 
    6548    base_ns = "{cansas1d/1.0}" 
     
    7558    ns_list = None 
    7659    # Temporary storage location for loading multiple data sets in a single file 
    77     current_datainfo = None 
    78     current_dataset = None 
    7960    current_data1d = None 
    8061    data = None 
    81     # List of data1D objects to be sent back to SasView 
    82     output = None 
    8362    # Wildcards 
    8463    type = ["XML files (*.xml)|*.xml", "SasView Save Files (*.svs)|*.svs"] 
     
    11089 
    11190    def read(self, xml_file, schema_path="", invalid=True): 
    112         """ 
    113         Validate and read in an xml_file file in the canSAS format. 
    114  
    115         :param xml_file: A canSAS file path in proper XML format 
    116         :param schema_path: A file path to an XML schema to validate the xml_file against 
    117         """ 
    118         # For every file loaded, reset everything to a base state 
     91        if schema_path != "" or invalid != True: 
     92            # read has been called from self.get_file_contents because xml file doens't conform to schema 
     93            _, self.extension = os.path.splitext(os.path.basename(xml_file)) 
     94            return self.get_file_contents(xml_file=xml_file, schema_path=schema_path, invalid=invalid) 
     95 
     96        # Otherwise, read has been called by the data loader - file_reader_base_class handles this 
     97        return super(XMLreader, self).read(xml_file) 
     98 
     99    def get_file_contents(self, xml_file=None, schema_path="", invalid=True): 
     100        # Reset everything since we're loading a new file 
    119101        self.reset_state() 
    120102        self.invalid = invalid 
    121         # Check that the file exists 
    122         if os.path.isfile(xml_file): 
    123             basename, extension = os.path.splitext(os.path.basename(xml_file)) 
    124             # If the file type is not allowed, return nothing 
    125             if extension in self.ext or self.allow_all: 
    126                 # Get the file location of 
    127                 self.load_file_and_schema(xml_file, schema_path) 
    128                 self.add_data_set() 
    129                 # Try to load the file, but raise an error if unable to. 
    130                 # Check the file matches the XML schema 
     103        if xml_file is None: 
     104            xml_file = self.f_open.name 
     105        # We don't sure f_open since lxml handles opnening/closing files 
     106        if not self.f_open.closed: 
     107            self.f_open.close() 
     108 
     109        basename, _ = os.path.splitext(os.path.basename(xml_file)) 
     110 
     111        try: 
     112            # Raises FileContentsException 
     113            self.load_file_and_schema(xml_file, schema_path) 
     114            self.current_datainfo = DataInfo() 
     115            # Raises FileContentsException if file doesn't meet CanSAS schema 
     116            self.is_cansas(self.extension) 
     117            self.invalid = False # If we reach this point then file must be valid CanSAS 
     118 
     119            # Parse each SASentry 
     120            entry_list = self.xmlroot.xpath('/ns:SASroot/ns:SASentry', namespaces={ 
     121                'ns': self.cansas_defaults.get("ns") 
     122            }) 
     123            # Look for a SASentry 
     124            self.names.append("SASentry") 
     125            self.set_processing_instructions() 
     126 
     127            for entry in entry_list: 
     128                self.current_datainfo.filename = basename + self.extension 
     129                self.current_datainfo.meta_data["loader"] = "CanSAS XML 1D" 
     130                self.current_datainfo.meta_data[PREPROCESS] = self.processing_instructions 
     131                self._parse_entry(entry) 
     132                has_error_dx = self.current_dataset.dx is not None 
     133                has_error_dy = self.current_dataset.dy is not None 
     134                self.remove_empty_q_values(has_error_dx=has_error_dx, 
     135                    has_error_dy=has_error_dy) 
     136                self.send_to_output() # Combine datasets with DataInfo 
     137                self.current_datainfo = DataInfo() # Reset DataInfo 
     138        except FileContentsException as fc_exc: 
     139            # File doesn't meet schema - try loading with a less strict schema 
     140            base_name = xml_reader.__file__ 
     141            base_name = base_name.replace("\\", "/") 
     142            base = base_name.split("/sas/")[0] 
     143            if self.cansas_version == "1.1": 
     144                invalid_schema = INVALID_SCHEMA_PATH_1_1.format(base, self.cansas_defaults.get("schema")) 
     145            else: 
     146                invalid_schema = INVALID_SCHEMA_PATH_1_0.format(base, self.cansas_defaults.get("schema")) 
     147            self.set_schema(invalid_schema) 
     148            if self.invalid: 
    131149                try: 
    132                     self.is_cansas(extension) 
    133                     self.invalid = False 
    134                     # Get each SASentry from XML file and add it to a list. 
    135                     entry_list = self.xmlroot.xpath( 
    136                             '/ns:SASroot/ns:SASentry', 
    137                             namespaces={'ns': self.cansas_defaults.get("ns")}) 
    138                     self.names.append("SASentry") 
    139  
    140                     # Get all preprocessing events and encoding 
    141                     self.set_processing_instructions() 
    142  
    143                     # Parse each <SASentry> item 
    144                     for entry in entry_list: 
    145                         # Create a new DataInfo object for every <SASentry> 
    146  
    147                         # Set the file name and then parse the entry. 
    148                         self.current_datainfo.filename = basename + extension 
    149                         self.current_datainfo.meta_data["loader"] = "CanSAS XML 1D" 
    150                         self.current_datainfo.meta_data[PREPROCESS] = \ 
    151                             self.processing_instructions 
    152  
    153                         # Parse the XML SASentry 
    154                         self._parse_entry(entry) 
    155                         # Combine datasets with datainfo 
    156                         self.add_data_set() 
    157                 except RuntimeError: 
    158                     # If the file does not match the schema, raise this error 
     150                    # Load data with less strict schema 
     151                    self.read(xml_file, invalid_schema, False) 
     152 
     153                    # File can still be read but doesn't match schema, so raise exception 
     154                    self.load_file_and_schema(xml_file) # Reload strict schema so we can find where error are in file 
    159155                    invalid_xml = self.find_invalid_xml() 
    160                     invalid_xml = INVALID_XML.format(basename + extension) + invalid_xml 
    161                     self.errors.add(invalid_xml) 
    162                     # Try again with an invalid CanSAS schema, that requires only a data set in each 
    163                     base_name = xml_reader.__file__ 
    164                     base_name = base_name.replace("\\", "/") 
    165                     base = base_name.split("/sas/")[0] 
    166                     if self.cansas_version == "1.1": 
    167                         invalid_schema = INVALID_SCHEMA_PATH_1_1.format(base, self.cansas_defaults.get("schema")) 
    168                     else: 
    169                         invalid_schema = INVALID_SCHEMA_PATH_1_0.format(base, self.cansas_defaults.get("schema")) 
    170                     self.set_schema(invalid_schema) 
    171                     try: 
    172                         if self.invalid: 
    173                             if self.is_cansas(): 
    174                                 self.output = self.read(xml_file, invalid_schema, False) 
    175                             else: 
    176                                 raise RuntimeError 
    177                         else: 
    178                             raise RuntimeError 
    179                     except RuntimeError: 
    180                         x = np.zeros(1) 
    181                         y = np.zeros(1) 
    182                         self.current_data1d = Data1D(x,y) 
    183                         self.current_data1d.errors = self.errors 
    184                         return [self.current_data1d] 
    185         else: 
    186             self.output.append("Not a valid file path.") 
    187         # Return a list of parsed entries that dataloader can manage 
    188         return self.output 
     156                    invalid_xml = INVALID_XML.format(basename + self.extension) + invalid_xml 
     157                    raise DataReaderException(invalid_xml) # Handled by base class 
     158                except FileContentsException as fc_exc: 
     159                    if not self.extension in self.ext: # If the file has no associated loader 
     160                        raise DefaultReaderException(msg) 
     161                    msg = "CanSAS Reader could not load the file {}".format(xml_file) 
     162                    if fc_exc.message is not None: # Propagate error messages from earlier 
     163                        msg = fc_exc.message 
     164                    raise FileContentsException(msg) 
     165                    pass 
     166            else: 
     167                raise fc_exc 
     168        except Exception as e: # Convert all other exceptions to FileContentsExceptions 
     169            raise FileContentsException(e.message) 
     170 
     171 
     172    def load_file_and_schema(self, xml_file, schema_path=""): 
     173        base_name = xml_reader.__file__ 
     174        base_name = base_name.replace("\\", "/") 
     175        base = base_name.split("/sas/")[0] 
     176 
     177        # Try and parse the XML file 
     178        try: 
     179            self.set_xml_file(xml_file) 
     180        except etree.XMLSyntaxError: # File isn't valid XML so can't be loaded 
     181            msg = "Cansas cannot load {}.\n Invalid XML syntax".format(xml_file) 
     182            raise FileContentsException(msg) 
     183 
     184        self.cansas_version = self.xmlroot.get("version", "1.0") 
     185        self.cansas_defaults = CANSAS_NS.get(self.cansas_version, "1.0") 
     186 
     187        if schema_path == "": 
     188            schema_path = "{}/sas/sascalc/dataloader/readers/schema/{}".format( 
     189                base, self.cansas_defaults.get("schema").replace("\\", "/") 
     190            ) 
     191        self.set_schema(schema_path) 
     192 
     193    def is_cansas(self, ext="xml"): 
     194        """ 
     195        Checks to see if the XML file is a CanSAS file 
     196 
     197        :param ext: The file extension of the data file 
     198        :raises FileContentsException: Raised if XML file isn't valid CanSAS 
     199        """ 
     200        if self.validate_xml(): # Check file is valid XML 
     201            name = "{http://www.w3.org/2001/XMLSchema-instance}schemaLocation" 
     202            value = self.xmlroot.get(name) 
     203            # Check schema CanSAS version matches file CanSAS version 
     204            if CANSAS_NS.get(self.cansas_version).get("ns") == value.rsplit(" ")[0]: 
     205                return True 
     206        if ext == "svs": 
     207            return True # Why is this required? 
     208        # If we get to this point then file isn't valid CanSAS 
     209        raise FileContentsException("The file is not valid CanSAS") 
    189210 
    190211    def _parse_entry(self, dom, recurse=False): 
    191         """ 
    192         Parse a SASEntry - new recursive method for parsing the dom of 
    193             the CanSAS data format. This will allow multiple data files 
    194             and extra nodes to be read in simultaneously. 
    195  
    196         :param dom: dom object with a namespace base of names 
    197         """ 
    198  
    199212        if not self._is_call_local() and not recurse: 
    200213            self.reset_state() 
    201             self.add_data_set() 
     214            self.data = [] 
     215            self.current_datainfo = DataInfo() 
    202216            self.names.append("SASentry") 
    203217            self.parent_class = "SASentry" 
    204         self._check_for_empty_data() 
    205         self.base_ns = "{0}{1}{2}".format("{", \ 
    206                             CANSAS_NS.get(self.cansas_version).get("ns"), "}") 
    207  
    208         # Go through each child in the parent element 
     218        # Create an empty dataset if no data has been passed to the reader 
     219        if self.current_dataset is None: 
     220            self.current_dataset = plottable_1D(np.empty(0), np.empty(0), 
     221                np.empty(0), np.empty(0)) 
     222        self.base_ns = "{" + CANSAS_NS.get(self.cansas_version).get("ns") + "}" 
     223 
     224        # Loop through each child in the parent element 
    209225        for node in dom: 
    210226            attr = node.attrib 
     
    217233            if tagname == "fitting_plug_in" or tagname == "pr_inversion" or tagname == "invariant": 
    218234                continue 
    219  
    220235            # Get where to store content 
    221236            self.names.append(tagname_original) 
     
    233248                        else: 
    234249                            self.current_dataset.shape = () 
    235                 # Recursion step to access data within the group 
    236                 self._parse_entry(node, True) 
     250                # Recurse to access data within the group 
     251                self._parse_entry(node, recurse=True) 
    237252                if tagname == "SASsample": 
    238253                    self.current_datainfo.sample.name = name 
     
    244259                    self.aperture.name = name 
    245260                    self.aperture.type = type 
    246                 self.add_intermediate() 
     261                self._add_intermediate() 
    247262            else: 
    248263                if isinstance(self.current_dataset, plottable_2D): 
     
    261276                    self.current_datainfo.notes.append(data_point) 
    262277 
    263                 # I and Q - 1D data 
     278                # I and Q points 
    264279                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    265280                    unit_list = unit.split("|") 
     
    283298                    self.current_dataset.dx = np.append(self.current_dataset.dx, data_point) 
    284299                elif tagname == 'dQw': 
     300                    if self.current_dataset.dqw is None: self.current_dataset.dqw = np.empty(0) 
    285301                    self.current_dataset.dxw = np.append(self.current_dataset.dxw, data_point) 
    286302                elif tagname == 'dQl': 
     303                    if self.current_dataset.dxl is None: self.current_dataset.dxl = np.empty(0) 
    287304                    self.current_dataset.dxl = np.append(self.current_dataset.dxl, data_point) 
    288305                elif tagname == 'Qmean': 
     
    356373                elif tagname == 'name' and self.parent_class == 'SASinstrument': 
    357374                    self.current_datainfo.instrument = data_point 
     375 
    358376                # Detector Information 
    359377                elif tagname == 'name' and self.parent_class == 'SASdetector': 
     
    401419                    self.detector.orientation.z = data_point 
    402420                    self.detector.orientation_unit = unit 
     421 
    403422                # Collimation and Aperture 
    404423                elif tagname == 'length' and self.parent_class == 'SAScollimation': 
     
    434453                elif tagname == 'term' and self.parent_class == 'SASprocess': 
    435454                    unit = attr.get("unit", "") 
    436                     dic = {} 
    437                     dic["name"] = name 
    438                     dic["value"] = data_point 
    439                     dic["unit"] = unit 
     455                    dic = { "name": name, "value": data_point, "unit": unit } 
    440456                    self.process.term.append(dic) 
    441457 
     
    490506        if not self._is_call_local() and not recurse: 
    491507            self.frm = "" 
    492             self.add_data_set() 
     508            self.current_datainfo.errors = set() 
     509            for error in self.errors: 
     510                self.current_datainfo.errors.add(error) 
     511            self.errors.clear() 
     512            self.send_to_output() 
    493513            empty = None 
    494514            return self.output[0], empty 
    495515 
    496  
    497516    def _is_call_local(self): 
    498         """ 
    499  
    500         """ 
    501517        if self.frm == "": 
    502518            inter = inspect.stack() 
     
    510526        return True 
    511527 
    512     def is_cansas(self, ext="xml"): 
    513         """ 
    514         Checks to see if the xml file is a CanSAS file 
    515  
    516         :param ext: The file extension of the data file 
    517         """ 
    518         if self.validate_xml(): 
    519             name = "{http://www.w3.org/2001/XMLSchema-instance}schemaLocation" 
    520             value = self.xmlroot.get(name) 
    521             if CANSAS_NS.get(self.cansas_version).get("ns") == \ 
    522                     value.rsplit(" ")[0]: 
    523                 return True 
    524         if ext == "svs": 
    525             return True 
    526         raise RuntimeError 
    527  
    528     def load_file_and_schema(self, xml_file, schema_path=""): 
    529         """ 
    530         Loads the file and associates a schema, if a schema is passed in or if one already exists 
    531  
    532         :param xml_file: The xml file path sent to Reader.read 
    533         :param schema_path: The path to a schema associated with the xml_file, or find one based on the file 
    534         """ 
    535         base_name = xml_reader.__file__ 
    536         base_name = base_name.replace("\\", "/") 
    537         base = base_name.split("/sas/")[0] 
    538  
    539         # Load in xml file and get the cansas version from the header 
    540         self.set_xml_file(xml_file) 
    541         self.cansas_version = self.xmlroot.get("version", "1.0") 
    542  
    543         # Generic values for the cansas file based on the version 
    544         self.cansas_defaults = CANSAS_NS.get(self.cansas_version, "1.0") 
    545         if schema_path == "": 
    546             schema_path = "{0}/sas/sascalc/dataloader/readers/schema/{1}".format \ 
    547                 (base, self.cansas_defaults.get("schema")).replace("\\", "/") 
    548  
    549         # Link a schema to the XML file. 
    550         self.set_schema(schema_path) 
    551  
    552     def add_data_set(self): 
    553         """ 
    554         Adds the current_dataset to the list of outputs after preforming final processing on the data and then calls a 
    555         private method to generate a new data set. 
    556  
    557         :param key: NeXus group name for current tree level 
    558         """ 
    559  
    560         if self.current_datainfo and self.current_dataset: 
    561             self._final_cleanup() 
    562         self.data = [] 
    563         self.current_datainfo = DataInfo() 
    564  
    565     def _initialize_new_data_set(self, node=None): 
    566         """ 
    567         A private class method to generate a new 1D data object. 
    568         Outside methods should call add_data_set() to be sure any existing data is stored properly. 
    569  
    570         :param node: XML node to determine if 1D or 2D data 
    571         """ 
    572         x = np.array(0) 
    573         y = np.array(0) 
    574         for child in node: 
    575             if child.tag.replace(self.base_ns, "") == "Idata": 
    576                 for i_child in child: 
    577                     if i_child.tag.replace(self.base_ns, "") == "Qx": 
    578                         self.current_dataset = plottable_2D() 
    579                         return 
    580         self.current_dataset = plottable_1D(x, y) 
    581  
    582     def add_intermediate(self): 
     528    def _add_intermediate(self): 
    583529        """ 
    584530        This method stores any intermediate objects within the final data set after fully reading the set. 
    585  
    586         :param parent: The NXclass name for the h5py Group object that just finished being processed 
    587         """ 
    588  
     531        """ 
    589532        if self.parent_class == 'SASprocess': 
    590533            self.current_datainfo.process.append(self.process) 
     
    605548            self._check_for_empty_resolution() 
    606549            self.data.append(self.current_dataset) 
    607  
    608     def _final_cleanup(self): 
    609         """ 
    610         Final cleanup of the Data1D object to be sure it has all the 
    611         appropriate information needed for perspectives 
    612         """ 
    613  
    614         # Append errors to dataset and reset class errors 
    615         self.current_datainfo.errors = set() 
    616         for error in self.errors: 
    617             self.current_datainfo.errors.add(error) 
    618         self.errors.clear() 
    619  
    620         # Combine all plottables with datainfo and append each to output 
    621         # Type cast data arrays to float64 and find min/max as appropriate 
    622         for dataset in self.data: 
    623             if isinstance(dataset, plottable_1D): 
    624                 if dataset.x is not None: 
    625                     dataset.x = np.delete(dataset.x, [0]) 
    626                     dataset.x = dataset.x.astype(np.float64) 
    627                     dataset.xmin = np.min(dataset.x) 
    628                     dataset.xmax = np.max(dataset.x) 
    629                 if dataset.y is not None: 
    630                     dataset.y = np.delete(dataset.y, [0]) 
    631                     dataset.y = dataset.y.astype(np.float64) 
    632                     dataset.ymin = np.min(dataset.y) 
    633                     dataset.ymax = np.max(dataset.y) 
    634                 if dataset.dx is not None: 
    635                     dataset.dx = np.delete(dataset.dx, [0]) 
    636                     dataset.dx = dataset.dx.astype(np.float64) 
    637                 if dataset.dxl is not None: 
    638                     dataset.dxl = np.delete(dataset.dxl, [0]) 
    639                     dataset.dxl = dataset.dxl.astype(np.float64) 
    640                 if dataset.dxw is not None: 
    641                     dataset.dxw = np.delete(dataset.dxw, [0]) 
    642                     dataset.dxw = dataset.dxw.astype(np.float64) 
    643                 if dataset.dy is not None: 
    644                     dataset.dy = np.delete(dataset.dy, [0]) 
    645                     dataset.dy = dataset.dy.astype(np.float64) 
    646                 np.trim_zeros(dataset.x) 
    647                 np.trim_zeros(dataset.y) 
    648                 np.trim_zeros(dataset.dy) 
    649             elif isinstance(dataset, plottable_2D): 
    650                 dataset.data = dataset.data.astype(np.float64) 
    651                 dataset.qx_data = dataset.qx_data.astype(np.float64) 
    652                 dataset.xmin = np.min(dataset.qx_data) 
    653                 dataset.xmax = np.max(dataset.qx_data) 
    654                 dataset.qy_data = dataset.qy_data.astype(np.float64) 
    655                 dataset.ymin = np.min(dataset.qy_data) 
    656                 dataset.ymax = np.max(dataset.qy_data) 
    657                 dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data 
    658                                          + dataset.qy_data * dataset.qy_data) 
    659                 if dataset.err_data is not None: 
    660                     dataset.err_data = dataset.err_data.astype(np.float64) 
    661                 if dataset.dqx_data is not None: 
    662                     dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
    663                 if dataset.dqy_data is not None: 
    664                     dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
    665                 if dataset.mask is not None: 
    666                     dataset.mask = dataset.mask.astype(dtype=bool) 
    667  
    668                 if len(dataset.shape) == 2: 
    669                     n_rows, n_cols = dataset.shape 
    670                     dataset.y_bins = dataset.qy_data[0::int(n_cols)] 
    671                     dataset.x_bins = dataset.qx_data[:int(n_cols)] 
    672                     dataset.data = dataset.data.flatten() 
    673                 else: 
    674                     dataset.y_bins = [] 
    675                     dataset.x_bins = [] 
    676                     dataset.data = dataset.data.flatten() 
    677  
    678             final_dataset = combine_data(dataset, self.current_datainfo) 
    679             self.output.append(final_dataset) 
    680  
    681     def _create_unique_key(self, dictionary, name, numb=0): 
    682         """ 
    683         Create a unique key value for any dictionary to prevent overwriting 
    684         Recurse until a unique key value is found. 
    685  
    686         :param dictionary: A dictionary with any number of entries 
    687         :param name: The index of the item to be added to dictionary 
    688         :param numb: The number to be appended to the name, starts at 0 
    689         """ 
    690         if dictionary.get(name) is not None: 
    691             numb += 1 
    692             name = name.split("_")[0] 
    693             name += "_{0}".format(numb) 
    694             name = self._create_unique_key(dictionary, name, numb) 
    695         return name 
    696550 
    697551    def _get_node_value(self, node, tagname): 
     
    801655        return node_value, value_unit 
    802656 
    803     def _check_for_empty_data(self): 
    804         """ 
    805         Creates an empty data set if no data is passed to the reader 
    806  
    807         :param data1d: presumably a Data1D object 
    808         """ 
    809         if self.current_dataset is None: 
    810             x_vals = np.empty(0) 
    811             y_vals = np.empty(0) 
    812             dx_vals = np.empty(0) 
    813             dy_vals = np.empty(0) 
    814             dxl = np.empty(0) 
    815             dxw = np.empty(0) 
    816             self.current_dataset = plottable_1D(x_vals, y_vals, dx_vals, dy_vals) 
    817             self.current_dataset.dxl = dxl 
    818             self.current_dataset.dxw = dxw 
    819  
    820657    def _check_for_empty_resolution(self): 
    821658        """ 
    822         A method to check all resolution data sets are the same size as I and Q 
    823         """ 
    824         if isinstance(self.current_dataset, plottable_1D): 
    825             dql_exists = False 
    826             dqw_exists = False 
    827             dq_exists = False 
    828             di_exists = False 
    829             if self.current_dataset.dxl is not None: 
    830                 dql_exists = True 
    831             if self.current_dataset.dxw is not None: 
    832                 dqw_exists = True 
    833             if self.current_dataset.dx is not None: 
    834                 dq_exists = True 
    835             if self.current_dataset.dy is not None: 
    836                 di_exists = True 
    837             if dqw_exists and not dql_exists: 
    838                 array_size = self.current_dataset.dxw.size - 1 
    839                 self.current_dataset.dxl = np.append(self.current_dataset.dxl, 
    840                                                      np.zeros([array_size])) 
    841             elif dql_exists and not dqw_exists: 
    842                 array_size = self.current_dataset.dxl.size - 1 
    843                 self.current_dataset.dxw = np.append(self.current_dataset.dxw, 
    844                                                      np.zeros([array_size])) 
    845             elif not dql_exists and not dqw_exists and not dq_exists: 
    846                 array_size = self.current_dataset.x.size - 1 
    847                 self.current_dataset.dx = np.append(self.current_dataset.dx, 
    848                                                     np.zeros([array_size])) 
    849             if not di_exists: 
    850                 array_size = self.current_dataset.y.size - 1 
    851                 self.current_dataset.dy = np.append(self.current_dataset.dy, 
    852                                                     np.zeros([array_size])) 
    853         elif isinstance(self.current_dataset, plottable_2D): 
    854             dqx_exists = False 
    855             dqy_exists = False 
    856             di_exists = False 
    857             mask_exists = False 
    858             if self.current_dataset.dqx_data is not None: 
    859                 dqx_exists = True 
    860             if self.current_dataset.dqy_data is not None: 
    861                 dqy_exists = True 
    862             if self.current_dataset.err_data is not None: 
    863                 di_exists = True 
    864             if self.current_dataset.mask is not None: 
    865                 mask_exists = True 
    866             if not dqy_exists: 
    867                 array_size = self.current_dataset.qy_data.size - 1 
    868                 self.current_dataset.dqy_data = np.append( 
    869                     self.current_dataset.dqy_data, np.zeros([array_size])) 
    870             if not dqx_exists: 
    871                 array_size = self.current_dataset.qx_data.size - 1 
    872                 self.current_dataset.dqx_data = np.append( 
    873                     self.current_dataset.dqx_data, np.zeros([array_size])) 
    874             if not di_exists: 
    875                 array_size = self.current_dataset.data.size - 1 
    876                 self.current_dataset.err_data = np.append( 
    877                     self.current_dataset.err_data, np.zeros([array_size])) 
    878             if not mask_exists: 
    879                 array_size = self.current_dataset.data.size - 1 
    880                 self.current_dataset.mask = np.append( 
    881                     self.current_dataset.mask, 
    882                     np.ones([array_size] ,dtype=bool)) 
    883  
    884     ####### All methods below are for writing CanSAS XML files ####### 
    885  
     659        a method to check all resolution data sets are the same size as I and q 
     660        """ 
     661        dql_exists = False 
     662        dqw_exists = False 
     663        dq_exists = False 
     664        di_exists = False 
     665        if self.current_dataset.dxl is not None: 
     666            dql_exists = True 
     667        if self.current_dataset.dxw is not None: 
     668            dqw_exists = True 
     669        if self.current_dataset.dx is not None: 
     670            dq_exists = True 
     671        if self.current_dataset.dy is not None: 
     672            di_exists = True 
     673        if dqw_exists and not dql_exists: 
     674            array_size = self.current_dataset.dxw.size - 1 
     675            self.current_dataset.dxl = np.append(self.current_dataset.dxl, 
     676                                                 np.zeros([array_size])) 
     677        elif dql_exists and not dqw_exists: 
     678            array_size = self.current_dataset.dxl.size - 1 
     679            self.current_dataset.dxw = np.append(self.current_dataset.dxw, 
     680                                                 np.zeros([array_size])) 
     681        elif not dql_exists and not dqw_exists and not dq_exists: 
     682            array_size = self.current_dataset.x.size - 1 
     683            self.current_dataset.dx = np.append(self.current_dataset.dx, 
     684                                                np.zeros([array_size])) 
     685        if not di_exists: 
     686            array_size = self.current_dataset.y.size - 1 
     687            self.current_dataset.dy = np.append(self.current_dataset.dy, 
     688                                                np.zeros([array_size])) 
     689 
     690    def _initialize_new_data_set(self, node=None): 
     691        if node is not None: 
     692            for child in node: 
     693                if child.tag.replace(self.base_ns, "") == "Idata": 
     694                    for i_child in child: 
     695                        if i_child.tag.replace(self.base_ns, "") == "Qx": 
     696                            self.current_dataset = plottable_2D() 
     697                            return 
     698        self.current_dataset = plottable_1D(np.array(0), np.array(0)) 
     699 
     700    ## Writing Methods 
    886701    def write(self, filename, datainfo): 
    887702        """ 
     
    15141329            exec "storage.%s = entry.text.strip()" % variable 
    15151330 
    1516  
    15171331# DO NOT REMOVE Called by outside packages: 
    15181332#    sas.sasgui.perspectives.invariant.invariant_state 
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rc94280c r8dec7e7  
    1313    TransmissionSpectrum, Detector 
    1414from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable 
    15  
    16  
    17 class Reader(): 
     15from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DefaultReaderException 
     16from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     17 
     18 
     19class Reader(FileReader): 
    1820    """ 
    1921    A class for reading in CanSAS v2.0 data files. The existing iteration opens 
     
    4042    # Raw file contents to be processed 
    4143    raw_data = None 
    42     # Data info currently being read in 
    43     current_datainfo = None 
    44     # SASdata set currently being read in 
    45     current_dataset = None 
    4644    # List of plottable1D objects that should be linked to the current_datainfo 
    4745    data1d = None 
     
    5654    # Flag to bypass extension check 
    5755    allow_all = True 
    58     # List of files to return 
    59     output = None 
    60  
    61     def read(self, filename): 
     56 
     57    def get_file_contents(self): 
    6258        """ 
    6359        This is the general read method that all SasView data_loaders must have. 
     
    6864        # Reinitialize when loading a new data file to reset all class variables 
    6965        self.reset_class_variables() 
     66 
     67        filename = self.f_open.name 
     68        self.f_open.close() # IO handled by h5py 
     69 
    7070        # Check that the file exists 
    7171        if os.path.isfile(filename): 
     
    7575            if extension in self.ext or self.allow_all: 
    7676                # Load the data file 
    77                 self.raw_data = h5py.File(filename, 'r') 
     77                try: 
     78                    self.raw_data = h5py.File(filename, 'r') 
     79                except Exception as e: 
     80                    if extension not in self.ext: 
     81                        msg = "CanSAS2.0 HDF5 Reader could not load file {}".format(basename + extension) 
     82                        raise DefaultReaderException(msg) 
     83                    raise FileContentsException(e.message) 
    7884                # Read in all child elements of top level SASroot 
    7985                self.read_children(self.raw_data, []) 
     
    427433        Data1D and Data2D objects 
    428434        """ 
    429  
    430435        # Type cast data arrays to float64 
    431436        if len(self.current_datainfo.trans_spectrum) > 0: 
     
    451456        # Type cast data arrays to float64 and find min/max as appropriate 
    452457        for dataset in self.data2d: 
    453             dataset.data = dataset.data.astype(np.float64) 
    454             dataset.err_data = dataset.err_data.astype(np.float64) 
    455             if dataset.qx_data is not None: 
    456                 dataset.xmin = np.min(dataset.qx_data) 
    457                 dataset.xmax = np.max(dataset.qx_data) 
    458                 dataset.qx_data = dataset.qx_data.astype(np.float64) 
    459             if dataset.dqx_data is not None: 
    460                 dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
    461             if dataset.qy_data is not None: 
    462                 dataset.ymin = np.min(dataset.qy_data) 
    463                 dataset.ymax = np.max(dataset.qy_data) 
    464                 dataset.qy_data = dataset.qy_data.astype(np.float64) 
    465             if dataset.dqy_data is not None: 
    466                 dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
    467             if dataset.q_data is not None: 
    468                 dataset.q_data = dataset.q_data.astype(np.float64) 
    469458            zeros = np.ones(dataset.data.size, dtype=bool) 
    470459            try: 
     
    489478                dataset.x_bins = dataset.qx_data[:n_cols] 
    490479                dataset.data = dataset.data.flatten() 
    491  
    492             final_dataset = combine_data_info_with_plottable( 
    493                 dataset, self.current_datainfo) 
    494             self.output.append(final_dataset) 
     480            self.current_dataset = dataset 
     481            self.send_to_output() 
    495482 
    496483        for dataset in self.data1d: 
    497             if dataset.x is not None: 
    498                 dataset.x = dataset.x.astype(np.float64) 
    499                 dataset.xmin = np.min(dataset.x) 
    500                 dataset.xmax = np.max(dataset.x) 
    501             if dataset.y is not None: 
    502                 dataset.y = dataset.y.astype(np.float64) 
    503                 dataset.ymin = np.min(dataset.y) 
    504                 dataset.ymax = np.max(dataset.y) 
    505             if dataset.dx is not None: 
    506                 dataset.dx = dataset.dx.astype(np.float64) 
    507             if dataset.dxl is not None: 
    508                 dataset.dxl = dataset.dxl.astype(np.float64) 
    509             if dataset.dxw is not None: 
    510                 dataset.dxw = dataset.dxw.astype(np.float64) 
    511             if dataset.dy is not None: 
    512                 dataset.dy = dataset.dy.astype(np.float64) 
    513             final_dataset = combine_data_info_with_plottable( 
    514                 dataset, self.current_datainfo) 
    515             self.output.append(final_dataset) 
     484            self.current_dataset = dataset 
     485            self.send_to_output() 
    516486 
    517487    def add_data_set(self, key=""): 
  • src/sas/sascalc/dataloader/readers/danse_reader.py

    r235f514 r713a047  
    55#This software was developed by the University of Tennessee as part of the 
    66#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation.  
     7#project funded by the US National Science Foundation. 
    88#If you use DANSE applications to do scientific research that leads to 
    99#publication, we ask that you acknowledge the use of the software with the 
     
    1414import math 
    1515import os 
    16 import sys 
    1716import numpy as np 
    1817import logging 
    19 from sas.sascalc.dataloader.data_info import Data2D, Detector 
     18from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
    2019from sas.sascalc.dataloader.manipulations import reader2D_converter 
     20from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     21from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
    2122 
    2223logger = logging.getLogger(__name__) 
     
    3031 
    3132 
    32 class Reader: 
     33class Reader(FileReader): 
    3334    """ 
    3435    Example data manipulation 
     
    4041    ## Extension 
    4142    ext  = ['.sans', '.SANS'] 
    42          
    43     def read(self, filename=None): 
    44         """ 
    45         Open and read the data in a file 
    46         @param file: path of the file 
    47         """ 
    48          
    49         read_it = False 
    50         for item in self.ext: 
    51             if filename.lower().find(item) >= 0: 
    52                 read_it = True 
    53                  
    54         if read_it: 
     43 
     44    def get_file_contents(self): 
     45        self.current_datainfo = DataInfo() 
     46        self.current_dataset = plottable_2D() 
     47        self.output = [] 
     48 
     49        loaded_correctly = True 
     50        error_message = "" 
     51 
     52        # defaults 
     53        # wavelength in Angstrom 
     54        wavelength = 10.0 
     55        # Distance in meter 
     56        distance   = 11.0 
     57        # Pixel number of center in x 
     58        center_x   = 65 
     59        # Pixel number of center in y 
     60        center_y   = 65 
     61        # Pixel size [mm] 
     62        pixel      = 5.0 
     63        # Size in x, in pixels 
     64        size_x     = 128 
     65        # Size in y, in pixels 
     66        size_y     = 128 
     67        # Format version 
     68        fversion   = 1.0 
     69 
     70        self.current_datainfo.filename = os.path.basename(self.f_open.name) 
     71        detector = Detector() 
     72        self.current_datainfo.detector.append(detector) 
     73 
     74        self.current_dataset.data = np.zeros([size_x, size_y]) 
     75        self.current_dataset.err_data = np.zeros([size_x, size_y]) 
     76 
     77        read_on = True 
     78        data_start_line = 1 
     79        while read_on: 
     80            line = self.f_open.readline() 
     81            data_start_line += 1 
     82            if line.find("DATA:") >= 0: 
     83                read_on = False 
     84                break 
     85            toks = line.split(':') 
    5586            try: 
    56                 datafile = open(filename, 'r') 
    57             except: 
    58                 raise  RuntimeError,"danse_reader cannot open %s" % (filename) 
    59          
    60             # defaults 
    61             # wavelength in Angstrom 
    62             wavelength = 10.0 
    63             # Distance in meter 
    64             distance   = 11.0 
    65             # Pixel number of center in x 
    66             center_x   = 65 
    67             # Pixel number of center in y 
    68             center_y   = 65 
    69             # Pixel size [mm] 
    70             pixel      = 5.0 
    71             # Size in x, in pixels 
    72             size_x     = 128 
    73             # Size in y, in pixels 
    74             size_y     = 128 
    75             # Format version 
    76             fversion   = 1.0 
    77              
    78             output = Data2D() 
    79             output.filename = os.path.basename(filename) 
    80             detector = Detector() 
    81             output.detector.append(detector) 
    82              
    83             output.data = np.zeros([size_x,size_y]) 
    84             output.err_data = np.zeros([size_x, size_y]) 
    85              
    86             data_conv_q = None 
    87             data_conv_i = None 
    88              
    89             if has_converter == True and output.Q_unit != '1/A': 
    90                 data_conv_q = Converter('1/A') 
    91                 # Test it 
    92                 data_conv_q(1.0, output.Q_unit) 
    93                  
    94             if has_converter == True and output.I_unit != '1/cm': 
    95                 data_conv_i = Converter('1/cm') 
    96                 # Test it 
    97                 data_conv_i(1.0, output.I_unit) 
    98          
    99             read_on = True 
    100             while read_on: 
    101                 line = datafile.readline() 
    102                 if line.find("DATA:") >= 0: 
    103                     read_on = False 
    104                     break 
    105                 toks = line.split(':') 
    10687                if toks[0] == "FORMATVERSION": 
    10788                    fversion = float(toks[1]) 
    108                 if toks[0] == "WAVELENGTH": 
     89                elif toks[0] == "WAVELENGTH": 
    10990                    wavelength = float(toks[1]) 
    11091                elif toks[0] == "DISTANCE": 
     
    120101                elif toks[0] == "SIZE_Y": 
    121102                    size_y = int(toks[1]) 
    122              
    123             # Read the data 
    124             data = [] 
    125             error = [] 
    126             if fversion == 1.0: 
    127                 data_str = datafile.readline() 
    128                 data = data_str.split(' ') 
    129             else: 
    130                 read_on = True 
    131                 while read_on: 
    132                     data_str = datafile.readline() 
    133                     if len(data_str) == 0: 
    134                         read_on = False 
    135                     else: 
    136                         toks = data_str.split() 
    137                         try: 
    138                             val = float(toks[0]) 
    139                             err = float(toks[1]) 
    140                             if data_conv_i is not None: 
    141                                 val = data_conv_i(val, units=output._yunit) 
    142                                 err = data_conv_i(err, units=output._yunit) 
    143                             data.append(val) 
    144                             error.append(err) 
    145                         except: 
    146                             logger.info("Skipping line:%s,%s" %(data_str, 
    147                                                                 sys.exc_value)) 
    148              
    149             # Initialize 
    150             x_vals = [] 
    151             y_vals = [] 
    152             ymin = None 
    153             ymax = None 
    154             xmin = None 
    155             xmax = None 
    156              
    157             # Qx and Qy vectors 
    158             theta = pixel / distance / 100.0 
    159             stepq = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
    160             for i_x in range(size_x): 
    161                 theta = (i_x - center_x + 1) * pixel / distance / 100.0 
    162                 qx = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
    163                  
    164                 if has_converter == True and output.Q_unit != '1/A': 
    165                     qx = data_conv_q(qx, units=output.Q_unit) 
    166                  
    167                 x_vals.append(qx) 
    168                 if xmin is None or qx < xmin: 
    169                     xmin = qx 
    170                 if xmax is None or qx > xmax: 
    171                     xmax = qx 
    172              
    173             ymin = None 
    174             ymax = None 
    175             for i_y in range(size_y): 
    176                 theta = (i_y - center_y + 1) * pixel / distance / 100.0 
    177                 qy = 4.0 * math.pi / wavelength * math.sin(theta/2.0) 
    178                  
    179                 if has_converter == True and output.Q_unit != '1/A': 
    180                     qy = data_conv_q(qy, units=output.Q_unit) 
    181                  
    182                 y_vals.append(qy) 
    183                 if ymin is None or qy < ymin: 
    184                     ymin = qy 
    185                 if ymax is None or qy > ymax: 
    186                     ymax = qy 
    187              
    188             # Store the data in the 2D array 
    189             i_x = 0 
    190             i_y = -1 
    191              
    192             for i_pt in range(len(data)): 
    193                 try: 
    194                     value = float(data[i_pt]) 
    195                 except: 
    196                     # For version 1.0, the data were still 
    197                     # stored as strings at this point. 
    198                     msg = "Skipping entry (v1.0):%s,%s" % (str(data[i_pt]), 
    199                                                            sys.exc_value) 
    200                     logger.info(msg) 
    201                  
    202                 # Get bin number 
    203                 if math.fmod(i_pt, size_x) == 0: 
    204                     i_x = 0 
    205                     i_y += 1 
    206                 else: 
    207                     i_x += 1 
    208                      
    209                 output.data[i_y][i_x] = value 
    210                 if fversion>1.0: 
    211                     output.err_data[i_y][i_x] = error[i_pt] 
    212                  
    213             # Store all data 
    214             # Store wavelength 
    215             if has_converter == True and output.source.wavelength_unit != 'A': 
    216                 conv = Converter('A') 
    217                 wavelength = conv(wavelength, 
    218                                   units=output.source.wavelength_unit) 
    219             output.source.wavelength = wavelength 
    220                  
    221             # Store distance 
    222             if has_converter == True and detector.distance_unit != 'm': 
    223                 conv = Converter('m') 
    224                 distance = conv(distance, units=detector.distance_unit) 
    225             detector.distance = distance 
    226              
    227             # Store pixel size 
    228             if has_converter == True and detector.pixel_size_unit != 'mm': 
    229                 conv = Converter('mm') 
    230                 pixel = conv(pixel, units=detector.pixel_size_unit) 
    231             detector.pixel_size.x = pixel 
    232             detector.pixel_size.y = pixel 
    233  
    234             # Store beam center in distance units 
    235             detector.beam_center.x = center_x * pixel 
    236             detector.beam_center.y = center_y * pixel 
    237              
    238             # Store limits of the image (2D array) 
    239             xmin = xmin - stepq / 2.0 
    240             xmax = xmax + stepq / 2.0 
    241             ymin = ymin - stepq /2.0 
    242             ymax = ymax + stepq / 2.0 
    243              
    244             if has_converter == True and output.Q_unit != '1/A': 
    245                 xmin = data_conv_q(xmin, units=output.Q_unit) 
    246                 xmax = data_conv_q(xmax, units=output.Q_unit) 
    247                 ymin = data_conv_q(ymin, units=output.Q_unit) 
    248                 ymax = data_conv_q(ymax, units=output.Q_unit) 
    249             output.xmin = xmin 
    250             output.xmax = xmax 
    251             output.ymin = ymin 
    252             output.ymax = ymax 
    253              
    254             # Store x and y axis bin centers 
    255             output.x_bins = x_vals 
    256             output.y_bins = y_vals 
    257             
    258             # Units 
    259             if data_conv_q is not None: 
    260                 output.xaxis("\\rm{Q_{x}}", output.Q_unit) 
    261                 output.yaxis("\\rm{Q_{y}}", output.Q_unit) 
    262             else: 
    263                 output.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
    264                 output.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
    265                  
    266             if data_conv_i is not None: 
    267                 output.zaxis("\\rm{Intensity}", output.I_unit) 
    268             else: 
    269                 output.zaxis("\\rm{Intensity}", "cm^{-1}") 
    270             
    271             if not fversion >= 1.0: 
    272                 msg = "Danse_reader can't read this file %s" % filename 
    273                 raise ValueError, msg 
    274             else: 
    275                 logger.info("Danse_reader Reading %s \n" % filename) 
    276              
    277             # Store loading process information 
    278             output.meta_data['loader'] = self.type_name 
    279             output = reader2D_converter(output) 
    280             return output 
    281          
    282         return None 
     103            except ValueError as e: 
     104                error_message += "Unable to parse {}. Default value used.\n".format(toks[0]) 
     105                loaded_correctly = False 
     106 
     107        # Read the data 
     108        data = [] 
     109        error = [] 
     110        if not fversion >= 1.0: 
     111            msg = "danse_reader can't read this file {}".format(self.f_open.name) 
     112            raise FileContentsException(msg) 
     113 
     114        for line_num, data_str in enumerate(self.f_open.readlines()): 
     115            toks = data_str.split() 
     116            try: 
     117                val = float(toks[0]) 
     118                err = float(toks[1]) 
     119                data.append(val) 
     120                error.append(err) 
     121            except ValueError as exc: 
     122                msg = "Unable to parse line {}: {}".format(line_num + data_start_line, data_str.strip()) 
     123                raise FileContentsException(msg) 
     124 
     125        num_pts = size_x * size_y 
     126        if len(data) < num_pts: 
     127            msg = "Not enough data points provided. Expected {} but got {}".format( 
     128                size_x * size_y, len(data)) 
     129            raise FileContentsException(msg) 
     130        elif len(data) > num_pts: 
     131            error_message += ("Too many data points provided. Expected {0} but" 
     132                " got {1}. Only the first {0} will be used.\n").format(num_pts, len(data)) 
     133            loaded_correctly = False 
     134            data = data[:num_pts] 
     135            error = error[:num_pts] 
     136 
     137        # Qx and Qy vectors 
     138        theta = pixel / distance / 100.0 
     139        i_x = np.arange(size_x) 
     140        theta = (i_x - center_x + 1) * pixel / distance / 100.0 
     141        x_vals = 4.0 * np.pi / wavelength * np.sin(theta / 2.0) 
     142        xmin = x_vals.min() 
     143        xmax = x_vals.max() 
     144 
     145        i_y = np.arange(size_y) 
     146        theta = (i_y - center_y + 1) * pixel / distance / 100.0 
     147        y_vals = 4.0 * np.pi / wavelength * np.sin(theta / 2.0) 
     148        ymin = y_vals.min() 
     149        ymax = y_vals.max() 
     150 
     151        self.current_dataset.data = np.array(data, dtype=np.float64).reshape((size_y, size_x)) 
     152        if fversion > 1.0: 
     153            self.current_dataset.err_data = np.array(error, dtype=np.float64).reshape((size_y, size_x)) 
     154 
     155        # Store all data 
     156        # Store wavelength 
     157        if has_converter == True and self.current_datainfo.source.wavelength_unit != 'A': 
     158            conv = Converter('A') 
     159            wavelength = conv(wavelength, 
     160                              units=self.current_datainfo.source.wavelength_unit) 
     161        self.current_datainfo.source.wavelength = wavelength 
     162 
     163        # Store distance 
     164        if has_converter == True and detector.distance_unit != 'm': 
     165            conv = Converter('m') 
     166            distance = conv(distance, units=detector.distance_unit) 
     167        detector.distance = distance 
     168 
     169        # Store pixel size 
     170        if has_converter == True and detector.pixel_size_unit != 'mm': 
     171            conv = Converter('mm') 
     172            pixel = conv(pixel, units=detector.pixel_size_unit) 
     173        detector.pixel_size.x = pixel 
     174        detector.pixel_size.y = pixel 
     175 
     176        # Store beam center in distance units 
     177        detector.beam_center.x = center_x * pixel 
     178        detector.beam_center.y = center_y * pixel 
     179 
     180 
     181        self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
     182        self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
     183        self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
     184 
     185        self.current_dataset.x_bins = x_vals 
     186        self.current_dataset.y_bins = y_vals 
     187 
     188        # Reshape data 
     189        x_vals = np.tile(x_vals, (size_y, 1)).flatten() 
     190        y_vals = np.tile(y_vals, (size_x, 1)).T.flatten() 
     191        if self.current_dataset.err_data == np.all(np.array(None)) or np.any(self.current_dataset.err_data <= 0): 
     192            new_err_data = np.sqrt(np.abs(self.current_dataset.data)) 
     193        else: 
     194            new_err_data = self.current_dataset.err_data.flatten() 
     195 
     196        self.current_dataset.err_data = new_err_data 
     197        self.current_dataset.qx_data = x_vals 
     198        self.current_dataset.qy_data = y_vals 
     199        self.current_dataset.q_data = np.sqrt(x_vals**2 + y_vals**2) 
     200        self.current_dataset.mask = np.ones(len(x_vals), dtype=bool) 
     201 
     202        # Store loading process information 
     203        self.current_datainfo.meta_data['loader'] = self.type_name 
     204 
     205        self.send_to_output() 
     206 
     207        if not loaded_correctly: 
     208            raise DataReaderException(error_message) 
  • src/sas/sascalc/dataloader/readers/red2d_reader.py

    ra1b8fee r2f85af7  
    55#This software was developed by the University of Tennessee as part of the 
    66#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation.  
     7#project funded by the US National Science Foundation. 
    88#See the license text in license.txt 
    99#copyright 2008, University of Tennessee 
    1010###################################################################### 
    11 from __future__ import print_function 
    12  
    1311import os 
    1412import numpy as np 
    1513import math 
    16 from sas.sascalc.dataloader.data_info import Data2D, Detector 
     14from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
     15from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     16from sas.sascalc.dataloader.loader_exceptions import FileContentsException 
    1717 
    1818# Look for unit converter 
     
    2222except: 
    2323    has_converter = False 
    24      
    25      
     24 
     25 
    2626def check_point(x_point): 
    2727    """ 
     
    3333    except: 
    3434        return 0 
    35        
    36          
    37 class Reader: 
     35 
     36 
     37class Reader(FileReader): 
    3838    """ Simple data reader for Igor data files """ 
    3939    ## File type 
     
    4343    ## Extension 
    4444    ext = ['.DAT', '.dat'] 
    45      
     45 
    4646    def write(self, filename, data): 
    4747        """ 
    4848        Write to .dat 
    49          
     49 
    5050        :param filename: file name to write 
    5151        :param data: data2D 
     
    5353        import time 
    5454        # Write the file 
    55         fd = open(filename, 'w') 
    56         t = time.localtime() 
    57         time_str = time.strftime("%H:%M on %b %d %y", t) 
    58          
    59         header_str = "Data columns are Qx - Qy - I(Qx,Qy)\n\nASCII data" 
    60         header_str += " created at %s \n\n" % time_str 
    61         # simple 2D header 
    62         fd.write(header_str) 
    63         # write qx qy I values 
    64         for i in range(len(data.data)): 
    65             fd.write("%g  %g  %g\n" % (data.qx_data[i], 
    66                                         data.qy_data[i], 
    67                                        data.data[i])) 
    68         # close 
    69         fd.close() 
    70  
    71     def read(self, filename=None): 
    72         """ Read file """ 
    73         if not os.path.isfile(filename): 
    74             raise ValueError, \ 
    75             "Specified file %s is not a regular file" % filename 
    76  
     55        try: 
     56            fd = open(filename, 'w') 
     57            t = time.localtime() 
     58            time_str = time.strftime("%H:%M on %b %d %y", t) 
     59 
     60            header_str = "Data columns are Qx - Qy - I(Qx,Qy)\n\nASCII data" 
     61            header_str += " created at %s \n\n" % time_str 
     62            # simple 2D header 
     63            fd.write(header_str) 
     64            # write qx qy I values 
     65            for i in range(len(data.data)): 
     66                fd.write("%g  %g  %g\n" % (data.qx_data[i], 
     67                                            data.qy_data[i], 
     68                                           data.data[i])) 
     69        finally: 
     70            fd.close() 
     71 
     72    def get_file_contents(self): 
    7773        # Read file 
    78         f = open(filename, 'r') 
    79         buf = f.read() 
    80         f.close() 
     74        buf = self.f_open.read() 
     75        self.f_open.close() 
    8176        # Instantiate data object 
    82         output = Data2D() 
    83         output.filename = os.path.basename(filename) 
    84         detector = Detector() 
    85         if len(output.detector) > 0: 
    86             print(str(output.detector[0])) 
    87         output.detector.append(detector) 
    88                  
     77        self.current_dataset = plottable_2D() 
     78        self.current_datainfo = DataInfo() 
     79        self.current_datainfo.filename = os.path.basename(self.f_open.name) 
     80        self.current_datainfo.detector.append(Detector()) 
     81 
    8982        # Get content 
    90         dataStarted = False 
    91          
     83        data_started = False 
     84 
    9285        ## Defaults 
    9386        lines = buf.split('\n') 
    9487        x = [] 
    9588        y = [] 
    96          
     89 
    9790        wavelength = None 
    9891        distance = None 
    9992        transmission = None 
    100          
     93 
    10194        pixel_x = None 
    10295        pixel_y = None 
    103          
    104         isInfo = False 
    105         isCenter = False 
    106  
    107         data_conv_q = None 
    108         data_conv_i = None 
    109          
    110         # Set units: This is the unit assumed for Q and I in the data file. 
    111         if has_converter == True and output.Q_unit != '1/A': 
    112             data_conv_q = Converter('1/A') 
    113             # Test it 
    114             data_conv_q(1.0, output.Q_unit) 
    115              
    116         if has_converter == True and output.I_unit != '1/cm': 
    117             data_conv_i = Converter('1/cm') 
    118             # Test it 
    119             data_conv_i(1.0, output.I_unit) 
    120          
    121                
     96 
     97        is_info = False 
     98        is_center = False 
     99 
    122100        # Remove the last lines before the for loop if the lines are empty 
    123101        # to calculate the exact number of data points 
     
    135113            ## Reading the header applies only to IGOR/NIST 2D q_map data files 
    136114            # Find setup info line 
    137             if isInfo: 
    138                 isInfo = False 
     115            if is_info: 
     116                is_info = False 
    139117                line_toks = line.split() 
    140118                # Wavelength in Angstrom 
     
    143121                    # Units 
    144122                    if has_converter == True and \ 
    145                     output.source.wavelength_unit != 'A': 
     123                    self.current_datainfo.source.wavelength_unit != 'A': 
    146124                        conv = Converter('A') 
    147125                        wavelength = conv(wavelength, 
    148                                           units=output.source.wavelength_unit) 
     126                                          units=self.current_datainfo.source.wavelength_unit) 
    149127                except: 
    150128                    #Not required 
     
    154132                    distance = float(line_toks[3]) 
    155133                    # Units 
    156                     if has_converter == True and detector.distance_unit != 'm': 
     134                    if has_converter == True and self.current_datainfo.detector[0].distance_unit != 'm': 
    157135                        conv = Converter('m') 
    158                         distance = conv(distance, units=detector.distance_unit) 
     136                        distance = conv(distance, 
     137                            units=self.current_datainfo.detector[0].distance_unit) 
    159138                except: 
    160139                    #Not required 
    161140                    pass 
    162                  
     141 
    163142                # Distance in meters 
    164143                try: 
     
    167146                    #Not required 
    168147                    pass 
    169                                              
     148 
    170149            if line.count("LAMBDA") > 0: 
    171                 isInfo = True 
    172                  
     150                is_info = True 
     151 
    173152            # Find center info line 
    174             if isCenter: 
    175                 isCenter = False 
     153            if is_center: 
     154                is_center = False 
    176155                line_toks = line.split() 
    177156                # Center in bin number 
     
    180159 
    181160            if line.count("BCENT") > 0: 
    182                 isCenter = True 
     161                is_center = True 
    183162            # Check version 
    184163            if line.count("Data columns") > 0: 
     
    187166            # Find data start 
    188167            if line.count("ASCII data") > 0: 
    189                 dataStarted = True 
     168                data_started = True 
    190169                continue 
    191170 
    192171            ## Read and get data. 
    193             if dataStarted == True: 
     172            if data_started == True: 
    194173                line_toks = line.split() 
    195174                if len(line_toks) == 0: 
    196175                    #empty line 
    197176                    continue 
    198                 # the number of columns must be stayed same  
     177                # the number of columns must be stayed same 
    199178                col_num = len(line_toks) 
    200179                break 
     
    204183        # index for lines_array 
    205184        lines_index = np.arange(len(lines)) 
    206          
     185 
    207186        # get the data lines 
    208187        data_lines = lines_array[lines_index >= (line_num - 1)] 
     
    213192        # split all data to one big list w/" "separator 
    214193        data_list = data_list.split() 
    215   
     194 
    216195        # Check if the size is consistent with data, otherwise 
    217196        #try the tab(\t) separator 
     
    233212            data_point = data_array.reshape(row_num, col_num).transpose() 
    234213        except: 
    235             msg = "red2d_reader: Can't read this file: Not a proper file format" 
    236             raise ValueError, msg 
     214            msg = "red2d_reader can't read this file: Incorrect number of data points provided." 
     215            raise FileContentsException(msg) 
    237216        ## Get the all data: Let's HARDcoding; Todo find better way 
    238217        # Defaults 
     
    257236        #if col_num > (6 + ver): mask[data_point[(6 + ver)] < 1] = False 
    258237        q_data = np.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data) 
    259             
    260         # Extra protection(it is needed for some data files):  
     238 
     239        # Extra protection(it is needed for some data files): 
    261240        # If all mask elements are False, put all True 
    262241        if not mask.any(): 
    263242            mask[mask == False] = True 
    264    
     243 
    265244        # Store limits of the image in q space 
    266245        xmin = np.min(qx_data) 
     
    269248        ymax = np.max(qy_data) 
    270249 
    271         # units 
    272         if has_converter == True and output.Q_unit != '1/A': 
    273             xmin = data_conv_q(xmin, units=output.Q_unit) 
    274             xmax = data_conv_q(xmax, units=output.Q_unit) 
    275             ymin = data_conv_q(ymin, units=output.Q_unit) 
    276             ymax = data_conv_q(ymax, units=output.Q_unit) 
    277              
    278250        ## calculate the range of the qx and qy_data 
    279251        x_size = math.fabs(xmax - xmin) 
    280252        y_size = math.fabs(ymax - ymin) 
    281          
     253 
    282254        # calculate the number of pixels in the each axes 
    283255        npix_y = math.floor(math.sqrt(len(data))) 
    284256        npix_x = math.floor(len(data) / npix_y) 
    285          
     257 
    286258        # calculate the size of bins 
    287259        xstep = x_size / (npix_x - 1) 
    288260        ystep = y_size / (npix_y - 1) 
    289          
     261 
    290262        # store x and y axis bin centers in q space 
    291263        x_bins = np.arange(xmin, xmax + xstep, xstep) 
    292264        y_bins = np.arange(ymin, ymax + ystep, ystep) 
    293         
     265 
    294266        # get the limits of q values 
    295267        xmin = xmin - xstep / 2 
     
    297269        ymin = ymin - ystep / 2 
    298270        ymax = ymax + ystep / 2 
    299          
     271 
    300272        #Store data in outputs 
    301273        #TODO: Check the lengths 
    302         output.data = data 
     274        self.current_dataset.data = data 
    303275        if (err_data == 1).all(): 
    304             output.err_data = np.sqrt(np.abs(data)) 
    305             output.err_data[output.err_data == 0.0] = 1.0 
     276            self.current_dataset.err_data = np.sqrt(np.abs(data)) 
     277            self.current_dataset.err_data[self.current_dataset.err_data == 0.0] = 1.0 
    306278        else: 
    307             output.err_data = err_data 
    308              
    309         output.qx_data = qx_data 
    310         output.qy_data = qy_data 
    311         output.q_data = q_data 
    312         output.mask = mask 
    313          
    314         output.x_bins = x_bins 
    315         output.y_bins = y_bins 
    316                 
    317         output.xmin = xmin 
    318         output.xmax = xmax 
    319         output.ymin = ymin 
    320         output.ymax = ymax 
    321          
    322         output.source.wavelength = wavelength 
    323          
     279            self.current_dataset.err_data = err_data 
     280 
     281        self.current_dataset.qx_data = qx_data 
     282        self.current_dataset.qy_data = qy_data 
     283        self.current_dataset.q_data = q_data 
     284        self.current_dataset.mask = mask 
     285 
     286        self.current_dataset.x_bins = x_bins 
     287        self.current_dataset.y_bins = y_bins 
     288 
     289        self.current_dataset.xmin = xmin 
     290        self.current_dataset.xmax = xmax 
     291        self.current_dataset.ymin = ymin 
     292        self.current_dataset.ymax = ymax 
     293 
     294        self.current_datainfo.source.wavelength = wavelength 
     295 
    324296        # Store pixel size in mm 
    325         detector.pixel_size.x = pixel_x 
    326         detector.pixel_size.y = pixel_y 
    327          
     297        self.current_datainfo.detector[0].pixel_size.x = pixel_x 
     298        self.current_datainfo.detector[0].pixel_size.y = pixel_y 
     299 
    328300        # Store the sample to detector distance 
    329         detector.distance = distance 
    330          
     301        self.current_datainfo.detector[0].distance = distance 
     302 
    331303        # optional data: if all of dq data == 0, do not pass to output 
    332304        if len(dqx_data) == len(qx_data) and dqx_data.any() != 0: 
     
    340312                    cos_th = qx_data / diag 
    341313                    sin_th = qy_data / diag 
    342                     output.dqx_data = np.sqrt((dqx_data * cos_th) * \ 
     314                    self.current_dataset.dqx_data = np.sqrt((dqx_data * cos_th) * \ 
    343315                                                 (dqx_data * cos_th) \ 
    344316                                                 + (dqy_data * sin_th) * \ 
    345317                                                  (dqy_data * sin_th)) 
    346                     output.dqy_data = np.sqrt((dqx_data * sin_th) * \ 
     318                    self.current_dataset.dqy_data = np.sqrt((dqx_data * sin_th) * \ 
    347319                                                 (dqx_data * sin_th) \ 
    348320                                                 + (dqy_data * cos_th) * \ 
    349321                                                  (dqy_data * cos_th)) 
    350322                else: 
    351                     output.dqx_data = dqx_data 
    352                     output.dqy_data = dqy_data 
     323                    self.current_dataset.dqx_data = dqx_data 
     324                    self.current_dataset.dqy_data = dqy_data 
    353325 
    354326        # Units of axes 
    355         if data_conv_q is not None: 
    356             output.xaxis("\\rm{Q_{x}}", output.Q_unit) 
    357             output.yaxis("\\rm{Q_{y}}", output.Q_unit) 
    358         else: 
    359             output.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
    360             output.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
    361         if data_conv_i is not None: 
    362             output.zaxis("\\rm{Intensity}", output.I_unit) 
    363         else: 
    364             output.zaxis("\\rm{Intensity}", "cm^{-1}") 
    365      
     327        self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
     328        self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
     329        self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
     330 
    366331        # Store loading process information 
    367         output.meta_data['loader'] = self.type_name 
    368  
    369         return output 
     332        self.current_datainfo.meta_data['loader'] = self.type_name 
     333 
     334        self.send_to_output() 
  • src/sas/sascalc/dataloader/readers/sesans_reader.py

    r149b8f6 rbe43448  
    88import numpy as np 
    99import os 
    10 from sas.sascalc.dataloader.data_info import Data1D 
     10from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     11from sas.sascalc.dataloader.data_info import plottable_1D, DataInfo 
     12from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
    1113 
    1214# Check whether we have a converter available 
     
    1820_ZERO = 1e-16 
    1921 
    20  
    21 class Reader: 
     22class Reader(FileReader): 
    2223    """ 
    2324    Class to load sesans files (6 columns). 
     
    2627    type_name = "SESANS" 
    2728 
    28     # Wildcards 
     29    ## Wildcards 
    2930    type = ["SESANS files (*.ses)|*.ses", 
    3031            "SESANS files (*..sesans)|*.sesans"] 
     
    3536    allow_all = True 
    3637 
    37     def read(self, path): 
    38         """ 
    39         Load data file 
     38    def get_file_contents(self): 
     39        self.current_datainfo = DataInfo() 
     40        self.current_dataset = plottable_1D(np.array([]), np.array([])) 
     41        self.current_datainfo.isSesans = True 
     42        self.output = [] 
    4043 
    41         :param path: file path 
     44        line = self.f_open.readline() 
     45        params = {} 
     46        while not line.startswith("BEGIN_DATA"): 
     47            terms = line.split() 
     48            if len(terms) >= 2: 
     49                params[terms[0]] = " ".join(terms[1:]) 
     50            line = self.f_open.readline() 
     51        self.params = params 
    4252 
    43         :return: SESANSData1D object, or None 
     53        if "FileFormatVersion" not in self.params: 
     54            raise FileContentsException("SES file missing FileFormatVersion") 
     55        if float(self.params["FileFormatVersion"]) >= 2.0: 
     56            raise FileContentsException("SASView only supports SES version 1") 
    4457 
    45         :raise RuntimeError: when the file can't be opened 
    46         :raise ValueError: when the length of the data vectors are inconsistent 
    47         """ 
    48         if os.path.isfile(path): 
    49             basename = os.path.basename(path) 
    50             _, extension = os.path.splitext(basename) 
    51             if not (self.allow_all or extension.lower() in self.ext): 
    52                 raise RuntimeError( 
    53                     "{} has an unrecognized file extension".format(path)) 
     58        if "SpinEchoLength_unit" not in self.params: 
     59            raise FileContentsException("SpinEchoLength has no units") 
     60        if "Wavelength_unit" not in self.params: 
     61            raise FileContentsException("Wavelength has no units") 
     62        if params["SpinEchoLength_unit"] != params["Wavelength_unit"]: 
     63            raise FileContentsException("The spin echo data has rudely used " 
     64                               "different units for the spin echo length " 
     65                               "and the wavelength.  While sasview could " 
     66                               "handle this instance, it is a violation " 
     67                               "of the file format and will not be " 
     68                               "handled by other software.") 
     69 
     70        headers = self.f_open.readline().split() 
     71 
     72        self._insist_header(headers, "SpinEchoLength") 
     73        self._insist_header(headers, "Depolarisation") 
     74        self._insist_header(headers, "Depolarisation_error") 
     75        self._insist_header(headers, "Wavelength") 
     76 
     77        data = np.loadtxt(self.f_open) 
     78 
     79        if data.shape[1] != len(headers): 
     80            raise FileContentsException( 
     81                "File has {} headers, but {} columns".format( 
     82                    len(headers), 
     83                    data.shape[1])) 
     84 
     85        if not data.size: 
     86            raise FileContentsException("{} is empty".format(path)) 
     87        x = data[:, headers.index("SpinEchoLength")] 
     88        if "SpinEchoLength_error" in headers: 
     89            dx = data[:, headers.index("SpinEchoLength_error")] 
    5490        else: 
    55             raise RuntimeError("{} is not a file".format(path)) 
    56         with open(path, 'r') as input_f: 
    57             line = input_f.readline() 
    58             params = {} 
    59             while not line.startswith("BEGIN_DATA"): 
    60                 terms = line.split() 
    61                 if len(terms) >= 2: 
    62                     params[terms[0]] = " ".join(terms[1:]) 
    63                 line = input_f.readline() 
    64             self.params = params 
     91            dx = x * 0.05 
     92        lam = data[:, headers.index("Wavelength")] 
     93        if "Wavelength_error" in headers: 
     94            dlam = data[:, headers.index("Wavelength_error")] 
     95        else: 
     96            dlam = lam * 0.05 
     97        y = data[:, headers.index("Depolarisation")] 
     98        dy = data[:, headers.index("Depolarisation_error")] 
    6599 
    66             if "FileFormatVersion" not in self.params: 
    67                 raise RuntimeError("SES file missing FileFormatVersion") 
    68             if float(self.params["FileFormatVersion"]) >= 2.0: 
    69                 raise RuntimeError("SASView only supports SES version 1") 
     100        lam_unit = self._unit_fetch("Wavelength") 
     101        x, x_unit = self._unit_conversion(x, "A", 
     102                                          self._unit_fetch( 
     103                                              "SpinEchoLength")) 
     104        dx, dx_unit = self._unit_conversion( 
     105            dx, lam_unit, 
     106            self._unit_fetch("SpinEchoLength")) 
     107        dlam, dlam_unit = self._unit_conversion( 
     108            dlam, lam_unit, 
     109            self._unit_fetch("Wavelength")) 
     110        y_unit = self._unit_fetch("Depolarisation") 
    70111 
    71             if "SpinEchoLength_unit" not in self.params: 
    72                 raise RuntimeError("SpinEchoLength has no units") 
    73             if "Wavelength_unit" not in self.params: 
    74                 raise RuntimeError("Wavelength has no units") 
    75             if params["SpinEchoLength_unit"] != params["Wavelength_unit"]: 
    76                 raise RuntimeError("The spin echo data has rudely used " 
    77                                    "different units for the spin echo length " 
    78                                    "and the wavelength.  While sasview could " 
    79                                    "handle this instance, it is a violation " 
    80                                    "of the file format and will not be " 
    81                                    "handled by other software.") 
     112        self.current_dataset.x = x 
     113        self.current_dataset.y = y 
     114        self.current_dataset.lam = lam 
     115        self.current_dataset.dy = dy 
     116        self.current_dataset.dx = dx 
     117        self.current_dataset.dlam = dlam 
     118        self.current_datainfo.isSesans = True 
    82119 
    83             headers = input_f.readline().split() 
     120        self.current_datainfo._yunit = y_unit 
     121        self.current_datainfo._xunit = x_unit 
     122        self.current_datainfo.source.wavelength_unit = lam_unit 
     123        self.current_datainfo.source.wavelength = lam 
     124        self.current_datainfo.filename = os.path.basename(self.f_open.name) 
     125        self.current_dataset.xaxis(r"\rm{z}", x_unit) 
     126        # Adjust label to ln P/(lam^2 t), remove lam column refs 
     127        self.current_dataset.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
     128        # Store loading process information 
     129        self.current_datainfo.meta_data['loader'] = self.type_name 
     130        self.current_datainfo.sample.name = params["Sample"] 
     131        self.current_datainfo.sample.ID = params["DataFileTitle"] 
     132        self.current_datainfo.sample.thickness = self._unit_conversion( 
     133            float(params["Thickness"]), "cm", 
     134            self._unit_fetch("Thickness"))[0] 
    84135 
    85             self._insist_header(headers, "SpinEchoLength") 
    86             self._insist_header(headers, "Depolarisation") 
    87             self._insist_header(headers, "Depolarisation_error") 
    88             self._insist_header(headers, "Wavelength") 
     136        self.current_datainfo.sample.zacceptance = ( 
     137            float(params["Theta_zmax"]), 
     138            self._unit_fetch("Theta_zmax")) 
    89139 
    90             data = np.loadtxt(input_f) 
     140        self.current_datainfo.sample.yacceptance = ( 
     141            float(params["Theta_ymax"]), 
     142            self._unit_fetch("Theta_ymax")) 
    91143 
    92             if data.shape[1] != len(headers): 
    93                 raise RuntimeError( 
    94                     "File has {} headers, but {} columns".format( 
    95                         len(headers), 
    96                         data.shape[1])) 
    97  
    98             if not data.size: 
    99                 raise RuntimeError("{} is empty".format(path)) 
    100             x = data[:, headers.index("SpinEchoLength")] 
    101             if "SpinEchoLength_error" in headers: 
    102                 dx = data[:, headers.index("SpinEchoLength_error")] 
    103             else: 
    104                 dx = x * 0.05 
    105             lam = data[:, headers.index("Wavelength")] 
    106             if "Wavelength_error" in headers: 
    107                 dlam = data[:, headers.index("Wavelength_error")] 
    108             else: 
    109                 dlam = lam * 0.05 
    110             y = data[:, headers.index("Depolarisation")] 
    111             dy = data[:, headers.index("Depolarisation_error")] 
    112  
    113             lam_unit = self._unit_fetch("Wavelength") 
    114             x, x_unit = self._unit_conversion(x, "A", 
    115                                               self._unit_fetch( 
    116                                                   "SpinEchoLength")) 
    117             dx, dx_unit = self._unit_conversion( 
    118                 dx, lam_unit, 
    119                 self._unit_fetch("SpinEchoLength")) 
    120             dlam, dlam_unit = self._unit_conversion( 
    121                 dlam, lam_unit, 
    122                 self._unit_fetch("Wavelength")) 
    123             y_unit = self._unit_fetch("Depolarisation") 
    124  
    125             output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, 
    126                             isSesans=True) 
    127  
    128             output.y_unit = y_unit 
    129             output.x_unit = x_unit 
    130             output.source.wavelength_unit = lam_unit 
    131             output.source.wavelength = lam 
    132             self.filename = output.filename = basename 
    133             output.xaxis(r"\rm{z}", x_unit) 
    134             # Adjust label to ln P/(lam^2 t), remove lam column refs 
    135             output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
    136             # Store loading process information 
    137             output.meta_data['loader'] = self.type_name 
    138             output.sample.name = params["Sample"] 
    139             output.sample.ID = params["DataFileTitle"] 
    140             output.sample.thickness = self._unit_conversion( 
    141                 float(params["Thickness"]), "cm", 
    142                 self._unit_fetch("Thickness"))[0] 
    143  
    144             output.sample.zacceptance = ( 
    145                 float(params["Theta_zmax"]), 
    146                 self._unit_fetch("Theta_zmax")) 
    147  
    148             output.sample.yacceptance = ( 
    149                 float(params["Theta_ymax"]), 
    150                 self._unit_fetch("Theta_ymax")) 
    151             return output 
     144        self.send_to_output() 
    152145 
    153146    @staticmethod 
    154147    def _insist_header(headers, name): 
    155148        if name not in headers: 
    156             raise RuntimeError( 
     149            raise FileContentsException( 
    157150                "Missing {} column in spin echo data".format(name)) 
    158151 
  • src/sas/sascalc/dataloader/readers/xml_reader.py

    r235f514 rfafe52a  
    1818from lxml import etree 
    1919from lxml.builder import E 
     20from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    2021 
    2122logger = logging.getLogger(__name__) 
     
    2324PARSER = etree.ETCompatXMLParser(remove_comments=True, remove_pis=False) 
    2425 
    25 class XMLreader(): 
     26class XMLreader(FileReader): 
    2627    """ 
    2728    Generic XML read and write class. Mostly helper functions. 
     
    7475        except etree.XMLSyntaxError as xml_error: 
    7576            logger.info(xml_error) 
     77            raise xml_error 
    7678        except Exception: 
    7779            self.xml = None 
     
    9193        except etree.XMLSyntaxError as xml_error: 
    9294            logger.info(xml_error) 
    93         except Exception: 
     95            raise xml_error 
     96        except Exception as exc: 
    9497            self.xml = None 
    9598            self.xmldoc = None 
    9699            self.xmlroot = None 
     100            raise exc 
    97101 
    98102    def set_schema(self, schema): 
     
    206210        Create a unique key value for any dictionary to prevent overwriting 
    207211        Recurses until a unique key value is found. 
    208          
     212 
    209213        :param dictionary: A dictionary with any number of entries 
    210214        :param name: The index of the item to be added to dictionary 
     
    222226        Create an element tree for processing from an etree element 
    223227 
    224         :param root: etree Element(s)  
     228        :param root: etree Element(s) 
    225229        """ 
    226230        return etree.ElementTree(root) 
  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    r235f514 rfafe52a  
    1111 
    1212from sas.sascalc.dataloader.loader import Loader 
     13from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException 
    1314from sas.sasgui.guiframe.plugin_base import PluginBase 
    1415from sas.sasgui.guiframe.events import StatusEvent 
     
    4142APPLICATION_WLIST = config.APPLICATION_WLIST 
    4243 
     44 
    4345class Plugin(PluginBase): 
    4446 
     
    5658        """ 
    5759        # menu for data files 
    58         menu_list = [] 
    5960        data_file_hint = "load one or more data in the application" 
    6061        menu_list = [('&Load Data File(s)', data_file_hint, self.load_data)] 
    6162        gui_style = self.parent.get_style() 
    6263        style = gui_style & GUIFRAME.MULTIPLE_APPLICATIONS 
    63         style1 = gui_style & GUIFRAME.DATALOADER_ON 
    6464        if style == GUIFRAME.MULTIPLE_APPLICATIONS: 
    6565            # menu for data from folder 
     
    102102        self.get_data(file_list) 
    103103 
    104  
    105104    def can_load_data(self): 
    106105        """ 
     
    108107        """ 
    109108        return True 
    110  
    111109 
    112110    def _load_folder(self, event): 
     
    140138        """ 
    141139        if error is not None or str(error).strip() != "": 
    142             dial = wx.MessageDialog(self.parent, str(error), 'Error Loading File', 
     140            dial = wx.MessageDialog(self.parent, str(error), 
     141                                    'Error Loading File', 
    143142                                    wx.OK | wx.ICON_EXCLAMATION) 
    144143            dial.ShowModal() 
     
    149148        """ 
    150149        if os.path.isdir(path): 
    151             return [os.path.join(os.path.abspath(path), filename) for filename in os.listdir(path)] 
     150            return [os.path.join(os.path.abspath(path), filename) for filename 
     151                    in os.listdir(path)] 
    152152 
    153153    def _process_data_and_errors(self, item, p_file, output, message): 
     
    178178        for p_file in path: 
    179179            basename = os.path.basename(p_file) 
     180            # Skip files that start with a period 
     181            if basename.startswith("."): 
     182                msg = "The folder included a potential hidden file - %s." \ 
     183                      % basename 
     184                msg += " Do you wish to load this file as data?" 
     185                msg_box = wx.MessageDialog(None, msg, 'Warning', 
     186                                           wx.OK | wx.CANCEL) 
     187                if msg_box.ShowModal() == wx.ID_CANCEL: 
     188                    continue 
    180189            _, extension = os.path.splitext(basename) 
    181190            if extension.lower() in EXTENSIONS: 
     
    213222                info="info") 
    214223 
    215             except: 
    216                 logger.error(sys.exc_value) 
    217  
    218                 error_message = "The Data file you selected could not be loaded.\n" 
    219                 error_message += "Make sure the content of your file" 
    220                 error_message += " is properly formatted.\n" 
    221                 error_message += "When contacting the SasView team, mention the" 
    222                 error_message += " following:\n" 
    223                 error_message += "Error: " + str(sys.exc_info()[1]) 
    224                 file_errors[basename] = [error_message] 
    225                 self.load_update(output=output, message=error_message, info="warning") 
     224            except NoKnownLoaderException as e: 
     225                exception_occurred = True 
     226                logging.error(e.message) 
     227 
     228                error_message = "Loading data failed!\n" + e.message 
     229                self.load_update(output=None, message=e.message, info="warning") 
     230 
     231            except Exception as e: 
     232                exception_occurred = True 
     233                logger.error(e.message) 
     234 
     235                file_err = "The Data file you selected could not be " 
     236                file_err += "loaded.\nMake sure the content of your file" 
     237                file_err += " is properly formatted.\n" 
     238                file_err += "When contacting the SasView team, mention the" 
     239                file_err += " following:\n" 
     240                file_err += e.message 
     241                file_errors[basename] = [file_err] 
    226242 
    227243        if len(file_errors) > 0: 
     
    233249                    error_message += message + "\n" 
    234250                error_message += "\n" 
    235             self.load_update(output=output, message=error_message, info="error") 
    236  
    237         self.load_complete(output=output, message="Loading data complete!", 
    238             info="info") 
     251            if not exception_occurred: # Some data loaded but with errors 
     252                self.load_update(output=output, message=error_message, info="error") 
     253 
     254        if not exception_occurred: # Everything loaded as expected 
     255            self.load_complete(output=output, message="Loading data complete!", 
     256                               info="info") 
     257        else: 
     258            self.load_complete(output=None, message=error_message, info="error") 
     259 
    239260 
    240261    def load_update(self, output=None, message="", info="warning"): 
     
    245266            wx.PostEvent(self.parent, StatusEvent(status=message, info=info, 
    246267                                                  type="progress")) 
    247     def load_complete(self, output, message="", error_message="", path=None, 
    248                       info="warning"): 
    249         """ 
    250          post message to  status bar and return list of data 
    251         """ 
    252         wx.PostEvent(self.parent, StatusEvent(status=message, 
    253                                               info=info, 
     268 
     269    def load_complete(self, output, message="", info="warning"): 
     270        """ 
     271         post message to status bar and return list of data 
     272        """ 
     273        wx.PostEvent(self.parent, StatusEvent(status=message, info=info, 
    254274                                              type="stop")) 
    255         # if error_message != "": 
    256         #    self.load_error(error_message) 
    257         self.parent.add_data(data_list=output) 
     275        if output is not None: 
     276            self.parent.add_data(data_list=output) 
  • src/sas/sasgui/perspectives/file_converter/converter_panel.py

    red9f872 r19296dc  
    2424from sas.sascalc.file_converter.otoko_loader import OTOKOLoader 
    2525from sas.sascalc.file_converter.bsl_loader import BSLLoader 
     26from sas.sascalc.file_converter.ascii2d_loader import ASCII2DLoader 
    2627from sas.sascalc.file_converter.nxcansas_writer import NXcanSASWriter 
    2728from sas.sascalc.dataloader.data_info import Detector 
     
    3536    _STATICBOX_WIDTH = 410 
    3637    _BOX_WIDTH = 200 
    37     PANEL_SIZE = 480 
     38    PANEL_SIZE = 520 
    3839    FONT_VARIANT = 0 
    3940else: 
     
    4142    _STATICBOX_WIDTH = 430 
    4243    _BOX_WIDTH = 200 
    43     PANEL_SIZE = 500 
     44    PANEL_SIZE = 540 
    4445    FONT_VARIANT = 1 
    4546 
     
    352353            w.write(frame_data, output_path) 
    353354 
     355    def convert_2d_data(self, dataset): 
     356        metadata = self.get_metadata() 
     357        for key, value in metadata.iteritems(): 
     358            setattr(dataset[0], key, value) 
     359 
     360        w = NXcanSASWriter() 
     361        w.write(dataset, self.output.GetPath()) 
     362 
    354363    def on_convert(self, event): 
    355364        """Called when the Convert button is clicked""" 
     
    367376                qdata, iqdata = self.extract_otoko_data(self.q_input.GetPath()) 
    368377                self.convert_1d_data(qdata, iqdata) 
     378            elif self.data_type == 'ascii2d': 
     379                loader = ASCII2DLoader(self.iq_input.GetPath()) 
     380                data = loader.load() 
     381                dataset = [data] # ASCII 2D only ever contains 1 frame 
     382                self.convert_2d_data(dataset) 
    369383            else: # self.data_type == 'bsl' 
    370384                dataset = self.extract_bsl_data(self.iq_input.GetPath()) 
     
    372386                    # Cancelled by user 
    373387                    return 
    374  
    375                 metadata = self.get_metadata() 
    376                 for key, value in metadata.iteritems(): 
    377                     setattr(dataset[0], key, value) 
    378  
    379                 w = NXcanSASWriter() 
    380                 w.write(dataset, self.output.GetPath()) 
     388                self.convert_2d_data(dataset) 
     389 
    381390        except Exception as ex: 
    382391            msg = str(ex) 
     
    399408    def validate_inputs(self): 
    400409        msg = "You must select a" 
    401         if self.q_input.GetPath() == '' and self.data_type != 'bsl': 
     410        if self.q_input.GetPath() == '' and self.data_type != 'bsl' \ 
     411            and self.data_type != 'ascii2d': 
    402412            msg += " Q Axis input file." 
    403413        elif self.iq_input.GetPath() == '': 
     
    472482        dtype = event.GetEventObject().GetName() 
    473483        self.data_type = dtype 
    474         if dtype == 'bsl': 
     484        if dtype == 'bsl' or dtype == 'ascii2d': 
    475485            self.q_input.SetPath("") 
    476486            self.q_input.Disable() 
     
    500510 
    501511        instructions = ( 
    502         "Select linked single column 1D ASCII files containing the Q-axis and " 
    503         "Intensity-axis data, or 1D BSL/OTOKO files, or a 2D BSL/OTOKO file, " 
    504         "then choose where to save the converted file, and click Convert.\n" 
    505         "1D ASCII and BSL/OTOKO files can be converted to CanSAS (XML) or " 
    506         "NXcanSAS (HDF5) formats. 2D BSL/OTOKO files can only be converted to " 
    507         "the NXcanSAS format.\n" 
    508         "Metadata can be optionally added for the CanSAS XML format." 
     512        "If converting a 1D dataset, select linked single-column ASCII files " 
     513        "containing the Q-axis and intensity-axis data, or a 1D BSL/OTOKO file." 
     514        " If converting 2D data, select an ASCII file in the ISIS 2D file " 
     515        "format, or a 2D BSL/OTOKO file. Choose where to save the converted " 
     516        "file and click convert.\n" 
     517        "One dimensional ASCII and BSL/OTOKO files can be converted to CanSAS " 
     518        "(XML) or NXcanSAS (HDF5) formats. Two dimensional datasets can only be" 
     519        " converted to the NXcanSAS format.\n" 
     520        "Metadata can also be optionally added to the output file." 
    509521        ) 
    510522 
     
    526538            wx.ALIGN_CENTER_VERTICAL, 5) 
    527539        radio_sizer = wx.BoxSizer(wx.HORIZONTAL) 
    528         ascii_btn = wx.RadioButton(self, -1, "ASCII", name="ascii", 
     540        ascii_btn = wx.RadioButton(self, -1, "ASCII 1D", name="ascii", 
    529541            style=wx.RB_GROUP) 
    530542        ascii_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
    531543        radio_sizer.Add(ascii_btn) 
     544        ascii2d_btn = wx.RadioButton(self, -1, "ASCII 2D", name="ascii2d") 
     545        ascii2d_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
     546        radio_sizer.Add(ascii2d_btn) 
    532547        otoko_btn = wx.RadioButton(self, -1, "BSL 1D", name="otoko") 
    533548        otoko_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
    534549        radio_sizer.Add(otoko_btn) 
    535         input_grid.Add(radio_sizer, (y,1), (1,1), wx.ALL, 5) 
    536550        bsl_btn = wx.RadioButton(self, -1, "BSL 2D", name="bsl") 
    537551        bsl_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
    538552        radio_sizer.Add(bsl_btn) 
     553        input_grid.Add(radio_sizer, (y,1), (1,1), wx.ALL, 5) 
    539554        y += 1 
    540555 
     
    549564        y += 1 
    550565 
    551         iq_label = wx.StaticText(self, -1, "Intensity-Axis Data: ") 
     566        iq_label = wx.StaticText(self, -1, "Intensity Data: ") 
    552567        input_grid.Add(iq_label, (y,0), (1,1), wx.ALIGN_CENTER_VERTICAL, 5) 
    553568 
     
    647662 
    648663    def __init__(self, parent=None, title='File Converter', base=None, 
    649         manager=None, size=(PANEL_SIZE * 1.05, PANEL_SIZE / 1.1), 
     664        manager=None, size=(PANEL_SIZE * 0.96, PANEL_SIZE * 0.9), 
    650665        *args, **kwargs): 
    651666        kwargs['title'] = title 
  • src/sas/sasgui/perspectives/file_converter/file_converter.py

    r463e7ffc r94e3572  
    2525        Returns a set of menu entries 
    2626        """ 
    27         help_txt = "Convert single column ASCII data to CanSAS format" 
     27        help_txt = "Convert ASCII or BSL/OTOKO data to CanSAS or NXcanSAS formats" 
    2828        return [("File Converter", help_txt, self.on_file_converter)] 
    2929 
  • src/sas/sasgui/perspectives/file_converter/media/file_converter_help.rst

    rd73998c r59decb81  
    1818*   Single-column ASCII data, with lines that end without any delimiter, 
    1919    or with a comma or semi-colon delimiter 
     20*   2D `ISIS ASCII formatted 
     21    <http://www.isis.stfc.ac.uk/instruments/loq/software/ 
     22    colette-ascii-file-format-descriptions9808.pdf>`_ data 
    2023*   `1D BSL/OTOKO format 
    2124    <http://www.diamond.ac.uk/Beamlines/Soft-Condensed-Matter/small-angle/ 
     
    3639 
    37401) Select the files containing your Q-axis and Intensity-axis data 
    38 2) Choose whether the files are in ASCII, 1D BSL/OTOKO or 2D BSL/OTOKO format 
     412) Choose whether the files are in ASCII 1D, ASCII 2D, 1D BSL/OTOKO or 2D BSL/OTOKO format 
    39423) Choose where you would like to save the converted file 
    40434) Optionally, input some metadata such as sample size, detector name, etc 
     
    4750file, a dialog will appear asking which frames you would like converted. You 
    4851may enter a start frame, end frame & increment, and all frames in that subset 
    49 will be converted. For example, entering 0, 50 and 10 will convert frames 0,  
     52will be converted. For example, entering 0, 50 and 10 will convert frames 0, 
    505310, 20, 30, 40 & 50. 
    5154 
     
    5659single file, so there is an option in the *Select Frame* dialog to output each 
    5760frame to its own file. The single file option will produce one file with 
    58 multiple `<SASdata>` elements. The multiple file option will output a separate  
    59 file with one `<SASdata>` element for each frame. The frame number will also be  
     61multiple `<SASdata>` elements. The multiple file option will output a separate 
     62file with one `<SASdata>` element for each frame. The frame number will also be 
    6063appended to the file name. 
    6164 
    62 The multiple file option is not available when exporting to NXcanSAS because  
     65The multiple file option is not available when exporting to NXcanSAS because 
    6366the HDF5 format is more efficient at handling large amounts of data. 
    6467 
Note: See TracChangeset for help on using the changeset viewer.