示例#1
0
    def __init__(self, name, **keys):
        shape = keys.pop('shape', None)
        dtype = keys.pop('dtype', None)

        DataNode.__init__(self, 'lima', name, **keys)

        if keys.get('create', False):
            self.info['shape'] = shape
            self.info['dtype'] = dtype

        cnx = self.db_connection
        self.data = QueueObjSetting('%s_data' % self.db_name, connection=cnx)
        self._merge_store = self.MergeB4Store(self)
示例#2
0
文件: lima.py 项目: mguijarr/bliss
 def __init__(self,name,**keys):
     DataNode.__init__(self,'lima',name,**keys)
     self.image_status_channel = channels.RawChannel(self.db_name()+"_"+"image_status",
                                                     redis = self.db_connection)
     saving_params_name = '%s_saving_params' % self.db_name()
     self._saving_params = QueueObjSetting(saving_params_name, connection=self.db_connection)
     self._storage_task = None
示例#3
0
    def __init__(self, name, **keys):
        shape = keys.pop('shape', None)
        dtype = keys.pop('dtype', None)

        DataNode.__init__(self, 'lima', name, **keys)

        if keys.get('create', False):
            self.info['shape'] = shape
            self.info['dtype'] = dtype

        cnx = self.db_connection
        self.data = QueueObjSetting('%s_data' % self.db_name,
                                    connection=cnx)
        self._merge_store = self.MergeB4Store(self)
