be_odf.py 47.1 KB
Newer Older
Somnath, Suhas's avatar
Somnath, Suhas committed
1
2
3
4
5
6
7
# -*- coding: utf-8 -*-
"""
Created on Tue Nov  3 15:24:12 2015

@author: Suhas Somnath, Stephen Jesse
"""

8
from __future__ import division, print_function, absolute_import, unicode_literals
9

Somnath, Suhas's avatar
Somnath, Suhas committed
10
from os import path, listdir, remove
11
from warnings import warn
12

Somnath, Suhas's avatar
Somnath, Suhas committed
13
14
import numpy as np
from scipy.io.matlab import loadmat  # To load parameters stored in Matlab .mat file
15

16
from .df_utils.be_utils import trimUDVS, getSpectroscopicParmLabel, parmsToDict, generatePlotGroups, \
17
    createSpecVals, requires_conjugate, nf32
18
from ...core.io.translator import Translator, generate_dummy_main_parms
19
from ...core.io.write_utils import INDICES_DTYPE, VALUES_DTYPE
20
from ...core.io.write_utils import build_ind_val_dsets, Dimension
21
from ...core.io.hdf_utils import get_h5_obj_refs, link_h5_objects_as_attrs, calc_chunks
22
from ...core.io.hdf_writer import HDFwriter
23
from ...core.io.virtual_data import VirtualGroup, VirtualDataset
24

25

Somnath, Suhas's avatar
Somnath, Suhas committed
26
27
28
29
30
class BEodfTranslator(Translator):
    """
    Translates either the Band Excitation (BE) scan or Band Excitation 
    Polarization Switching (BEPS) data format from the old data format(s) to .h5
    """
Unknown's avatar
Unknown committed
31

Chris Smith's avatar
Chris Smith committed
32
33
34
35
    def __init__(self, *args, **kwargs):
        super(BEodfTranslator, self).__init__(*args, **kwargs)
        self.hdf = None
        self.h5_raw = None
36
        self.num_rand_spectra = kwargs.pop('num_rand_spectra', 1000)
Unknown's avatar
Unknown committed
37
38
39
        self.FFT_BE_wave = None
        self.signal_type = None
        self.expt_type = None
Chris Smith's avatar
Chris Smith committed
40

41
    def translate(self, file_path, show_plots=True, save_plots=True, do_histogram=False, verbose=False):
Somnath, Suhas's avatar
Somnath, Suhas committed
42
43
44
45
46
47
48
49
50
51
52
53
54
55
        """
        Translates .dat data file(s) to a single .h5 file
        
        Parameters
        -------------
        file_path : String / Unicode
            Absolute file path for one of the data files. 
            It is assumed that this file is of the OLD data format.
        show_plots : (optional) Boolean
            Whether or not to show intermediate plots
        save_plots : (optional) Boolean
            Whether or not to save plots to disk
        do_histogram : (optional) Boolean
            Whether or not to construct histograms to visualize data quality. Note - this takes a fair amount of time
56
57
        verbose : (optional) Boolean
            Whether or not to print statements
Somnath, Suhas's avatar
Somnath, Suhas committed
58
59
60
61
62
63
64
            
        Returns
        ----------
        h5_path : String / Unicode
            Absolute path of the resultant .h5 file
        """
        (folder_path, basename) = path.split(file_path)
65
        (basename, path_dict) = self._parse_file_path(file_path)
Unknown's avatar
Unknown committed
66

Somnath, Suhas's avatar
Somnath, Suhas committed
67
        h5_path = path.join(folder_path, basename + '.h5')
Somnath, Suhas's avatar
Somnath, Suhas committed
68
69
        tot_bins_multiplier = 1
        udvs_denom = 2
Unknown's avatar
Unknown committed
70

Somnath, Suhas's avatar
Somnath, Suhas committed
71
        if 'parm_txt' in path_dict.keys():
Unknown's avatar
Unknown committed
72
            (isBEPS, parm_dict) = parmsToDict(path_dict['parm_txt'])
Somnath, Suhas's avatar
Somnath, Suhas committed
73
74
        elif 'old_mat_parms' in path_dict.keys():
            isBEPS = True
Somnath, Suhas's avatar
Somnath, Suhas committed
75
            parm_dict = self.__get_parms_from_old_mat(path_dict['old_mat_parms'])
Somnath, Suhas's avatar
Somnath, Suhas committed
76
        else:
77
            raise IOError('No parameters file found! Cannot translate this dataset!')
Unknown's avatar
Unknown committed
78

Somnath, Suhas's avatar
Somnath, Suhas committed
79
80
81
        ignored_plt_grps = []
        if isBEPS:
            parm_dict['data_type'] = 'BEPSData'
Unknown's avatar
Unknown committed
82

Somnath, Suhas's avatar
Somnath, Suhas committed
83
84
            field_mode = parm_dict['VS_measure_in_field_loops']
            std_expt = parm_dict['VS_mode'] != 'load user defined VS Wave from file'
Unknown's avatar
Unknown committed
85

Somnath, Suhas's avatar
Somnath, Suhas committed
86
            if not std_expt:
87
                raise ValueError('This translator does not handle user defined voltage spectroscopy')
Unknown's avatar
Unknown committed
88
89
90

            spec_label = getSpectroscopicParmLabel(parm_dict['VS_mode'])

Somnath, Suhas's avatar
Somnath, Suhas committed
91
            if parm_dict['VS_mode'] in ['DC modulation mode', 'current mode']:
Somnath, Suhas's avatar
Somnath, Suhas committed
92
93
94
95
96
97
98
99
100
101
102
                if field_mode == 'in and out-of-field':
                    tot_bins_multiplier = 2
                    udvs_denom = 1
                else:
                    if field_mode == 'out-of-field':
                        ignored_plt_grps = ['in-field']
                    else:
                        ignored_plt_grps = ['out-of-field']
            else:
                tot_bins_multiplier = 1
                udvs_denom = 1
Unknown's avatar
Unknown committed
103

Somnath, Suhas's avatar
Somnath, Suhas committed
104
105
106
        else:
            spec_label = 'None'
            parm_dict['data_type'] = 'BELineData'
Unknown's avatar
Unknown committed
107

Somnath, Suhas's avatar
Somnath, Suhas committed
108
109
        # Check file sizes:
        if 'read_real' in path_dict.keys():
Somnath, Suhas's avatar
Somnath, Suhas committed
110
111
            real_size = path.getsize(path_dict['read_real'])
            imag_size = path.getsize(path_dict['read_imag'])
Somnath, Suhas's avatar
Somnath, Suhas committed
112
113
114
        else:
            real_size = path.getsize(path_dict['write_real'])
            imag_size = path.getsize(path_dict['write_imag'])
Unknown's avatar
Unknown committed
115

Somnath, Suhas's avatar
Somnath, Suhas committed
116
117
118
        if real_size != imag_size:
            raise ValueError("Real and imaginary file sizes DON'T match!. Ending")

Unknown's avatar
Unknown committed
119
        add_pix = False
Somnath, Suhas's avatar
Somnath, Suhas committed
120
121
        num_rows = int(parm_dict['grid_num_rows'])
        num_cols = int(parm_dict['grid_num_cols'])
Unknown's avatar
Unknown committed
122
123
        num_pix = num_rows * num_cols
        tot_bins = real_size / (num_pix * 4)
Chris Smith's avatar
Chris Smith committed
124
        # Check for case where only a single pixel is missing.
Unknown's avatar
Unknown committed
125
126
127
        check_bins = real_size / ((num_pix - 1) * 4)

        if tot_bins % 1 and check_bins % 1:
128
            raise ValueError('Aborting! Some parameter appears to have changed in-between')
Somnath, Suhas's avatar
Somnath, Suhas committed
129
        elif not tot_bins % 1:
Chris Smith's avatar
Chris Smith committed
130
            # Everything's ok
Somnath, Suhas's avatar
Somnath, Suhas committed
131
132
133
            pass
        elif not check_bins % 1:
            tot_bins = check_bins
Unknown's avatar
Unknown committed
134
135
136
137
138
            warn('Warning:  A pixel seems to be missing from the data.  File will be padded with zeros.')
            add_pix = True

        tot_bins = int(tot_bins) * tot_bins_multiplier

Somnath, Suhas's avatar
Somnath, Suhas committed
139
        if 'parm_mat' in path_dict.keys():
Somnath, Suhas's avatar
Somnath, Suhas committed
140
            (bin_inds, bin_freqs, bin_FFT, ex_wfm) = self.__read_parms_mat(path_dict['parm_mat'], isBEPS)
