Changeset 7af652d in sasview for src/sas/sascalc
- Timestamp:
- Mar 5, 2019 4:26:14 PM (5 years ago)
- Branches:
- master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1249
- Children:
- 1342f6a
- Parents:
- dbfd307 (diff), 8c9e65c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent. - git-author:
- Paul Kienzle <pkienzle@…> (03/05/19 16:26:14)
- git-committer:
- GitHub <noreply@…> (03/05/19 16:26:14)
- Location:
- src/sas/sascalc
- Files:
-
- 3 deleted
- 23 edited
-
calculator/c_extensions/__init__.py (deleted)
-
calculator/c_extensions/sld2i_module.c (modified) (6 diffs)
-
calculator/sas_gen.py (modified) (5 diffs)
-
corfunc/transform_thread.py (modified) (2 diffs)
-
data_util/nxsunit.py (modified) (2 diffs)
-
dataloader/data_info.py (modified) (4 diffs)
-
dataloader/file_reader_base_class.py (modified) (10 diffs)
-
dataloader/loader.py (modified) (1 diff)
-
dataloader/readers/abs_reader.py (modified) (4 diffs)
-
dataloader/readers/ascii_reader.py (modified) (1 diff)
-
dataloader/readers/associations.py (modified) (1 diff)
-
dataloader/readers/cansas_reader.py (modified) (1 diff)
-
dataloader/readers/danse_reader.py (modified) (1 diff)
-
dataloader/readers/red2d_reader.py (modified) (1 diff)
-
file_converter/bsl_loader.py (modified) (2 diffs)
-
file_converter/c_ext/__init__.py (deleted)
-
file_converter/c_ext/bsl_loader.c (modified) (2 diffs)
-
file_converter/nxcansas_writer.py (modified) (12 diffs)
-
pr/c_extensions/Cinvertor.c (modified) (25 diffs)
-
pr/c_extensions/__init__.py (deleted)
-
pr/fit/BumpsFitting.py (modified) (2 diffs)
-
pr/fit/Loader.py (modified) (1 diff)
-
pr/invertor.py (modified) (10 diffs)
-
pr/num_term.py (modified) (3 diffs)
-
corfunc/corfunc_calculator.py (modified) (1 diff)
-
invariant/invariant.py (modified) (1 diff)
Legend:
- Unmodified
- Added
- Removed
-
src/sas/sascalc/calculator/c_extensions/sld2i_module.c
ra1daf86 r7ba6470 2 2 SLD2I module to perform point and I calculations 3 3 */ 4 #include <stdio.h> 5 6 //#define Py_LIMITED_API 0x03020000 4 7 #include <Python.h> 5 #include <stdio.h> 8 6 9 #include "sld2i.h" 7 10 … … 13 16 #endif 14 17 15 16 // Utilities 17 #define INVECTOR(obj,buf,len) \ 18 do { \ 19 int err = PyObject_AsReadBuffer(obj, (const void **)(&buf), &len); \ 20 if (err < 0) return NULL; \ 21 len /= sizeof(*buf); \ 22 } while (0) 23 24 #define OUTVECTOR(obj,buf,len) \ 25 do { \ 26 int err = PyObject_AsWriteBuffer(obj, (void **)(&buf), &len); \ 27 if (err < 0) return NULL; \ 28 len /= sizeof(*buf); \ 29 } while (0) 30 18 // Vector binding glue 19 #if (PY_VERSION_HEX > 0x03000000) && !defined(Py_LIMITED_API) 20 // Assuming that a view into a writable vector points to a 21 // non-changing pointer for the duration of the C call, capture 22 // the view pointer and immediately free the view. 23 #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 24 Py_buffer VEC_view; \ 25 int VEC_err = PyObject_GetBuffer(VEC_obj, &VEC_view, PyBUF_WRITABLE|PyBUF_FORMAT); \ 26 if (VEC_err < 0 || sizeof(*VEC_buf) != VEC_view.itemsize) return NULL; \ 27 VEC_buf = (typeof(VEC_buf))VEC_view.buf; \ 28 VEC_len = VEC_view.len/sizeof(*VEC_buf); \ 29 PyBuffer_Release(&VEC_view); \ 30 } while (0) 31 #else 32 #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 33 int VEC_err = PyObject_AsWriteBuffer(VEC_obj, (void **)(&VEC_buf), &VEC_len); \ 34 if (VEC_err < 0) return NULL; \ 35 VEC_len /= sizeof(*VEC_buf); \ 36 } while (0) 37 #endif 31 38 32 39 /** … … 73 80 //printf("new GenI\n"); 74 81 if (!PyArg_ParseTuple(args, "iOOOOOOOOddd", &is_avg, &x_val_obj, &y_val_obj, &z_val_obj, &sldn_val_obj, &mx_val_obj, &my_val_obj, &mz_val_obj, &vol_pix_obj, &inspin, &outspin, &stheta)) return NULL; 75 INVECTOR(x_val_obj, x_val, n_x);76 INVECTOR(y_val_obj, y_val, n_y);77 INVECTOR(z_val_obj, z_val, n_z);78 INVECTOR(sldn_val_obj, sldn_val, n_sld);79 INVECTOR(mx_val_obj, mx_val, n_mx);80 INVECTOR(my_val_obj, my_val, n_my);81 INVECTOR(mz_val_obj, mz_val, n_mz);82 INVECTOR(vol_pix_obj, vol_pix, n_vol_pix);82 VECTOR(x_val_obj, x_val, n_x); 83 VECTOR(y_val_obj, y_val, n_y); 84 VECTOR(z_val_obj, z_val, n_z); 85 VECTOR(sldn_val_obj, sldn_val, n_sld); 86 VECTOR(mx_val_obj, mx_val, n_mx); 87 VECTOR(my_val_obj, my_val, n_my); 88 VECTOR(mz_val_obj, mz_val, n_mz); 89 VECTOR(vol_pix_obj, vol_pix, n_vol_pix); 83 90 sld2i = PyMem_Malloc(sizeof(GenI)); 84 91 //printf("sldi:%p\n", sld2i); … … 108 115 if (!PyArg_ParseTuple(args, "OOOO", &gen_obj, &qx_obj, &qy_obj, &I_out_obj)) return NULL; 109 116 sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI"); 110 INVECTOR(qx_obj, qx, n_qx);111 INVECTOR(qy_obj, qy, n_qy);112 OUTVECTOR(I_out_obj, I_out, n_out);117 VECTOR(qx_obj, qx, n_qx); 118 VECTOR(qy_obj, qy, n_qy); 119 VECTOR(I_out_obj, I_out, n_out); 113 120 //printf("qx, qy, I_out: %d %d %d, %d %d %d\n", qx, qy, I_out, n_qx, n_qy, n_out); 114 121 … … 136 143 if (!PyArg_ParseTuple(args, "OOO", &gen_obj, &q_obj, &I_out_obj)) return NULL; 137 144 sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI"); 138 INVECTOR(q_obj, q, n_q);139 OUTVECTOR(I_out_obj, I_out, n_out);145 VECTOR(q_obj, q, n_q); 146 VECTOR(I_out_obj, I_out, n_out); 140 147 141 148 // Sanity check … … 160 167 161 168 #define MODULE_DOC "Sld2i C Library" 162 #define MODULE_NAME " sld2i"163 #define MODULE_INIT2 init sld2i164 #define MODULE_INIT3 PyInit_ sld2i169 #define MODULE_NAME "_sld2i" 170 #define MODULE_INIT2 init_sld2i 171 #define MODULE_INIT3 PyInit__sld2i 165 172 #define MODULE_METHODS module_methods 166 173 -
src/sas/sascalc/calculator/sas_gen.py
r144e032a r952ea1f 14 14 import numpy as np 15 15 16 from . core import sld2i as mod16 from . import _sld2i 17 17 from .BaseComponent import BaseComponent 18 18 … … 145 145 self.params['Up_frac_out'], 146 146 self.params['Up_theta']) 147 model = mod.new_GenI(*args)147 model = _sld2i.new_GenI(*args) 148 148 if len(qy): 149 149 qx, qy = _vec(qx), _vec(qy) 150 150 I_out = np.empty_like(qx) 151 151 #print("npoints", qx.shape, "npixels", pos_x.shape) 152 mod.genicomXY(model, qx, qy, I_out)152 _sld2i.genicomXY(model, qx, qy, I_out) 153 153 #print("I_out after", I_out) 154 154 else: 155 155 qx = _vec(qx) 156 156 I_out = np.empty_like(qx) 157 mod.genicom(model, qx, I_out)157 _sld2i.genicom(model, qx, I_out) 158 158 vol_correction = self.data_total_volume / self.params['total_volume'] 159 159 result = (self.params['scale'] * vol_correction * I_out … … 304 304 z_dir2 *= z_dir2 305 305 mask = (x_dir2 + y_dir2 + z_dir2) <= 1.0 306 except Exception :307 logger.error( sys.exc_value)306 except Exception as exc: 307 logger.error(exc) 308 308 self.output = MagSLD(self.pos_x[mask], self.pos_y[mask], 309 309 self.pos_z[mask], self.sld_n[mask], … … 600 600 y_lines.append(y_line) 601 601 z_lines.append(z_line) 602 except Exception :603 logger.error( sys.exc_value)602 except Exception as exc: 603 logger.error(exc) 604 604 605 605 output = MagSLD(pos_x, pos_y, pos_z, sld_n, sld_mx, sld_my, sld_mz) … … 691 691 _vol_pix = float(toks[7]) 692 692 vol_pix = np.append(vol_pix, _vol_pix) 693 except Exception :693 except Exception as exc: 694 694 vol_pix = None 695 except Exception :695 except Exception as exc: 696 696 # Skip non-data lines 697 logger.error( sys.exc_value)697 logger.error(exc) 698 698 output = MagSLD(pos_x, pos_y, pos_z, sld_n, 699 699 sld_mx, sld_my, sld_mz) -
src/sas/sascalc/corfunc/transform_thread.py
ra859f99 ref74a8b 45 45 # gamma3(R) = 1/R int_{0}^{R} gamma1(x) dx 46 46 # trapz uses the trapezium rule to calculate the integral 47 mask = xs <= 200.0 # Only calculate gamma3 up to x=200 (as this is all that's plotted)47 mask = xs <= 1000.0 # Only calculate gamma3 up to x=1000 (as this is all that's plotted) 48 48 # gamma3 = [trapz(gamma1[:n], xs[:n])/xs[n-1] for n in range(2, len(xs[mask]) + 1)]j 49 49 # gamma3.insert(0, 1.0) # Gamma_3(0) is defined as 1 … … 79 79 80 80 transform1 = Data1D(xs, gamma1) 81 transform3 = Data1D(xs[xs <= 200], gamma3)81 transform3 = Data1D(xs[xs <= 1000], gamma3) 82 82 idf = Data1D(xs, idf) 83 83 -
src/sas/sascalc/data_util/nxsunit.py
re090ba90 r8c9e65c 135 135 sld = { '10^-6 Angstrom^-2': 1e-6, 'Angstrom^-2': 1 } 136 136 Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1, 137 '1/Angstrom': 1, '1/angstrom': 1, 'A^{-1}': 1, 'cm^{-1}': 1e-8, 137 138 '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8, '1/m': 1e-10, 138 'nm^ -1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 }139 'nm^{-1}': 1, 'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 } 139 140 140 141 _caret_optional(sld) … … 156 157 # units for that particular dimension. 157 158 # Note: don't have support for dimensionless units. 158 unknown = {None:1, '???':1, '': 1, 'a.u.': 1 }159 unknown = {None:1, '???':1, '': 1, 'a.u.': 1, 'Counts': 1, 'counts': 1} 159 160 160 161 def __init__(self, name): -
src/sas/sascalc/dataloader/data_info.py
re090ba90 r8c9e65c 957 957 _str += "Data:\n" 958 958 _str += " Type: %s\n" % self.__class__.__name__ 959 _str += " X- & Y-axis: %s\t[%s]\n" % (self._yaxis, self._yunit) 959 _str += " X-axis: %s\t[%s]\n" % (self._xaxis, self._xunit) 960 _str += " Y-axis: %s\t[%s]\n" % (self._yaxis, self._yunit) 960 961 _str += " Z-axis: %s\t[%s]\n" % (self._zaxis, self._zunit) 961 962 _str += " Length: %g \n" % (len(self.data)) … … 986 987 qx_data=qx_data, qy_data=qy_data, 987 988 q_data=q_data, mask=mask) 989 990 clone._xaxis = self._xaxis 991 clone._yaxis = self._yaxis 992 clone._zaxis = self._zaxis 993 clone._xunit = self._xunit 994 clone._yunit = self._yunit 995 clone._zunit = self._zunit 996 clone.x_bins = self.x_bins 997 clone.y_bins = self.y_bins 988 998 989 999 clone.title = self.title … … 1156 1166 def combine_data_info_with_plottable(data, datainfo): 1157 1167 """ 1158 A function that combines the DataInfo data in self.current_datainto with a plottable_1D or 2D data object. 1168 A function that combines the DataInfo data in self.current_datainto with a 1169 plottable_1D or 2D data object. 1159 1170 1160 1171 :param data: A plottable_1D or plottable_2D data object … … 1174 1185 final_dataset.yaxis(data._yaxis, data._yunit) 1175 1186 elif isinstance(data, plottable_2D): 1176 final_dataset = Data2D(data.data, data.err_data, data.qx_data, data.qy_data, data.q_data, 1177 data.mask, data.dqx_data, data.dqy_data) 1187 final_dataset = Data2D(data.data, data.err_data, data.qx_data, 1188 data.qy_data, data.q_data, data.mask, 1189 data.dqx_data, data.dqy_data) 1178 1190 final_dataset.xaxis(data._xaxis, data._xunit) 1179 1191 final_dataset.yaxis(data._yaxis, data._yunit) 1180 1192 final_dataset.zaxis(data._zaxis, data._zunit) 1181 if len(data.data.shape) == 2: 1182 n_rows, n_cols = data.data.shape 1183 final_dataset.y_bins = data.qy_data[0::int(n_cols)] 1184 final_dataset.x_bins = data.qx_data[:int(n_cols)] 1193 final_dataset.y_bins = data.y_bins 1194 final_dataset.x_bins = data.x_bins 1185 1195 else: 1186 return_string = "Should Never Happen: _combine_data_info_with_plottable input is not a plottable1d or " + \ 1187 "plottable2d data object" 1196 return_string = ("Should Never Happen: _combine_data_info_with_plottabl" 1197 "e input is not a plottable1d or plottable2d data " 1198 "object") 1188 1199 return return_string 1189 1200 -
src/sas/sascalc/dataloader/file_reader_base_class.py
r4a8d55c rc222c27 16 16 from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 17 17 combine_data_info_with_plottable 18 from sas.sascalc.data_util.nxsunit import Converter 18 19 19 20 logger = logging.getLogger(__name__) … … 37 38 "SasView cannot guarantee the accuracy of the data.") 38 39 40 39 41 class FileReader(object): 40 42 # String to describe the type of data this reader can load … … 45 47 ext = ['.txt'] 46 48 # Deprecated extensions 47 deprecated_extensions = ['.asc' , '.nxs']49 deprecated_extensions = ['.asc'] 48 50 # Bypass extension check and try to load anyway 49 51 allow_all = False … … 98 100 if len(self.output) > 0: 99 101 # Sort the data that's been loaded 100 self. sort_one_d_data()101 self.sort_ two_d_data()102 self.convert_data_units() 103 self.sort_data() 102 104 else: 103 105 msg = "Unable to find file at: {}\n".format(filepath) … … 140 142 Returns the entire file as a string. 141 143 """ 142 #return self.f_open.read()143 144 return decode(self.f_open.read()) 144 145 … … 166 167 self.output.append(data_obj) 167 168 168 def sort_ one_d_data(self):169 def sort_data(self): 169 170 """ 170 171 Sort 1D data along the X axis for consistency … … 174 175 # Normalize the units for 175 176 data.x_unit = self.format_unit(data.x_unit) 177 data._xunit = data.x_unit 176 178 data.y_unit = self.format_unit(data.y_unit) 179 data._yunit = data.y_unit 177 180 # Sort data by increasing x and remove 1st point 178 181 ind = np.lexsort((data.y, data.x)) … … 203 206 data.ymin = np.min(data.y) 204 207 data.ymax = np.max(data.y) 208 elif isinstance(data, Data2D): 209 # Normalize the units for 210 data.Q_unit = self.format_unit(data.Q_unit) 211 data.I_unit = self.format_unit(data.I_unit) 212 data._xunit = data.Q_unit 213 data._yunit = data.Q_unit 214 data._zunit = data.I_unit 215 data.data = data.data.astype(np.float64) 216 data.qx_data = data.qx_data.astype(np.float64) 217 data.xmin = np.min(data.qx_data) 218 data.xmax = np.max(data.qx_data) 219 data.qy_data = data.qy_data.astype(np.float64) 220 data.ymin = np.min(data.qy_data) 221 data.ymax = np.max(data.qy_data) 222 data.q_data = np.sqrt(data.qx_data * data.qx_data 223 + data.qy_data * data.qy_data) 224 if data.err_data is not None: 225 data.err_data = data.err_data.astype(np.float64) 226 if data.dqx_data is not None: 227 data.dqx_data = data.dqx_data.astype(np.float64) 228 if data.dqy_data is not None: 229 data.dqy_data = data.dqy_data.astype(np.float64) 230 if data.mask is not None: 231 data.mask = data.mask.astype(dtype=bool) 232 233 if len(data.data.shape) == 2: 234 n_rows, n_cols = data.data.shape 235 data.y_bins = data.qy_data[0::int(n_cols)] 236 data.x_bins = data.qx_data[:int(n_cols)] 237 data.data = data.data.flatten() 238 data = self._remove_nans_in_data(data) 239 if len(data.data) > 0: 240 data.xmin = np.min(data.qx_data) 241 data.xmax = np.max(data.qx_data) 242 data.ymin = np.min(data.qy_data) 243 data.ymax = np.max(data.qy_data) 205 244 206 245 @staticmethod … … 242 281 return data 243 282 244 def sort_two_d_data(self): 245 for dataset in self.output: 246 if isinstance(dataset, Data2D): 247 # Normalize the units for 248 dataset.x_unit = self.format_unit(dataset.Q_unit) 249 dataset.y_unit = self.format_unit(dataset.I_unit) 250 dataset.data = dataset.data.astype(np.float64) 251 dataset.qx_data = dataset.qx_data.astype(np.float64) 252 dataset.xmin = np.min(dataset.qx_data) 253 dataset.xmax = np.max(dataset.qx_data) 254 dataset.qy_data = dataset.qy_data.astype(np.float64) 255 dataset.ymin = np.min(dataset.qy_data) 256 dataset.ymax = np.max(dataset.qy_data) 257 dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data 258 + dataset.qy_data * dataset.qy_data) 259 if dataset.err_data is not None: 260 dataset.err_data = dataset.err_data.astype(np.float64) 261 if dataset.dqx_data is not None: 262 dataset.dqx_data = dataset.dqx_data.astype(np.float64) 263 if dataset.dqy_data is not None: 264 dataset.dqy_data = dataset.dqy_data.astype(np.float64) 265 if dataset.mask is not None: 266 dataset.mask = dataset.mask.astype(dtype=bool) 267 268 if len(dataset.data.shape) == 2: 269 n_rows, n_cols = dataset.data.shape 270 dataset.y_bins = dataset.qy_data[0::int(n_cols)] 271 dataset.x_bins = dataset.qx_data[:int(n_cols)] 272 dataset.data = dataset.data.flatten() 273 dataset = self._remove_nans_in_data(dataset) 274 if len(dataset.data) > 0: 275 dataset.xmin = np.min(dataset.qx_data) 276 dataset.xmax = np.max(dataset.qx_data) 277 dataset.ymin = np.min(dataset.qy_data) 278 dataset.ymax = np.max(dataset.qx_data) 283 @staticmethod 284 def set_default_1d_units(data): 285 """ 286 Set the x and y axes to the default 1D units 287 :param data: 1D data set 288 :return: 289 """ 290 data.xaxis(r"\rm{Q}", '1/A') 291 data.yaxis(r"\rm{Intensity}", "1/cm") 292 return data 293 294 @staticmethod 295 def set_default_2d_units(data): 296 """ 297 Set the x and y axes to the default 2D units 298 :param data: 2D data set 299 :return: 300 """ 301 data.xaxis("\\rm{Q_{x}}", '1/A') 302 data.yaxis("\\rm{Q_{y}}", '1/A') 303 data.zaxis("\\rm{Intensity}", "1/cm") 304 return data 305 306 def convert_data_units(self, default_q_unit="1/A"): 307 """ 308 Converts al; data to the sasview default of units of A^{-1} for Q and 309 cm^{-1} for I. 310 :param default_q_unit: The default Q unit used by Sasview 311 """ 312 convert_q = True 313 new_output = [] 314 for data in self.output: 315 if data.isSesans: 316 new_output.append(data) 317 continue 318 try: 319 file_x_unit = data._xunit 320 data_conv_x = Converter(file_x_unit) 321 except KeyError: 322 logger.info("Unrecognized Q units in data file. No data " 323 "conversion attempted") 324 convert_q = False 325 try: 326 327 if isinstance(data, Data1D): 328 if convert_q: 329 data.x = data_conv_x(data.x, units=default_q_unit) 330 data._xunit = default_q_unit 331 data.x_unit = default_q_unit 332 if data.dx is not None: 333 data.dx = data_conv_x(data.dx, 334 units=default_q_unit) 335 if data.dxl is not None: 336 data.dxl = data_conv_x(data.dxl, 337 units=default_q_unit) 338 if data.dxw is not None: 339 data.dxw = data_conv_x(data.dxw, 340 units=default_q_unit) 341 elif isinstance(data, Data2D): 342 if convert_q: 343 data.qx_data = data_conv_x(data.qx_data, 344 units=default_q_unit) 345 if data.dqx_data is not None: 346 data.dqx_data = data_conv_x(data.dqx_data, 347 units=default_q_unit) 348 try: 349 file_y_unit = data._yunit 350 data_conv_y = Converter(file_y_unit) 351 data.qy_data = data_conv_y(data.qy_data, 352 units=default_q_unit) 353 if data.dqy_data is not None: 354 data.dqy_data = data_conv_y(data.dqy_data, 355 units=default_q_unit) 356 except KeyError: 357 logger.info("Unrecognized Qy units in data file. No" 358 " data conversion attempted") 359 except KeyError: 360 message = "Unable to convert Q units from {0} to 1/A." 361 message.format(default_q_unit) 362 data.errors.append(message) 363 new_output.append(data) 364 self.output = new_output 279 365 280 366 def format_unit(self, unit=None): … … 367 453 self.current_dataset.qy_data)) 368 454 if has_error_dy: 369 self.current_dataset.err_data = self.current_dataset.err_data[x != 0] 455 self.current_dataset.err_data = self.current_dataset.err_data[ 456 x != 0] 370 457 if has_error_dqx: 371 self.current_dataset.dqx_data = self.current_dataset.dqx_data[x != 0] 458 self.current_dataset.dqx_data = self.current_dataset.dqx_data[ 459 x != 0] 372 460 if has_error_dqy: 373 self.current_dataset.dqy_data = self.current_dataset.dqy_data[x != 0] 461 self.current_dataset.dqy_data = self.current_dataset.dqy_data[ 462 x != 0] 374 463 if has_mask: 375 464 self.current_dataset.mask = self.current_dataset.mask[x != 0] -
src/sas/sascalc/dataloader/loader.py
re090ba90 r8c9e65c 367 367 try: 368 368 return fn(path, data) 369 except Exception: 370 pass # give other loaders a chance to succeed 371 # If we get here it is because all loaders failed 372 raise # reraises last exception 369 except Exception as exc: 370 msg = "Saving file {} using the {} writer failed.\n".format( 371 path, type(fn).__name__) 372 msg += str(exc) 373 logger.exception(msg) # give other loaders a chance to succeed 373 374 374 375 -
src/sas/sascalc/dataloader/readers/abs_reader.py
rbd5c3b1 rd96744de 48 48 detector = Detector() 49 49 data_line = 0 50 x_index = 4 50 51 self.reset_data_list(len(lines)) 51 52 self.current_datainfo.detector.append(detector) … … 63 64 for line in lines: 64 65 # Information line 1 66 if line.find(".bt5") > 0: 67 x_index = 0 65 68 if is_info: 66 69 is_info = False … … 171 174 172 175 try: 173 _x = float(toks[ 4])176 _x = float(toks[x_index]) 174 177 _y = float(toks[1]) 175 178 _dy = float(toks[2]) … … 225 228 raise ValueError("ascii_reader: could not load file") 226 229 230 self.current_dataset = self.set_default_1d_units(self.current_dataset) 227 231 if data_conv_q is not None: 228 232 self.current_dataset.xaxis("\\rm{Q}", base_q_unit) 229 else:230 self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}')231 233 if data_conv_i is not None: 232 234 self.current_dataset.yaxis("\\rm{Intensity}", base_i_unit) 233 else:234 self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}")235 235 236 236 # Store loading process information -
src/sas/sascalc/dataloader/readers/ascii_reader.py
r9e6aeaf r3bab401 157 157 158 158 self.remove_empty_q_values() 159 self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 160 self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 159 self.current_dataset = self.set_default_1d_units(self.current_dataset) 161 160 162 161 # Store loading process information -
src/sas/sascalc/dataloader/readers/associations.py
re090ba90 r8c9e65c 23 23 ".ses": "sesans_reader", 24 24 ".h5": "cansas_reader_HDF5", 25 ".nxs": "cansas_reader_HDF5", 25 26 ".txt": "ascii_reader", 26 27 ".dat": "red2d_reader", -
src/sas/sascalc/dataloader/readers/cansas_reader.py
re090ba90 r8c9e65c 812 812 node.append(point) 813 813 self.write_node(point, "Q", datainfo.x[i], 814 {'unit': datainfo. x_unit})814 {'unit': datainfo._xunit}) 815 815 if len(datainfo.y) >= i: 816 816 self.write_node(point, "I", datainfo.y[i], 817 {'unit': datainfo. y_unit})817 {'unit': datainfo._yunit}) 818 818 if datainfo.dy is not None and len(datainfo.dy) > i: 819 819 self.write_node(point, "Idev", datainfo.dy[i], 820 {'unit': datainfo. y_unit})820 {'unit': datainfo._yunit}) 821 821 if datainfo.dx is not None and len(datainfo.dx) > i: 822 822 self.write_node(point, "Qdev", datainfo.dx[i], 823 {'unit': datainfo. x_unit})823 {'unit': datainfo._xunit}) 824 824 if datainfo.dxw is not None and len(datainfo.dxw) > i: 825 825 self.write_node(point, "dQw", datainfo.dxw[i], 826 {'unit': datainfo. x_unit})826 {'unit': datainfo._xunit}) 827 827 if datainfo.dxl is not None and len(datainfo.dxl) > i: 828 828 self.write_node(point, "dQl", datainfo.dxl[i], 829 {'unit': datainfo. x_unit})829 {'unit': datainfo._xunit}) 830 830 if datainfo.isSesans: 831 831 sesans_attrib = {'x_axis': datainfo._xaxis, -
src/sas/sascalc/dataloader/readers/danse_reader.py
r2469df7 rfc51d06 180 180 detector.beam_center.y = center_y * pixel 181 181 182 183 self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 184 self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 185 self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 186 182 self.current_dataset = self.set_default_2d_units(self.current_dataset) 187 183 self.current_dataset.x_bins = x_vals 188 184 self.current_dataset.y_bins = y_vals -
src/sas/sascalc/dataloader/readers/red2d_reader.py
rc8321cfc r058f6c3 317 317 318 318 # Units of axes 319 self.current_dataset.xaxis(r"\rm{Q_{x}}", 'A^{-1}') 320 self.current_dataset.yaxis(r"\rm{Q_{y}}", 'A^{-1}') 321 self.current_dataset.zaxis(r"\rm{Intensity}", "cm^{-1}") 319 self.current_dataset = self.set_default_2d_units(self.current_dataset) 322 320 323 321 # Store loading process information -
src/sas/sascalc/file_converter/bsl_loader.py
rf00691d4 r952ea1f 1 from sas.sascalc.file_converter. core.bsl_loader import CLoader1 from sas.sascalc.file_converter._bsl_loader import CLoader 2 2 from sas.sascalc.dataloader.data_info import Data2D 3 3 from copy import deepcopy … … 67 67 'swap_bytes': int(metadata[3]) 68 68 } 69 except :69 except Exception: 70 70 is_valid = False 71 71 err_msg = "Invalid metadata in header file for {}" -
src/sas/sascalc/file_converter/c_ext/bsl_loader.c
rd5aeaa3 r952ea1f 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 //#define Py_LIMITED_API 0x03020000 1 5 #include <Python.h> 6 #include <structmember.h> 2 7 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 3 8 #include <numpy/arrayobject.h> 4 #include <stdio.h> 5 #include <stdlib.h> 6 #include "structmember.h" 9 7 10 #include "bsl_loader.h" 8 11 … … 292 295 293 296 #define MODULE_DOC "C module for loading bsl." 294 #define MODULE_NAME " bsl_loader"295 #define MODULE_INIT2 init bsl_loader296 #define MODULE_INIT3 PyInit_ bsl_loader297 #define MODULE_NAME "_bsl_loader" 298 #define MODULE_INIT2 init_bsl_loader 299 #define MODULE_INIT3 PyInit__bsl_loader 297 300 #define MODULE_METHODS module_methods 298 301 -
src/sas/sascalc/file_converter/nxcansas_writer.py
r574adc7 r109afbd 8 8 import os 9 9 10 from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader as Cansas2Reader10 from sas.sascalc.dataloader.readers.cansas_reader_HDF5 import Reader 11 11 from sas.sascalc.dataloader.data_info import Data1D, Data2D 12 12 13 class NXcanSASWriter( Cansas2Reader):13 class NXcanSASWriter(Reader): 14 14 """ 15 15 A class for writing in NXcanSAS data files. Any number of data sets may be … … 87 87 entry[names[2]].attrs['units'] = units 88 88 89 valid_data = all([is subclass(d.__class__, (Data1D, Data2D)) for d in dataset])89 valid_data = all([isinstance(d, (Data1D, Data2D)) for d in dataset]) 90 90 if not valid_data: 91 raise ValueError("All entries of dataset must be Data1D or Data2D objects") 91 raise ValueError("All entries of dataset must be Data1D or Data2D" 92 "objects") 92 93 93 94 # Get run name and number from first Data object … … 109 110 sasentry.attrs['version'] = '1.0' 110 111 111 i = 1 112 113 for data_obj in dataset: 114 data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i)) 112 for i, data_obj in enumerate(dataset): 113 data_entry = sasentry.create_group("sasdata{0:0=2d}".format(i+1)) 115 114 data_entry.attrs['canSAS_class'] = 'SASdata' 116 115 if isinstance(data_obj, Data1D): … … 118 117 elif isinstance(data_obj, Data2D): 119 118 self._write_2d_data(data_obj, data_entry) 120 i += 1121 119 122 120 data_info = dataset[0] … … 148 146 sample_entry.create_dataset('details', data=details) 149 147 150 # Instrum ment metadata148 # Instrument metadata 151 149 instrument_entry = sasentry.create_group('sasinstrument') 152 150 instrument_entry.attrs['canSAS_class'] = 'SASinstrument' … … 176 174 units=data_info.source.beam_size_unit, write_fn=_write_h5_float) 177 175 178 179 176 # Collimation metadata 180 177 if len(data_info.collimation) > 0: 181 i = 1 182 for coll_info in data_info.collimation: 178 for i, coll_info in enumerate(data_info.collimation): 183 179 collimation_entry = instrument_entry.create_group( 184 'sascollimation{0:0=2d}'.format(i ))180 'sascollimation{0:0=2d}'.format(i + 1)) 185 181 collimation_entry.attrs['canSAS_class'] = 'SAScollimation' 186 182 if coll_info.length is not None: 187 183 _write_h5_float(collimation_entry, coll_info.length, 'SDD') 188 collimation_entry['SDD'].attrs['units'] = coll_info.length_unit 184 collimation_entry['SDD'].attrs['units'] =\ 185 coll_info.length_unit 189 186 if coll_info.name is not None: 190 187 collimation_entry['name'] = _h5_string(coll_info.name) 191 188 else: 192 # Create a blank one - at least 1 set of collimation metadata 193 # required by format 194 collimation_entry = instrument_entry.create_group('sascollimation01') 189 # Create a blank one - at least 1 collimation required by format 190 instrument_entry.create_group('sascollimation01') 195 191 196 192 # Detector metadata 197 193 if len(data_info.detector) > 0: 198 194 i = 1 199 for det_info in data_info.detector:195 for i, det_info in enumerate(data_info.detector): 200 196 detector_entry = instrument_entry.create_group( 201 'sasdetector{0:0=2d}'.format(i ))197 'sasdetector{0:0=2d}'.format(i + 1)) 202 198 detector_entry.attrs['canSAS_class'] = 'SASdetector' 203 199 if det_info.distance is not None: 204 200 _write_h5_float(detector_entry, det_info.distance, 'SDD') 205 detector_entry['SDD'].attrs['units'] = det_info.distance_unit 201 detector_entry['SDD'].attrs['units'] =\ 202 det_info.distance_unit 206 203 if det_info.name is not None: 207 204 detector_entry['name'] = _h5_string(det_info.name) … … 209 206 detector_entry['name'] = _h5_string('') 210 207 if det_info.slit_length is not None: 211 _write_h5_float(detector_entry, det_info.slit_length, 'slit_length') 212 detector_entry['slit_length'].attrs['units'] = det_info.slit_length_unit 208 _write_h5_float(detector_entry, det_info.slit_length, 209 'slit_length') 210 detector_entry['slit_length'].attrs['units'] =\ 211 det_info.slit_length_unit 213 212 _write_h5_vector(detector_entry, det_info.offset) 214 213 # NXcanSAS doesn't save information about pitch, only roll … … 224 223 names=['x_pixel_size', 'y_pixel_size'], 225 224 write_fn=_write_h5_float, units=det_info.pixel_size_unit) 226 227 i += 1228 225 else: 229 226 # Create a blank one - at least 1 detector required by format … … 231 228 detector_entry.attrs['canSAS_class'] = 'SASdetector' 232 229 detector_entry.attrs['name'] = '' 230 231 # Process meta data 232 for i, process in enumerate(data_info.process): 233 process_entry = sasentry.create_group('sasprocess{0:0=2d}'.format( 234 i + 1)) 235 process_entry.attrs['canSAS_class'] = 'SASprocess' 236 if process.name: 237 name = _h5_string(process.name) 238 process_entry.create_dataset('name', data=name) 239 if process.date: 240 date = _h5_string(process.date) 241 process_entry.create_dataset('date', data=date) 242 if process.description: 243 desc = _h5_string(process.description) 244 process_entry.create_dataset('description', data=desc) 245 for j, term in enumerate(process.term): 246 # Don't save empty terms 247 if term: 248 h5_term = _h5_string(term) 249 process_entry.create_dataset('term{0:0=2d}'.format( 250 j + 1), data=h5_term) 251 for j, note in enumerate(process.notes): 252 # Don't save empty notes 253 if note: 254 h5_note = _h5_string(note) 255 process_entry.create_dataset('note{0:0=2d}'.format( 256 j + 1), data=h5_note) 257 258 # Transmission Spectrum 259 for i, trans in enumerate(data_info.trans_spectrum): 260 trans_entry = sasentry.create_group( 261 'sastransmission_spectrum{0:0=2d}'.format(i + 1)) 262 trans_entry.attrs['canSAS_class'] = 'SAStransmission_spectrum' 263 trans_entry.attrs['signal'] = 'T' 264 trans_entry.attrs['T_axes'] = 'T' 265 trans_entry.attrs['name'] = trans.name 266 if trans.timestamp is not '': 267 trans_entry.attrs['timestamp'] = trans.timestamp 268 transmission = trans_entry.create_dataset('T', 269 data=trans.transmission) 270 transmission.attrs['unertainties'] = 'Tdev' 271 trans_entry.create_dataset('Tdev', 272 data=trans.transmission_deviation) 273 trans_entry.create_dataset('lambda', data=trans.wavelength) 233 274 234 275 note_entry = sasentry.create_group('sasnote'.format(i)) … … 254 295 data_entry.attrs['signal'] = 'I' 255 296 data_entry.attrs['I_axes'] = 'Q' 256 data_entry.attrs['I_uncertainties'] = 'Idev' 257 data_entry.attrs['Q_indicies'] = 0 258 259 dI = data_obj.dy 260 if dI is None: 261 dI = np.zeros((data_obj.y.shape)) 262 263 data_entry.create_dataset('Q', data=data_obj.x) 264 data_entry.create_dataset('I', data=data_obj.y) 265 data_entry.create_dataset('Idev', data=dI) 297 data_entry.attrs['Q_indices'] = [0] 298 q_entry = data_entry.create_dataset('Q', data=data_obj.x) 299 q_entry.attrs['units'] = data_obj.x_unit 300 i_entry = data_entry.create_dataset('I', data=data_obj.y) 301 i_entry.attrs['units'] = data_obj.y_unit 302 if data_obj.dy is not None: 303 i_entry.attrs['uncertainties'] = 'Idev' 304 i_dev_entry = data_entry.create_dataset('Idev', data=data_obj.dy) 305 i_dev_entry.attrs['units'] = data_obj.y_unit 306 if data_obj.dx is not None: 307 q_entry.attrs['resolutions'] = 'dQ' 308 dq_entry = data_entry.create_dataset('dQ', data=data_obj.dx) 309 dq_entry.attrs['units'] = data_obj.x_unit 310 elif data_obj.dxl is not None: 311 q_entry.attrs['resolutions'] = ['dQl','dQw'] 312 dql_entry = data_entry.create_dataset('dQl', data=data_obj.dxl) 313 dql_entry.attrs['units'] = data_obj.x_unit 314 dqw_entry = data_entry.create_dataset('dQw', data=data_obj.dxw) 315 dqw_entry.attrs['units'] = data_obj.x_unit 266 316 267 317 def _write_2d_data(self, data, data_entry): … … 273 323 """ 274 324 data_entry.attrs['signal'] = 'I' 275 data_entry.attrs['I_axes'] = 'Q,Q' 276 data_entry.attrs['I_uncertainties'] = 'Idev' 277 data_entry.attrs['Q_indicies'] = [0,1] 325 data_entry.attrs['I_axes'] = 'Qx,Qy' 326 data_entry.attrs['Q_indices'] = [0,1] 278 327 279 328 (n_rows, n_cols) = (len(data.y_bins), len(data.x_bins)) 280 329 281 if n_rows == 0 and n_cols == 0:330 if (n_rows == 0 and n_cols == 0) or (n_cols*n_rows != data.data.size): 282 331 # Calculate rows and columns, assuming detector is square 283 332 # Same logic as used in PlotPanel.py _get_bins … … 288 337 raise ValueError("Unable to calculate dimensions of 2D data") 289 338 290 I = np.reshape(data.data, (n_rows, n_cols)) 291 dI = np.zeros((n_rows, n_cols)) 292 if not all(data.err_data == [None]): 293 dI = np.reshape(data.err_data, (n_rows, n_cols)) 294 qx = np.reshape(data.qx_data, (n_rows, n_cols)) 339 intensity = np.reshape(data.data, (n_rows, n_cols)) 340 qx = np.reshape(data.qx_data, (n_rows, n_cols)) 295 341 qy = np.reshape(data.qy_data, (n_rows, n_cols)) 296 342 297 I_entry = data_entry.create_dataset('I', data=I) 298 I_entry.attrs['units'] = data.I_unit 299 Qx_entry = data_entry.create_dataset('Qx', data=qx) 300 Qx_entry.attrs['units'] = data.Q_unit 301 Qy_entry = data_entry.create_dataset('Qy', data=qy) 302 Qy_entry.attrs['units'] = data.Q_unit 303 Idev_entry = data_entry.create_dataset('Idev', data=dI) 304 Idev_entry.attrs['units'] = data.I_unit 343 i_entry = data_entry.create_dataset('I', data=intensity) 344 i_entry.attrs['units'] = data.I_unit 345 qx_entry = data_entry.create_dataset('Qx', data=qx) 346 qx_entry.attrs['units'] = data.Q_unit 347 qy_entry = data_entry.create_dataset('Qy', data=qy) 348 qy_entry.attrs['units'] = data.Q_unit 349 if (data.err_data is not None 350 and not all(v is None for v in data.err_data)): 351 d_i = np.reshape(data.err_data, (n_rows, n_cols)) 352 i_entry.attrs['uncertainties'] = 'Idev' 353 i_dev_entry = data_entry.create_dataset('Idev', data=d_i) 354 i_dev_entry.attrs['units'] = data.I_unit 355 if (data.dqx_data is not None 356 and not all(v is None for v in data.dqx_data)): 357 qx_entry.attrs['resolutions'] = 'dQx' 358 dqx_entry = data_entry.create_dataset('dQx', data=data.dqx_data) 359 dqx_entry.attrs['units'] = data.Q_unit 360 if (data.dqy_data is not None 361 and not all(v is None for v in data.dqy_data)): 362 qy_entry.attrs['resolutions'] = 'dQy' 363 dqy_entry = data_entry.create_dataset('dQy', data=data.dqy_data) 364 dqy_entry.attrs['units'] = data.Q_unit 365 if data.mask is not None and not all(v is None for v in data.mask): 366 data_entry.attrs['mask'] = "mask" 367 mask = np.invert(np.asarray(data.mask, dtype=bool)) 368 data_entry.create_dataset('mask', data=mask) -
src/sas/sascalc/pr/c_extensions/Cinvertor.c
ra52f32f r7ba6470 5 5 * 6 6 */ 7 #include <Python.h>8 #include "structmember.h"9 7 #include <stdio.h> 10 8 #include <stdlib.h> … … 12 10 #include <time.h> 13 11 12 //#define Py_LIMITED_API 0x03050000 13 #include <Python.h> 14 #include <structmember.h> 15 16 // Vector binding glue 17 #if (PY_VERSION_HEX > 0x03000000) && !defined(Py_LIMITED_API) 18 // Assuming that a view into a writable vector points to a 19 // non-changing pointer for the duration of the C call, capture 20 // the view pointer and immediately free the view. 21 #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 22 Py_buffer VEC_view; \ 23 int VEC_err = PyObject_GetBuffer(VEC_obj, &VEC_view, PyBUF_WRITABLE|PyBUF_FORMAT); \ 24 if (VEC_err < 0 || sizeof(*VEC_buf) != VEC_view.itemsize) return NULL; \ 25 VEC_buf = (typeof(VEC_buf))VEC_view.buf; \ 26 VEC_len = VEC_view.len/sizeof(*VEC_buf); \ 27 PyBuffer_Release(&VEC_view); \ 28 } while (0) 29 #else 30 #define VECTOR(VEC_obj, VEC_buf, VEC_len) do { \ 31 int VEC_err = PyObject_AsWriteBuffer(VEC_obj, (void **)(&VEC_buf), &VEC_len); \ 32 if (VEC_err < 0) return NULL; \ 33 VEC_len /= sizeof(*VEC_buf); \ 34 } while (0) 35 #endif 36 14 37 #include "invertor.h" 15 16 38 17 39 /// Error object for raised exceptions 18 40 PyObject * CinvertorError; 19 20 #define INVECTOR(obj,buf,len) \21 do { \22 int err = PyObject_AsReadBuffer(obj, (const void **)(&buf), &len); \23 if (err < 0) return NULL; \24 len /= sizeof(*buf); \25 } while (0)26 27 #define OUTVECTOR(obj,buf,len) \28 do { \29 int err = PyObject_AsWriteBuffer(obj, (void **)(&buf), &len); \30 if (err < 0) return NULL; \31 len /= sizeof(*buf); \32 } while (0)33 34 41 35 42 // Class definition … … 99 106 100 107 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 101 OUTVECTOR(data_obj,data,ndata);108 VECTOR(data_obj,data,ndata); 102 109 103 110 free(self->params.x); … … 131 138 132 139 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 133 OUTVECTOR(data_obj, data, ndata);140 VECTOR(data_obj, data, ndata); 134 141 135 142 // Check that the input array is large enough … … 164 171 165 172 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 166 OUTVECTOR(data_obj,data,ndata);173 VECTOR(data_obj,data,ndata); 167 174 168 175 free(self->params.y); … … 196 203 197 204 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 198 OUTVECTOR(data_obj, data, ndata);205 VECTOR(data_obj, data, ndata); 199 206 200 207 // Check that the input array is large enough … … 229 236 230 237 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 231 OUTVECTOR(data_obj,data,ndata);238 VECTOR(data_obj,data,ndata); 232 239 233 240 free(self->params.err); … … 261 268 262 269 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 263 OUTVECTOR(data_obj, data, ndata);270 VECTOR(data_obj, data, ndata); 264 271 265 272 // Check that the input array is large enough … … 517 524 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 518 525 519 OUTVECTOR(data_obj,pars,npars);526 VECTOR(data_obj,pars,npars); 520 527 521 528 // PyList of residuals … … 568 575 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 569 576 570 OUTVECTOR(data_obj,pars,npars);577 VECTOR(data_obj,pars,npars); 571 578 572 579 // Should create this list only once and refill it … … 609 616 610 617 if (!PyArg_ParseTuple(args, "Od", &data_obj, &q)) return NULL; 611 OUTVECTOR(data_obj,pars,npars);618 VECTOR(data_obj,pars,npars); 612 619 613 620 iq_value = iq(pars, self->params.d_max, (int)npars, q); … … 634 641 635 642 if (!PyArg_ParseTuple(args, "Od", &data_obj, &q)) return NULL; 636 OUTVECTOR(data_obj,pars,npars);643 VECTOR(data_obj,pars,npars); 637 644 638 645 iq_value = iq_smeared(pars, self->params.d_max, (int)npars, … … 659 666 660 667 if (!PyArg_ParseTuple(args, "Od", &data_obj, &r)) return NULL; 661 OUTVECTOR(data_obj,pars,npars);668 VECTOR(data_obj,pars,npars); 662 669 663 670 pr_value = pr(pars, self->params.d_max, (int)npars, r); … … 686 693 687 694 if (!PyArg_ParseTuple(args, "OOd", &data_obj, &err_obj, &r)) return NULL; 688 OUTVECTOR(data_obj,pars,npars);695 VECTOR(data_obj,pars,npars); 689 696 690 697 if (err_obj == Py_None) { … … 692 699 pr_err_value = 0.0; 693 700 } else { 694 OUTVECTOR(err_obj,pars_err,npars2);701 VECTOR(err_obj,pars_err,npars2); 695 702 pr_err(pars, pars_err, self->params.d_max, (int)npars, r, &pr_value, &pr_err_value); 696 703 } … … 726 733 727 734 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 728 OUTVECTOR(data_obj,pars,npars);735 VECTOR(data_obj,pars,npars); 729 736 730 737 oscill = reg_term(pars, self->params.d_max, (int)npars, 100); … … 747 754 748 755 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 749 OUTVECTOR(data_obj,pars,npars);756 VECTOR(data_obj,pars,npars); 750 757 751 758 count = npeaks(pars, self->params.d_max, (int)npars, 100); … … 768 775 769 776 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 770 OUTVECTOR(data_obj,pars,npars);777 VECTOR(data_obj,pars,npars); 771 778 772 779 fraction = positive_integral(pars, self->params.d_max, (int)npars, 100); … … 792 799 793 800 if (!PyArg_ParseTuple(args, "OO", &data_obj, &err_obj)) return NULL; 794 OUTVECTOR(data_obj,pars,npars);795 OUTVECTOR(err_obj,pars_err,npars2);801 VECTOR(data_obj,pars,npars); 802 VECTOR(err_obj,pars_err,npars2); 796 803 797 804 fraction = positive_errors(pars, pars_err, self->params.d_max, (int)npars, 51); … … 813 820 814 821 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 815 OUTVECTOR(data_obj,pars,npars);822 VECTOR(data_obj,pars,npars); 816 823 817 824 value = rg(pars, self->params.d_max, (int)npars, 101); … … 833 840 834 841 if (!PyArg_ParseTuple(args, "O", &data_obj)) return NULL; 835 OUTVECTOR(data_obj,pars,npars);842 VECTOR(data_obj,pars,npars); 836 843 837 844 value = 4.0*acos(-1.0)*int_pr(pars, self->params.d_max, (int)npars, 101); … … 874 881 875 882 if (!PyArg_ParseTuple(args, "iiOO", &nfunc, &nr, &a_obj, &b_obj)) return NULL; 876 OUTVECTOR(a_obj,a,n_a);877 OUTVECTOR(b_obj,b,n_b);883 VECTOR(a_obj,a,n_a); 884 VECTOR(b_obj,b,n_b); 878 885 879 886 assert(n_b>=nfunc); … … 947 954 948 955 if (!PyArg_ParseTuple(args, "iiOO", &nfunc, &nr, &a_obj, &cov_obj)) return NULL; 949 OUTVECTOR(a_obj,a,n_a);950 OUTVECTOR(cov_obj,inv_cov,n_cov);956 VECTOR(a_obj,a,n_a); 957 VECTOR(cov_obj,inv_cov,n_cov); 951 958 952 959 assert(n_cov>=nfunc*nfunc); … … 981 988 982 989 if (!PyArg_ParseTuple(args, "iiO", &nfunc, &nr, &a_obj)) return NULL; 983 OUTVECTOR(a_obj,a,n_a);990 VECTOR(a_obj,a,n_a); 984 991 985 992 assert(n_a>=nfunc*(nr+self->params.npoints)); … … 1121 1128 1122 1129 #define MODULE_DOC "C extension module for inversion to P(r)." 1123 #define MODULE_NAME " pr_inversion"1124 #define MODULE_INIT2 init pr_inversion1125 #define MODULE_INIT3 PyInit_ pr_inversion1130 #define MODULE_NAME "_pr_inversion" 1131 #define MODULE_INIT2 init_pr_inversion 1132 #define MODULE_INIT3 PyInit__pr_inversion 1126 1133 #define MODULE_METHODS module_methods 1127 1134 -
src/sas/sascalc/pr/fit/BumpsFitting.py
r9a5097c r3e6829d 2 2 BumpsFitting module runs the bumps optimizer. 3 3 """ 4 from __future__ import division 5 4 6 import os 5 7 from datetime import timedelta, datetime … … 34 36 class Progress(object): 35 37 def __init__(self, history, max_step, pars, dof): 36 remaining_time = int(history.time[0]*( float(max_step)/history.step[0]-1))38 remaining_time = int(history.time[0]*(max_step/history.step[0]-1)) 37 39 # Depending on the time remaining, either display the expected 38 40 # time of completion, or the amount of time remaining. Use precision -
src/sas/sascalc/pr/fit/Loader.py
r574adc7 r57e48ca 1 """ 2 class Loader to load any kind of file 3 """ 4 1 5 from __future__ import print_function 2 6 3 # class Loader to load any king of file4 #import wx5 #import string6 7 import numpy as np 7 8 -
src/sas/sascalc/pr/invertor.py
rdbfd307 r7af652d 6 6 FIXME: The way the Invertor interacts with its C component should be cleaned up 7 7 """ 8 from __future__ import division 8 9 9 10 import numpy as np … … 17 18 from numpy.linalg import lstsq 18 19 from scipy import optimize 19 from sas.sascalc.pr. core.pr_inversion import Cinvertor20 from sas.sascalc.pr._pr_inversion import Cinvertor 20 21 21 22 logger = logging.getLogger(__name__) … … 71 72 A[j][i] = (Fourier transformed base function for point j) 72 73 73 We the mchoose a number of r-points, n_r, to evaluate the second74 We then choose a number of r-points, n_r, to evaluate the second 74 75 derivative of P(r) at. This is used as our regularization term. 75 76 For a vector r of length n_r, the following n_r rows are set to :: … … 144 145 x, y, err, d_max, q_min, q_max and alpha 145 146 """ 146 if 147 if name == 'x': 147 148 if 0.0 in value: 148 149 msg = "Invertor: one of your q-values is zero. " … … 268 269 A[i][j] = (Fourier transformed base function for point j) 269 270 270 We the mchoose a number of r-points, n_r, to evaluate the second271 We then choose a number of r-points, n_r, to evaluate the second 271 272 derivative of P(r) at. This is used as our regularization term. 272 273 For a vector r of length n_r, the following n_r rows are set to :: … … 416 417 A[i][j] = (Fourier transformed base function for point j) 417 418 418 We the mchoose a number of r-points, n_r, to evaluate the second419 We then choose a number of r-points, n_r, to evaluate the second 419 420 derivative of P(r) at. This is used as our regularization term. 420 421 For a vector r of length n_r, the following n_r rows are set to :: … … 498 499 try: 499 500 cov = np.linalg.pinv(inv_cov) 500 err = math.fabs(chi2 / float(npts - nfunc)) * cov501 except :501 err = math.fabs(chi2 / (npts - nfunc)) * cov 502 except Exception as exc: 502 503 # We were not able to estimate the errors 503 504 # Return an empty error matrix 504 logger.error( sys.exc_value)505 logger.error(exc) 505 506 506 507 # Keep a copy of the last output … … 539 540 540 541 """ 541 from num_term import NTermEstimator542 from .num_term import NTermEstimator 542 543 estimator = NTermEstimator(self.clone()) 543 544 try: 544 545 return estimator.num_terms(isquit_func) 545 except :546 except Exception as exc: 546 547 # If we fail, estimate alpha and return the default 547 548 # number of terms 548 549 best_alpha, _, _ = self.estimate_alpha(self.nfunc) 549 logger.warning("Invertor.estimate_numterms: %s" % sys.exc_value)550 logger.warning("Invertor.estimate_numterms: %s" % exc) 550 551 return self.nfunc, best_alpha, "Could not estimate number of terms" 551 552 … … 633 634 return best_alpha, message, elapsed 634 635 635 except :636 message = "Invertor.estimate_alpha: %s" % sys.exc_value636 except Exception as exc: 637 message = "Invertor.estimate_alpha: %s" % exc 637 638 return 0, message, elapsed 638 639 … … 750 751 self.cov[i][i] = float(toks2[1]) 751 752 752 except :753 msg = "Invertor.from_file: corrupted file\n%s" % sys.exc_value753 except Exception as exc: 754 msg = "Invertor.from_file: corrupted file\n%s" % exc 754 755 raise RuntimeError(msg) 755 756 else: -
src/sas/sascalc/pr/num_term.py
re090ba90 r8c9e65c 1 from __future__ import print_function 1 from __future__ import print_function, division 2 2 3 3 import math … … 51 51 osc = self.sort_osc() 52 52 dv = len(osc) 53 med = float(dv) / 2.053 med = 0.5*dv 54 54 odd = self.is_odd(dv) 55 55 medi = 0 … … 140 140 nts = self.compare_err() 141 141 div = len(nts) 142 tem = float(div) / 2.0142 tem = 0.5*div 143 143 if self.is_odd(div): 144 144 nt = nts[int(tem)] -
src/sas/sascalc/corfunc/corfunc_calculator.py
re090ba90 rdbfd307 245 245 """Fit the Guinier region of the curve""" 246 246 A = np.vstack([q**2, np.ones(q.shape)]).T 247 return lstsq(A, np.log(iq), rcond=None) 247 # CRUFT: numpy>=1.14.0 allows rcond=None for the following default 248 rcond = np.finfo(float).eps * max(A.shape) 249 return lstsq(A, np.log(iq), rcond=rcond) 248 250 249 251 def _fit_porod(self, q, iq): -
src/sas/sascalc/invariant/invariant.py
re090ba90 rdbfd307 344 344 else: 345 345 A = np.vstack([linearized_data.x / linearized_data.dy, 1.0 / linearized_data.dy]).T 346 # CRUFT: numpy>=1.14.0 allows rcond=None for the following default 347 rcond = np.finfo(float).eps * max(A.shape) 346 348 p, residuals, _, _ = np.linalg.lstsq(A, linearized_data.y / linearized_data.dy, 347 rcond= None)349 rcond=rcond) 348 350 349 351 # Get the covariance matrix, defined as inv_cov = a_transposed * a
Note: See TracChangeset
for help on using the changeset viewer.