示例#4
0
class LimaImageChannelDataNode(DataNode):
    class _GetView(object):
        DataArrayMagic = struct.unpack('>I', 'DTAY')[0]

        def __init__(self, data, from_index, to_index):
            self.data = data
            self._update()
            self.from_index = from_index
            self.to_index = to_index
            self._image_mode = {
                0: numpy.uint8,
                1: numpy.uint16,
                2: numpy.uint32,
                4: numpy.int8,
                5: numpy.int16,
                6: numpy.int32,
            }

        @property
        def ref_status(self):
            return self.data[0]

        @property
        def ref_data(self):
            return self.data[1:]

        @property
        def last_index(self):
            """ evaluate the last image index
            """
            if self.to_index >= 0:
                return self.to_index
            return self.last_image_acquired if self.last_image_acquired > 0 else 0

        @property
        def current_lima_acq(self):
            """ return the current server acquisition number
            """
            cnx = self.data._cnx()
            lima_acq = cnx.get(self.server_url)
            return int(lima_acq if lima_acq is not None else -1)

        def __iter__(self):
            self._update()
            try:
                proxy = DeviceProxy(self.server_url) if self.server_url else None
            except Exception:
                proxy = None
            for image_nb in range(self.from_index, self.last_index):
                data = self._get_from_server_memory(proxy, image_nb)
                if data is None:
                    yield self._get_from_file(image_nb)
                else:
                    yield data
                self._update()

        def __len__(self):
            self._update()
            return 1+(self.last_index - self.from_index)

        def _update(self):
            """ update view status
            """
            ref_status = self.ref_status
            for key in ('server_url', 'lima_acq_nb', 'buffer_max_number', 'last_image_acquired',
                 'last_image_ready', 'last_counter_ready', 'last_image_saved'):
                setattr(self, key, ref_status[key])

        def _get_from_server_memory(self, proxy, image_nb):
            if not proxy:
                return None

            if self.current_lima_acq == self.lima_acq_nb:  # current acquisition is this one
                if self.last_image_ready < image_nb:      # image not yet available
                    raise RuntimeError('image is not available yet')
                # should be in memory
                if self.buffer_max_number > (self.last_image_ready - image_nb):
                    try:
                        raw_msg = proxy.readImage(image_nb)
                    except Exception:
                        # As it's asynchronous, image seams to be no
                        # more available so read it from file
                        return None
                    else:
                        return self._tango_unpack(raw_msg[-1])

        def _get_filenames(self, ref_data, *image_nbs):
            saving_mode = ref_data.get('saving_mode', 'MANUAL')
            if saving_mode == 'MANUAL': # file are not saved
                raise RuntimeError("Image were not saved")

            overwrite_policy = ref_data.get('saving_overwrite',
                                              'ABORT').lower()
            if overwrite_policy == 'multiset':
                nb_image_per_file = ref_data['acq_nb_frames']
            else:
                nb_image_per_file = ref_data.get('saving_frame_per_file', 1)

            last_image_saved = self.last_image_saved
            first_file_number = ref_data.get('saving_next_number', 0)
            path_format = os.path.join(ref_data['saving_directory'],
                                       '%s%s%s' % (ref_data['saving_prefix'],
                                                   ref_data.get('saving_index_format', '%04d'),
                                                   ref_data['saving_suffix']))
            returned_params = list()
            file_format = ref_data['saving_format']
            for image_nb in image_nbs:
                if image_nb > last_image_saved:
                    raise RuntimeError("Image %d was not saved" % image_nb)

                image_index_in_file = image_nb % nb_image_per_file
                file_nb = first_file_number + image_index_in_file
                file_path = path_format % file_nb
                if file_format == 'HDF5':
                    returned_params.append((file_path, "/entry_%04d" % 1,
                                            image_index_in_file, file_format))
                else:
                    returned_params.append((file_path, '',
                                            image_index_in_file, file_format))
            return returned_params

        def _get_from_file(self, image_nb):
            for ref_data in self.ref_data:
                values = self._get_filenames(ref_data, image_nb)
                filename, path_in_file, image_index, file_format = values[0]

                if file_format in ('EDF', 'EDFGZ', 'EDFConcat'):
                    if file_format == 'EDFConcat':
                        image_index = 0
                    if EdfFile is not None:
                        f = EdfFile.EdfFile(filename)
                        return f.GetData(image_index)
                    else:
                        raise RuntimeError("EdfFile module is not available, "
                                           "cannot return image data.")
                elif file_format == 'HDF5':
                    if h5py is not None:
                        with h5py.File(filename) as f:
                            dataset = f[path_in_file]
                            return dataset[image_index]
                else:
                    raise RuntimeError("Format net yet managed")
            else:
                raise RuntimeError(
                    "Can't retrieved image %d from file" % image_nb)

        def _tango_unpack(self, msg):
            struct_format = '<IHHIIHHHHHHHHHHHHHHHHHHIII'
            header_size = struct.calcsize(struct_format)
            values = struct.unpack(struct_format, msg[:header_size])
            if values[0] != self.DataArrayMagic:
                raise RuntimeError('Not a lima data')
            header_offset = values[2]
            data = numpy.fromstring(
                msg[header_offset:], dtype=self._image_mode.get(values[4]))
            data.shape = values[8], values[7]
            return data

    class MergeB4Store(object):
        """
        This class merge lima ref event to redis database.

        Actually the real update is done on idle state of gevent loop so,
        we can have several update (update_status) before a real store (_do_store).
        """

        def __init__(self, cnt):
            self._new_image_status_event = gevent.event.Event()
            self._new_image_status = dict()
            self._storage_task = gevent.spawn(self._do_store)
            self._cnt = weakref.proxy(cnt, self.stop)
            self._stop_flag = False

        def _do_store(self):
            while True:
                succeed = self._new_image_status_event.wait(1)
                if succeed:
                    self._new_image_status_event.clear()
                else:           # test if cnt is still alive
                    try:
                        self._cnt.data
                        continue
                    except ReferenceError:
                        break

                local_dict = self._new_image_status
                self._new_image_status = dict()
                if local_dict:
                    ref_data = self._cnt.data[0]
                    ref_data.update(local_dict)
                    self._cnt.data[0] = ref_data
                if self._stop_flag:
                    break
                gevent.idle()

        def update_status(self, new_status):
            """
            Post the update of lima reference
            """
            self._new_image_status.update(new_status)
            self._new_image_status_event.set()

        def stop(self, ref = None):
            """
            This method should be called to stop the store task.
            """
            self._stop_flag = True
            if self._storage_task is not None:
                self._new_image_status_event.set()
                self._storage_task.join()

    def __init__(self, name, **keys):
        shape = keys.pop('shape', None)
        dtype = keys.pop('dtype', None)

        DataNode.__init__(self, 'lima', name, **keys)

        if keys.get('create', False):
            self.info['shape'] = shape
            self.info['dtype'] = dtype

        cnx = self.db_connection
        self.data = QueueObjSetting('%s_data' % self.db_name,
                                    connection=cnx)
        self._merge_store = self.MergeB4Store(self)

    def get(self, from_index, to_index=None):
        """
        return a view on data references.

        **from_index** from which image index you want to get
        **to_index** to which index you want images
            if to_index is None => only one image which as index from_index
            if to_index < 0 => to the end of acquisition
        """
        return self._GetView(self.data, from_index, 
                             to_index if to_index is not None else from_index + 1)

    def store(self, signal, event_dict):
        desc = event_dict['description']
        data = event_dict['data']
        try:
            ref_data = self.data[0]
        except IndexError:
            ref_data = data
            ref_data['lima_acq_nb'] = self.db_connection.incr(data['server_url'])
            self.data.append(ref_data)
            self.add_reference_data(desc)
        else:
            self._merge_store.update_status(data)
            
    def add_reference_data(self, ref_data):
        """Save reference data in database
  
        In case of Lima, this corresponds to acquisition ref_data,
        in particular saving data
        """
        self.data.append(ref_data)

    def get_file_references(self):
        """
        Retrieve all files references for this data set
        """
        # take the last in list because it's should be the final
        final_ref_data = self.data[-1]
        # in that case only one reference will be returned
        overwrite_policy = final_ref_data['overwritePolicy'].lower()
        if overwrite_policy == 'multiset':
            last_file_number = final_ref_data['nextNumber'] + 1
        else:
            nb_files = int(math.ceil(float(final_ref_data['acqNbFrames']) /
                                     final_ref_data['framesPerFile']))
            last_file_number = final_ref_data['nextNumber'] + nb_files

        path_format = '%s%s%s%s' % (final_ref_data['directory'],
                                    final_ref_data['prefix'],
                                    final_ref_data['indexFormat'],
                                    final_ref_data['suffix'])
        references = []
        file_format = final_ref_data['fileFormat'].lower()
        for next_number in xrange(final_ref_data['nextNumber'],
                                  last_file_number):
            full_path = path_format % next_number
            if file_format == 'hdf5':
                #@todo see what's is needed for hdf5 dataset link
                pass
            references.append(full_path)
        return references

    def _get_db_names(self):
        db_names = DataNode._get_db_names(self)
        db_names.append(self.db_name+"_data")
        try:
            url = self.data[0].get('server_url')
        except IndexError:
            url = None
        if url is not None:
            db_names.append(url)
        return db_names