Somnath, Suhas's avatar
Somnath, Suhas committed
141
        elif 'old_mat_parms' in path_dict.keys():
Somnath, Suhas's avatar
Somnath, Suhas committed
142
            (bin_inds, bin_freqs, bin_FFT, ex_wfm, dc_amp_vec) = self.__read_old_mat_be_vecs(path_dict['old_mat_parms'])
Somnath, Suhas's avatar
Somnath, Suhas committed
143
        else:
Unknown's avatar
Unknown committed
144
            band_width = parm_dict['BE_band_width_[Hz]'] * (0.5 - parm_dict['BE_band_edge_trim'])
Somnath, Suhas's avatar
Somnath, Suhas committed
145
            st_f = parm_dict['BE_center_frequency_[Hz]'] - band_width
Unknown's avatar
Unknown committed
146
            en_f = parm_dict['BE_center_frequency_[Hz]'] + band_width
Somnath, Suhas's avatar
Somnath, Suhas committed
147
            bin_freqs = np.linspace(st_f, en_f, tot_bins, dtype=np.float32)
Unknown's avatar
Unknown committed
148

149
            warn('No parms .mat file found.... Filling dummy values into ancillary datasets.')
Somnath, Suhas's avatar
Somnath, Suhas committed
150
151
152
            bin_inds = np.zeros(shape=tot_bins, dtype=np.int32)
            bin_FFT = np.zeros(shape=tot_bins, dtype=np.complex64)
            ex_wfm = np.zeros(shape=100, dtype=np.float32)
Unknown's avatar
Unknown committed
153

Somnath, Suhas's avatar
Somnath, Suhas committed
154
155
156
157
158
        # Forcing standardized datatypes:
        bin_inds = np.int32(bin_inds)
        bin_freqs = np.float32(bin_freqs)
        bin_FFT = np.complex64(bin_FFT)
        ex_wfm = np.float32(ex_wfm)
159

160
        ds_ex_wfm = VirtualDataset('Excitation_Waveform', ex_wfm)
161

Somnath, Suhas's avatar
Somnath, Suhas committed
162
        self.FFT_BE_wave = bin_FFT
163

164
        pos_desc = [Dimension('X', 'm', np.arange(num_cols)), Dimension('Y', 'm', np.arange(num_rows))]
165
        ds_pos_ind, ds_pos_val = build_ind_val_dsets(pos_desc, is_spectral=False, verbose=verbose)
Unknown's avatar
Unknown committed
166

Somnath, Suhas's avatar
Somnath, Suhas committed
167
        if isBEPS:
Somnath, Suhas's avatar
Somnath, Suhas committed
168
            (UDVS_labs, UDVS_units, UDVS_mat) = self.__build_udvs_table(parm_dict)
Unknown's avatar
Unknown committed
169
170

            #             Remove the unused plot group columns before proceeding:
Somnath, Suhas's avatar
Somnath, Suhas committed
171
            (UDVS_mat, UDVS_labs, UDVS_units) = trimUDVS(UDVS_mat, UDVS_labs, UDVS_units, ignored_plt_grps)
Unknown's avatar
Unknown committed
172

173
            spec_inds = np.zeros(shape=(2, tot_bins), dtype=INDICES_DTYPE)
Unknown's avatar
Unknown committed
174
175
176
177
178

            #             Will assume that all excitation waveforms have same number of bins
            num_actual_udvs_steps = UDVS_mat.shape[0] / udvs_denom
            bins_per_step = tot_bins / num_actual_udvs_steps

Somnath, Suhas's avatar
Somnath, Suhas committed
179
            if bins_per_step % 1:
Somnath, Suhas's avatar
Somnath, Suhas committed
180
181
                print('UDVS mat shape: {}, total bins: {}, bins per step: {}'.format(UDVS_mat.shape, tot_bins,
                                                                                     bins_per_step))
182
                raise ValueError('Non integer number of bins per step!')
Unknown's avatar
Unknown committed
183

Somnath, Suhas's avatar
Somnath, Suhas committed
184
185
            bins_per_step = int(bins_per_step)
            num_actual_udvs_steps = int(num_actual_udvs_steps)
Unknown's avatar
Unknown committed
186
187
188

            stind = 0
            for step_index in range(UDVS_mat.shape[0]):
Unknown's avatar
Unknown committed
189
190
191
                if UDVS_mat[step_index, 2] < 1E-3:  # invalid AC amplitude
                    continue
                # Bin step
192
                spec_inds[0, stind:stind + bins_per_step] = np.arange(bins_per_step, dtype=INDICES_DTYPE)
Unknown's avatar
Unknown committed
193
                # UDVS step
194
                spec_inds[1, stind:stind + bins_per_step] = step_index * np.ones(bins_per_step, dtype=INDICES_DTYPE)
Somnath, Suhas's avatar
Somnath, Suhas committed
195
                stind += bins_per_step
Somnath, Suhas's avatar
Somnath, Suhas committed
196
            del stind, step_index
Unknown's avatar
Unknown committed
197

Somnath, Suhas's avatar
Somnath, Suhas committed
198
        else:  # BE Line
Somnath, Suhas's avatar
Somnath, Suhas committed
199
            self.signal_type = 1
Somnath, Suhas's avatar
Somnath, Suhas committed
200
            self.expt_type = 1  # Stephen has not used this index for some reason
Somnath, Suhas's avatar
Somnath, Suhas committed
201
202
            num_actual_udvs_steps = 1
            bins_per_step = tot_bins
Somnath, Suhas's avatar
Somnath, Suhas committed
203
            UDVS_labs = ['step_num', 'dc_offset', 'ac_amp', 'wave_type', 'wave_mod', 'be-line']
Somnath, Suhas's avatar
Somnath, Suhas committed
204
            UDVS_units = ['', 'V', 'A', '', '', '']
Somnath, Suhas's avatar
Somnath, Suhas committed
205
206
            UDVS_mat = np.array([1, 0, parm_dict['BE_amplitude_[V]'], 1, 1, 1],
                                dtype=np.float32).reshape(1, len(UDVS_labs))
Somnath, Suhas's avatar
Somnath, Suhas committed
207

208
            spec_inds = np.vstack((np.arange(tot_bins, dtype=INDICES_DTYPE), np.zeros(tot_bins, dtype=INDICES_DTYPE)))
Unknown's avatar
Unknown committed
209

Somnath, Suhas's avatar
Somnath, Suhas committed
210
211
212
        # Some very basic information that can help the processing / analysis crew
        parm_dict['num_bins'] = tot_bins
        parm_dict['num_pix'] = num_pix
213
        parm_dict['num_udvs_steps'] = num_actual_udvs_steps
Unknown's avatar
Unknown committed
214

Somnath, Suhas's avatar
Somnath, Suhas committed
215
        udvs_slices = dict()
Somnath, Suhas's avatar
Somnath, Suhas committed
216
        for col_ind, col_name in enumerate(UDVS_labs):
Unknown's avatar
Unknown committed
217
            udvs_slices[col_name] = (slice(None), slice(col_ind, col_ind + 1))
218
        ds_UDVS = VirtualDataset('UDVS', UDVS_mat)
Somnath, Suhas's avatar
Somnath, Suhas committed
219
220
        ds_UDVS.attrs['labels'] = udvs_slices
        ds_UDVS.attrs['units'] = UDVS_units
Unknown's avatar
Unknown committed
221
        #         ds_udvs_labs = MicroDataset('UDVS_Labels',np.array(UDVS_labs))
222
        ds_UDVS_inds = VirtualDataset('UDVS_Indices', spec_inds[1])
Unknown's avatar
Unknown committed
223
224

        #         ds_spec_labs = MicroDataset('Spectroscopic_Labels',np.array(['Bin','UDVS_Step']))
225
        ds_bin_steps = VirtualDataset('Bin_Step', np.arange(bins_per_step, dtype=INDICES_DTYPE), dtype=INDICES_DTYPE)
Unknown's avatar
Unknown committed
226

Somnath, Suhas's avatar
Somnath, Suhas committed
227
        # Need to add the Bin Waveform type - infer from UDVS        
Unknown's avatar
Unknown committed
228
        exec_bin_vec = self.signal_type * np.ones(len(bin_inds), dtype=np.int32)
Somnath, Suhas's avatar
Somnath, Suhas committed
229
230
231

        if self.expt_type == 2:
            # Need to double the vectors:
Unknown's avatar
Unknown committed
232
            exec_bin_vec = np.hstack((exec_bin_vec, -1 * exec_bin_vec))
