def test_can_write_numpy_timestamp_data_with_dates(self): tzinfo = None if pytz: tzinfo = pytz.utc input_data = np.array([ '2017-07-09', '2017-07-09', '2017-07-09'], dtype='datetime64') segment = ChannelObject("group", "timedata", input_data) output_file = BytesIO() with TdmsWriter(output_file) as tdms_writer: tdms_writer.write_segment([segment]) output_file.seek(0) tdms_file = TdmsFile(output_file) output_data = tdms_file.object("group", "timedata").data self.assertEqual(len(output_data), 3) self.assertEqual( output_data[0], datetime(2017, 7, 9, 0, 0, 0, 0, tzinfo)) self.assertEqual( output_data[1], datetime(2017, 7, 9, 0, 0, 0, 0, tzinfo)) self.assertEqual( output_data[2], datetime(2017, 7, 9, 0, 0, 0, 0, tzinfo))
def test_can_read_tdms_file_properties_after_writing(self): test_time = datetime.utcnow() if pytz: test_time = test_time.replace(tzinfo=pytz.utc) a_segment = RootObject(properties={ "prop1": "foo", "prop2": 3, }) b_segment = GroupObject("group_name", properties={ "prop3": 1.2345, "prop4": test_time, }) output_file = BytesIO() with TdmsWriter(output_file) as tdms_writer: tdms_writer.write_segment([a_segment, b_segment]) output_file.seek(0) tdms_file = TdmsFile(output_file) a_output = tdms_file.object() b_output = tdms_file.object("group_name") self.assertTrue("prop1" in a_output.properties, msg="prop1 not found") self.assertTrue("prop2" in a_output.properties, msg="prop2 not found") self.assertTrue("prop3" in b_output.properties, msg="prop3 not found") self.assertTrue("prop4" in b_output.properties, msg="prop4 not found") self.assertEqual(a_output.properties["prop1"], "foo") self.assertEqual(a_output.properties["prop2"], 3) self.assertEqual(b_output.properties["prop3"], 1.2345) self.assertEqual(b_output.properties["prop4"], test_time)
def test_can_append_to_file_using_path(self): input_1 = np.linspace(0.0, 1.0, 10) input_2 = np.linspace(1.0, 2.0, 10) segment_1 = ChannelObject("group", "a", input_1) segment_2 = ChannelObject("group", "a", input_2) tempdir = tempfile.mkdtemp() temppath = "%s/test_file.tdms" % tempdir try: with TdmsWriter(temppath) as tdms_writer: tdms_writer.write_segment([segment_1]) with TdmsWriter(temppath, 'a') as tdms_writer: tdms_writer.write_segment([segment_2]) tdms_file = TdmsFile(temppath) output = tdms_file.object("group", "a").data self.assertEqual(len(output), 20) np.testing.assert_almost_equal( output, np.concatenate([input_1, input_2])) finally: if os.path.exists(temppath): os.remove(temppath) os.rmdir(tempdir)
def test_can_write_timestamp_data(self): tzinfo = None if pytz: tzinfo = pytz.utc input_data = [ datetime(2017, 7, 9, 12, 35, 0, 0, tzinfo), datetime(2017, 7, 9, 12, 36, 0, 0, tzinfo), datetime(2017, 7, 9, 12, 37, 0, 0, tzinfo), ] segment = ChannelObject("group", "timedata", input_data) output_file = BytesIO() with TdmsWriter(output_file) as tdms_writer: tdms_writer.write_segment([segment]) output_file.seek(0) tdms_file = TdmsFile(output_file) output_data = tdms_file.object("group", "timedata").data self.assertEqual(len(output_data), 3) self.assertEqual(output_data[0], input_data[0]) self.assertEqual(output_data[1], input_data[1]) self.assertEqual(output_data[2], input_data[2])
def import_tdmsfile_to_tempodb(file_path, series_key_base=None): # Parse the TDMS file and get a handle to the object tdmsfile = TdmsFile(file_path) # Logging options show_properties = True show_data = False show_time = False import_data = True count = 0 level = 0 root = tdmsfile.object() display('/', level) if show_properties: display_properties(root, level) for group in tdmsfile.groups(): level = 1 group_obj = tdmsfile.object(group) display("%s" % group_obj.path, level) if show_properties: display_properties(group_obj, level) for channel in tdmsfile.group_channels(group): level = 2 display("%s" % channel.path, level) if show_properties: level = 3 display("data type: %s" % channel.data_type.name, level) display_properties(channel, level) if show_data: level = 3 data = channel.data display("data: %s" % data, level) if show_time: level = 3 time = channel.time_track() display("time: %s" % time, level) if import_data: level = 3 try: if series_key_base: series_key = "%s-%i" % (series_key_base, count) count += 1 # "Paul-Python-TDMS-1" else: # series_key_base = "%s-%s-%s" % os.path.basename(os.path.splitext(file_path))[0], group_obj. series_key = channel.path import_channel_to_tempodb(channel, series_key) except KeyError as ke: display("There is no embedded time data in this channel.", level) print ke print print
def load_tdms(self): """ Looks for .tdms files in folder and loads the first one it finds """ for fname in os.listdir(self.folder): ext = os.path.splitext(fname)[1] if ext=='.tdms': self.tdms = TdmsFile(self.folder+fname) if not self.tdms: print 'Tdms file not found'
def _load(self, filename=None, *args, **kargs): """TDMS file loader routine. Args: filename (string or bool): File to load. If None then the existing filename is used, if False, then a file dialog will be used. Returns: A copy of the itself after loading the data. """ if filename is None or not filename: self.get_filename("r") else: self.filename = filename # Open the file and read the main file header and unpack into a dict try: f = TdmsFile(self.filename) column_headers = [] data = np.array([]) for grp in f.objects.keys(): if grp == "/": pass # skip the rooot group elif grp == "/'TDI Format 1.5'": metadata = f.object("TDI Format 1.5") for k, v in metadata.properties.items(): self.metadata[k] = self.metadata.string_to_type(str(v)) else: if f.objects[grp].has_data: chnl = grp.split("/")[-1] chnl.strip().strip("'") column_headers.append(chnl) if data.size == 0: data = f.objects[grp].data else: data = np.column_stack([data, f.objects[grp].data]) self.data = data self.column_headers = column_headers except Exception: from traceback import format_exc raise Core.StonerLoadError("Not a TDMS File \n{}".format(format_exc())) return self
def convert_tdms(fileName,tempo,env): if tempo: time.sleep(20) path=env.path tdms_file=TdmsFile(os.path.join(path,fileName+'.tdms')) # tdms_file=TdmsFile(r'D:\DATA\00838_Data.tdms') hdf5=h5py.File(path+os.sep+fileName+'.h5','w') #channel=tdms_file.object('PXI M6251','Lang_U') #group=tdms_file.object('PXI M6251') grouplist=tdms_file.groups() #print grouplist for i in grouplist: group=tdms_file.object(i) grouph=hdf5.create_group(i) print group.path if group.path=='/\'PXI M6251\'': nbchannels=group.properties['Nchannel'] tstart=group.properties['Tstart'] sampling=group.properties['SampleTime'] if group.path=='/\'Tektronix\'': tstart=group.properties['Tstart'] #sampling=group.properties['SampleTime'] sampling=1/1.25e9 nbchannels=group.properties['Nchannel'] if group.path=='/\'S7\'': nbchannels=group.properties['Nchannel'] tstart=0. sampling=1. #print nbchannels,tstart,sampling grouph.attrs['Nchannel']=nbchannels grouph.attrs['Tstart']=tstart grouph.attrs['sampling']=1/float(sampling) liste=tdms_file.group_channels(i) for j in liste: grouph.create_dataset(re.sub('[\']','',j.path),data=j.data,compression="gzip") # conn=sqlite3.connect('ishtar') # curs=conn.cursor() # curs.execute('insert into shots values(?,?,?,?,?)',(int(fileName[0:-5]),fileName,0.,0.,0.)) # conn.commit() hdf5.create_group('Process') hdf5.close() env.process.addFile(fileName)
def test_indexing_channel_after_read_data(): """ Test indexing into a channel after reading all data """ test_file, expected_data = scenarios.chunked_segment().values with test_file.get_tempfile() as temp_file: tdms_file = TdmsFile.read(temp_file.file) for ((group, channel), expected_channel_data) in expected_data.items(): channel_object = tdms_file[group][channel] assert channel_object[0] == expected_channel_data[0] compare_arrays(channel_object[:], expected_channel_data)
def test_can_write_string_data(self): input_data = [ "hello world", u"\u3053\u3093\u306b\u3061\u306f\u4e16\u754c"] segment = ChannelObject("group", "string_data", input_data) output_file = BytesIO() with TdmsWriter(output_file) as tdms_writer: tdms_writer.write_segment([segment]) output_file.seek(0) tdms_file = TdmsFile(output_file) output_data = tdms_file.object("group", "string_data").data self.assertEqual(len(output_data), 2) self.assertEqual(output_data[0], input_data[0]) self.assertEqual(output_data[1], input_data[1])
def test_indexing_channel_with_integer(index): """ Test indexing into a channel with an integer index """ test_file, expected_data = scenarios.chunked_segment().values with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_channel_data) in expected_data.items(): channel_object = tdms_file[group][channel] assert channel_object[index] == expected_channel_data[index]
def read_cal_TDMS(tdms_filename, porttype='2-port'): from nptdms import TdmsFile tdms_file = TdmsFile(tdms_filename) ## list groups #print(tdms_file.groups()) ## scan properties #print(tdms_file.object('Parameters').properties) ## 2-port data twoport = tdms_file.group_channels('2-port') cal_paramsR = {} cal_paramsI = {} for idx in range(0,len(twoport)): tmpvar = twoport[idx] path = [item.replace('\'', '') for item in tmpvar.path.split('/') if item!=''] name = path[len(path)-1].split('_') term = name[0] realORimag = name[1] values = tmpvar.data bins = tmpvar.time_track() if realORimag=='X': cal_paramsR[term] = values elif realORimag=='Y': cal_paramsI[term] = values else: raise('ParseNameError') # # cal_params = {} for each in cal_paramsR.keys(): cal_params[each] = cal_paramsR[each] + 1j*cal_paramsI[each] # #from collections import namedtuple #return namedtuple('GenericDict', cal_params.keys())(**cal_params) return cal_params
def _init_data_with_tdms(self, tdms_filename): """Initializes the current RT-DC dataset with a tdms file. """ tdms_file = TdmsFile(str(tdms_filename)) # time is always there table = "Cell Track" # Edit naming.dclab2tdms to add features for arg in naming.tdms2dclab: try: data = tdms_file.object(table, arg).data except KeyError: pass else: if data is None or len(data) == 0: # Ignore empty features. npTDMS treats empty # features in the following way: # - in nptdms 0.8.2, `data` is `None` # - in nptdms 0.9.0, `data` is an array of length 0 continue self._events[naming.tdms2dclab[arg]] = data # Set up configuration tdms_config = Configuration( files=[self.path.with_name(self._mid + "_para.ini"), self.path.with_name(self._mid + "_camera.ini")], ) dclab_config = Configuration() for section in naming.configmap: for pname in naming.configmap[section]: meta = naming.configmap[section][pname] typ = dfn.config_funcs[section][pname] if isinstance(meta, tuple): osec, opar = meta if osec in tdms_config and opar in tdms_config[osec]: val = tdms_config[osec].pop(opar) dclab_config[section][pname] = typ(val) else: dclab_config[section][pname] = typ(meta) self.config = dclab_config self._complete_config_tdms(tdms_config) self._init_filters()
def __init__(self, fname): tdms_file = TdmsFile(fname)["main"] t0 = tdms_file["t0"][:] t0 -= t0[0] t0 /= 1e6 self.tdms_file = tdms_file self.t0 = t0 self.Nrecords = len(self.t0) self.colletion_name = "Collection channel is not set!" self.collection = []
def _parseFile(self): if self.filename.lower().endswith('.tdms'): tdms = TdmsFile(self.filename) self.time = {} self.data = {} self.groups = tdms.groups() self.channels = {} for g in self.groups: self.time[g] = {} self.data[g] = {} self.channels[g] = tdms.group_channels(g) for c in self.channels[g]: if c.has_data: props = c.properties self.time[g][props["NI_ChannelName"]] = c.time_track() self.data[g][props["NI_ChannelName"]] = c.data elif self.filename.lower().endswith('.txt'): fid = open(self.filename, "r") if "<Mach-1 File>" in fid.readline(): contents = fid.readlines() fid.close() self.time = OrderedDict() self.data = OrderedDict() self.channels = OrderedDict() info_blocks = [i for i, j in izip(count(), contents) if "<INFO>" in j or "<END INFO>" in j] info_blocks = izip(islice(info_blocks, 0, None, 2), islice(info_blocks, 1, None, 2)) data_blocks = [i for i, j in izip(count(), contents) if "<DATA>" in j or "<END DATA>" in j] data_blocks = izip(islice(data_blocks, 0, None, 2), islice(data_blocks, 1, None, 2)) self.groups = range(1, len(list(info_blocks))+1) for i, ind in enumerate(data_blocks): g = self.groups[i] header = contents[ind[0]+1].rstrip("\r\n").split("\t") self.channels[g] = header data = contents[ind[0]+2:ind[1]] for j, d in enumerate(data): data[j] = d.rstrip("\r\n").split("\t") data = np.array(data, float) self.time[g] = OrderedDict() self.data[g] = OrderedDict() for j, c in enumerate(self.channels[g][1:]): self.time[g][c] = data[:, 0] self.data[g][c] = data[:, j+1]
def load_sdata(self, del_data=True, skip_cal=False): if (del_data == True): self.delete_data() self.prop['fns'] = filedialog.askopenfilenames( filetypes=[("TDMS", "*.tdms")], title='open s-polarized excitation data') self.prop['Nf'] = len(self.prop['fns']) self.prop['PxCols'] = list( tdms(self.prop['fns'][0]).properties.items())[11][1] self.prop['PxRows'] = list( tdms(self.prop['fns'][0]).properties.items())[12][1] self.sIs = np.zeros( (self.prop['PxCols'], self.prop['PxRows'], self.prop['Nf'])) self.sIp = np.zeros( (self.prop['PxCols'], self.prop['PxRows'], self.prop['Nf'])) for i in range(self.prop['Nf']): sDat = tdms.read(self.prop['fns'][i]).groups()[0].channels( )[1].data #channel 2 is PBS reflection path -> s-polarized light pDat = tdms.read(self.prop['fns'][i]).groups()[0].channels( )[2].data #channel 3 is PBS transmission path -> p-polarized light for j in range(self.prop['PxCols']): self.sIs[j, :, i] = sDat[(j * self.prop['PxRows']):((j + 1) * self.prop['PxRows'])] self.sIp[j, :, i] = pDat[(j * self.prop['PxRows']):((j + 1) * self.prop['PxRows'])] print(np.mean(self.sIp)) print(np.mean(self.sIs)) # beware of doulbe processing when using calibrate function if (skip_cal == False): self.axelrod() self.s_sensitivity(missing=False)
def parameterSearch(self,TDMSPath): config = ConfigParser.ConfigParser() config.read(u'config.txt') #This section reads the needed information from the config file startFreq = config.getint(u'Frequencies',u'Start Frequency') stopFreq = config.getint(u'Frequencies',u'Stop Frequency') stepFreq = config.getint(u'Frequencies',u'Step Frequency') NUM_POINTS = config.getint(u'Symbolic Constants',u'Num Points') JUMP_BACK = config.getint(u'Symbolic Constants',u'Jump Back') TDMS_Time = [] TDMS_Data = [] TDMSfiles = os.listdir(TDMSPath) TDMSfiles = [file for file in TDMSfiles if file.endswith(u'.tdms')] for file in TDMSfiles: #Loop through all TDMS files in order to get the data within each path = TDMSPath + u'/' + file TDMS = TdmsFile(path) #Function that reads the specific TDMS file group = TDMS.groups()[0] channel = TDMS.object(group, u'Dev1/ai0') #returns a channel type data = channel.data time = channel.time_track() #Determining starting point to read file #if highest point is more than JUMP_BACK points into the data, start there if numpy.argmax(data)>JUMP_BACK: start = numpy.argmax(data)-JUMP_BACK else: start = 0 #otherwise start at the beginning of the file t = time[start:start+NUM_POINTS] #time information from the start point to the end point s = data[start:start+NUM_POINTS] #data from the start point to the end point TDMS_Time.append(t) #add the TDMS files data to the set of all TDMS files data TDMS_Data.append(s) #Now that the data has all been found it can be set using the InputData class InputData.Set_Start_Freq(startFreq) InputData.Set_Stop_Freq(stopFreq) InputData.Set_Step_Freq(stepFreq) InputData.Set_TDMS_Time(TDMS_Time) InputData.Set_TDMS_Data(TDMS_Data)
def tdms2csv(tdmsFolderName): tdmsFiles = [] tdmsFolderNameFull = originTDMSFolder + '/' + tdmsFolderName + '/data' if not os.path.exists(tdmsFolderNameFull): return for file in os.listdir(tdmsFolderNameFull): if file.endswith(".tdms"): tdmsFiles += [file] #%% Check if the destination foldername exists destinationFolderName = destinationCSVFolder + '/' + tdmsFolderName if not os.path.exists(destinationFolderName): os.makedirs(destinationFolderName) #%% directoryIndex = 1 for file in tdmsFiles: print(file) tdms_file = TdmsFile(tdmsFolderNameFull + '/' + file) directory = destinationCSVFolder + '/' + tdmsFolderName + '/data_' + str( directoryIndex) directoryIndex += 1 if not os.path.exists(directory): os.makedirs(directory) for channelName in channelNames: channel = tdms_file.object('data', channelName) data = channel.data s = channel.property('wf_start_time') samplingIncrement = channel.property('wf_increment') np.savetxt(directory + '/' + channelName + '.csv', data, delimiter=',') np.savetxt(directory + '/timingMetaData.csv', [[ s.hour, s.minute, s.second, s.microsecond, samplingIncrement ]], delimiter=',')
def signal_plot(PDname=None, method='diff'): if PDname is None: PDname = FindFile('Photodiode') PDfile = TdmsFile(PDname) PDdata = PDfile.as_dataframe(time_index=True, absolute_time=False) num_tests = int(len(PDdata.columns) / 4) plot_num = test_enter(num_tests) new_data = PDdata[PDdata.columns[plot_num * 4:(plot_num * 4) + 4]] new_data.columns = [ 'Test {0} '.format(plot_num) + 'PD1', 'Test {0} '.format(plot_num) + 'PD2', 'Test {0} '.format(plot_num) + 'PD3', 'Test {0} '.format(plot_num) + 'PD4' ] new_data.index.name = 'Time (s)' # Determine the values of the 1st finite difference diff_val = new_data.diff() # Plot the desired signals new_data.plot(linewidth=3) # Plot locations of the maximum values of the signals plt.plot(new_data.idxmax(), new_data.max(), marker='o', linestyle='None', markersize=8, label='Max', color='black', markerfacecolor='black') # Plot locations of the maximum values of the 1st finite difference plt.plot(diff_val.idxmax(), np.diag(new_data.loc[diff_val.idxmax(), new_data.columns]), marker='s', linestyle='None', markersize=8, label='Grad', color='black') plt.legend() plt.show() # PDdata.plot(y=list(PDdata.columns[plot_num*4:(plot_num*4)+4])) return new_data
def test_stream_interleaved_data_channel(benchmark): """ Benchmark streaming channel data from an interleaved data file """ with TdmsFile.open( get_interleaved_file().get_bytes_io_file()) as tdms_file: channel = tdms_file['group']['channel3'] channel_data = benchmark(stream_chunks, channel) channel_data = np.concatenate(channel_data) expected_data = np.repeat([3], 10000) np.testing.assert_equal(channel_data, expected_data)
def test_index_interleaved_data_channel(benchmark): """ Benchmark reading a data from a interleaved data file using integer indices """ with TdmsFile.open( get_interleaved_file().get_bytes_io_file()) as tdms_file: channel = tdms_file['group']['channel3'] channel_data = np.zeros(10000, dtype=channel.dtype) benchmark(index_values, channel, channel_data) expected_data = np.repeat([3], 10000) np.testing.assert_equal(channel_data, expected_data)
def f_open_tdms(filename, channel): if filename == 'Input': filename = filedialog.askopenfilename() file = TdmsFile.read(filename) all_groups = file.groups() group = all_groups[0] data_channel = group[channel] data = data_channel[:] return data
def test_read_data_after_close_throws(): """ Trying to read after opening and closing without reading data should throw """ test_file, expected_data = scenarios.single_segment_with_one_channel().values group, channel = list(expected_data.keys())[0] with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: pass with pytest.raises(RuntimeError) as exc_info: tdms_file[group][channel].read_data() assert "Cannot read data after the underlying TDMS reader is closed" in str(exc_info.value)
def test_indexing_channel_with_invalid_type_raises_error(index): """ Test indexing into a channel with an invalid index type """ test_file, expected_data = scenarios.chunked_segment().values with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_channel_data) in expected_data.items(): channel_object = tdms_file[group][channel] with pytest.raises(TypeError) as exc_info: _ = channel_object[index] assert "Invalid index type" in str(exc_info.value)
def test_indexing_channel_with_zero_step_raises_error(): """ Test indexing into a channel with a slice with zero step size raises an error """ test_file, expected_data = scenarios.chunked_segment().values with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_channel_data) in expected_data.items(): channel_object = tdms_file[group][channel] with pytest.raises(ValueError) as exc_info: _ = channel_object[::0] assert str(exc_info.value) == "Step size cannot be zero"
def test_stream_channel_data_chunks(test_file, expected_data): """Test streaming chunks of data for a single channel from a TDMS file """ with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_channel_data) in expected_data.items(): actual_data = [] for chunk in tdms_file[group][channel].data_chunks(): assert chunk.offset == len(actual_data) actual_data.extend(chunk[:]) compare_arrays(actual_data, expected_channel_data)
def test_can_write_multiple_segments(self): input_1 = np.linspace(0.0, 1.0, 10) input_2 = np.linspace(2.0, 3.0, 10) segment_1 = ChannelObject("group", "a", input_1) segment_2 = ChannelObject("group", "a", input_2) output_file = BytesIO() with TdmsWriter(output_file) as tdms_writer: tdms_writer.write_segment([segment_1]) tdms_writer.write_segment([segment_2]) output_file.seek(0) tdms_file = TdmsFile(output_file) output_data = tdms_file.object("group", "a").data expected_data = np.append(input_1, input_2) self.assertEqual(len(output_data), len(expected_data)) self.assertTrue((output_data == expected_data).all())
def test_lazily_read_raw_channel_data(): """Test reading raw channel data lazily""" test_file, expected_data = scenarios.single_segment_with_one_channel( ).values with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_data) in expected_data.items(): actual_data = tdms_file[group][channel].read_data(scaled=False) assert actual_data.dtype == expected_data.dtype compare_arrays(actual_data, expected_data)
def test_lazily_read_channel_data_with_channel_data_method(): """Test reading channel data lazily using the channel_data method of TdmsFile """ test_file, expected_data = scenarios.single_segment_with_two_channels( ).values with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_data) in expected_data.items(): actual_data = tdms_file.channel_data(group, channel) assert actual_data.dtype == expected_data.dtype np.testing.assert_almost_equal(actual_data, expected_data)
def test_invalid_length_in_read_data_throws(): """ Exception is thrown when reading a subset of data with an invalid length """ test_file, expected_data = scenarios.single_segment_with_one_channel( ).values group, channel = list(expected_data.keys())[0] with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: with pytest.raises(ValueError) as exc_info: tdms_file[group][channel].read_data(0, -5) assert "length must be non-negative" in str(exc_info.value)
def test_indexing_channel_with_invalid_integer_raises_error(index): """ Test indexing into a channel with an invalid integer index """ test_file, expected_data = scenarios.chunked_segment().values with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_channel_data) in expected_data.items(): channel_object = tdms_file[group][channel] with pytest.raises(IndexError): _ = channel_object[index]
def read_noise_tdms(filename, sampleRate=51200): # read metadata and TDMS channel data noisedata = TdmsFile(filename) # parse start time of recording # strip off folders startTime = filename.split("/")[-1].split("_")[:2] # join date (YYYYMMDD) to time (HHMMSS) startTime = "_".join(startTime) # convert tdms data to pd.DataFrame noisedf = noisedata.as_dataframe() # Make time index noisedf.index = pd.TimedeltaIndex(data=1 / sampleRate * np.arange(len(noisedf)), unit="s") return noisedf, startTime
def tdms_extract(entry): try: if (entry.endswith('.tdms')): tdms_file = TdmsFile(entry) for group in tdms_file.groups(): data = tdms_file.object(group).as_dataframe() if group == 'Events': data["TimeStamp"] = data["TimeStamp"].astype( float).values - float(data["TimeStamp"].values[0]) if group == 'Channels': data["TimeStamp (sec)"] = data[ "TimeStamp (sec)"].values - data[ "TimeStamp (sec)"].values[0] if not os.path.exists('C:/Niagara/UEF/' + group): os.makedirs('C:/Niagara/UEF/' + group) name = entry.split('\\')[-1] data.to_csv('C:/Niagara/UEF/' + group + "/" + name[:-5] + ".csv") except Exception as e: pass
def testTdmsFile(): tdms = TdmsFile( "/Volumes/RAID-0/LockheedMartin/TDMS_200120_12-40_2020-01-20 ATRQ Build 2/Slice00122.tdms" ) # tdms.as_hdf('/tmp/Slice00122.h5') properties = tdms.properties for property in properties: print(f'PROPERTY: {property} = {properties[property]}') objects = tdms.objects for obj in objects: print(f'OBJECT: {obj}') groups = tdms.groups() for part in groups: print(f'GROUP: {part}') # get the data from each group's channel and make a CSV channels = tdms.group_channels(part) # make a 2D array, and populate it with the arrays in this loop. groupCSV = [] areaCol = [] xCol = [] yCol = [] paramCol = [] intensityCol = [] laserCol = [] csvCount = 0 # copy each channel's data to its respective frame for channel in channels: print(f' CHANNEL: {channel}') names = [] for i in channels: wordList = str(i).split("/") name = wordList[-1] name = name.strip(">") name = name.strip("'") names.append(name) colNames = names
def test_read_data_after_open_in_read_mode_throws(): """ Trying to read channel data after reading all data initially should throw """ test_file, expected_data = scenarios.single_segment_with_one_channel( ).values group, channel = list(expected_data.keys())[0] with test_file.get_tempfile() as temp_file: tdms_file = TdmsFile.read(temp_file.file) with pytest.raises(RuntimeError) as exc_info: tdms_file[group][channel].read_data() assert "Cannot read data after the underlying TDMS reader is closed" in str( exc_info.value)
def test_read_channel_data(test_file, expected_data): """Test reading data""" with test_file.get_tempfile() as temp_file: tdms_data = TdmsFile.read(temp_file.file) for ((group, channel), expected_data) in expected_data.items(): channel_obj = tdms_data[group][channel] actual_data = channel_obj.data assert actual_data.dtype == expected_data.dtype assert channel_obj.dtype == expected_data.dtype compare_arrays(actual_data, expected_data)
def test_iterate_channel_data_in_read_mode(): """Test iterating over channel data after reading all data """ test_file, expected_data = scenarios.chunked_segment().values with test_file.get_tempfile() as temp_file: tdms_file = TdmsFile.read(temp_file.file) for ((group, channel), expected_channel_data) in expected_data.items(): actual_data = [] for value in tdms_file[group][channel]: actual_data.append(value) compare_arrays(actual_data, expected_channel_data)
def test_reading_subset_of_data_for_scenario(test_file, expected_data, offset, length): """Test reading a subset of a channel's data """ assume(any(offset <= len(d) for d in expected_data.values())) with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_data) in expected_data.items(): actual_data = tdms_file[group][channel].read_data( offset, length) compare_arrays(actual_data, expected_data[offset:offset + length])
def test_indexing_scaled_channel_with_integer(): """ Test indexing into a channel with an integer index when the channel is scaled """ test_file, expected_data = scenarios.scaled_data().values with test_file.get_tempfile() as temp_file: with TdmsFile.open(temp_file.file) as tdms_file: for ((group, channel), expected_channel_data) in expected_data.items(): channel_object = tdms_file[group][channel] values = [] for i in range(len(channel_object)): values.append(channel_object[i]) compare_arrays(values, expected_channel_data)
def read(self): # File information below tdms_file = TdmsFile(self.fname + '.tdms') # Reads a tdms file. group_name = "Trap" # Get the group name channels = tdms_file.group_channels( group_name) # Get the channel object self.ch = np.zeros( (len(channels), self.N_total)) # Make a 2D array (ch, timetrace) for trap data for i, channel in enumerate(channels): self.ch[i, ] = channel.data[range(self.N_total)] self.QPDx = self.ch[0] - np.mean(self.ch[0]) self.QPDy = self.ch[1] - np.mean(self.ch[1]) self.QPDs = self.ch[2] self.PZTx = (self.ch[3] - np.mean(self.ch[3])) * PZT_nm2V[0] self.PZTy = (self.ch[4] - np.mean(self.ch[4])) * PZT_nm2V[1] self.QPDx = self.QPDx / self.QPDs self.QPDy = self.QPDy / self.QPDs
def test_can_read_tdms_file_after_writing(self): a_input = np.linspace(0.0, 1.0, 100) b_input = np.linspace(0.0, 100.0, 100) a_segment = ChannelObject("group", "a", a_input) b_segment = ChannelObject("group", "b", b_input) output_file = BytesIO() with TdmsWriter(output_file) as tdms_writer: tdms_writer.write_segment([a_segment, b_segment]) output_file.seek(0) tdms_file = TdmsFile(output_file) a_output = tdms_file.object("group", "a").data b_output = tdms_file.object("group", "b").data self.assertEqual(len(a_output), len(a_input)) self.assertEqual(len(b_output), len(b_input)) self.assertTrue((a_output == a_input).all()) self.assertTrue((b_output == b_input).all())
def check_for_same_length(tdms_operator: nptdms.TdmsFile) -> either.Either: """Checks whether all relevant channels of the Tdms file have the same length. """ array_lengths = [[ len(channel) for channel in group.channels() if len(channel) > 0 ] for group in tdms_operator.groups()] array_lengths = np.array(array_lengths).flatten() all_lengths_equal = len(set(array_lengths)) == 1 if not all_lengths_equal: return either.Left(ErrorCode.LENGTHERROR) return either.Right(tdms_operator)
def TDMS_to_dict(TDMS_filename, input_chan, output_chan): """Convert raw data from a Labview VI into a dictionary of Python dictionaries Usage: TDMS_filename (string): full path to the input data filename input_chan (list of int): List of channel to be saved output_chan (list of strings): Identifier for each of the saved channels """ tdms_file = TdmsFile(TDMS_filename) list_out = {} for idx in range(len(input_chan)): channel_name = 'Dev2/ai' + str(input_chan[idx]) pdb.set_trace() channel = tdms_file.object('Untitled', channel_name) data = channel.data time = channel.time_track() sr = 1 / (time[1] - time[0]) entry = {'data': data, 'time': time, 'sr': sr} list_out[output_chan[idx]] = entry return list_out
def lade_tdms(par, typ): """ :type par: Parameter.Parameter :type typ: str """ daten = [] namen = [] # Dateinamen aufteilen und numerisch sortieren: sorted_fnames = sorted( glob(os.path.join(par.verzeichnis, typ + '*.tdms')), # alle Dateien in diesem Ordner mit der Endung TDMS key=lambda x: int(x.split(os.sep)[-1].split(typ)[1].split('.')[0]) # Zeilennummer hinter dem Typnamen ) # Offenbar das falsche Verzeichnis, wenn gar keine TDMS-Dateien gefunden wurden if len(sorted_fnames) == 0: raise Fehler(mw_tdms[lang]) verbleibend = par.messpunkte for tdms_fname in sorted_fnames: if verbleibend != 0: verbleibend -= 1 tdms_file = TdmsFile(tdms_fname) channel = tdms_file.object('Untitled', 'Untitled') # erster Name ist der Gruppenname, dann der Kanalname daten.append(np.array(channel.data)) namen.append(tdms_fname.split(os.sep)[-1]) else: break # Es fehlen Messdaten, die letzte Zeile wird einfach vervielfacht if verbleibend > 0: print("Fehlende Messdaten (" + typ + ")") while verbleibend > 0: verbleibend -= 1 daten.append(daten[-1]) return daten, namen
def load_trace(mname): """Loads the traces and returns them as a dictionary Currently, only loading traces from tdms files is supported. This forces us to load the full tdms file into memory which takes some time. """ tname = TraceColumn.find_trace_file(mname) # Initialize empty trace dictionary trace = {} if tname is None: pass elif tname.suffix == ".tdms": # Again load the measurement tdms file. # This might increase memory usage, but it is cleaner # when looking at code structure. mdata = TdmsFile(str(mname)) sampleids = mdata.object("Cell Track", "FL1index").data # Load the trace data. The traces file is usually larger than the # measurement file. tdata = TdmsFile(str(tname)) for trace_key in dfn.FLUOR_TRACES: group, ch = naming.tr_data_map[trace_key] try: trdat = tdata.object(group, ch).data except KeyError: pass else: if trdat is not None and trdat.size != 0: # Only add trace if there is actual data. # Split only needs the position of the sections, # so we remove the first (0) index. trace[trace_key] = np.split(trdat, sampleids[1:]) return trace
def test_can_write_tdms_objects_read_from_file(self): group_segment = GroupObject("group", properties={ "prop1": "bar" }) input_data = np.linspace(0.0, 1.0, 10) channel_segment = ChannelObject("group", "a", input_data, properties={ "prop1": "foo", "prop2": 3, }) tempdir = tempfile.mkdtemp() temppath = "%s/test_file.tdms" % tempdir try: with TdmsWriter(temppath) as tdms_writer: tdms_writer.write_segment([group_segment, channel_segment]) tdms_file = TdmsFile(temppath) read_group = tdms_file.object("group") read_channel = tdms_file.object("group", "a") with TdmsWriter(temppath) as tdms_writer: tdms_writer.write_segment([read_group, read_channel]) tdms_file = TdmsFile(temppath) read_group = tdms_file.object("group") read_channel = tdms_file.object("group", "a") self.assertFalse(read_group.has_data) self.assertEqual(read_group.properties["prop1"], "bar") self.assertEqual(len(read_channel.data), 10) np.testing.assert_almost_equal(read_channel.data, input_data) self.assertEqual(read_channel.properties["prop1"], "foo") self.assertEqual(read_channel.properties["prop2"], 3) finally: if os.path.exists(temppath): os.remove(temppath) os.rmdir(tempdir)
#import channel list channels = pd.read_csv(info_dir+'Channels.csv', index_col = 'Channel') helmet_channels = pd.read_csv(info_dir+'Helmet_Channels.csv', index_col = 'Channel') #import test descriptions test_des = pd.read_csv(info_dir+'Test_Descriptions.csv',index_col = 'Test Name') events_dict = {} data_dict = {} for test in test_des.index.values: print(test) data_df = TdmsFile(data_dir+test+'/'+test+'.tdms').as_dataframe() events_df = data_df.iloc[:,-2:].dropna() events_df.columns = ['Event','Time'] #Ignition is taken as the first event followin background ignition = events_df['Time'][int(test_des['Ignition Event Index'][test])].split('-')[-1] hh,mm,ss = ignition.split(':') ignition = 3600*int(hh) + 60*int(mm) + int(ss) event_times = [] for time in events_df['Time']: timestamp = time.split('-')[-1] hh,mm,ss = timestamp.split(':') timestamp = 3600*int(hh)+60*int(mm)+int(ss)-int(ignition) event_times.append(timestamp)
import numpy as np import pandas as pandas # lampTrain1 = np.genfromtxt('/Users/Chryssia/Desktop/SchoolStuff/Gatech/ECE4011/SeniorDesign/Scikit/MachineLearningData/Lamp/LampAverage_1.csv',delimiter=' ',dtype=None) # Item ID # 1. No load # 2. Lamp # 3. Hair Drier # 4. Small Blender # 5. Big Blender # 6. Hand Mixer # 7. TV Box # 8. Hair Drier and Lamp # Lamp Training lamp_tdms = TdmsFile("Lamp_001.tdms") a = lamp_tdms.object("Untitled","Untitled 5") x_train=np.array([a.data]) y_train = np.array(['2']) for x in range(1, 10): a = lamp_tdms.object("Untitled","Untitled "+str(x*5)) np1=np.array([a.data]) x_train = np.concatenate((x_train,np1),axis=0) y_train = np.concatenate((y_train,[2]),axis=0) # Hair Drier Training hairDrier_tdms = TdmsFile("HairDyer_001.tdms") for x in range(1, 11): a = hairDrier_tdms.object("Untitled","Untitled "+str(x*5))
def Reduce_data(data_X, data_Y, x1): Mx = np.column_stack((data_X[:, np.newaxis], data_Y[:, np.newaxis])) M2 = Red.rdp(Mx, x1) data_X2 = M2[:, 0].transpose() data_Y2 = M2[:, 1].transpose() return data_X2, data_Y2 def PandasResample(df, length): td = (df.index[-1] - df.index[0]) / (length - 1) return df.resample(td, how='mean').interpolate() # Handle NaNs when upsampling tdms_file = TdmsFile('data/10676_3531053.tdms') data = tdms_file.as_dataframe() channel = tdms_file.object("Unbenannt", "ProbenMitte") # print channel.property('wf_increment') # print channel.property('wf_start_time') # print channel.time_track() # kills alle leeren Spalten data = data.dropna(axis=1, how='all') # doppelte Spaltennamen aufloesen name_col = [] for jh in data.columns: tdummy = jh.split('/')[-1] name_col.append(tdummy.replace("\'", ""))
# prop = ['C','C','C','B','B','B','A','A','A','A','A','A','B','B','B','C','C','C'] charts_to_skip = {10: ['Gas_A','Carbon_Monoxide_A'], 18:['13TC']} experiment_info = pd.DataFrame({'Experiment':experiments,'Prop':prop}) experiment_info = experiment_info.set_index('Experiment') for experiment in experiment_info.index: if experiment in charts_to_skip: skip_charts = charts_to_skip[experiment] else: skip_charts = [] print ('Plotting Experiment ' + str(experiment)) tdms_file = TdmsFile(data_location + 'Experiment_' + str(experiment) + '/Experiment_' + str(experiment) + '.tdms') # Read in channel list if experiment_info['Prop'][experiment] is 'A': channel_list = pd.read_csv(channel_location+'Channels_A.csv') if experiment_info['Prop'][experiment] is 'B': if experiment == 14 or 15: print ('Using alternate Channel List') channel_list = pd.read_csv(channel_location+'Channels_B_alt.csv') else: channel_list = pd.read_csv(channel_location+'Channels_B.csv') if experiment_info['Prop'][experiment] is 'C': if experiment==18: print ('Using alternate Channel List') channel_list = pd.read_csv(channel_location+'Channels_C_alt.csv') else:
def __init__(self, tdms_filename): """ Load tdms file and set all variables """ # Kernel density estimator dictionaries self._KDE_Scatter = {} self._KDE_Contour = {} self._old_filters = {} # for comparison to new filters self._Downsampled_Scatter = {} self._polygon_filter_ids = [] self.tdms_filename = tdms_filename self.name = os.path.split(tdms_filename)[1].split(".tdms")[0] self.fdir = os.path.dirname(tdms_filename) mx = os.path.join(self.fdir, self.name.split("_")[0]) self.title = u"{} - {}".format( GetProjectNameFromPath(tdms_filename), os.path.split(mx)[1]) f2hash = [ tdms_filename, mx+"_camera.ini", mx+"_para.ini" ] self.file_hashes = [(fname, _hashfile(fname)) for fname in f2hash] self.identifier = self.file_hashes[0][1] tdms_file = TdmsFile(tdms_filename) ## Set all necessary internal parameters as defined in ## definitions.py ## Note that this is meta-programming. If you want to add a ## different column from tdms files, then edit definitions.py: ## -> uid, axl, rdv, tfd # time is always there datalen = len(tdms_file.object("Cell Track", "time").data) for i, group in enumerate(dfn.tfd): table = group[0] if not isinstance(group[1], list): group[1] = [group[1]] func = group[2] args = [] try: for arg in group[1]: data = tdms_file.object(table, arg).data args.append(data) except KeyError: # set it to zero func = lambda x: x args = [np.zeros(datalen)] finally: setattr(self, dfn.rdv[i], func(*args)) # Plotting filters, set by "GetDownSampledScatter". # This is a nested filter which is applied after self._filter self._plot_filter = np.ones_like(self.time, dtype=bool) # Set array filters: # This is the filter that will be used for plotting: self._filter = np.ones_like(self.time, dtype=bool) # The filtering array for a general data event limit: self._filter_limit = np.ones_like(self._filter) attrlist = dir(self) # Find attributes to be filtered # These are the filters from which self._filter is computed inifilter = np.ones(data.shape, dtype=bool) for attr in attrlist: # only allow filterable attributes from global dfn.cfgmap if not dfn.cfgmap.has_key(attr): continue data = getattr(self, attr) if isinstance(data, np.ndarray): # great, we are dealing with an array setattr(self, "_filter_"+attr, inifilter.copy()) self._filter_polygon = inifilter.copy() self.SetConfiguration() # Get video file name videos = [] for f in os.listdir(self.fdir): if f.endswith(".avi") and f.startswith(self.name[:2]): videos.append(f) videos.sort() if len(videos) == 0: self.video = None else: # Defaults to first avi file self.video = videos[0] # g/q video file names. q comes first. for v in videos: if v.endswith("imag.avi"): self.video = v break # add this here, because fRT-DC measurements also contain # videos ..._proc.avi elif v.endswith("imaq.avi"): self.video = v break # Get contours self.contours = {} for f in os.listdir(self.fdir): if f.endswith("_contours.txt") and f.startswith(self.name[:2]): with open(os.path.join(self.fdir, f), "r") as c: # read entire file cdat = c.read(-1) for cont in cdat.split("Contour in frame"): cont = cont.strip() if len(cont) == 0: continue cont = cont.splitlines() # the frame is the first number frame = int(cont.pop(0)) cont = [ np.fromstring(c.strip("()"), sep=",") for c in cont ] cont = np.array(cont, dtype=np.uint8) self.contours[frame] = cont
#!/usr/bin/env python from nptdms import TdmsFile import glob import re # Update paths below to directory with tdms files (input_dir) and directory for csv outputs (output_dir) input_dir = '/Users/prioberoi/Documents/nist/netZero/data/raw/' output_dir = '/Users/prioberoi/Documents/nist/netZero/data/raw/' for filename in glob.iglob(input_dir+'*.tdms'): #update filepath to location with .tdms files from LabView tdms_file = TdmsFile(filename) temp = tdms_file.as_dataframe(time_index=False, absolute_time=False) start_loc = re.search(' All Day.tdms', filename).start()-10 stop_loc = re.search(' All Day.tdms', filename).start() temp.to_csv(path_or_buf=(output_dir+filename[start_loc:stop_loc]+".csv"), encoding='utf-8')
filedir = '/home/tiago/Data/Lab.local/PAG/probe/' fname = 'SE-CSC-RAW-Ch11_.nex' r = neo.io.NeuroExplorerIO(filename=(filedir + fname)) seg = r.read_segment(lazy=False, cascade=True) data = np.array(seg.analogsignals[0]) filedir = '/home/tiago/Data/Lab.local/PAG/probe/' fname = 'Analog Input Ch16_.nex' f = neo.io.NeuroExplorerIO(filename=(filedir + fname)) fseg = f.read_segment(lazy=False, cascade=True) frames = np.array(fseg.analogsignals[0]) # Get tdms file corresponding to the recording filedir = '/home/tiago/Data/Lab.local/PAG/probe/' fname = '02-07-2015-19-48-64207_VG2_SC_probe_t1.tdms' tdms = TdmsFile(filedir+fname) ############# # Pre-process ############# # Get rid of probe starting artefact i = frames<(-1000) counter = np.arange(0,len(i)) dataStart = counter[i][-1]+100 frames = frames[dataStart:] # Get the start of each frame dframes = np.diff(frames) counter = np.arange(0,len(dframes)) i = dframes>1000
def lade_tdms(self, datei): """ :type datei: str :return: Die gemittelten Messwerte aus der angegebenen Datei :rtype: numpy.mutliarray.ndarray """ # Beschnittene Daten (links: positiv, rechts: negativ) daten = np.zeros(self.par.messpunkte - self.par.bereich_links + self.par.bereich_rechts) try: tdat = TdmsFile(datei) tdms = tdat.object(tdat.groups()[0], 'Untitled') except (ValueError, IOError): print('Datei ' + datei + ' nicht auslesbar') return daten index_fehler = False for mittelung in range(self.par.mittelungen): try: """ Mittelung (durch Addition) UND Begrenzung des Fitbereichs (zur Eliminierung von parasitären Frequenzpeaks) nach Angabe in GUI """ start = mittelung * self.par.messpunkte links = start + self.par.bereich_links rechts = start + self.par.messpunkte + self.par.bereich_rechts daten += tdms.data[links:rechts] """if mittelung == 0: name = raw_input('$') import matplotlib.pyplot as plt plt.title(name+ ": Einzelmessung") plt.xlabel(u"Frequenz / Hz") plt.ylabel(u"Amplitude / µV") plt.plot( self.frequenzen, daten * (1000*1000/50/2.9), antialiased=True ) plt.show() elif mittelung == self.par.mittelungen-1: name = raw_input('$') import matplotlib.pyplot as plt plt.title(name+ ": 200x gemittelt") plt.xlabel(u"Frequenz / Hz") plt.ylabel(u"Amplitude / µV") plt.plot( self.frequenzen, daten / self.par.mittelungen * (1000*1000/180), antialiased=True ) plt.show()""" except (ValueError, IndexError): """ In diesem Fall ist ein Messfehler aufgetreten. Das kann (sehr selten) passieren, weshalb der Fit dennoch funktionieren muss. Hier ist dann aber ein Einbruch in der Amplitude zu verzeichnen. """ if not index_fehler: index_fehler = True print('Fehlende Messwerte in Datei ' + datei) return daten / self.par.mittelungen
ncfile.createDimension('y',pixel) dd=ncfile.createVariable(name,np.dtype('int32').char,('x','y')) data_out2=np.int32(((data_out+abs(data_out.min()))/(data_out.max()-data_out.min()))*(np.power(2,31)-1)) dd[:] = data_out2 ncfile.close() data=[] phase=[] messpunkte=200 # die Anzahl der Messpunkte pro Resonanzkurve pixel=200 # anzahl der Resonanzkurven ############## TDMS Datei einlesen '''''''''''''''''''''''''''''''''''''' fnames=glob("/home/sebadur/Dokumente/Studium/Master/Fit-GUI/Messung 06.11.14/amp*.tdms") # alle dateien in diesem Ordner mit der Endung TDMS sorted_fnames = sorted(fnames, key=lambda x: int(x.split('/')[-1].split('amp')[1].split('.')[0])) # Dateiname aufgeteilt und Nummerisch sortiert for i in range(pixel): tdms_file = TdmsFile(sorted_fnames[i]) channel = tdms_file.object('Unbenannt', 'Untitled') # erster Name ist der Gruppenname dann der Kanalname data.append(np.array(channel.data)) ###################--phase-- ############################ fnames=glob("/home/sebadur/Dokumente/Studium/Master/Fit-GUI/Messung 06.11.14/phase*.tdms") # alle dateien in diesem Ordner mit der Endung TDMS sorted_fnames = sorted(fnames, key=lambda x: int(x.split('/')[-1].split('phase')[1].split('.')[0])) # Dateiname aufgeteilt und Nummerisch sortiert for i in np.arange(pixel): tdms_file = TdmsFile(sorted_fnames[i]) channel = tdms_file.object('Unbenannt', 'Untitled') # erster Name ist der Gruppenname dann der Kanalname #data[i]=np.array(channel.data) phase.append(np.array(channel.data)) if pixel!=len(data[1])/messpunkte:
def chunker(seq, size): return (seq[pos:pos + size] for pos in xrange(0, len(seq), size)) def Reduce_data(data_X, data_Y, x1): Mx = np.column_stack((data_X[:, np.newaxis], data_Y[:, np.newaxis])) M2 = Red.rdp(Mx, x1) data_X2 = M2[:, 0].transpose() data_Y2 = M2[:, 1].transpose() return data_X2, data_Y2 def PandasResample(df, length): td = (df.index[-1] - df.index[0]) / (length - 1) return df.resample(td, how='mean').interpolate() # Handle NaNs when upsampling tdms_file = TdmsFile('data/_1620291.tdms') data = tdms_file.as_dataframe() print data.columns tizm = tdms_file.object("Unbenannt", "Zeit") channel = tdms_file.object("Unbenannt", "OfenIO") channel1 = tdms_file.object("Unbenannt", "T_X6") channel2 = tdms_file.object("Unbenannt", "Soll") # plt.plot(tizm.data,channel.data) # ax.scatter(x, y, c=c, cmap=cmap) plt.scatter(tizm.data, channel2.data, c=channel.data * 3., cmap=plt.cm.hot) plt.show()
tdmsVoltageFilename = os.path.join(sys.argv[1], "Voltage.tdms") tdmsCurrentFilename = os.path.join(sys.argv[1], "Current.tdms") #print "made file names" voltageTempNames = [] currentTempNames = [] timestamps = [] voltageGroupChannels = [] currentGroupChannels = [] voltageChannelNames = [] currentChannelNames = [] tdmsVoltageFile = TdmsFile(tdmsVoltageFilename) tdmsCurrentFile = TdmsFile(tdmsCurrentFilename) #print "called file names" ###### find group name # look at meta file #find "Log signal names:" #extract group name and channel names metaVoltageFile = open(metaVoltageFilename) metaCurrentFile = open(metaCurrentFilename) #print "successfully opened meta files" voltageTempNames = [] currentTempNames = []
bin_acc = 0. newcount = 0 for count in range(0,len(datax)): if(datax[count] >= startbin + binsize): newx.append(startbin + binsize/2.) newy.append(bin_acc) newcount = newcount + 1 startbin += binsize bin_acc = 0. bin_acc += abs(datay[count]) return (newx,newy) # reading TDMS file filename = sys.argv[1] datafile = TdmsFile(filename) # TdmsFile is a function from the library/class npTDMS?? # get the group names print filename list_of_groups = datafile.groups() # groups is a function from npTDMS, what returns the names of the groups # print list_of_groups[0] it's only possible to print element 0, so the list has only one element number_of_groups = len(list_of_groups) # print number_of_groups this gives a "1", so there is only one group for groupname in list_of_groups: print groupname # the groupname is "data"; it means to print every element of a list list_of_channels = datafile.group_channels(groupname) # group channels is a function from npTDMS, what returns a list of channel objects for channel in list_of_channels: print channel # extracting first waveform # getting voltages