示例#5
0
class LimaImageChannelDataNode(DataNode):
    class _GetView(object):
        DataArrayMagic = struct.unpack('>I', 'DTAY')[0]

        def __init__(self, data, from_index, to_index):
            self.data = data
            self._update()
            self.from_index = from_index
            self.to_index = to_index
            self._image_mode = {
                0: numpy.uint8,
                1: numpy.uint16,
                2: numpy.uint32,
                4: numpy.int8,
                5: numpy.int16,
                6: numpy.int32,
            }

        @property
        def ref_status(self):
            return self.data[0]

        @property
        def ref_data(self):
            return self.data[1:]

        @property
        def last_index(self):
            """ evaluate the last image index
            """
            if self.to_index >= 0:
                return self.to_index
            return self.last_image_acquired if self.last_image_acquired > 0 else 0

        @property
        def current_lima_acq(self):
            """ return the current server acquisition number
            """
            cnx = self.data._cnx()
            lima_acq = cnx.get(self.server_url)
            return int(lima_acq if lima_acq is not None else -1)

        def __iter__(self):
            self._update()
            try:
                proxy = DeviceProxy(
                    self.server_url) if self.server_url else None
            except Exception:
                proxy = None
            for image_nb in range(self.from_index, self.last_index):
                data = self._get_from_server_memory(proxy, image_nb)
                if data is None:
                    yield self._get_from_file(image_nb)
                else:
                    yield data
                self._update()

        def __len__(self):
            self._update()
            return 1 + (self.last_index - self.from_index)

        def _update(self):
            """ update view status
            """
            ref_status = self.ref_status
            for key in ('server_url', 'lima_acq_nb', 'buffer_max_number',
                        'last_image_acquired', 'last_image_ready',
                        'last_counter_ready', 'last_image_saved'):
                setattr(self, key, ref_status[key])

        def _get_from_server_memory(self, proxy, image_nb):
            if not proxy:
                return None

            if self.current_lima_acq == self.lima_acq_nb:  # current acquisition is this one
                if self.last_image_ready < image_nb:  # image not yet available
                    raise RuntimeError('image is not available yet')
                # should be in memory
                if self.buffer_max_number > (self.last_image_ready - image_nb):
                    try:
                        raw_msg = proxy.readImage(image_nb)
                    except Exception:
                        # As it's asynchronous, image seams to be no
                        # more available so read it from file
                        return None
                    else:
                        return self._tango_unpack(raw_msg[-1])

        def _get_filenames(self, ref_data, *image_nbs):
            saving_mode = ref_data.get('saving_mode', 'MANUAL')
            if saving_mode == 'MANUAL':  # file are not saved
                raise RuntimeError("Image were not saved")

            overwrite_policy = ref_data.get('saving_overwrite',
                                            'ABORT').lower()
            if overwrite_policy == 'multiset':
                nb_image_per_file = ref_data['acq_nb_frames']
            else:
                nb_image_per_file = ref_data.get('saving_frame_per_file', 1)

            last_image_saved = self.last_image_saved
            first_file_number = ref_data.get('saving_next_number', 0)
            path_format = os.path.join(
                ref_data['saving_directory'],
                '%s%s%s' % (ref_data['saving_prefix'],
                            ref_data.get('saving_index_format',
                                         '%04d'), ref_data['saving_suffix']))
            returned_params = list()
            file_format = ref_data['saving_format']
            for image_nb in image_nbs:
                if image_nb > last_image_saved:
                    raise RuntimeError("Image %d was not saved" % image_nb)

                image_index_in_file = image_nb % nb_image_per_file
                file_nb = first_file_number + image_index_in_file
                file_path = path_format % file_nb
                if file_format == 'HDF5':
                    returned_params.append((file_path, "/entry_%04d" % 1,
                                            image_index_in_file, file_format))
                else:
                    returned_params.append(
                        (file_path, '', image_index_in_file, file_format))
            return returned_params

        def _get_from_file(self, image_nb):
            for ref_data in self.ref_data:
                values = self._get_filenames(ref_data, image_nb)
                filename, path_in_file, image_index, file_format = values[0]

                if file_format in ('EDF', 'EDFGZ', 'EDFConcat'):
                    if file_format == 'EDFConcat':
                        image_index = 0
                    if EdfFile is not None:
                        f = EdfFile.EdfFile(filename)
                        return f.GetData(image_index)
                    else:
                        raise RuntimeError("EdfFile module is not available, "
                                           "cannot return image data.")
                elif file_format == 'HDF5':
                    if h5py is not None:
                        with h5py.File(filename) as f:
                            dataset = f[path_in_file]
                            return dataset[image_index]
                else:
                    raise RuntimeError("Format net yet managed")
            else:
                raise RuntimeError("Can't retrieved image %d from file" %
                                   image_nb)

        def _tango_unpack(self, msg):
            struct_format = '<IHHIIHHHHHHHHHHHHHHHHHHIII'
            header_size = struct.calcsize(struct_format)
            values = struct.unpack(struct_format, msg[:header_size])
            if values[0] != self.DataArrayMagic:
                raise RuntimeError('Not a lima data')
            header_offset = values[2]
            data = numpy.fromstring(msg[header_offset:],
                                    dtype=self._image_mode.get(values[4]))
            data.shape = values[8], values[7]
            return data

    class MergeB4Store(object):
        """
        This class merge lima ref event to redis database.

        Actually the real update is done on idle state of gevent loop so,
        we can have several update (update_status) before a real store (_do_store).
        """
        def __init__(self, cnt):
            self._new_image_status_event = gevent.event.Event()
            self._new_image_status = dict()
            self._storage_task = gevent.spawn(self._do_store)
            self._cnt = weakref.proxy(cnt, self.stop)
            self._stop_flag = False

        def _do_store(self):
            while True:
                succeed = self._new_image_status_event.wait(1)
                if succeed:
                    self._new_image_status_event.clear()
                else:  # test if cnt is still alive
                    try:
                        self._cnt.data
                        continue
                    except ReferenceError:
                        break

                local_dict = self._new_image_status
                self._new_image_status = dict()
                if local_dict:
                    ref_data = self._cnt.data[0]
                    ref_data.update(local_dict)
                    self._cnt.data[0] = ref_data
                if self._stop_flag:
                    break
                gevent.idle()

        def update_status(self, new_status):
            """
            Post the update of lima reference
            """
            self._new_image_status.update(new_status)
            self._new_image_status_event.set()

        def stop(self, ref=None):
            """
            This method should be called to stop the store task.
            """
            self._stop_flag = True
            if self._storage_task is not None:
                self._new_image_status_event.set()
                self._storage_task.join()

    def __init__(self, name, **keys):
        shape = keys.pop('shape', None)
        dtype = keys.pop('dtype', None)

        DataNode.__init__(self, 'lima', name, **keys)

        if keys.get('create', False):
            self.info['shape'] = shape
            self.info['dtype'] = dtype

        cnx = self.db_connection
        self.data = QueueObjSetting('%s_data' % self.db_name, connection=cnx)
        self._merge_store = self.MergeB4Store(self)

    def get(self, from_index, to_index=None):
        """
        return a view on data references.

        **from_index** from which image index you want to get
        **to_index** to which index you want images
            if to_index is None => only one image which as index from_index
            if to_index < 0 => to the end of acquisition
        """
        return self._GetView(
            self.data, from_index,
            to_index if to_index is not None else from_index + 1)

    def store(self, signal, event_dict):
        desc = event_dict['description']
        data = event_dict['data']
        try:
            ref_data = self.data[0]
        except IndexError:
            ref_data = data
            ref_data['lima_acq_nb'] = self.db_connection.incr(
                data['server_url'])
            self.data.append(ref_data)
            self.add_reference_data(desc)
        else:
            self._merge_store.update_status(data)

    def add_reference_data(self, ref_data):
        """Save reference data in database
  
        In case of Lima, this corresponds to acquisition ref_data,
        in particular saving data
        """
        self.data.append(ref_data)

    def get_file_references(self):
        """
        Retrieve all files references for this data set
        """
        # take the last in list because it's should be the final
        final_ref_data = self.data[-1]
        # in that case only one reference will be returned
        overwrite_policy = final_ref_data['overwritePolicy'].lower()
        if overwrite_policy == 'multiset':
            last_file_number = final_ref_data['nextNumber'] + 1
        else:
            nb_files = int(
                math.ceil(
                    float(final_ref_data['acqNbFrames']) /
                    final_ref_data['framesPerFile']))
            last_file_number = final_ref_data['nextNumber'] + nb_files

        path_format = '%s%s%s%s' % (
            final_ref_data['directory'], final_ref_data['prefix'],
            final_ref_data['indexFormat'], final_ref_data['suffix'])
        references = []
        file_format = final_ref_data['fileFormat'].lower()
        for next_number in xrange(final_ref_data['nextNumber'],
                                  last_file_number):
            full_path = path_format % next_number
            if file_format == 'hdf5':
                #@todo see what's is needed for hdf5 dataset link
                pass
            references.append(full_path)
        return references

    def _get_db_names(self):
        db_names = DataNode._get_db_names(self)
        db_names.append(self.db_name + "_data")
        try:
            url = self.data[0].get('server_url')
        except IndexError:
            url = None
        if url is not None:
            db_names.append(url)
        return db_names