Somnath, Suhas's avatar
Somnath, Suhas committed
233
234
            bin_inds = np.hstack((bin_inds, bin_inds))
            bin_freqs = np.hstack((bin_freqs, bin_freqs))
Somnath, Suhas's avatar
Somnath, Suhas committed
235
            # This is wrong but I don't know what else to do
Somnath, Suhas's avatar
Somnath, Suhas committed
236
            bin_FFT = np.hstack((bin_FFT, bin_FFT))
Unknown's avatar
Unknown committed
237

238
        ds_bin_inds = VirtualDataset('Bin_Indices', bin_inds, dtype=INDICES_DTYPE)
239
240
241
        ds_bin_freq = VirtualDataset('Bin_Frequencies', bin_freqs)
        ds_bin_FFT = VirtualDataset('Bin_FFT', bin_FFT)
        ds_wfm_typ = VirtualDataset('Bin_Wfm_Type', exec_bin_vec)
Unknown's avatar
Unknown committed
242

Somnath, Suhas's avatar
Somnath, Suhas committed
243
        # Create Spectroscopic Values and Spectroscopic Values Labels datasets
Somnath, Suhas's avatar
Somnath, Suhas committed
244
245
246
247
248
249
250
        spec_vals, spec_inds, spec_vals_labs, spec_vals_units, spec_vals_labs_names = createSpecVals(UDVS_mat,
                                                                                                     spec_inds,
                                                                                                     bin_freqs,
                                                                                                     exec_bin_vec,
                                                                                                     parm_dict,
                                                                                                     UDVS_labs,
                                                                                                     UDVS_units)
Chris Smith's avatar
Chris Smith committed
251

Somnath, Suhas's avatar
Somnath, Suhas committed
252
        spec_vals_slices = dict()
Unknown's avatar
Unknown committed
253
254
255
        #         if len(spec_vals_labs) == 1:
        #             spec_vals_slices[spec_vals_labs[0]]=(slice(0,1,None),)
        #         else:
Somnath, Suhas's avatar
Somnath, Suhas committed
256
257

        for row_ind, row_name in enumerate(spec_vals_labs):
Unknown's avatar
Unknown committed
258
            spec_vals_slices[row_name] = (slice(row_ind, row_ind + 1), slice(None))
Somnath, Suhas's avatar
Somnath, Suhas committed
259

260
        ds_spec_mat = VirtualDataset('Spectroscopic_Indices', spec_inds, dtype=INDICES_DTYPE)
Somnath, Suhas's avatar
Somnath, Suhas committed
261
        ds_spec_mat.attrs['labels'] = spec_vals_slices
Unknown's avatar
Unknown committed
262
        ds_spec_mat.attrs['units'] = spec_vals_units
263
        ds_spec_vals_mat = VirtualDataset('Spectroscopic_Values', np.array(spec_vals, dtype=VALUES_DTYPE))
Somnath, Suhas's avatar
Somnath, Suhas committed
264
265
266
        ds_spec_vals_mat.attrs['labels'] = spec_vals_slices
        ds_spec_vals_mat.attrs['units'] = spec_vals_units
        for entry in spec_vals_labs_names:
Unknown's avatar
Unknown committed
267
            label = entry[0] + '_parameters'
Somnath, Suhas's avatar
Somnath, Suhas committed
268
            names = entry[1]
Somnath, Suhas's avatar
Somnath, Suhas committed
269
270
            ds_spec_mat.attrs[label] = names
            ds_spec_vals_mat.attrs[label] = names
Chris Smith's avatar
Chris Smith committed
271

Somnath, Suhas's avatar
Somnath, Suhas committed
272
        # Noise floor should be of shape: (udvs_steps x 3 x positions)
273
274
        ds_noise_floor = VirtualDataset('Noise_Floor', np.zeros(shape=(num_pix, num_actual_udvs_steps), dtype=nf32),
                                        chunking=(1, num_actual_udvs_steps))
Somnath, Suhas's avatar
Somnath, Suhas committed
275
276

        """
Chris Smith's avatar
Chris Smith committed
277
        New Method for chunking the Main_Data dataset.  Chunking is now done in N-by-N squares
Somnath, Suhas's avatar
Somnath, Suhas committed
278
        of UDVS steps by pixels.  N is determined dynamically based on the dimensions of the
Chris Smith's avatar
Chris Smith committed
279
        dataset.  Currently it is set such that individual chunks are less than 10kB in size.
Somnath, Suhas's avatar
Somnath, Suhas committed
280
281
282
        
        Chris Smith -- csmith55@utk.edu
        """
Chris Smith's avatar
Chris Smith committed
283
284
285
        BEPS_chunks = calc_chunks([num_pix, tot_bins],
                                  np.complex64(0).itemsize,
                                  unit_chunks=(1, bins_per_step))
286
        ds_main_data = VirtualDataset('Raw_Data', data=None,
287
288
289
290
                                      maxshape=(num_pix, tot_bins),
                                      dtype=np.complex64,
                                      chunking=BEPS_chunks,
                                      compression='gzip')
Unknown's avatar
Unknown committed
291

292
        chan_grp = VirtualGroup('Channel_')
Somnath, Suhas's avatar
Somnath, Suhas committed
293
        chan_grp.attrs['Channel_Input'] = parm_dict['IO_Analog_Input_1']
294
295
296
297
        chan_grp.add_children([ds_main_data, ds_noise_floor])
        chan_grp.add_children([ds_ex_wfm, ds_pos_ind, ds_pos_val, ds_spec_mat, ds_UDVS,
                               ds_bin_steps, ds_bin_inds, ds_bin_freq, ds_bin_FFT,
                               ds_wfm_typ, ds_spec_vals_mat, ds_UDVS_inds])
Unknown's avatar
Unknown committed
298

Somnath, Suhas's avatar
Somnath, Suhas committed
299
        # technically should change the date, etc.
300
        meas_grp = VirtualGroup('Measurement_')
Somnath, Suhas's avatar
Somnath, Suhas committed
301
        meas_grp.attrs = parm_dict
302
        meas_grp.add_children([chan_grp])
Unknown's avatar
Unknown committed
303

304
        spm_data = VirtualGroup('')
305
        global_parms = generate_dummy_main_parms()
Somnath, Suhas's avatar
Somnath, Suhas committed
306
307
        global_parms['grid_size_x'] = parm_dict['grid_num_cols']
        global_parms['grid_size_y'] = parm_dict['grid_num_rows']
Somnath, Suhas's avatar
Somnath, Suhas committed
308
309
310
311
        try:
            global_parms['experiment_date'] = parm_dict['File_date_and_time']
        except KeyError:
            global_parms['experiment_date'] = '1:1:1'
Chris Smith's avatar
Chris Smith committed
312

Somnath, Suhas's avatar
Somnath, Suhas committed
313
        # assuming that the experiment was completed:
Unknown's avatar
Unknown committed
314
315
        global_parms['current_position_x'] = parm_dict['grid_num_cols'] - 1
        global_parms['current_position_y'] = parm_dict['grid_num_rows'] - 1
Somnath, Suhas's avatar
Somnath, Suhas committed
316
        global_parms['data_type'] = parm_dict['data_type']
Somnath, Suhas's avatar
Somnath, Suhas committed
317
        global_parms['translator'] = 'ODF'
Unknown's avatar
Unknown committed
318

Somnath, Suhas's avatar
Somnath, Suhas committed
319
        spm_data.attrs = global_parms
320
        spm_data.add_children([meas_grp])
Unknown's avatar
Unknown committed
321

Somnath, Suhas's avatar
Somnath, Suhas committed
322
323
        if path.exists(h5_path):
            remove(h5_path)
Unknown's avatar
Unknown committed
324

Somnath, Suhas's avatar
Somnath, Suhas committed
325
        # Write everything except for the main data.
326
        self.hdf = HDFwriter(h5_path)
Unknown's avatar
Unknown committed
327

328
        h5_refs = self.hdf.write(spm_data, print_log=verbose)
Unknown's avatar
Unknown committed
329

330
        self.h5_raw = get_h5_obj_refs(['Raw_Data'], h5_refs)[0]
Unknown's avatar
Unknown committed
331

332
        # Now doing link_h5_objects_as_attrs:
Somnath, Suhas's avatar
Somnath, Suhas committed
333
334
335
        aux_ds_names = ['Excitation_Waveform', 'Position_Indices', 'Position_Values',
                        'Spectroscopic_Indices', 'UDVS', 'Bin_Step', 'Bin_Indices', 'UDVS_Indices',
                        'Bin_Frequencies', 'Bin_FFT', 'Bin_Wfm_Type', 'Noise_Floor', 'Spectroscopic_Values']
