diff --git a/src/toolbox_scs/constants.py b/src/toolbox_scs/constants.py
index 0f521b44a5fedd80a2c9e3f6fbbf9dedf23a03d1..12a9b7ea0fd29cbd5132f999b99c3e7e19b4f34e 100644
--- a/src/toolbox_scs/constants.py
+++ b/src/toolbox_scs/constants.py
@@ -626,7 +626,10 @@ mnemonics = {
"FFT_SAM_Z_ENC": ({'source': 'SCS_CDIFFT_MOV/ENC/SAM_Z',
'key': 'value.value',
'dim': None},),
- "magnet": ({'source': 'SCS_CDIFFT_MAG/ASENS/PSU_CMON',
+ "magnet": ({'source': 'SCS_CDIFFT_MAG/MDL/FIELD',
+ 'key': 'actualPosition.value',
+ 'dim': None},),
+ "magnet_current": ({'source': 'SCS_CDIFFT_MAG/ASENS/PSU_CMON',
'key': 'value.value',
'dim': None},
{'source': 'SCS_CDIFFT_MAG/ASENS/CURRENT',
diff --git a/src/toolbox_scs/detectors/viking.py b/src/toolbox_scs/detectors/viking.py
index 6372881ada19dfaa3228c1bdd565d8a030e1d3f7..fe62261dd5e3951a993e13d20b778d00fbd2830c 100644
--- a/src/toolbox_scs/detectors/viking.py
+++ b/src/toolbox_scs/detectors/viking.py
@@ -138,7 +138,7 @@ class Viking:
'use_dark', 'bl_poly_deg', 'bl_signal_range', 'fields')
return {param: getattr(self, param.upper()) for param in params}
- def from_run(self, runNB, add_attrs=True):
+ def from_run(self, runNB, add_attrs=True, tid_offset=-1):
"""load a run
Load the run `runNB`. A thin wrapper around `toolbox_scs.load`.
@@ -150,6 +150,8 @@ class Viking:
add_attrs: bool
if True, adds the camera parameters as attributes to the dataset
(see get_camera_params())
+ tid_offset: int
+ train Id offset of Newton camera
Output
------
@@ -165,11 +167,20 @@ class Viking:
data2 = v.from_run(155) # load run 155
data = xarray.concat([data1, data2], 'trainId') # combine both
"""
+ #separately load newton image and deal with trainId mismatch
roi = {'newton': {'newton': {'roi': (self.Y_RANGE, self.X_RANGE),
'dim': ['newt_y', 'newt_x']}}}
- run, data = tb.load(self.PROPOSAL, runNB,
- fields=self.FIELDS, rois=roi)
- data['newton'] = data['newton'].astype(float)
+ run, newton = tb.load(self.PROPOSAL, runNB, 'newton', rois=roi)
+ newton = newton.shift(trainId=tid_offset).astype(float)
+
+ #load the rest
+ fields = [f for f in self.FIELDS if f != 'newton']
+ if len(fields) == 0:
+ data = newton
+ else:
+ run, data = tb.load(self.PROPOSAL, runNB,
+ fields=fields)
+ data = data.merge(newton, join='inner')
data = data.assign_coords(newt_x=np.polyval(self.ENERGY_CALIB,
data['newt_x']))
if add_attrs:
@@ -259,18 +270,24 @@ class Viking:
'endX': 'imageSpecifications.endX.value',
'startY': 'imageSpecifications.startY.value',
'endY': 'imageSpecifications.endY.value',
- 'temperature': 'CoolerActual.temperature.value',
+ 'temperature': 'coolerActual.temperature.value',
'high_capacity': 'HighCapacity.value',
'exposure_s': 'exposureTime.value'
}
ret = {}
- for k, v in dic.items():
- ret[k] = run.get_run_value('SCS_EXP_NEWTON/CAM/CAMERA', v)
+ try:
+ for k, v in dic.items():
+ ret[k] = run.get_run_value('SCS_EXP_NEWTON/CAM/CAMERA', v)
+ except Exception as e:
+ print(e)
+ dic['temperature'] = 'CoolerActual.temperature.value'
+ for k, v in dic.items():
+ ret[k] = run.get_run_value('SCS_EXP_NEWTON/CAM/CAMERA', v)
ret['gain'] = self.get_camera_gain(run)
ret['photoelectrons_per_count'] = self.e_per_counts(run, ret['gain'])
return ret
- def removePolyBaseline(self, data):
+ def removePolyBaseline(self, data, key='spectrum'):
"""
Removes a polynomial baseline to a spectrum, assuming a fixed
position for the signal.
@@ -279,6 +296,7 @@ class Viking:
----------
data: xarray Dataset
The Viking data containing the variable "spectrum"
+ or given by argument key
Output
------
@@ -287,10 +305,11 @@ class Viking:
containing the baseline subtracted spectra.
"""
- if 'spectrum' not in data:
+ if key not in data:
return
x = data.newt_x
- spectra = data['spectrum']
+ spectra = data[key]
+ #print(x)
mask = xr.ones_like(x, dtype=bool)
if len(self.BL_SIGNAL_RANGE) > 0:
if not hasattr(self.BL_SIGNAL_RANGE[0], '__len__'):
@@ -299,18 +318,22 @@ class Viking:
ranges = self.BL_SIGNAL_RANGE
for xrange in ranges:
mask = mask & ((x < xrange[0]) | (x > xrange[1]))
- x_bl = x.where(mask, drop=True)
+ x_bl = x.where(mask, drop=True).astype(x.dtype)
bl = spectra.sel(newt_x=x_bl)
+ #print(mask)
+ #print(x_bl)
+ #print(bl)
fit = np.polyfit(x_bl, bl.T, self.BL_POLY_DEG)
if len(spectra.shape) == 1:
return spectra - np.polyval(fit, x)
final_bl = np.empty(spectra.shape)
for t in range(spectra.shape[0]):
final_bl[t] = np.polyval(fit[:, t], x)
- data['spectrum_nobl'] = spectra - final_bl
+ data[key+'_nobl'] = spectra - final_bl
return data
-
- def xas(self, data, data_ref, thickness=1, plot=False,
+
+
+ def xas(self, sam, ref, thickness=1, dim='newt_x', plot=False,
plot_errors=True, xas_ylim=(-1, 3)):
"""
Given two independent datasets (one with sample and one reference),
@@ -320,13 +343,15 @@ class Viking:
Parameters
----------
- data: xarray Dataset
- the dataset containing the spectra with sample
- data_ref: xarray Dataset
- the dataset containing the spectra without sample
+ sam: xarray DataArray
+ the data array containing the spectra with sample
+ ref: xarray DataArray
+ the data array containing the spectra without sample
thickness: float
the thickness used for the calculation of the absorption
coefficient
+ dim: string
+ the name of the dimension along the dispersion axis
plot: bool
If True, plot the resulting average spectra.
plot_errors: bool
@@ -341,15 +366,14 @@ class Viking:
I0, It, absorptionCoef and their associated errors.
"""
- key = 'spectrum_nobl' if 'spectrum_nobl' in data else 'spectrum'
- if data['newt_x'].equals(data_ref['newt_x']) is False:
+ if sam[dim].equals(ref[dim]) is False:
return
- spectrum = data[key].mean(dim='trainId')
- std = data[key].std(dim='trainId')
- std_err = std / np.sqrt(data.sizes['trainId'])
- spectrum_ref = data_ref[key].mean(dim='trainId')
- std_ref = data_ref[key].std(dim='trainId')
- std_err_ref = std_ref / np.sqrt(data_ref.sizes['trainId'])
+ spectrum = sam.mean(dim='trainId')
+ std = sam.std(dim='trainId')
+ std_err = std / np.sqrt(sam.sizes['trainId'])
+ spectrum_ref = ref.mean(dim='trainId')
+ std_ref = ref.std(dim='trainId')
+ std_err_ref = std_ref / np.sqrt(ref.sizes['trainId'])
ds = xr.Dataset()
ds['It'] = spectrum
@@ -369,14 +393,15 @@ class Viking:
np.abs(absorption))
ds['absorptionCoef_stderr'] = absorption_stderr / (thickness *
np.abs(absorption))
- ds.attrs['n_It'] = data[key].sizes['trainId']
- ds.attrs['n_I0'] = data_ref[key].sizes['trainId']
+ ds.attrs['n_It'] = sam.sizes['trainId']
+ ds.attrs['n_I0'] = ref.sizes['trainId']
if plot:
plot_viking_xas(ds, plot_errors, xas_ylim)
return ds
- def calibrate(self, runList, plot=True):
+
+ def calibrate(self, runList, source='nrj', order=2, xrange=slice(None,None), plot=True):
"""
This routine determines the calibration coefficients to translate the
camera pixels into energy in eV. The Viking spectrometer is calibrated
@@ -398,6 +423,7 @@ class Viking:
energy_calib: np.array
the calibration coefficients (2nd degree polynomial)
"""
+ old_calib = self.ENERGY_CALIB
self.ENERGY_CALIB = [0, 1, 0]
x_pos = []
nrj = []
@@ -407,11 +433,16 @@ class Viking:
for i, runNB in enumerate(runList):
if plot:
print(runNB)
+ xrange0 = self.X_RANGE
+ self.X_RANGE=xrange
ds = self.from_run(runNB)
self.integrate(ds)
- avg_spectrum = ds['spectrum'].mean(dim='trainId')
+ ds = self.removePolyBaseline(ds)
+ avg_spectrum = ds['spectrum_nobl'].mean(dim='trainId')
p0 = [np.max(avg_spectrum)-np.min(avg_spectrum),
- avg_spectrum.argmax().values, 10, np.min(avg_spectrum)]
+ avg_spectrum['newt_x'][avg_spectrum.argmax()].values,
+ 10, np.min(avg_spectrum)]
+ eV_unit = 1e3 if 'UND' in source else 1
try:
popt, pcov = curve_fit(gauss1d, avg_spectrum['newt_x'].values,
avg_spectrum.values, p0=p0)
@@ -419,17 +450,21 @@ class Viking:
gaussian_fits.append(popt)
spectra.append(avg_spectrum)
runNBs.append(runNB)
- nrj.append(tb.load_run_values(self.PROPOSAL, runNB)['nrj'])
+ nrj.append(tb.load_run_values(self.PROPOSAL, runNB)[source]*eV_unit)
except Exception as e:
print(f'error with run {runNB}:', e)
+ self.ENERGY_CALIB = old_calib
+ finally:
+ self.X_RANGE = xrange0
x_pos = np.array(x_pos)
nrj = np.array(nrj)
idx = np.argsort(x_pos)
x_pos = x_pos[idx]
nrj = nrj[idx]
- energy_calib = np.polyfit(x_pos, nrj, 2)
+ energy_calib = np.polyfit(x_pos, nrj, order)
if plot:
plot_viking_calibration(spectra, x_pos, nrj, energy_calib,
gaussian_fits, runNBs)
self.ENERGY_CALIB = energy_calib
+ self.GAUSSIAN_FITS = gaussian_fits
return energy_calib