示例#6
0
文件: lima.py 项目: mguijarr/bliss
class LimaDataNode(DataNode):
    class DataChannel(object):
        def __init__(self,dataset):
            self._dataset = dataset
            self._device_proxy = None
            self._image_mode = {
                0 : numpy.uint8,
                1 : numpy.uint16,
                2 : numpy.uint32,
                4 : numpy.int8,
                5 :numpy.int16 ,
                6 : numpy.int32 ,
            }        
  
        def get(self,from_index,to_index = None):
            cnx = self._dataset._data._cnx()
            url = self._dataset._data.url_server
            if url is None:     # data is no more available
                raise RuntimeError('dataset is no more available')

            current_lima_acq = int(cnx.get(url))
            
            (lima_acq_nb,acq_nb_buffer,
             LastImageAcquired,LastCounterReady,
             LastImageSaved) = [int(x) for x in cnx.hmget(self.db_name,
                                                          'lima_acq_nb',
                                                          'acq_nb_buffer',
                                                          'LastImageAcquired',
                                                          'LastCounterReady',
                                                          'LastImageSaved')]
            if to_index is None:
                
                #first we try to get image directly from the server
                if current_lima_acq == lima_acq_nb and DeviceProxy: # current acquisition
                    if LastImageAcquired < from_index: # image is not yet available
                        raise RuntimeError('image is not yet available')
                    #should be still in server memory
                    if acq_nb_buffer > LastImageAcquired - from_index:
                        try:
                            if self._device_proxy is None:
                                self._device_proxy = DeviceProxy(url)
                            raw_msg = self._device_proxy.readImage(from_index)
                            return self._tango_unpack(raw_msg[-1])
                        except: 
                            # As it's asynchronous, image seams to be no
                            # more available so read it from file
                            return self._read_from_file(from_index)
                else:
                    return self._read_from_file(from_index)
            else:
                raise NotImplementedError('Not yet done')

    def _tango_unpack(self,msg):
        struct_format = '<IHHIIHHHHHHHHHHHHHHHHHHIII'
        header_size = struct.calcsize(struct_format)
        values = struct.unpack(msg[:header_size])
        if values[0] != 0x44544159:
            raise RuntimeError('Not a lima data')
        header_offset = values[2]
        data = numpy.fromstring(msg[header_offset:],data=self._image_mode.get(values[4]))
        data.shape = values[8],values[7]
        return data

    def _read_from_file(self,from_index):
        #@todo should read file from any format?????
        for saving_parameters in self._dataset._saving_params:
            pass

    def __init__(self,name,**keys):
        DataNode.__init__(self,'lima',name,**keys)
        self.image_status_channel = channels.RawChannel(self.db_name()+"_"+"image_status",
                                                        redis = self.db_connection)
        saving_params_name = '%s_saving_params' % self.db_name()
        self._saving_params = QueueObjSetting(saving_params_name, connection=self.db_connection)
        self._storage_task = None

    def channel_name(self):
        return 'image'

    #@brief update image status
    #
    def update_status(self,image_status):
        cnx = self._data._cnx()
        db_name = self.db_name()

        pipeline = cnx.pipeline()
        for key,value in image_status.iteritems():
            pipeline.hset(db_name,key,value)
        pipeline.execute()

    def _end_storage(self):
        self._new_image_status = None
        if self._storage_task is not None:
            self._new_image_status_event.set()
            self._storage_task.join()
            
    def _do_store(self):
        while True:
            self._new_image_status_event.wait()
            self._new_image_status_event.clear()
            if self._new_image_status is None:
                break
            self.db_connection.hmset(self.db_name(), self._new_image_status)
            self.image_status_channel.value = self._new_image_status
            #TODO: remove the comment, for use without simulator
            #gevent.idle()

    def store(self, signal, event_dict):
        if signal == 'start':
            self._end_storage()
            self._new_image_status_event = gevent.event.Event()
            self._storage_task = gevent.spawn(self._do_store)
        elif signal == 'end':
            self._end_storage()
        else:
            local_dict = dict(event_dict)
            data_type = local_dict.pop('type')
            if data_type == 'lima/image':
                self._new_image_status = local_dict
                self._new_image_status_event.set()


    #@brief set the number of buffer for this acquisition
    def set_nb_buffer(self,acq_nb_buffer):
        self._data.acq_nb_buffer = acq_nb_buffer

    #@brief set the server url and 
    #calculate an unique id for this acquisition
    def set_server_url(self,url):
        self._data.url_server = url
        
        cnx = self._data._cnx()
        self._data.lima_acq_nb = cnx.incr(url)
        
    def set_acq_parameters(self,acq_params):
        self.set_info('acq_params',acq_params)

    #@brief saving parameters
    def add_saving_parameters(self,parameters):
        self._saving_params.append(parameters)
        if self._ttl > 0:
            self._saving_params.ttl(self._ttl)

    #@brief this methode should retrives all files
    #references for this data set
    def get_file_references(self):
        #take the last in list because it's should be the final
        final_params = self._saving_params[-1]
        acq_params = self._info['acq_params']
        #in that case only one reference will be return
        overwritePolicy = final_params['overwritePolicy'].lower()
        if overwritePolicy == 'multiset':
            last_file_number = final_params['nextNumber'] + 1
        else:
            nb_files = int(math.ceil(float(acq_params['acqNbFrames']) / 
                                     final_params['framesPerFile']))
            last_file_number = final_params['nextNumber'] + nb_files

        format = '%s%s%s%s' % (final_params['directory'],
                               final_params['prefix'],
                               final_params['indexFormat'],
                               final_params['suffix'])
        references = []
        file_format = final_params['fileFormat'].lower()
        for nextNumber in xrange(final_params['nextNumber'],
                                 last_file_number):
            full_path = format % nextNumber
            if file_format == 'hdf5':
                #@todo see what's is needed for hdf5 dataset link
                pass
            references.append(full_path)
        return references

    
    #@brief for now lima has only on data channel
    #we will provide in a second time all counters (roi_counters,roi_spectrum...)
    def get_channel(self,**keys):
        return DatasetLima.DataChannel(self)