336
        link_h5_objects_as_attrs(self.h5_raw, get_h5_obj_refs(aux_ds_names, h5_refs))
Somnath, Suhas's avatar
Somnath, Suhas committed
337

Chris Smith's avatar
Chris Smith committed
338
        self._read_data(UDVS_mat, parm_dict, path_dict, real_size, isBEPS, add_pix)
Unknown's avatar
Unknown committed
339

Somnath, Suhas's avatar
Somnath, Suhas committed
340
341
        generatePlotGroups(self.h5_raw, self.hdf, self.mean_resp, folder_path, basename,
                           self.max_resp, self.min_resp, max_mem_mb=self.max_ram,
Somnath, Suhas's avatar
Somnath, Suhas committed
342
                           spec_label=spec_label, show_plots=show_plots, save_plots=save_plots,
Unknown's avatar
Unknown committed
343
                           do_histogram=do_histogram, debug=verbose)
Unknown's avatar
Unknown committed
344

Somnath, Suhas's avatar
Somnath, Suhas committed
345
        self.hdf.close()
Unknown's avatar
Unknown committed
346

Somnath, Suhas's avatar
Somnath, Suhas committed
347
        return h5_path
Chris Smith's avatar
Chris Smith committed
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375

    def _read_data(self, UDVS_mat, parm_dict, path_dict, real_size, isBEPS, add_pix):
        """
        Checks if the data is BEPS or BELine and calls the correct function to read the data from
        file

        Parameters
        ----------
        UDVS_mat : numpy.ndarray of float
            UDVS table
        parm_dict : dict
            Experimental parameters
        path_dict : dict
            Dictionary of data files to be read
        real_size : dict
            Size of each data file
        isBEPS : boolean
            Is the data BEPS
        add_pix : boolean
            Does the reader need to add extra pixels to the end of the dataset

        Returns
        -------
        None
        """
        # Now read the raw data files:
        if not isBEPS:
            # Do this for all BE-Line (always small enough to read in one shot)
376
            self.__quick_read_data(path_dict['read_real'], path_dict['read_imag'], parm_dict['num_udvs_steps'])
Chris Smith's avatar
Chris Smith committed
377
378
        elif real_size < self.max_ram and parm_dict['VS_measure_in_field_loops'] == 'out-of-field':
            # Do this for out-of-field BEPS ONLY that is also small (256 MB)
379
            self.__quick_read_data(path_dict['read_real'], path_dict['read_imag'], parm_dict['num_udvs_steps'])
Chris Smith's avatar
Chris Smith committed
380
381
        elif real_size < self.max_ram and parm_dict['VS_measure_in_field_loops'] == 'in-field':
            # Do this for in-field only
382
            self.__quick_read_data(path_dict['write_real'], path_dict['write_imag'], parm_dict['num_udvs_steps'])
Chris Smith's avatar
Chris Smith committed
383
384
        else:
            # Large BEPS datasets OR those with in-and-out of field
Somnath, Suhas's avatar
Somnath, Suhas committed
385
            self.__read_beps_data(path_dict, UDVS_mat.shape[0], parm_dict['VS_measure_in_field_loops'], add_pix)
Chris Smith's avatar
Chris Smith committed
386
387
        self.hdf.file.flush()

Somnath, Suhas's avatar
Somnath, Suhas committed
388
    def __read_beps_data(self, path_dict, udvs_steps, mode, add_pixel=False):
Somnath, Suhas's avatar
Somnath, Suhas committed
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
        """
        Reads the imaginary and real data files pixelwise and writes to the H5 file 
        
        Parameters 
        --------------------
        path_dict : dictionary
            Dictionary containing the absolute paths of the real and imaginary data files
        udvs_steps : unsigned int
            Number of UDVS steps
        mode : String / Unicode
            'in-field', 'out-of-field', or 'in and out-of-field'
        add_pixel : boolean. (Optional; default is False)
            If an empty pixel worth of data should be written to the end             
        
        Returns 
        -------------------- 
        None
        """
Unknown's avatar
Unknown committed
407

Somnath, Suhas's avatar
Somnath, Suhas committed
408
        print('---- reading pixel-by-pixel ----------')
Unknown's avatar
Unknown committed
409
410
411
412

        bytes_per_pix = self.h5_raw.shape[1] * 4
        step_size = self.h5_raw.shape[1] / udvs_steps

Somnath, Suhas's avatar
Somnath, Suhas committed
413
        if mode == 'out-of-field':
Unknown's avatar
Unknown committed
414
            parsers = [BEodfParser(path_dict['read_real'], path_dict['read_imag'],
Somnath, Suhas's avatar
Somnath, Suhas committed
415
                                   self.h5_raw.shape[0], bytes_per_pix)]
Somnath, Suhas's avatar
Somnath, Suhas committed
416
        elif mode == 'in-field':
Unknown's avatar
Unknown committed
417
            parsers = [BEodfParser(path_dict['write_real'], path_dict['write_imag'],
Somnath, Suhas's avatar
Somnath, Suhas committed
418
                                   self.h5_raw.shape[0], bytes_per_pix)]
Somnath, Suhas's avatar
Somnath, Suhas committed
419
420
        elif mode == 'in and out-of-field':
            # each file will only have half the udvs steps:
Unknown's avatar
Unknown committed
421
            if 0.5 * udvs_steps % 1:
422
423
                raise ValueError('Odd number of UDVS')

Unknown's avatar
Unknown committed
424
            udvs_steps = int(0.5 * udvs_steps)
Somnath, Suhas's avatar
Somnath, Suhas committed
425
            # be careful - each pair contains only half the necessary bins - so read half
Unknown's avatar
Unknown committed
426
            parsers = [BEodfParser(path_dict['write_real'], path_dict['write_imag'],
Somnath, Suhas's avatar
Somnath, Suhas committed
427
                                   self.h5_raw.shape[0], int(bytes_per_pix / 2)),
Unknown's avatar
Unknown committed
428
429
430
                       BEodfParser(path_dict['read_real'], path_dict['read_imag'],
                                   self.h5_raw.shape[0], int(bytes_per_pix / 2))]

Somnath, Suhas's avatar
Somnath, Suhas committed
431
            if step_size % 1:
432
433
                raise ValueError('strange number of bins per UDVS step. Exiting')

Somnath, Suhas's avatar
Somnath, Suhas committed
434
            step_size = int(step_size)
435

436
437
        rand_spectra = self.__get_random_spectra(parsers, self.h5_raw.shape[0], udvs_steps, step_size,
                                                 num_spectra=self.num_rand_spectra)
438
        take_conjugate = requires_conjugate(rand_spectra)
439

Somnath, Suhas's avatar
Somnath, Suhas committed
440
441
442
443
        self.mean_resp = np.zeros(shape=(self.h5_raw.shape[1]), dtype=np.complex64)
        self.max_resp = np.zeros(shape=(self.h5_raw.shape[0]), dtype=np.float32)
        self.min_resp = np.zeros(shape=(self.h5_raw.shape[0]), dtype=np.float32)

Unknown's avatar
Unknown committed
444
        numpix = self.h5_raw.shape[0]
Somnath, Suhas's avatar
Somnath, Suhas committed
445
446
447
        """ 
        Don't try to do the last step if a pixel is missing.   
        This will be handled after the loop. 
Unknown's avatar
Unknown committed
448
449
450
451
        """
        if add_pixel:
            numpix -= 1

Somnath, Suhas's avatar
Somnath, Suhas committed
452
        for pix_indx in range(numpix):
Somnath, Suhas's avatar
Somnath, Suhas committed
453
            if self.h5_raw.shape[0] > 5:
Unknown's avatar
Unknown committed
454
455
456
                if pix_indx % int(round(self.h5_raw.shape[0] / 10)) == 0:
                    print('Reading... {} complete'.format(round(100 * pix_indx / self.h5_raw.shape[0])))

Somnath, Suhas's avatar
Somnath, Suhas committed
457
458
459
            # get the raw stream from each parser
            pxl_data = list()
            for prsr in parsers:
Somnath, Suhas's avatar
Somnath, Suhas committed
460
                pxl_data.append(prsr.read_pixel())
Unknown's avatar
Unknown committed
461

Somnath, Suhas's avatar
Somnath, Suhas committed
462
463
464
465
466
            # interleave if both in and out of field
            # we are ignoring user defined possibilities...
            if mode == 'in and out-of-field':
                in_fld = pxl_data[0]
                out_fld = pxl_data[1]
Unknown's avatar
Unknown committed
467

