def test_individual_strings(self):
base_folder = ""
test_input = [
# simple case
{"input": ["scan_0.csv","scan_1.csv","scan_2.csv","scan_3.csv", "fiets_0.csv"], "result": 4, "base_filename":"scan", "extension":".csv", "test": "equal"},
# unequal case
{"input": ["scan_0.csv","scan_1.csv","scan_2.csv","scan_3.csv", "fiets_0.csv"], "result": 6, "base_filename":"scan", "extension":".csv", "test": "not equal"},
# high number
{"input": ["scan_0.csv","scan_1.csv","scan_2.csv","scan_200.csv", "fiets_0.csv"], "result": 201, "base_filename":"scan", "extension":".csv", "test": "equal"},
# more numbers
{"input": [ "/Users/robbert/Dropbox/Amsterdam/20151029/find_t0_crystal_f1_141458/find_t0_crystal_f1_141458_wavenumbers_0.csv", "/Users/robbert/Dropbox/Amsterdam/20151029/find_t0_crystal_f1_141458/find_t0_crystal_f1_141458_wavenumbers_1.csv",
"/Users/robbert/Dropbox/Amsterdam/20151029/find_t0_crystal_f1_141458/find_t0_crystal_f1_141458_wavenumbers_2.csv",
"/Users/robbert/Dropbox/Amsterdam/20151029/find_t0_crystal_f1_141458/find_t0_crystal_f1_141458_wavenumbers_3.csv",
"/Users/robbert/Dropbox/Amsterdam/20151029/find_t0_crystal_f1_141458/find_t0_crystal_f1_141458_delays_3.csv"],
"result": 4,
"base_filename":"/Users/robbert/Dropbox/Amsterdam/20151029/find_t0_crystal_f1_141458/find_t0_crystal_f1_141458_wavenumbers",
"extension":".csv",
"test": "equal"},
]
for i in range(len(test_input)):
res = IOM.find_number_of_scans(base_folder = "", base_filename = test_input[i]["base_filename"], extension = test_input[i]["extension"], flag_verbose = self.flag_verbose, test_input = test_input[i]["input"])
if test_input[i]["test"] == "equal":
self.assertEqual(res, test_input[i]["result"])
elif test_input[i]["test"] == "not equal":
self.assertNotEqual(res, test_input[i]["result"])
else:
print("Invalid test")
def test_import_delays_A(self):
"""
Multiple delays
"""
de, n_de = IOM.import_delays(self.file_dict_A, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_de, 5)
self.assertEqual(de[0], 0)
self.assertEqual(de[-1], 400)
def test_import_delays_B(self):
"""
Single delay
"""
de, n_de = IOM.import_delays(self.file_dict_B, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_de, 1)
self.assertEqual(de[0], 300)
self.assertEqual(de[-1], 300)
def test_import_slowModulation_A(self):
sm, sm_names, n_sm = IOM.import_slow_modulation(self.file_dict_A, self.fileformat, flag_verbose = self.flag_verbose)
print(sm, sm_names, n_sm)
self.assertEqual(sm, numpy.array([]))
self.assertEqual(sm_names, numpy.array([]))
self.assertEqual(n_sm, 1)
def test_ndarray_1d_2d_inv(self):
"""
In is same as out.
"""
n_var_in = (1,4)
var_in = numpy.zeros(n_var_in)
var_out, n_var_out = IOM.check_and_make_list(var_in, flag_verbose = self.flag_verbose)
self.assertEqual(n_var_in, n_var_out)
res = numpy.all(var_in == var_out)
self.assertTrue(res)
def test_list_of_strings(self):
base_folder = ""
test_input = [
{"input": ["fiets_123456.csv", "fiets_123456_LV_fileformat.345"], "result": 345, "test": "equal"},
]
for i in range(len(test_input)):
res = IOM.find_LV_fileformat(base_folder, flag_verbose = self.flag_verbose, test_input = test_input[i]["input"])
if test_input[i]["test"] == "equal":
self.assertEqual(res, test_input[i]["result"])
elif test_input[i]["test"] == "not equal":
self.assertNotEqual(res, test_input[i]["result"])
else:
print("Invalid test")
def import_data(self, flag_verbose = False):
"""
There can be different file formats, indicated by the file 'LV_file_format.N', where N is the format. The file format should be changed when a new or adapted import method is needed.
For example, the format '1' writes data as .csv, while '2' writes data as .bin. Format '1' needs import method 'IOM.import_data_LV_A'. Format 2 can use a modified version of that (add an extra flag indicating .bin files, it should default to .csv to maintain compatibility with older scripts) or make a completly new method 'IOM.import_data_LV_B'.
Note that the 'LV_file_format.N' are numbered by numbers, while the versions of 'IOM.import_data_LV_X' are indicated by letters.
'LV_file_format.666' is reserved for testing purposes.
"""
self.verbose("Import data", flag_verbose)
try:
filelist = os.listdir(self.path)
except OSError:
self.printError("Directory can not be found.", inspect.stack())
return False
if "LV_file_format.1" in filelist:
self.verbose(" LabView file format 1", flag_verbose)
res = IOM.import_data_LV_A(self.path, self.base_filename)
if res:
R, NR, t1fs_axis, t1fr_axis, w3_axis, phase, lastpump, n_fringes, n_pixels = res
else:
# res == False means error in importing
return False
else:
self.printError("Unknown file format. Please check 'LV_file_format.N' is present.", inspect.stack())
return False
self.r[0] = R
self.r[1] = NR
self.r_axis[0] = t1fs_axis
self.r_axis[2] = w3_axis
self.s_axis[2] = w3_axis
self.phase_degrees = phase
self.comment = lastpump
if self.n_fringes == 0:
self.n_fringes = n_fringes
if self.n_pixels == 0:
self.n_pixels = n_pixels
self.r_units = ["fs", "fs", "cm-1"]
self.n_scans += 1
return True
def test_individual_strings(self):
base_folder = ""
test_input = [
{"input": "fiets_LV_fileformat.3", "result": 34, "test": "not equal"},
{"input": "fiets_LV_fileformat.3", "result": 3, "test": "equal"},
{"input": "fiets_LV_fileformat.345", "result": 345, "test": "equal"},
{"input": "fiets_123_LV_fileformat.345", "result": 345, "test": "equal"},
{"input": "fiets_123LV_fileformat.345", "result": 345, "test": "equal"},
{"input": "/Users/robbert/Dropbox/Amsterdam/20151029/find_t0_crystal_f1_141458/find_t0_crystal_f1_141458_LV_fileformat.3", "result": 3, "test": "equal"},
]
for i in range(len(test_input)):
res = IOM.find_LV_fileformat(base_folder, flag_verbose = self.flag_verbose, test_input = test_input[i]["input"])
if test_input[i]["test"] == "equal":
self.assertEqual(res, test_input[i]["result"])
elif test_input[i]["test"] == "not equal":
self.assertNotEqual(res, test_input[i]["result"])
else:
print("Invalid test")
def test_import_bins_inverted(self):
"""
Bins and times have the opposite direction
"""
t1_bins, t1_fs, bin_sign, n_t1_bins, n_t1_fs, t1_zero_index = IOM.import_bins(file_dict = self.file_dict_B, fileformat = self.fileformat, flag_verbose = self.flag_verbose)
self.assertTrue(bin_sign)
self.assertEqual(t1_bins[0], 0)
self.assertEqual(t1_bins[-1], 854)
self.assertEqual(numpy.shape(t1_bins)[0], 855)
self.assertEqual(t1_fs[0], -301.843484)
self.assertEqual(t1_fs[-1], 1500.774246)
self.assertEqual(numpy.shape(t1_fs)[0], 855)
self.assertEqual(n_t1_bins, 855)
self.assertEqual(n_t1_fs, 712)
self.assertEqual(t1_zero_index, 143)
def test_individual_strings(self):
base_folder = ""
test_input = [
# simplest case
{"input": [
"azide_intensity_175815_count_ds0_sp0_sm0_de0_du0_0.csv",
],
"result": 1,
"base_filename":"scan",
"extension":".csv",
"test": "equal"},
# fail test
{"input": [
"azide_intensity_175815_count_ds0_sp0_sm0_de0_du0_0.csv",
],
"result": 2,
"base_filename":"scan",
"extension":".csv",
"test": "not equal"},
# simple case
{"input": [
"azide_intensity_175815_count_ds0_sp0_sm0_de0_du0_0.csv",
"azide_intensity_175815_count_ds0_sp0_sm0_de0_du0_1.csv",
"azide_intensity_175815_count_ds1_sp0_sm0_de0_du0_0.csv",
"azide_intensity_175815_count_ds1_sp0_sm0_de0_du0_1.csv",
"azide_intensity_175815_intensity_ds0_sp0_sm0_de0_du0_0.csv",
"azide_intensity_175815_intensity_ds0_sp0_sm0_de0_du0_1.csv",
"azide_intensity_175815_intensity_ds1_sp0_sm0_de0_du0_0.csv",
"azide_intensity_175815_intensity_ds1_sp0_sm0_de0_du0_1.csv",
],
"result": 2,
"base_filename":"scan",
"extension":".csv",
"test": "equal"},
# long filenames
{"input": [
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds0_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds0_sp0_sm0_de0_du0_1.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds1_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds1_sp0_sm0_de0_du0_1.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds0_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds0_sp0_sm0_de0_du0_1.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds1_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds1_sp0_sm0_de0_du0_1.csv",
],
"result": 2,
"base_filename":"scan",
"extension":".csv",
"test": "equal"},
# long filenames, higher numbers
{"input": [
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds10_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds10_sp0_sm0_de0_du0_1.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds11_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_count_ds11_sp0_sm0_de0_du0_1.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds10_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds10_sp0_sm0_de0_du0_1.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds11_sp0_sm0_de0_du0_0.csv",
"/Users/robbert/Desktop/20151006/azide_intensity_175815/azide_intensity_175815_intensity_ds11_sp0_sm0_de0_du0_1.csv",
],
"result": 12,
"base_filename":"scan",
"extension":".csv",
"test": "equal"},
]
for i in range(len(test_input)):
res = IOM.find_number_of_datastates(base_folder = "", flag_verbose = self.flag_verbose, test_input = test_input[i]["input"])
if test_input[i]["test"] == "equal":
self.assertEqual(res, test_input[i]["result"])
elif test_input[i]["test"] == "not equal":
self.assertNotEqual(res, test_input[i]["result"])
else:
print("Invalid test")
def test_import_spectraAndDatastates_B(self):
spds, n_sp, n_ds = IOM.import_spectraAndDatastates(self.file_dict_B, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_ds, 2)
self.assertEqual(n_sp, 1)
self.assertTrue(numpy.all(spds == numpy.array([[0,1],[0,-1]])))
def test_import_nshots(self):
n_sh = IOM.import_nshots(self.file_dict_A, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_sh, 100)
def test_import_wavelengths(self):
wl, n_wl = IOM.import_wavelengths(self.file_dict_A, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_wl, 32)
self.assertEqual(wl[0], 5078.435469)
self.assertEqual(wl[-1], 4662.957173)
def test_import_wavenumbers(self):
w3_axis_wn, n_w3 = IOM.import_wavenumbers(self.file_dict_A, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_w3, 32)
self.assertEqual(w3_axis_wn[0], 1969.110381)
self.assertEqual(w3_axis_wn[-1], 2144.561837)
def test_import_ndatastates_2(self):
"""
2 datastates
"""
n_ds = IOM.import_ndatastates(self.file_dict_B, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_ds, 2)
def test_import_ndatastates_1(self):
"""
1 datastate
"""
n_ds = IOM.import_ndatastates(self.file_dict_A, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_ds, 1)
def test_import_nspectra(self):
n_sp = IOM.import_nspectra(self.file_dict_A, self.fileformat, flag_verbose = self.flag_verbose)
self.assertEqual(n_sp, 1)
def add_data(self, scan, flag_construct_r = False, flag_verbose = False):
# import the reference and some other stuff
if len(self.imported_scans) == 0:
self.verbose(" importing reference and meta", flag_verbose)
path_and_filename = self.path + self.base_filename + "_ref.dat"
out = self.import_reference_VB6(path_and_filename, self.n_pixels)
self.r_axis[2] = out[0]
self.reference = out[1]
path_and_filename = self.path + self.base_filename + "_meta.txt"
out = self.import_meta_VB6(path_and_filename)
self.date = out[0]
self.data_type_version = out[1]
self.n_shots = out[2]
self.n_fringes = out[3]
self.phase_degrees = out[4]
self.comment = out[5]
# self.temp_scans = out[6]
# see if we already imported this file
if scan in self.imported_scans:
self.printWarning("Scan is already imported, but will be imported anyway because flag_import_override is set to True.", inspect.stack())
return False
else:
self.verbose(" scan has not been imported before ", flag_verbose)
filename = self.make_filenames(scan)
# for the 4 files
for k in range(4):
flag_skip_binning = False
# to distuinguish between the two diagrams
if k < 2:
diagram = 0
else:
diagram = 1
# import the data
try:
self.verbose(" importing data, data_type_version: " + self.data_type_version, flag_verbose)
if self.data_type_version == "1.2":
[m, fringes] = IOM.import_raw_data(filename[k], n_shots = self.n_shots, n_channels = self.n_channels, flag_counter = False)
elif self.data_type_version == "1.3":
[m, c, fringes] = IOM.import_raw_data(filename[k], n_shots = self.n_shots, n_channels = self.n_channels, flag_counter = True)
elif self.data_type_version == "1.4":
result = self.import_binned_data(filename[k], diagram)
flag_skip_binning = True
if result == False:
try:
[m, c, fringes] = self.import_raw_data(filename[k], flag_counter = True)
flag_skip_binning = False
except IOError:
return False
except IOError:
return False
# if the number of fringes can not be set using the meta file, find it here
if self.n_fringes == 0:
self.n_fringes = int(numpy.abs(fringes[1] - fringes[0]))
# counter
if self.data_type_version == "1.2":
# need to reconstruct it
m_axis, counter, correct_count = self.reconstruct_counter(m, self.x_channel, self.y_channel, fringes[0], fringes[1], flag_plot = False)
elif self.data_type_version == "1.3":
# only need to check the value
m_axis = c + fringes[0]
if m_axis[-1] == fringes[1]:
correct_count = True
else:
correct_count = False
elif self.data_type_version == "1.4":
# the case where the binning failed and VB6 reverts to data version 1.3
if flag_skip_binning == False:
m_axis = c + fringes[0]
if m_axis[-1] == fringes[1]:
correct_count = True
else:
correct_count = False
else:
correct_count = True
else:
self.printError("Unknown data type", inspect.stack())
correct_count = False
# check for consistency
if correct_count == False:
print("Scan: " + str(scan) + ", File: " + str(k) + ": Miscount!")
self.incorrect_count[k] += 1
# if it is consistent, continue to bin the data
elif flag_skip_binning == False:
print("Scan: " + str(scan) + ", File: " + str(k) + ": Count is correct!")
# make b the correct size, if it isn't already
if numpy.shape(self.b_axis)[-1] == 2:
self.make_arrays()
# bin the data
self.bin_data(m, m_axis, diagram)
else:
print("Scan: " + str(scan) + ", File: " + str(k) + ": Scan imported")
# all the data is now written into self.b*
# construct the actual measurement
# this should catch the situation that there are 4 miscounts in the first scan
if type(self.b_count) == numpy.ndarray:
if flag_construct_r:
self.construct_r()
self.imported_scans.append(scan)
self.n_scans = len(self.imported_scans)
return True
else:
return False
def save_data(self, export_path, r=False, s=True, flag_verbose=False):
if s and numpy.shape(self.s) != (1,):
IOM.save_data_PE(export_path, self.base_filename, s=self.s, s_axis=self.s_axis)
if r and numpy.shape(self.r) != (3,):
IOM.save_data_PE(export_path, self.base_filename, r=self.r, r_axis=self.r_axis)
