acoular 24.3__py3-none-any.whl → 24.5__py3-none-any.whl

acoular/fileimport.py

@@ -1,380 +0,0 @@
-# -*- coding: utf-8 -*-
-#pylint: disable-msg=E0611, E1101, C0103, R0901, R0902, R0903, R0904, W0232
-#------------------------------------------------------------------------------
-# Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
-"""
-Contains classes for importing time data in several file formats.
-Standard HDF (`*.h5`) import can be done using 
-:class:`~acoular.sources.TimeSamples` objects.
-
-.. autosummary::
-    :toctree: generated/
-
-    time_data_import
-    csv_import
-    td_import
-    bk_mat_import
-    datx_import
-"""
-
-from numpy import fromstring, float32, newaxis, empty, sort, zeros
-from traits.api import HasPrivateTraits, Float, Int, \
-File, CArray, Property, Any, Str
-from os import path
-import pickle
-import configparser
-import struct
-
-# acoular imports
-from .h5files import H5CacheFileBase, _get_h5file_class
-from .configuration import config
-class time_data_import( HasPrivateTraits ):
-    """
-    Base class for import of time data.
-    """
-
-    def get_data (self, td):
-        """
-        Imports the data into an arbitrary time_data object td.
-        This is a dummy function and should not be used directly.
-        """
-        td.data = None
-        td.numsamples = 0
-        td.numchannels = 0
-        td.sample_freq = 0
-
-class csv_import( time_data_import ):
-    """
-    Class that supports the import of CSV data as saved by NI VI Logger.
-    """
-
-    #: Name of the comma delimited file to import.
-    from_file = File(filter = ['*.txt'], 
-        desc = "name of the comma delimited file to import")
-
-    #: Header length, defaults to 6.
-    header_length =  Int(6, 
-        desc = "length of the header to ignore during import")
-
-    #: Number of leading columns (will be ignored during import), defaults to 1.
-    dummy_columns = Int(1, 
-        desc = "number of leading columns to ignore during import")
-
-    def get_data (self, td):
-        """
-        Imports the data from CSV file into a
-        :class:`~acoular.sources.TimeSamples` object `td`.
-        Also, a `*.h5` file will be written, so this import
-        need not be performed every time the data is needed
-        """
-        if not path.isfile(self.from_file):
-            # no file there
-            time_data_import.get_data(self, td)
-            return
-        #import data
-        c = self.header_length
-        d = self.dummy_columns
-        f = open(self.from_file)
-        #read header
-        for line in f:
-            c -= 1
-            h = line.split(':')
-            if h[0] == 'Scan rate':
-                sample_freq = int(1./float(h[1].split(' ')[1]))
-            if c == 0:
-                break
-        line = next(f)
-        data = fromstring(line, dtype = float32, sep = ', ')[d:]
-        numchannels = len(data)
-        name = td.name
-        if name == "":
-            name = path.join(config.td_dir, \
-                path.splitext(path.basename(self.from_file))[0]+'.h5')
-        else:
-            if td.h5f !=  None:
-                td.h5f.close()
-        # TODO problems with already open h5 files from other instances
-        file = _get_h5file_class()
-        f5h = file(name, mode = 'w')
-        f5h.create_extendable_array(
-                'time_data', (0, numchannels), "float32")
-        ac = f5h.get_data_by_reference('time_data')
-        f5h.set_node_attribute(ac,'sample_freq',sample_freq)
-        f5h.append_data(ac,data[newaxis, :])
-        for line in f:
-            f5h.append_data(ac,fromstring(line, dtype=float32, sep=', ')[newaxis, d:])
-        f5h.close()
-        td.name = name
-        td.load_data()
-
-class td_import( time_data_import ):
-    """
-    Import of `*.td` data as saved by earlier versions
-    """
-
-    #: Name of the comma delimited file to import.
-    from_file = File(filter = ['*.td'], 
-        desc = "name of the *.td file to import")
-
-    def get_data (self, td):
-        """
-        Main work is done here: imports the data from `*.td` file into
-        TimeSamples object `td` and saves also a `*.h5` file so this import
-        need not be performed only once.
-        """
-        if not path.isfile(self.from_file):
-            # no file there
-            time_data_import.get_data(self, td)
-            return
-        f = open(self.from_file, 'rb')
-        h = pickle.load(f)
-        f.close()
-        sample_freq = h['sample_freq']
-        data = h['data']
-        numchannels = data.shape[1]
-        name = td.name
-        if name == "":
-            name = path.join(config.td_dir, \
-                        path.splitext(path.basename(self.from_file))[0]+'.h5')
-        else:
-            if td.h5f !=  None:
-                td.h5f.close()
-        # TODO problems with already open h5 files from other instances
-        file = _get_h5file_class()
-        f5h = file(name, mode = 'w')
-        f5h.create_extendable_array(
-                'time_data', (0, numchannels), "float32")
-        ac = f5h.get_data_by_reference('time_data')
-        f5h.set_node_attribute(ac,'sample_freq',sample_freq)
-        f5h.append_data(ac,data)
-        f5h.close()
-        td.name = name
-        td.load_data()
-
-
-class bk_mat_import( time_data_import ):
-    """
-    Import of BK pulse matlab data.
-    """
-
-    #: Name of the mat file to import
-    from_file = File(filter = ['*.mat'], 
-        desc = "name of the BK pulse mat file to import")
-
-    def get_data (self, td):
-        """
-        Main work is done here: imports the data from pulse .mat file into
-        time_data object 'td' and saves also a `*.h5` file so this import
-        need not be performed every time the data is needed.
-        """
-        if not path.isfile(self.from_file):
-            # no file there
-            time_data_import.get_data(self, td)
-            return
-        #import data
-        from scipy.io import loadmat
-        m = loadmat(self.from_file)
-        fh = m['File_Header']
-        numchannels = int(fh.NumberOfChannels)
-        l = int(fh.NumberOfSamplesPerChannel)
-        sample_freq = float(fh.SampleFrequency.replace(', ', '.'))
-        data = empty((l, numchannels), 'f')
-        for i in range(numchannels):
-            # map SignalName "Point xx" to channel xx-1
-            ii = int(m["Channel_%i_Header" % (i+1)].SignalName[-2:])-1
-            data[:, ii] = m["Channel_%i_Data" % (i+1)]
-        name = td.name
-        if name == "":
-            name = path.join(config.td_dir, \
-                path.splitext(path.basename(self.from_file))[0]+'.h5')
-        else:
-            if td.h5f !=  None:
-                td.h5f.close()
-        # TODO problems with already open h5 files from other instances
-        file = _get_h5file_class()
-        f5h = file(name, mode = 'w')
-        f5h.create_extendable_array(
-                'time_data', (0, numchannels), "float32")
-        ac = f5h.get_data_by_reference('time_data')
-        f5h.set_node_attribute(ac,'sample_freq',sample_freq)
-        f5h.append_data(ac,data)
-        f5h.close()
-        td.name = name
-        td.load_data()
-
-class datx_d_file(HasPrivateTraits):
-    """
-    Helper class for import of `*.datx` data, represents
-    datx data file.
-    """
-    # File name
-    name = File(filter = ['*.datx'], 
-        desc = "name of datx data file")
-
-    # File object
-    f = Any()
-
-    # Properties
-    data_offset = Int()
-    channel_count = Int()
-    num_samples_per_block = Int()
-    bytes_per_sample = Int()
-    block_size = Property()
-
-    # Number of blocks to read in one pull
-    blocks = Int()
-    # The actual block data
-    data = CArray()
-
-    def _get_block_size( self ):
-        return self.channel_count*self.num_samples_per_block*\
-                self.bytes_per_sample
-
-    def get_next_blocks( self ):
-        """ pulls next blocks """
-        s = self.f.read(self.blocks*self.block_size)
-        ls = len(s)
-        if ls == 0:
-            return -1
-        bl_no = ls/self.block_size
-        self.data = fromstring(s, dtype = 'Int16').reshape((bl_no, \
-            self.channel_count, self.num_samples_per_block)).swapaxes(0, \
-            1).reshape((self.channel_count, bl_no*self.num_samples_per_block))
-
-    def __init__(self, name, blocks = 128):
-        self.name = name
-        self.f = open(self.name, 'rb')
-        s = self.f.read(32)
-        # header
-        s0 = struct.unpack('IIIIIIHHf', s)        
-        # Getting information about Properties of data-file 
-        # 3 = Offset to data 4 = channel count 
-        # 5 = number of samples per block 6 = bytes per sample
-        self.data_offset = s0[3]
-        self.channel_count = s0[4]
-        self.num_samples_per_block = s0[5]
-        self.bytes_per_sample = s0[6]
-        self.blocks = blocks
-        self.f.seek(self.data_offset)
-
-class datx_channel(HasPrivateTraits):
-    """
-    Helper class for import of .datx data, represents
-    one channel.
-    """
-
-    label = Str()
-    d_file = Str()
-    ch_no = Int()
-    ch_K = Str()
-    volts_per_count = Float()
-    msl_ccf = Float()
-    cal_corr_factor = Float()
-    internal_gain = Float()
-    external_gain = Float()
-    tare_volts = Float()
-    cal_coeff_2 = Float()
-    cal_coeff_1 = Float()
-    tare_eu = Float()
-    z0 = Float()
-
-
-    def __init__(self, config, channel):
-        d_file, ch_no, ch_K = config.get('channels', channel).split(', ') 
-        # Extraction and Splitting of Channel information
-        self.d_file = d_file
-        self.ch_no = int(ch_no)
-        self.label = config.get(ch_K, 'channel_label')
-        self.ch_K = ch_K
-        # V                                                     
-        # Reading conversion factors
-        self.volts_per_count = float(config.get(ch_K, 'volts_per_count'))
-        self.msl_ccf = float(config.get(ch_K, 'msl_ccf'))
-        self.cal_corr_factor = float(config.get(ch_K, 'cal_corr_factor'))
-        self.internal_gain = float(config.get(ch_K, 'internal_gain'))
-        self.external_gain = float(config.get(ch_K, 'external_gain'))
-        self.tare_volts = float(config.get(ch_K, 'tare_volts'))
-        # EU
-        self.cal_coeff_2 = float(config.get(ch_K, 'cal_coeff_2'))
-        self.cal_coeff_1 = float(config.get(ch_K, 'cal_coeff_1'))
-        self.tare_eu = float(config.get(ch_K, 'tare_eu'))
-        self.z0 = (self.volts_per_count * self.msl_ccf * self.cal_corr_factor) \
-                    / (self.internal_gain * self.external_gain)
-
-    def scale(self, x):
-        """ scale function to produce output in engineering units """
-        return (x * self.z0 - self.tare_volts) * self.cal_coeff_2 + \
-                self.cal_coeff_1 - self.tare_eu
-
-class datx_import(time_data_import):
-    """
-    Import of .datx data
-    """
-
-    #: Name of the datx index file to import.
-    from_file = File(filter = ['*.datx_index'], 
-        desc = "name of the datx index file to import")
-
-    def get_data (self, td):
-        """
-        Main work is done here: imports the data from datx files into
-        time_data object td and saves also a `*.h5` file so this import
-        need not be performed every time the data is needed
-        """
-        if not path.isfile(self.from_file):
-            # no file there
-            time_data_import.get_data(self, td)
-            return
-        #browse datx information
-        f0 = open(self.from_file)
-        config = configparser.ConfigParser()
-        config.readfp(f0)
-        sample_rate = float(config.get('keywords', 'sample_rate'))
-        # reading sample-rate from index-file
-        channels = []
-        d_files = {}
-        # Loop over all channels assigned in index-file
-        for channel in sort(config.options('channels')):
-            ch = datx_channel(config, channel)
-            if ch.label.find('Mic') >= 0:
-                channels.append(ch)
-                if not d_files.has_key(ch.d_file):
-                    d_files[ch.d_file] = \
-                        datx_d_file(path.join(path.dirname(self.from_file), \
-                            config.get(ch.d_file, 'fn')), 32)
-        numchannels = len(channels)
-        # prepare hdf5
-        name = td.name
-        if name == "":
-            name = path.join(config.td_dir, \
-                path.splitext(path.basename(self.from_file))[0]+'.h5')
-        else:
-            if td.h5f !=  None:
-                td.h5f.close()
-        # TODO problems with already open h5 files from other instances
-        file = _get_h5file_class()
-        f5h = file(name, mode = 'w')
-        f5h.create_extendable_array(
-                'time_data', (0, numchannels), "float32")
-        ac = f5h.get_data_by_reference('time_data')
-        f5h.set_node_attribute(ac,'sample_freq',sample_rate)
-        block_data = \
-            zeros((128*d_files[channels[0].d_file].num_samples_per_block, \
-                numchannels), 'Float32')
-        flag = 0
-        while(not flag):
-            for i in d_files.values():
-                flag = i.get_next_blocks()
-            if flag:
-                continue
-            for i in range(numchannels):
-                data = d_files[channels[i].d_file].data[channels[i].ch_no]
-                block_data[:data.size, i] = channels[i].scale(data)
-            f5h.append_data(ac,block_data[:data.size])
-        f5h.close()
-        f0.close()
-        for i in d_files.values():
-            i.f.close()
-        td.name = name
-        td.load_data()