Somnath, Suhas's avatar
Somnath, Suhas committed
468
469
                in_fld_2 = in_fld.reshape(udvs_steps, step_size)
                out_fld_2 = out_fld.reshape(udvs_steps, step_size)
Unknown's avatar
Unknown committed
470
                raw_mat = np.empty((udvs_steps * 2, step_size), dtype=out_fld.dtype)
Somnath, Suhas's avatar
Somnath, Suhas committed
471
472
                raw_mat[0::2, :] = in_fld_2
                raw_mat[1::2, :] = out_fld_2
Somnath, Suhas's avatar
Somnath, Suhas committed
473
474
                raw_vec = raw_mat.reshape(in_fld.size + out_fld.size).transpose()
            else:
Somnath, Suhas's avatar
Somnath, Suhas committed
475
                raw_vec = pxl_data[0]  # only one parser
Somnath, Suhas's avatar
Somnath, Suhas committed
476
477
            self.max_resp[pix_indx] = np.max(np.abs(raw_vec))
            self.min_resp[pix_indx] = np.min(np.abs(raw_vec))
Unknown's avatar
Unknown committed
478
            self.mean_resp = (1 / (pix_indx + 1)) * (raw_vec + pix_indx * self.mean_resp)
479
480
481

            if take_conjugate:
                raw_vec = np.conjugate(raw_vec)
482
            self.h5_raw[pix_indx, :] = np.complex64(raw_vec[:])
Somnath, Suhas's avatar
Somnath, Suhas committed
483
            self.hdf.file.flush()
Unknown's avatar
Unknown committed
484

Somnath, Suhas's avatar
Somnath, Suhas committed
485
        # Add zeros to main_data for the missing pixel. 
Unknown's avatar
Unknown committed
486
487
488
        if add_pixel:
            self.h5_raw[-1, :] = 0 + 0j

Somnath, Suhas's avatar
Somnath, Suhas committed
489
        print('---- Finished reading files -----')
490
491

    def __quick_read_data(self, real_path, imag_path, udvs_steps):
Somnath, Suhas's avatar
Somnath, Suhas committed
492
        """
Somnath, Suhas's avatar
Somnath, Suhas committed
493
494
495
496
497
498
499
500
        Returns information about the excitation BE waveform present in the .mat file

        Parameters
        -----------
        real_path : String / Unicode
            Absolute file path of the real data file
        imag_path : String / Unicode
            Absolute file path of the real data file
501
502
        udvs_steps : unsigned int
            Number of UDVS steps
Somnath, Suhas's avatar
Somnath, Suhas committed
503
        """
Unknown's avatar
Unknown committed
504
        print('---- reading all data at once ----------')
Somnath, Suhas's avatar
Somnath, Suhas committed
505

Unknown's avatar
Unknown committed
506
        parser = BEodfParser(real_path, imag_path, self.h5_raw.shape[0], self.h5_raw.shape[1] * 4)
507
508

        step_size = self.h5_raw.shape[1] / udvs_steps
509
510
        rand_spectra = self.__get_random_spectra([parser], self.h5_raw.shape[0], udvs_steps, step_size,
                                                 num_spectra=self.num_rand_spectra)
511
        take_conjugate = requires_conjugate(rand_spectra)
Somnath, Suhas's avatar
Somnath, Suhas committed
512
        raw_vec = parser.read_all_data()
513
        if take_conjugate:
514
            print('Taking conjugate to ensure positive Quality factors')
515
            raw_vec = np.conjugate(raw_vec)
Unknown's avatar
Unknown committed
516

Somnath, Suhas's avatar
Somnath, Suhas committed
517
        raw_mat = raw_vec.reshape(self.h5_raw.shape[0], self.h5_raw.shape[1])
Unknown's avatar
Unknown committed
518

Somnath, Suhas's avatar
Somnath, Suhas committed
519
        # Write to the h5 dataset:
Somnath, Suhas's avatar
Somnath, Suhas committed
520
521
522
        self.mean_resp = np.mean(raw_mat, axis=0)
        self.max_resp = np.amax(np.abs(raw_mat), axis=0)
        self.min_resp = np.amin(np.abs(raw_mat), axis=0)
523
        self.h5_raw[:, :] = np.complex64(raw_mat)
Somnath, Suhas's avatar
Somnath, Suhas committed
524
525
        self.hdf.file.flush()

Unknown's avatar
Unknown committed
526
527
        print('---- Finished reading files -----')

528
    def _parse_file_path(self, data_filepath):
Somnath, Suhas's avatar
Somnath, Suhas committed
529
530
531
532
533
534
535
        """
        Returns the basename and a dictionary containing the absolute file paths for the
        real and imaginary data files, text and mat parameter files in a dictionary
        
        Parameters 
        --------------------
        data_filepath: String / Unicode
Somnath, Suhas's avatar
Somnath, Suhas committed
536
            Absolute path of any file in the same directory as the .dat files
Somnath, Suhas's avatar
Somnath, Suhas committed
537
538
539
540
541
542
543
544
545
        
        Returns 
        --------------------
        basename : String / Unicode
            Basename of the dataset      
        path_dict : Dictionary
            Dictionary containing absolute paths of all necessary data and parameter files
        """
        (folder_path, basename) = path.split(data_filepath)
Unknown's avatar
Unknown committed
546
        (super_folder, basename) = path.split(folder_path)
Somnath, Suhas's avatar
Somnath, Suhas committed
547
548
549
550
551
552
553
554
555
556
557

        if basename.endswith('_d'):
            # Old old data format where the folder ended with a _d for some reason
            basename = basename[:-2]
        """
        A single pair of real and imaginary files are / were generated for:
            BE-Line and BEPS (compiled version only generated out-of-field or 'read')
        Two pairs of real and imaginary files were generated for later BEPS datasets
            These have 'read' and 'write' prefixes to denote out or in field respectively
        """
        path_dict = dict()
Unknown's avatar
Unknown committed
558

Somnath, Suhas's avatar
Somnath, Suhas committed
559
        for file_name in listdir(folder_path):
Chris Smith's avatar
Chris Smith committed
560
            abs_path = path.join(folder_path, file_name)
Somnath, Suhas's avatar
Somnath, Suhas committed
561
562
563
564
565
            if file_name.endswith('.txt') and file_name.find('parm') > 0:
                path_dict['parm_txt'] = abs_path
            elif file_name.find('.mat') > 0:
                if file_name.find('more_parms') > 0:
                    path_dict['parm_mat'] = abs_path
Unknown's avatar
Unknown committed
566
                elif file_name == (basename + '.mat'):
Somnath, Suhas's avatar
Somnath, Suhas committed
567
568
569
570
571
572
573
574
575
576
577
578
                    path_dict['old_mat_parms'] = abs_path
            elif file_name.endswith('.dat'):
                # Need to account for the second AI channel here
                file_tag = 'read'
                if file_name.find('write') > 0:
                    file_tag = 'write'
                if file_name.find('real') > 0:
                    file_tag += '_real'
                elif file_name.find('imag') > 0:
                    file_tag += '_imag'
                path_dict[file_tag] = abs_path

Chris Smith's avatar
Chris Smith committed
579
        return basename, path_dict
Somnath, Suhas's avatar
Somnath, Suhas committed
580
581
582

    @staticmethod
    def __read_old_mat_be_vecs(file_path):
Somnath, Suhas's avatar
Somnath, Suhas committed
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
        """
        Returns information about the excitation BE waveform present in the 
        more parms.mat file
        
        Parameters 
        --------------------
        filepath : String or unicode
            Absolute filepath of the .mat parameter file
        
        Returns 
        --------------------
        bin_inds : 1D numpy unsigned int array
            Indices of the excited and measured frequency bins
        bin_w : 1D numpy float array
            Excitation bin Frequencies
        bin_FFT : 1D numpy complex array
            FFT of the BE waveform for the excited bins
        BE_wave : 1D numpy float array
            Band Excitation waveform
        dc_amp_vec_full : 1D numpy float array
            spectroscopic waveform. 
            This information will be necessary for fixing the UDVS for AC modulation for example
        """
Unknown's avatar
Unknown committed
606
        matread = loadmat(file_path, squeeze_me=True)
Somnath, Suhas's avatar
Somnath, Suhas committed
607
        BE_wave = matread['BE_wave']
Unknown's avatar
Unknown committed
608
        bin_inds = matread['bin_ind'] - 1  # Python base 0
Somnath, Suhas's avatar
Somnath, Suhas committed
609
610
611
        bin_w = matread['bin_w']
        dc_amp_vec_full = matread['dc_amp_vec_full']
        FFT_full = np.fft.fftshift(np.fft.fft(BE_wave))
