def test_read_srs(): a = scp.read('irdata/omnic series/rapid_scan.srs') assert str(a) == 'NDDataset: [float64] V (shape: (y:643, x:4160))' b = scp.read('irdata/omnic series/rapid_scan_reprocessed.srs') assert str(b) == 'NDDataset: [float64] a.u. (shape: (y:643, x:3734))' c = scp.read('irdata/omnic series/GC Demo.srs') assert c == [] d = scp.read('irdata/omnic series/TGA demo.srs') assert d == []
def test_issue417(): X = scp.read_omnic("irdata/nh4y-activation.spg") x = X - X[-1] print("--subtract with ds from read_omnic") print(f"mean x: {np.mean(x.data)}") print(f"var x: {np.var(x.data)}") print("") f = X.write("X.scp") X_r = scp.read("X.scp") f.unlink() assert_array_equal(X.data, X_r.data) assert_dataset_equal(X, X_r) assert_equal_units(X.units, X_r.units) assert_dataset_equal(X[-1], X_r[-1]) x_r = X_r - X_r[-1] print("--subtract after write/read_scp") print(f"mean x_r: {np.mean(x_r.data)}") print(f"var x_r: {np.var(x_r.data)}") print("") x_r2 = X_r - X_r[-1].data print("--subtract with data field") print(f"mean x_r2: {np.mean(x_r2.data)}") print(f"var x_r2: {np.var(x_r2.data)}") assert_array_equal(x.data, x_r2.data) assert_array_equal(x.data, x_r.data) assert_dataset_equal(x, x_r)
def test_read_labspec(): ramandir = Path('ramandata') scp.info_(ramandir) A = scp.read_labspec('Activation.txt', directory=ramandir) A.plot() A = scp.read_labspec('532nm-191216-Si 200mu.txt', directory=ramandir) A.plot() A = scp.read_labspec('serie190214-1.txt', directory=ramandir) A.plot(colorbar=True) A.plot_map(colorbar=True) A = scp.read_labspec('SMC1-Initial RT.txt', directory=ramandir) A.plot() B = scp.read(protocol='labspec', directory=ramandir) # this pack all spectra of the subdir directory B = scp.read_dir(directory=ramandir / 'subdir') B.plot() scp.show()
def test_bug_462(): A = scp.random((10, 100)) A.x = scp.Coord(np.arange(0.0, 100.0, 1), title="coord1") A.write("A.scp", confirm=False) B = scp.read("A.scp") assert B.x == A.x, "incorrect encoding/decoding" C = scp.random((10, 100)) C.x = [ scp.Coord(np.arange(0.0, 100.0, 1), title="coord1"), scp.Coord(np.arange(0.0, 1000.0, 10), title="coord2"), ] C.write("C.scp", confirm=False) D = scp.read("C.scp") assert len(D.x) == 2, "incorrect encoding/decoding"
def test_issue_227(): # IR spectrum, we want to make a baseline correction on the absorbance vs. time axis: ir = scp.read("irdata/nh4y-activation.spg") # baseline correction along x blc = scp.BaselineCorrection(ir) s1 = blc([5999.0, 3500.0], [1800.0, 1500.0], method="multivariate", interpolation="pchip") # baseline correction the transposed data along x (now on axis 0) -> should produce the same results # baseline correction along axis -1 previuosly blc = scp.BaselineCorrection(ir.T) s2 = blc( [5999.0, 3500.0], [1800.0, 1500.0], dim="x", method="multivariate", interpolation="pchip", ) # compare assert_dataset_equal(s1, s2.T) ir.y = ir.y - ir[0].y irs = ir[:, 2000.0:2020.0] blc = scp.BaselineCorrection(irs) blc.compute(*[[0.0, 2.0e3], [3.0e4, 3.3e4]], dim="y", interpolation="polynomial", order=1, method="sequential") blc.corrected.plot() # MS profiles, we want to make a baseline correction on the ion current vs. time axis: ms = scp.read("msdata/ion_currents.asc", timestamp=False) blc = scp.BaselineCorrection(ms[10.0:20.0, :]) blc.compute(*[[10.0, 11.0], [19.0, 20.0]], dim="y", interpolation="polynomial", order=1, method="sequential") blc.corrected.T.plot() show()
def test_read_spa(): nd = scp.read_spa('irdata/subdir/20-50/7_CZ0-100 Pd_21.SPA') assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:1, x:5549))' nd = scp.read_spa('irdata/subdir', merge=True) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:4, x:5549))' nd = scp.read_spa('irdata/subdir', merge=True, recursive=True) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:8, x:5549))' lst = scp.read('irdata', merge=True, recursive=True) # not selective on extension assert isinstance(lst, list) assert len(lst) >= 88
def test_generic_read(): # filename + extension specified ds = scp.read('wodger.spg') assert ds.name == 'wodger' # save with no filename (should save wodger.scp) path = ds.save() assert isinstance(path, Path) assert path.stem == ds.name assert path.parent == ds.directory # read should be équivalent to load (but read is a more general function, dataset = NDDataset.load('wodger.scp') assert dataset.name == 'wodger'
def addDataset(self, dataset=None): scp.debug_('Add a dataset') # Read the dataset try: if not dataset: dataset = scp.read(Qt_parent=self.parent, default_filter='omnic') if dataset is None: # still not determined. return except Exception as e: scp.error_(e) # Create a subproject with this dataset subproj = scp.Project() self.project.add_project(subproj, dataset.name) subproj.add_dataset(dataset, f'{dataset.name}/original') # Signal self.dirty = True self.sigProjectChanged.emit('dataset added')
def test_read_dir(): datadir = Path(prefs.datadir) A = scp.read() # should open a dialog (but to selects individual filename # if we want the whole dir - listdir must be used # this is equivalent to read_dir with a dialog to select directories only A = scp.read(listdir=True, directory=datadir / 'irdata' / 'subdir') assert len(A) == 4 A1 = scp.read_dir(directory=datadir / 'irdata' / 'subdir') assert A == A1 # listdir is not necessary if a directory location is given as a single argument B = scp.read(datadir / 'irdata' / 'subdir', listdir=True) B1 = scp.read(datadir / 'irdata' / 'subdir') assert B == B1 # if a directory is passed as a keyword, the behavior is different: # a dialog for file selection occurs except if listdir is set to True scp.read(directory=datadir / 'irdata' / 'subdir', listdir=True) # -> file selection dialog scp.read(directory=datadir / 'irdata' / 'subdir', listdir=True) # -> directory selection dialog
def test_round_docstring_example(): ds = scp.read("wodger.spg") ds_transformed1 = np.round(ds, 3) ds_transformed2 = np.around(ds, 3) ds_transformed3 = scp.around(ds, 3) ds_transformed4 = scp.round(ds, 3) ds_transformed5 = ds.round(3) ds_transformed6 = NDDataset.round(ds, 3) assert_dataset_equal(ds_transformed1, ds_transformed2) assert_dataset_equal(ds_transformed1, ds_transformed3) assert_dataset_equal(ds_transformed1, ds_transformed4) assert_dataset_equal(ds_transformed1, ds_transformed5) assert_dataset_equal(ds_transformed1, ds_transformed6) ds[:, 3000.0:3500.0] = scp.MASKED dsm_transformed1 = np.ma.round(ds) dsm_transformed2 = np.around(ds) dsm_transformed3 = scp.around(ds) dsm_transformed4 = ds.round() assert_dataset_equal(dsm_transformed1, dsm_transformed2) assert_dataset_equal(dsm_transformed1, dsm_transformed3) assert_dataset_equal(dsm_transformed1, dsm_transformed4)
# %% slideshow={"slide_type": "fragment"} tags=["hide-output"] import spectrochempy as scp # %% [markdown] slideshow={"slide_type": "subslide"} # ## NDDataset, the main object # %% [markdown] slideshow={"slide_type": "subslide"} # NDDataset is a python object, actually a container, which can represent most of your multidimensional spectroscopic # data. # %% [markdown] slideshow={"slide_type": "subslide"} # For instance, in the following we read data from a series of FTIR experiments, # provided by the OMNIC software, and create a **NDDataset** from these data # %% ds = scp.read('irdata/nh4y-activation.spg') print(ds) # %% [markdown] slideshow={"slide_type": "subslide"} # ### Display dataset information # %% ds # %% [markdown] slideshow={"slide_type": "subslide"} # ### Plotting a dataset # %% slideshow={"slide_type": "fragment"} _ = ds.plot() # %% [markdown] slideshow={"slide_type": "subslide"}
dfit = lst.inverse_transform() dfit.plot_pen(clear=False, color="g", lw=2, label=" Fitted line", legend="best") # %% [markdown] # ## NDDataset modelling using the Fit method # %% [markdown] # First we will load an IR dataset # %% nd = scp.read('irdata/nh4y-activation.spg"') # %% [markdown] # As we want to start with a single 1D spectra, we select the last one (index -1) # %% nd = nd[-1].squeeze() # nd[-1] returns a nddataset with shape (1,5549) # this is why we squeeze it to get a pure 1D dataset with shape (5549,) # %% [markdown] # Now we slice it to keep only the OH vibration region: # %% ndOH = nd[3700.0:3300.0] ndOH.plot()
def test_read(): f = Path('irdata/OPUS/test.0000') A1 = NDDataset.read_opus(f) assert A1.shape == (1, 2567) # single file read with protocol specified A2 = NDDataset.read(f, protocol='opus') assert A2 == A1 A3 = scp.read('irdata/nh4y-activation.spg', protocol='omnic') assert str(A3) == 'NDDataset: [float64] a.u. (shape: (y:55, x:5549))' # single file without protocol # inferred from filename A4 = NDDataset.read(f) assert A4 == A1 A5 = scp.read('irdata/nh4y-activation.spg') assert str(A5) == 'NDDataset: [float64] a.u. (shape: (y:55, x:5549))' # native format f = A5.save_as('nh4y.scp') A6 = scp.read('irdata/nh4y.scp') assert str(A6) == 'NDDataset: [float64] a.u. (shape: (y:55, x:5549))' A7 = scp.read('nh4y', directory='irdata', protocol='scp') assert str(A7) == 'NDDataset: [float64] a.u. (shape: (y:55, x:5549))' A8 = scp.read('nh4y', directory='irdata') assert str(A8) == 'NDDataset: [float64] a.u. (shape: (y:55, x:5549))' f.unlink() # multiple compatible 1D files automatically merged B = NDDataset.read('test.0000', 'test.0001', 'test.0002', directory=os.path.join('irdata', 'OPUS')) assert str(B) == 'NDDataset: [float64] a.u. (shape: (y:3, x:2567))' assert len(B) == 3 # multiple compatible 1D files not merged if the merge keyword is set to False C = scp.read('test.0000', 'test.0001', 'test.0002', directory=os.path.join('irdata', 'OPUS'), merge=False) assert isinstance(C, list) # multiple 1D files to merge D = NDDataset.read(['test.0000', 'test.0001', 'test.0002'], directory=os.path.join('irdata', 'OPUS')) assert D.shape == (3, 2567) # multiple 1D files not merged : they are passed as a list but merge is set to false E = scp.read(['test.0000', 'test.0001', 'test.0002'], directory=os.path.join('irdata', 'OPUS'), merge=False) assert isinstance(E, list) assert len(E) == 3 # read contents datadir = Path(prefs.datadir) p = datadir / 'irdata' / 'OPUS' / 'test.0000' content = p.read_bytes() F = NDDataset.read({p.name: content}) assert F.name == p.name assert F.shape == (1, 2567) # read multiple 1D contents and merge them lst = [datadir / 'irdata' / 'OPUS' / f'test.000{i}' for i in range(3)] G = NDDataset.read({p.name: p.read_bytes() for p in lst}) assert G.shape == (3, 2567) assert len(G) == 3 # read multiple 1D contents awithout merging lst = [datadir / 'irdata' / 'OPUS' / f'test.000{i}' for i in range(3)] H = NDDataset.read({p.name: p.read_bytes() for p in lst}, merge=False) isinstance(H, list) assert len(H) == 3 filename = datadir / 'wodger.spg' content = filename.read_bytes() # change the filename to be sure that the file will be read from the passed content filename = 'try.spg' # The most direct way to pass the byte content information nd = NDDataset.read(filename, content=content) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:2, x:5549))' # It can also be passed using a dictionary structure {filename:content, ....} nd = NDDataset.read({filename: content}) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:2, x:5549))' # Case where the filename is not provided nd = NDDataset.read(content) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:2, x:5549))' # Try with an .spa file filename = datadir / 'irdata/subdir/7_CZ0-100 Pd_101.SPA' content = filename.read_bytes() filename = 'try.spa' filename2 = datadir / 'irdata/subdir/7_CZ0-100 Pd_102.SPA' content2 = filename2.read_bytes() filename = 'try2.spa' nd = NDDataset.read({filename: content}) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:1, x:5549))' # Try with only a .spa content nd = NDDataset.read(content) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:1, x:5549))' # Try with several .spa content (should be stacked into a single nddataset) nd = NDDataset.read({filename: content, filename2: content2}) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:2, x:5549))' nd = NDDataset.read(content, content2) assert str(nd) == 'NDDataset: [float64] a.u. (shape: (y:2, x:5549))'
# Fist, as usual, we need to load the API. # %% import spectrochempy as scp # %% [markdown] # ## Loading an experimental dataset # %% [markdown] # A typical IR dataset (CO adsorption on supported CoMo catalyst in the 2300-1900 cm-1 region) will be used throughout. # %% [markdown] # We load the data using the generic API method `read` (the type of data is inferred from the extension) # %% ds = scp.read('irdata/CO@Mo_Al2O3.SPG') # %% ds.y -= ds.y.data[0] # start time a 0 for the first spectrum ds.y.title = 'time' ds.y = ds.y.to('minutes') # %% [markdown] # Let's set some preferences for plotting # %% prefs = ds.preferences prefs.method_1D = 'scatter+pen' prefs.method_2D = 'stack' prefs.colorbar = True prefs.colormap = 'Dark2'
# %% import spectrochempy as scp # %% [markdown] # ## Dialog boxes # # Retrieving Files and Directories, in day-to-day work is often made through Dialog Boxes. While we do not recommend # this procedure for advanced usage (see below), it is quite easy to do that with SCPy. To do so, we can use the # `read` function which open a dialog, allowing the selection of data file form various origin. By default, # the native SCPy type of data is proposed (file suffix: `.scp`). The desired type of files to display can be chosen # in a dropdown field. # %% X = scp.read() # %% [markdown] # The dialog box such as shown in this image: # # <center><img id='drawings' width='600px' src='./images/read.png'></img></center> # # The dialog Box allows selecting the file which data will be loaded in the variable `X`. Try for instance to run the # cell below, and select an omnic spg datafile (select the .spg extension), which you can find in the `irdata` # directory. # # <div class='alert alert-warning'> # <b>Tip</b> # # the dialog box does not necessarily pop up in the foreground: check your task bar ! # </div>
# ====================================================================================================================== """ 2D-IRIS analysis example ========================= In this example, we perform the 2D IRIS analysis of CO adsorption on a sulfide catalyst. """ import spectrochempy as scp ######################################################################################################################## # Uploading dataset # ----------------- X = scp.read("irdata/CO@Mo_Al2O3.SPG") ######################################################################################################################## # ``X`` has two coordinates: # * `wavenumbers` named "x" # * and `timestamps` (*i.e.,* the time of recording) named "y". print(X.coordset) ######################################################################################################################## # Setting new coordinates # ----------------------- # # The ``y`` coordinates of the dataset is the acquisition timestamp. However, each spectrum has been recorded # with a given pressure of CO in the infrared cell. # # Hence, it would be interesting to add pressure coordinates to the ``y`` dimension:
def test_protocolerror(): # wrong protocol with pytest.raises(ProtocolError): _ = scp.read("wodger", protocol="xxx")
# Before using the package, we must load the **API (Application Programming Interface)** # %% import spectrochempy as scp # %% [markdown] # ## NDDataset, the main object # %% [markdown] # NDDataset is a python object, actually a container, which can represent most of your multidimensional spectroscopic # data. # # For instance, in the following we read data from a series of FTIR experiments, provided by the OMNIC software: # %% ds = scp.read("irdata/nh4y-activation.spg") # %% [markdown] # ### Display dataset information # %% [markdown] # Short information: # %% print(ds) # %% [markdown] # Detailed information on the main metadata: # %% ds
############################################################################### # or may be simpler using `ur`: ur = scp.ur 10.0 * ur.meter / ur.gram / ur.volt ############################################################################### # `ur` stands for **unit registry**, which handle many type of units (and conversion between them) ############################################################################### # ## Units for dataset # # When loading experimental dataset using the `read` method, units are generally affected to coordinates and data ds = scp.read('wodger.spg')[0] prefs = ds.preferences prefs.figure.figsize = (7, 3) _ = ds.plot() ############################################################################### # * `wavenumbers` (`x`) coordinates are here expressed in $cm^{-1}$ # * and `data` are in absorbance ($a.u.$) units. ############################################################################### # ## Convert between units # # Here are some examples x = 36 * ur('km/hr') x.to('cm/s')