acoular/nidaqimport.py

@@ -1,273 +0,0 @@
-# coding=UTF-8
-#------------------------------------------------------------------------------
-# Copyright (c) Acoular Development Team.
-#------------------------------------------------------------------------------
-
-"""
-nidaqimport.py: interface to nidaq mx
-"""
-from __future__ import print_function
-from .sources import TimeSamples
-from .h5cache import td_dir
-from .fileimport import time_data_import
-import ctypes
-import numpy
-import tables
-from traits.api import Float, List, Str, Long
-from datetime import datetime
-from os import path
-
-try:
-	nidaq = ctypes.windll.nicaiu # load the DLL
-except:
-	raise ImportError
-# type definitions
-int32 = ctypes.c_long
-uInt32 = ctypes.c_ulong
-uInt64 = ctypes.c_ulonglong
-float64 = ctypes.c_double
-TaskHandle = uInt32
-
-# DAQmx constants
-DAQmx_Val_Cfg_Default = int32(-1)
-DAQmx_Val_GroupByChannel = 0
-DAQmx_Val_GroupByScanNumber = 1
-DAQmx_Val_FiniteSamps = 10178 # Acquire or generate a finite number of samples.
-DAQmx_Val_ContSamps = 10123 # Acquire or generate samples until you stop the task.
-DAQmx_Val_HWTimedSinglePoint = 12522 # Acquire or generate samples continuously using hardware timing without a buffer. Hardware timed single point sample mode is supported only for the sample clock and change detection timing types.
-
-##############################
-
-def ECFactory(func):
-    def func_new(*args):
-        err = func(*args)
-        if err < 0:
-            buf_size = 256
-#            buf = ctypes.create_string_buffer('\000' * buf_size)
-            buf = ctypes.create_string_buffer(b'\000' * buf_size)
-            nidaq.DAQmxGetErrorString(err,ctypes.byref(buf),buf_size)
-#            buf1 = ctypes.create_string_buffer('\000' * buf_size)
-            buf1 = ctypes.create_string_buffer(b'\000' * buf_size)
-
-##            nidaq.DAQmxGetExtendedErrorInfo(ctypes.byref(buf1),buf_size)
-##            print buf1.value
-            raise RuntimeError('nidaq call failed with error %d: %s'%(err,repr(buf.value)))
-    return func_new
-
-DAQmxGetSysTasks = ECFactory(nidaq.DAQmxGetSysTasks)
-DAQmxLoadTask = ECFactory(nidaq.DAQmxLoadTask)
-DAQmxClearTask = ECFactory(nidaq.DAQmxClearTask)
-DAQmxStartTask = ECFactory(nidaq.DAQmxStartTask)
-DAQmxStopTask = ECFactory(nidaq.DAQmxStopTask)
-DAQmxGetTaskDevices = ECFactory(nidaq.DAQmxGetTaskDevices)
-#DAQmxGetTaskNumDevices = ECFactory(nidaq.DAQmxGetTaskNumDevices)
-DAQmxGetTaskNumChans = ECFactory(nidaq.DAQmxGetTaskNumChans)
-DAQmxGetTaskChannels = ECFactory(nidaq.DAQmxGetTaskChannels)
-DAQmxGetBufInputBufSize = ECFactory(nidaq.DAQmxGetBufInputBufSize)
-DAQmxReadAnalogF64 = ECFactory(nidaq.DAQmxReadAnalogF64)
-DAQmxIsTaskDone = ECFactory(nidaq.DAQmxIsTaskDone)
-DAQmxGetSampQuantSampMode = ECFactory(nidaq.DAQmxGetSampQuantSampMode)
-DAQmxGetSampQuantSampPerChan = ECFactory(nidaq.DAQmxGetSampQuantSampPerChan)
-DAQmxSetSampQuantSampPerChan = ECFactory(nidaq.DAQmxSetSampQuantSampPerChan)
-DAQmxGetSampClkRate = ECFactory(nidaq.DAQmxGetSampClkRate)
-DAQmxSetSampClkRate = ECFactory(nidaq.DAQmxSetSampClkRate)
-
-class nidaq_import( time_data_import ):
-    """
-    This class provides an interface to import of measurement data 
-    using NI-DAQmx.
-    """
-
-    #: Name of the NI task to use
-    taskname = Str(
-        desc="name of the NI task to use for the measurement")
-
-    #: Sampling frequency, defaults to 48000.
-    sample_freq = Float(48000.0,
-        desc="sampling frequency")
-
-    #: Number of time data samples, defaults to 48000.
-    numsamples = Long(48000,
-        desc="number of samples")
-
-    #: Number of channels; is set automatically.
-    numchannels =  Long(0,
-        desc="number of channels in the task")
-
-    #: Number of devices; is set automatically.
-    numdevices = Long(0,
-        desc="number of devices in the task")
-
-    #: Name of channels; is set automatically.
-    namechannels =  List(
-        desc="names of channels in the task")
-
-    #: Name of devices; is set automatically.
-    namedevices = List(
-        desc="names of devices in the task")
-
-    #: Name of available and valid tasks.
-    tasknames = List
-
-    def __init__ ( self, **traits ):
-        time_data_import.__init__(self, **traits )
-        taskHandle = TaskHandle(0)
-        buf_size = 1024
-#        buf = ctypes.create_string_buffer('\000' * buf_size)
-        buf = ctypes.create_string_buffer(b'\000' * buf_size)
-        DAQmxGetSysTasks(ctypes.byref(buf),buf_size)
-#        tasknamelist = buf.value.split(', ')
-        tasknamelist = buf.value.split(b', ')
-
-        self.tasknames=[]
-        for taskname in tasknamelist:
-            # is task valid ?? try to load
-            try:
-                DAQmxLoadTask(taskname,ctypes.byref(taskHandle))
-            except RuntimeError:
-                continue
-            self.tasknames.append(taskname)
-            DAQmxClearTask(taskHandle)
-
-    def _taskname_changed ( self ):
-        taskHandle = TaskHandle(0)
-        buf_size = 1024*4
-#        buf = ctypes.create_string_buffer('\000' * buf_size)
-        buf = ctypes.create_string_buffer(b'\000' * buf_size)
-
-        num = uInt32()
-        fnum = float64()
-        lnum = uInt64()
-        try:
-            DAQmxLoadTask(str.encode(self.taskname),ctypes.byref(taskHandle))
-        except RuntimeError:
-            return
-        DAQmxGetTaskNumChans(taskHandle,ctypes.byref(num))
-        self.numchannels = num.value
-        # commented for compatibility with older NIDAQmx
-        #~ DAQmxGetTaskNumDevices(taskHandle,ctypes.byref(num))
-        #~ self.numdevices = num.value
-        DAQmxGetTaskChannels(taskHandle,ctypes.byref(buf),buf_size)
-        self.namechannels = buf.value.decode().split(', ')
-        DAQmxGetTaskDevices(taskHandle,ctypes.byref(buf),buf_size)
-        self.namedevices = buf.value.decode().split(', ')
-        self.numdevices = len(self.namedevices)
-        DAQmxGetSampClkRate(taskHandle,ctypes.byref(fnum))
-        self.sample_freq = fnum.value
-        DAQmxGetSampQuantSampMode(taskHandle,ctypes.byref(num))
-        if num.value==DAQmx_Val_FiniteSamps:
-            DAQmxGetSampQuantSampPerChan(taskHandle,ctypes.byref(lnum))
-            self.numsamples = lnum.value
-        DAQmxClearTask(taskHandle)
-
-    def _sample_freq_changed(self,dispatch='ui'):
-        taskHandle = TaskHandle(0)
-        fnum = float64()
-        try:
-            DAQmxLoadTask(str.encode(self.taskname),ctypes.byref(taskHandle))
-        except RuntimeError:
-            return
-        try:
-            DAQmxSetSampClkRate(taskHandle,float64(self.sample_freq))
-        except RuntimeError:
-            pass
-        DAQmxGetSampClkRate(taskHandle,ctypes.byref(fnum))
-        self.sample_freq = fnum.value
-        DAQmxClearTask(taskHandle)
-        print(self.sample_freq)
-
-
-    def get_data (self, td):
-        """
-        Main work is done here: loads data from buffer into
-        :class:`~acoular.sources.TimeSamples` object `td` and saves also a 
-        '*.h5' file.
-        """
-        taskHandle = TaskHandle(0)
-        read = uInt32()
-        fnum = float64()
-        lnum = uInt64()
-        try:
-            DAQmxLoadTask(str.encode(self.taskname),ctypes.byref(taskHandle))
-            if self.numchannels<1:
-                raise RuntimeError
-            DAQmxSetSampClkRate(taskHandle,float64(self.sample_freq))
-        except RuntimeError:
-            # no valid task
-            time_data_import.get_data(self,td)
-            return
-        #import data
-        name = td.name
-        if name=='':
-            name = datetime.now().isoformat('_').replace(':','-').replace('.','_')
-            name = path.join(td_dir,name+'.h5')
-        f5h = tables.open_file(name,mode='w')
-        ac = f5h.create_earray(f5h.root,'time_data',tables.atom.Float32Atom(),(0,self.numchannels))
-        ac.set_attr('sample_freq',self.sample_freq)
-        DAQmxSetSampQuantSampPerChan(taskHandle,uInt64(100000))
-        DAQmxGetSampQuantSampPerChan(taskHandle,ctypes.byref(lnum))
-        max_num_samples = lnum.value
-        print("Puffergroesse: %i" % max_num_samples)
-        data = numpy.empty((max_num_samples,self.numchannels),dtype=numpy.float64)
-        DAQmxStartTask(taskHandle)
-        count = 0
-        numsamples = self.numsamples
-        while count<numsamples:
-            #~ DAQmxReadAnalogF64(taskHandle,-1,float64(10.0),
-                                     #~ DAQmx_Val_GroupByScanNumber,data.ctypes.data,
-                                     #~ data.size,ctypes.byref(read),None)
-            DAQmxReadAnalogF64(taskHandle,1024,float64(10.0),
-                                     DAQmx_Val_GroupByScanNumber,data.ctypes.data,
-                                     data.size,ctypes.byref(read),None)
-            ac.append(numpy.array(data[:min(read.value,numsamples-count)],dtype=numpy.float32))
-            count+=read.value
-            #~ if read.value>200:
-                #~ print count, read.value
-        DAQmxStopTask(taskHandle)
-        DAQmxClearTask(taskHandle)
-        f5h.close()
-        td.name = name
-        td.load_data()
-        
-    def get_single (self):
-        """
-        Gets one block of data
-        """
-        taskHandle = TaskHandle(0)
-        read = uInt32()
-        fnum = float64()
-        lnum = uInt64()
-        try:
-            DAQmxLoadTask(str.encode(self.taskname),ctypes.byref(taskHandle))
-            if self.numchannels<1:
-                raise RuntimeError
-        except RuntimeError:
-            # no valid task
-            time_data_import.get_data(self,td)
-            return
-        #import data
-        ac = numpy.empty((self.numsamples,self.numchannels),numpy.float32)
-        DAQmxGetSampQuantSampPerChan(taskHandle,ctypes.byref(lnum))
-        max_num_samples = lnum.value
-        data = numpy.empty((max_num_samples,self.numchannels),dtype=numpy.float64)
-        DAQmxStartTask(taskHandle)
-        count = 0
-        numsamples = self.numsamples
-        while count<numsamples:
-            DAQmxReadAnalogF64(taskHandle,-1,float64(10.0),
-                                     DAQmx_Val_GroupByScanNumber,data.ctypes.data,
-                                     data.size,ctypes.byref(read),None)
-            anz = min(read.value,numsamples-count)
-            ac[count:count+anz]=numpy.array(data[:anz],dtype=numpy.float32)
-            count+=read.value
-        DAQmxStopTask(taskHandle)
-        DAQmxClearTask(taskHandle)
-        return ac
-        
-
-if __name__=='__main__':
-    x=nidaq_import()
-    x.taskname = 'test1'
-    x.configure_traits()
-    td=TimeSamples()
-    x.get_data(td)