Somnath, Suhas's avatar
Somnath, Suhas committed
612
613
        bin_FFT = np.conjugate(FFT_full[bin_inds])
        return bin_inds, bin_w, bin_FFT, BE_wave, dc_amp_vec_full
Unknown's avatar
Unknown committed
614

Somnath, Suhas's avatar
Somnath, Suhas committed
615
616
    @staticmethod
    def __get_parms_from_old_mat(file_path):
Somnath, Suhas's avatar
Somnath, Suhas committed
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
        """
        Formats parameters found in the old parameters .mat file into a dictionary
        as though the dataset had a parms.txt describing it
        
        Parameters 
        --------------------
        file_path : Unicode / String
            absolute filepath of the .mat file containing the parameters
            
        Returns 
        --------------------
        parm_dict : dictionary
            Parameters describing experiment
        """
        parm_dict = dict()
        matread = loadmat(file_path, squeeze_me=True)
Unknown's avatar
Unknown committed
633
634
635

        parm_dict['IO_rate'] = str(int(matread['AO_rate'] / 1E+6)) + ' MHz'

Somnath, Suhas's avatar
Somnath, Suhas committed
636
637
638
639
640
        position_vec = matread['position_vec']
        parm_dict['grid_current_row'] = position_vec[0]
        parm_dict['grid_current_col'] = position_vec[1]
        parm_dict['grid_num_rows'] = position_vec[2]
        parm_dict['grid_num_cols'] = position_vec[3]
Unknown's avatar
Unknown committed
641

Somnath, Suhas's avatar
Somnath, Suhas committed
642
643
        if position_vec[0] != position_vec[1] or position_vec[2] != position_vec[3]:
            warn('WARNING: Incomplete dataset. Translation not guaranteed!')
Somnath, Suhas's avatar
Somnath, Suhas committed
644
            parm_dict['grid_num_rows'] = position_vec[0]  # set to number of present cols and rows
Somnath, Suhas's avatar
Somnath, Suhas committed
645
            parm_dict['grid_num_cols'] = position_vec[1]
Unknown's avatar
Unknown committed
646

Somnath, Suhas's avatar
Somnath, Suhas committed
647
648
649
650
651
652
653
654
655
        BE_parm_vec_1 = matread['BE_parm_vec_1']
        # Not required for translation but necessary to have
        if BE_parm_vec_1[0] == 3:
            parm_dict['BE_phase_content'] = 'chirp-sinc hybrid'
        else:
            parm_dict['BE_phase_content'] = 'Unknown'
        parm_dict['BE_center_frequency_[Hz]'] = BE_parm_vec_1[1]
        parm_dict['BE_band_width_[Hz]'] = BE_parm_vec_1[2]
        parm_dict['BE_amplitude_[V]'] = BE_parm_vec_1[3]
Somnath, Suhas's avatar
Somnath, Suhas committed
656
657
        parm_dict['BE_band_edge_smoothing_[s]'] = BE_parm_vec_1[4]  # 150 most likely
        parm_dict['BE_phase_variation'] = BE_parm_vec_1[5]  # 0.01 most likely
Unknown's avatar
Unknown committed
658
659
660
        parm_dict['BE_window_adjustment'] = BE_parm_vec_1[6]
        parm_dict['BE_points_per_step'] = 2 ** int(BE_parm_vec_1[7])
        parm_dict['BE_repeats'] = 2 ** int(BE_parm_vec_1[8])
Somnath, Suhas's avatar
Somnath, Suhas committed
661
662
663
664
        try:
            parm_dict['BE_bins_per_read'] = matread['bins_per_band_s']
        except KeyError:
            parm_dict['BE_bins_per_read'] = len(matread['bin_w'])
Unknown's avatar
Unknown committed
665

Somnath, Suhas's avatar
Somnath, Suhas committed
666
        assembly_parm_vec = matread['assembly_parm_vec']
Unknown's avatar
Unknown committed
667

Somnath, Suhas's avatar
Somnath, Suhas committed
668
669
670
671
672
673
        if assembly_parm_vec[2] == 0:
            parm_dict['VS_measure_in_field_loops'] = 'out-of-field'
        elif assembly_parm_vec[2] == 1:
            parm_dict['VS_measure_in_field_loops'] = 'in and out-of-field'
        else:
            parm_dict['VS_measure_in_field_loops'] = 'in-field'
Unknown's avatar
Unknown committed
674

Somnath, Suhas's avatar
Somnath, Suhas committed
675
676
677
678
679
        parm_dict['IO_Analog_Input_1'] = '+/- 10V, FFT'
        if assembly_parm_vec[3] == 0:
            parm_dict['IO_Analog_Input_2'] = 'off'
        else:
            parm_dict['IO_Analog_Input_2'] = '+/- 10V, FFT'
Unknown's avatar
Unknown committed
680

Somnath, Suhas's avatar
Somnath, Suhas committed
681
682
        # num_driving_bands = assembly_parm_vec[0]  # 0 = 1, 1 = 2 bands
        # band_combination_order = assembly_parm_vec[1]  # 0 parallel 1 series
Unknown's avatar
Unknown committed
683

Somnath, Suhas's avatar
Somnath, Suhas committed
684
685
        VS_parms = matread['SS_parm_vec']
        dc_amp_vec_full = matread['dc_amp_vec_full']
Unknown's avatar
Unknown committed
686
687
688
689

        VS_start_V = VS_parms[4]
        VS_start_loop_amp = VS_parms[5]
        VS_final_loop_amp = VS_parms[6]
Somnath, Suhas's avatar
Somnath, Suhas committed
690
        # VS_read_write_ratio = VS_parms[8]  # 1 <- SS_read_write_ratio
Unknown's avatar
Unknown committed
691

Somnath, Suhas's avatar
Somnath, Suhas committed
692
        parm_dict['VS_set_pulse_amplitude_[V]'] = VS_parms[9]  # 0 <- SS_set_pulse_amp
Unknown's avatar
Unknown committed
693
        parm_dict['VS_read_voltage_[V]'] = VS_parms[3]
Somnath, Suhas's avatar
Somnath, Suhas committed
694
695
        parm_dict['VS_steps_per_full_cycle'] = VS_parms[7]
        parm_dict['VS_cycle_fraction'] = 'full'
Unknown's avatar
Unknown committed
696
        parm_dict['VS_cycle_phase_shift'] = 0
Somnath, Suhas's avatar
Somnath, Suhas committed
697
        parm_dict['VS_number_of_cycles'] = VS_parms[2]
Somnath, Suhas's avatar
Somnath, Suhas committed
698
699
700
701
702
        parm_dict['FORC_num_of_FORC_cycles'] = 1
        parm_dict['FORC_V_high1_[V]'] = 0
        parm_dict['FORC_V_high2_[V]'] = 0
        parm_dict['FORC_V_low1_[V]'] = 0
        parm_dict['FORC_V_low2_[V]'] = 0
Unknown's avatar
Unknown committed
703

Somnath, Suhas's avatar
Somnath, Suhas committed
704
705
        if VS_parms[0] == 0:
            parm_dict['VS_mode'] = 'DC modulation mode'
Unknown's avatar
Unknown committed
706
707
708
            parm_dict['VS_amplitude_[V]'] = 0.5 * (
                max(dc_amp_vec_full) - min(dc_amp_vec_full))  # SS_max_offset_amplitude
            parm_dict['VS_offset_[V]'] = max(dc_amp_vec_full) + min(dc_amp_vec_full)
Somnath, Suhas's avatar
Somnath, Suhas committed
709
710
711
        elif VS_parms[0] == 1:
            # FORC
            parm_dict['VS_mode'] = 'DC modulation mode'
Somnath, Suhas's avatar
Somnath, Suhas committed
712
            parm_dict['VS_amplitude_[V]'] = 1  # VS_parms[1] # SS_max_offset_amplitude
Somnath, Suhas's avatar
Somnath, Suhas committed
713
            parm_dict['VS_offset_[V]'] = 0
Unknown's avatar
Unknown committed
714
            parm_dict['VS_number_of_cycles'] = 1
Somnath, Suhas's avatar
Somnath, Suhas committed
715
716
717
718
719
            parm_dict['FORC_num_of_FORC_cycles'] = VS_parms[2]
            parm_dict['FORC_V_high1_[V]'] = VS_start_V
            parm_dict['FORC_V_high2_[V]'] = VS_start_V
            parm_dict['FORC_V_low1_[V]'] = VS_start_V - VS_start_loop_amp
            parm_dict['FORC_V_low2_[V]'] = VS_start_V - VS_final_loop_amp
Somnath, Suhas's avatar
Somnath, Suhas committed
720
721
722
        elif VS_parms[0] == 2:
            # AC mode 
            parm_dict['VS_mode'] = 'AC modulation mode with time reversal'
Somnath, Suhas's avatar
Somnath, Suhas committed
723
724
            parm_dict['VS_amplitude_[V]'] = 0.5 * VS_final_loop_amp
            parm_dict['VS_offset_[V]'] = 0  # this is not correct. Fix manually when it comes to UDVS generation?
Somnath, Suhas's avatar
Somnath, Suhas committed
725
726
        else:
            parm_dict['VS_mode'] = 'Custom'
Unknown's avatar
Unknown committed
727

Somnath, Suhas's avatar
Somnath, Suhas committed
728
        return parm_dict
Unknown's avatar
Unknown committed
729

Somnath, Suhas's avatar
Somnath, Suhas committed
730
731
    @staticmethod
    def __read_parms_mat(file_path, is_beps):
Somnath, Suhas's avatar
Somnath, Suhas committed
732
733
734
735
736
        """
        Returns information about the excitation BE waveform present in the more parms.mat file
        
        Parameters 
        --------------------
Somnath, Suhas's avatar
Somnath, Suhas committed
737
        file_path : String / Unicode
Somnath, Suhas's avatar
Somnath, Suhas committed
738
            Absolute filepath of the .mat parameter file
Somnath, Suhas's avatar
Somnath, Suhas committed
739
        is_beps : Boolean
Somnath, Suhas's avatar
Somnath, Suhas committed
740
741
742
743
744
745
746
747
748
749
750
751
752
            Whether or not this is BEPS or BE-Line
        
        Returns 
        --------------------
        BE_bin_ind : 1D numpy unsigned int array
            Indices of the excited and measured frequency bins
        BE_bin_w : 1D numpy float array
            Excitation bin Frequencies
        BE_bin_FFT : 1D numpy complex array
            FFT of the BE waveform for the excited bins
        ex_wfm : 1D numpy float array
            Band Excitation waveform
        """
Somnath, Suhas's avatar
Somnath, Suhas committed
753
        if not path.exists(file_path):
754
            raise IOError('NO "More parms" file found')
Somnath, Suhas's avatar
Somnath, Suhas committed
755
        if is_beps:
Somnath, Suhas's avatar
Somnath, Suhas committed
756
757
758
            fft_name = 'FFT_BE_wave'
        else:
            fft_name = 'FFT_BE_rev_wave'
Somnath, Suhas's avatar
Somnath, Suhas committed
759
        matread = loadmat(file_path, variable_names=['BE_bin_ind', 'BE_bin_w', fft_name])
Unknown's avatar
Unknown committed
760
        BE_bin_ind = np.squeeze(matread['BE_bin_ind']) - 1  # From Matlab (base 1) to Python (base 0)
Somnath, Suhas's avatar
Somnath, Suhas committed
761
762
        BE_bin_w = np.squeeze(matread['BE_bin_w'])
        FFT_full = np.complex64(np.squeeze(matread[fft_name]))
Somnath, Suhas's avatar
Somnath, Suhas committed
763
        # For whatever weird reason, the sign of the imaginary portion is flipped. Correct it:
Unknown's avatar
Unknown committed
764
        # BE_bin_FFT = np.conjugate(FFT_full[BE_bin_ind])
Somnath, Suhas's avatar
Somnath, Suhas committed
765
766
        BE_bin_FFT = np.zeros(len(BE_bin_ind), dtype=np.complex64)
        BE_bin_FFT.real = np.real(FFT_full[BE_bin_ind])
Unknown's avatar
Unknown committed
767
768
        BE_bin_FFT.imag = -1 * np.imag(FFT_full[BE_bin_ind])

Somnath, Suhas's avatar
Somnath, Suhas committed
769
        ex_wfm = np.real(np.fft.ifft(np.fft.ifftshift(FFT_full)))
Somnath, Suhas's avatar
Somnath, Suhas committed
770
771

        return BE_bin_ind, BE_bin_w, BE_bin_FFT, ex_wfm
Unknown's avatar
Unknown committed
772

Somnath, Suhas's avatar
Somnath, Suhas committed
773
    def __build_udvs_table(self, parm_dict):
Somnath, Suhas's avatar
Somnath, Suhas committed
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
        """
        Generates the UDVS table using the parameters
        
        Parameters 
        --------------------
        parm_dict : dictionary
            Parameters describing experiment
        
        Returns 
        --------------------      
        UD_VS_table_label : List of strings
            Labels for columns in the UDVS table
        UD_VS_table_unit : List of strings
            Units for the columns in the UDVS table
        UD_VS_table : 2D numpy float array
            UDVS data table
        """
Unknown's avatar
Unknown committed
791

Somnath, Suhas's avatar
Somnath, Suhas committed
792
        def translate_val(target, strvals, numvals):
Somnath, Suhas's avatar
Somnath, Suhas committed
793
794
            """
            Internal function - Interprets the provided value using the provided lookup table
Somnath, Suhas's avatar
Somnath, Suhas committed
795
796
797
798
799
800
801
802
803

            Parameters
            ----------
            target : String
                Item we are looking for in the strvals list
            strvals : list of strings
                List of source values
            numvals : list of numbers
                List of results
Somnath, Suhas's avatar
Somnath, Suhas committed
804
            """
Unknown's avatar
Unknown committed
805

Somnath, Suhas's avatar
Somnath, Suhas committed
806
            if len(strvals) is not len(numvals):
Unknown's avatar
Unknown committed
807
                return None
Somnath, Suhas's avatar
Somnath, Suhas committed
808
            for strval, fltval in zip(strvals, numvals):
Somnath, Suhas's avatar
Somnath, Suhas committed
809
810
                if target == strval:
                    return fltval
Somnath, Suhas's avatar
Somnath, Suhas committed
811
            return None  # not found in list
Unknown's avatar
Unknown committed
812
813

        # % Extract values from parm text file
Unknown's avatar
Unknown committed
814
        BE_signal_type = translate_val(parm_dict['BE_phase_content'],
Unknown's avatar
Unknown committed
815
816
817
                                       ['chirp-sinc hybrid', '1/2 harmonic excitation',
                                        '1/3 harmonic excitation', 'pure sine'],
                                       [1, 2, 3, 4])
Somnath, Suhas's avatar
Somnath, Suhas committed
818
819
820
821
822
823
        # This is necessary when normalzing the AI by the AO
        self.harmonic = BE_signal_type
        self.signal_type = BE_signal_type
        if BE_signal_type is 4:
            self.harmonic = 1
        BE_amp = parm_dict['BE_amplitude_[V]']
Unknown's avatar
Unknown committed
824

Somnath, Suhas's avatar
Somnath, Suhas committed
825
826
        VS_amp = parm_dict['VS_amplitude_[V]']
        VS_offset = parm_dict['VS_offset_[V]']
Unknown's avatar
Unknown committed
827
        # VS_read_voltage = parm_dict['VS_read_voltage_[V]']
Somnath, Suhas's avatar
Somnath, Suhas committed
828
829
        VS_steps = parm_dict['VS_steps_per_full_cycle']
        VS_cycles = parm_dict['VS_number_of_cycles']
Somnath, Suhas's avatar
Somnath, Suhas committed
830
831
832
        VS_fraction = translate_val(parm_dict['VS_cycle_fraction'],
                                    ['full', '1/2', '1/4', '3/4'],
                                    [1., 0.5, 0.25, 0.75])
Somnath, Suhas's avatar
Somnath, Suhas committed
833
834
        VS_shift = parm_dict['VS_cycle_phase_shift']
        if VS_shift is not 0:
Somnath, Suhas's avatar
Somnath, Suhas committed
835
836
837
838
839
840
841
            VS_shift = translate_val(VS_shift, ['1/4', '1/2', '3/4'], [0.25, 0.5, 0.75])
        VS_in_out_cond = translate_val(parm_dict['VS_measure_in_field_loops'],
                                       ['out-of-field', 'in-field', 'in and out-of-field'], [0, 1, 2])
        VS_ACDC_cond = translate_val(parm_dict['VS_mode'],
                                     ['DC modulation mode', 'AC modulation mode with time reversal',
                                      'load user defined VS Wave from file', 'current mode'],
                                     [0, 2, 3, 4])
Somnath, Suhas's avatar
Somnath, Suhas committed
842
843
844
845
        self.expt_type = VS_ACDC_cond
        FORC_cycles = parm_dict['FORC_num_of_FORC_cycles']
        FORC_A1 = parm_dict['FORC_V_high1_[V]']
        FORC_A2 = parm_dict['FORC_V_high2_[V]']
Unknown's avatar
Unknown committed
846
        # FORC_repeats = parm_dict['# of FORC repeats']
Somnath, Suhas's avatar
Somnath, Suhas committed
847
848
        FORC_B1 = parm_dict['FORC_V_low1_[V]']
        FORC_B2 = parm_dict['FORC_V_low2_[V]']
Unknown's avatar
Unknown committed
849
850
851

        # % build vector of voltage spectroscopy values

Somnath, Suhas's avatar
Somnath, Suhas committed
852
        if VS_ACDC_cond == 0 or VS_ACDC_cond == 4:  # DC voltage spectroscopy or current mode
Unknown's avatar
Unknown committed
853
            VS_amp_vec_1 = np.arange(0, 1 + 1 / (VS_steps / 4), 1 / (VS_steps / 4))
Somnath, Suhas's avatar
Somnath, Suhas committed
854
855
            VS_amp_vec_2 = np.flipud(VS_amp_vec_1[:-1])
            VS_amp_vec_3 = -VS_amp_vec_1[1:]
Unknown's avatar
Unknown committed
856
857
            VS_amp_vec_4 = VS_amp_vec_1[1:-1] - 1
            vs_amp_vec = VS_amp * (np.hstack((VS_amp_vec_1, VS_amp_vec_2, VS_amp_vec_3, VS_amp_vec_4)))
Unknown's avatar
Unknown committed
858
            # apply phase shift to VS wave
Unknown's avatar
Unknown committed
859
            vs_amp_vec = np.roll(vs_amp_vec, int(np.floor(VS_steps / VS_fraction * VS_shift)))
Unknown's avatar
Unknown committed
860
            # cut VS waveform
Unknown's avatar
Unknown committed
861
            vs_amp_vec = vs_amp_vec[:int(np.floor(VS_steps * VS_fraction))]
Unknown's avatar
Unknown committed
862
            # repeat VS waveform
Somnath, Suhas's avatar
Somnath, Suhas committed
863
            vs_amp_vec = np.tile(vs_amp_vec, int(VS_cycles))
Unknown's avatar
Unknown committed
864
865
            vs_amp_vec = vs_amp_vec + VS_offset

Somnath, Suhas's avatar
Somnath, Suhas committed
866
        elif VS_ACDC_cond == 2:  # AC voltage spectroscopy with time reversal
Unknown's avatar
Unknown committed
867
868
            vs_amp_vec = VS_amp * np.arange(1 / (VS_steps / 2 / VS_fraction), 1 + 1 / (VS_steps / 2 / VS_fraction),
                                            1 / (VS_steps / 2 / VS_fraction))
Somnath, Suhas's avatar
Somnath, Suhas committed
869
            vs_amp_vec = np.roll(vs_amp_vec,
Unknown's avatar
Unknown committed
870
871
                                 int(np.floor(VS_steps / VS_fraction * VS_shift)))  # apply phase shift to VS wave
            vs_amp_vec = vs_amp_vec[:int(np.floor(VS_steps * VS_fraction / 2))]  # cut VS waveform
Somnath, Suhas's avatar
Somnath, Suhas committed
872
            vs_amp_vec = np.tile(vs_amp_vec, VS_cycles * 2)  # repeat VS waveform
Unknown's avatar
Unknown committed
873

Somnath, Suhas's avatar
Somnath, Suhas committed
874
        if FORC_cycles > 1:
Unknown's avatar
Unknown committed
875
876
877
878
879
880
881
            vs_amp_vec = vs_amp_vec / np.max(np.abs(vs_amp_vec))
            FORC_cycle_vec = np.arange(0, FORC_cycles + 1, FORC_cycles / (FORC_cycles - 1))
            FORC_A_vec = FORC_cycle_vec * (FORC_A2 - FORC_A1) / FORC_cycles + FORC_A1
            FORC_B_vec = FORC_cycle_vec * (FORC_B2 - FORC_B1) / FORC_cycles + FORC_B1
            FORC_amp_vec = (FORC_A_vec - FORC_B_vec) / 2
            FORC_off_vec = (FORC_A_vec + FORC_B_vec) / 2

Somnath, Suhas's avatar
Somnath, Suhas committed
882
883
884
            VS_amp_mat = np.tile(vs_amp_vec, [FORC_cycles, 1])
            FORC_amp_mat = np.tile(FORC_amp_vec, [len(vs_amp_vec), 1]).transpose()
            FORC_off_mat = np.tile(FORC_off_vec, [len(vs_amp_vec), 1]).transpose()
Unknown's avatar
Unknown committed
885
886
887
            VS_amp_mat = VS_amp_mat * FORC_amp_mat + FORC_off_mat
            vs_amp_vec = VS_amp_mat.reshape(int(FORC_cycles * VS_cycles * VS_fraction * VS_steps))

Somnath, Suhas's avatar
Somnath, Suhas committed
888
889
        # Build UDVS table:
        if VS_ACDC_cond is 0 or VS_ACDC_cond is 4:  # DC voltage spectroscopy or current mode
Unknown's avatar
Unknown committed
890

Somnath, Suhas's avatar
Somnath, Suhas committed
891
            if VS_ACDC_cond is 0:
Somnath, Suhas's avatar
Somnath, Suhas committed
892
                UD_dc_vec = np.vstack((vs_amp_vec, np.zeros(len(vs_amp_vec))))
Somnath, Suhas's avatar
Somnath, Suhas committed
893
            if VS_ACDC_cond is 4:
Somnath, Suhas's avatar
Somnath, Suhas committed
894
                UD_dc_vec = np.vstack((vs_amp_vec, vs_amp_vec))
Unknown's avatar
Unknown committed
895

Somnath, Suhas's avatar
Somnath, Suhas committed
896
            UD_dc_vec = UD_dc_vec.transpose().reshape(UD_dc_vec.size)
Somnath, Suhas's avatar
Somnath, Suhas committed
897
            num_VS_steps = UD_dc_vec.size
Unknown's avatar
Unknown committed
898

Somnath, Suhas's avatar
Somnath, Suhas committed
899
            UD_VS_table_label = ['step_num', 'dc_offset', 'ac_amp', 'wave_type', 'wave_mod', 'in-field', 'out-of-field']
Somnath, Suhas's avatar
Somnath, Suhas committed
900
            UD_VS_table_unit = ['', 'V', 'A', '', '', 'V', 'V']
Somnath, Suhas's avatar
Somnath, Suhas committed
901
            udvs_table = np.zeros(shape=(num_VS_steps, 7), dtype=np.float32)
Unknown's avatar
Unknown committed
902

Somnath, Suhas's avatar
Somnath, Suhas committed
903
904
            udvs_table[:, 0] = np.arange(0, num_VS_steps)  # Python base 0
            udvs_table[:, 1] = UD_dc_vec
Unknown's avatar
Unknown committed
905
906
907
908

            BE_IF_switch = np.abs(np.imag(np.exp(1j * np.pi / 2 * np.arange(1, num_VS_steps + 1))))
            BE_OF_switch = np.abs(np.real(np.exp(1j * np.pi / 2 * np.arange(1, num_VS_steps + 1))))

Somnath, Suhas's avatar
Somnath, Suhas committed
909
910
911
912
913
914
            if VS_in_out_cond is 0:  # out of field only
                udvs_table[:, 2] = BE_amp * BE_OF_switch
            elif VS_in_out_cond is 1:  # in field only
                udvs_table[:, 2] = BE_amp * BE_IF_switch
            elif VS_in_out_cond is 2:  # both in and out of field
                udvs_table[:, 2] = BE_amp * np.ones(num_VS_steps)
Unknown's avatar
Unknown committed
915

Somnath, Suhas's avatar
Somnath, Suhas committed
916
917
            udvs_table[:, 3] = np.ones(num_VS_steps)  # wave type
            udvs_table[:, 4] = np.ones(num_VS_steps) * BE_signal_type  # wave mod
Unknown's avatar
Unknown committed
918
919
920
921

            udvs_table[:, 5] = float('NaN') * np.ones(num_VS_steps)
            udvs_table[:, 6] = float('NaN') * np.ones(num_VS_steps)

Somnath, Suhas's avatar
Somnath, Suhas committed
922
923
            udvs_table[BE_IF_switch == 1, 5] = udvs_table[BE_IF_switch == 1, 1]
            udvs_table[BE_OF_switch == 1, 6] = udvs_table[BE_IF_switch == 1, 1]