pyerrors.input.bdio

  1import ctypes
  2import hashlib
  3import autograd.numpy as np  # Thinly-wrapped numpy
  4from ..obs import Obs
  5
  6
  7def read_ADerrors(file_path, bdio_path='./libbdio.so', **kwargs):
  8    """ Extract generic MCMC data from a bdio file
  9
 10    read_ADerrors requires bdio to be compiled into a shared library. This can be achieved by
 11    adding the flag -fPIC to CC and changing the all target to
 12
 13    all:		bdio.o $(LIBDIR)
 14                gcc -shared -Wl,-soname,libbdio.so -o $(BUILDDIR)/libbdio.so $(BUILDDIR)/bdio.o
 15                cp $(BUILDDIR)/libbdio.so $(LIBDIR)/
 16
 17    Parameters
 18    ----------
 19    file_path -- path to the bdio file
 20    bdio_path -- path to the shared bdio library libbdio.so (default ./libbdio.so)
 21
 22    Returns
 23    -------
 24    data : List[Obs]
 25        Extracted data
 26    """
 27    bdio = ctypes.cdll.LoadLibrary(bdio_path)
 28
 29    bdio_open = bdio.bdio_open
 30    bdio_open.restype = ctypes.c_void_p
 31
 32    bdio_close = bdio.bdio_close
 33    bdio_close.restype = ctypes.c_int
 34    bdio_close.argtypes = [ctypes.c_void_p]
 35
 36    bdio_seek_record = bdio.bdio_seek_record
 37    bdio_seek_record.restype = ctypes.c_int
 38    bdio_seek_record.argtypes = [ctypes.c_void_p]
 39
 40    bdio_get_rlen = bdio.bdio_get_rlen
 41    bdio_get_rlen.restype = ctypes.c_int
 42    bdio_get_rlen.argtypes = [ctypes.c_void_p]
 43
 44    bdio_get_ruinfo = bdio.bdio_get_ruinfo
 45    bdio_get_ruinfo.restype = ctypes.c_int
 46    bdio_get_ruinfo.argtypes = [ctypes.c_void_p]
 47
 48    bdio_read = bdio.bdio_read
 49    bdio_read.restype = ctypes.c_size_t
 50    bdio_read.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.c_void_p]
 51
 52    bdio_read_f64 = bdio.bdio_read_f64
 53    bdio_read_f64.restype = ctypes.c_size_t
 54    bdio_read_f64.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_void_p]
 55
 56    bdio_read_int32 = bdio.bdio_read_int32
 57    bdio_read_int32.restype = ctypes.c_size_t
 58    bdio_read_int32.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_void_p]
 59
 60    b_path = file_path.encode('utf-8')
 61    read = 'r'
 62    b_read = read.encode('utf-8')
 63
 64    fbdio = bdio_open(ctypes.c_char_p(b_path), ctypes.c_char_p(b_read), None)
 65
 66    return_list = []
 67
 68    print('Reading of bdio file started')
 69    while True:
 70        bdio_seek_record(fbdio)
 71        ruinfo = bdio_get_ruinfo(fbdio)
 72
 73        if ruinfo == 7:
 74            print('MD5sum found')  # For now we just ignore these entries and do not perform any checks on them
 75            continue
 76
 77        if ruinfo < 0:
 78            # EOF reached
 79            break
 80        bdio_get_rlen(fbdio)
 81
 82        def read_c_double():
 83            d_buf = ctypes.c_double
 84            pd_buf = d_buf()
 85            ppd_buf = ctypes.c_void_p(ctypes.addressof(pd_buf))
 86            bdio_read_f64(ppd_buf, ctypes.c_size_t(8), ctypes.c_void_p(fbdio))
 87            return pd_buf.value
 88
 89        mean = read_c_double()
 90        print('mean', mean)
 91
 92        def read_c_size_t():
 93            d_buf = ctypes.c_size_t
 94            pd_buf = d_buf()
 95            ppd_buf = ctypes.c_void_p(ctypes.addressof(pd_buf))
 96            bdio_read_int32(ppd_buf, ctypes.c_size_t(4), ctypes.c_void_p(fbdio))
 97            return pd_buf.value
 98
 99        neid = read_c_size_t()
100        print('neid', neid)
101
102        ndata = []
103        for index in range(neid):
104            ndata.append(read_c_size_t())
105        print('ndata', ndata)
106
107        nrep = []
108        for index in range(neid):
109            nrep.append(read_c_size_t())
110        print('nrep', nrep)
111
112        vrep = []
113        for index in range(neid):
114            vrep.append([])
115            for jndex in range(nrep[index]):
116                vrep[-1].append(read_c_size_t())
117        print('vrep', vrep)
118
119        ids = []
120        for index in range(neid):
121            ids.append(read_c_size_t())
122        print('ids', ids)
123
124        nt = []
125        for index in range(neid):
126            nt.append(read_c_size_t())
127        print('nt', nt)
128
129        zero = []
130        for index in range(neid):
131            zero.append(read_c_double())
132        print('zero', zero)
133
134        four = []
135        for index in range(neid):
136            four.append(read_c_double())
137        print('four', four)
138
139        d_buf = ctypes.c_double * np.sum(ndata)
140        pd_buf = d_buf()
141        ppd_buf = ctypes.c_void_p(ctypes.addressof(pd_buf))
142        bdio_read_f64(ppd_buf, ctypes.c_size_t(8 * np.sum(ndata)), ctypes.c_void_p(fbdio))
143        delta = pd_buf[:]
144
145        samples = np.split(np.asarray(delta) + mean, np.cumsum([a for su in vrep for a in su])[:-1])
146        no_reps = [len(o) for o in vrep]
147        assert len(ids) == len(no_reps)
148        tmp_names = []
149        ens_length = max([len(str(o)) for o in ids])
150        for loc_id, reps in zip(ids, no_reps):
151            for index in range(reps):
152                missing_chars = ens_length - len(str(loc_id))
153                tmp_names.append(str(loc_id) + ' ' * missing_chars + '|r' + '{0:03d}'.format(index))
154
155        return_list.append(Obs(samples, tmp_names))
156
157    bdio_close(fbdio)
158    print()
159    print(len(return_list), 'observable(s) extracted.')
160    return return_list
161
162
163def write_ADerrors(obs_list, file_path, bdio_path='./libbdio.so', **kwargs):
164    """ Write Obs to a bdio file according to ADerrors conventions
165
166    read_mesons requires bdio to be compiled into a shared library. This can be achieved by
167    adding the flag -fPIC to CC and changing the all target to
168
169    all:		bdio.o $(LIBDIR)
170                gcc -shared -Wl,-soname,libbdio.so -o $(BUILDDIR)/libbdio.so $(BUILDDIR)/bdio.o
171                cp $(BUILDDIR)/libbdio.so $(LIBDIR)/
172
173    Parameters
174    ----------
175    file_path -- path to the bdio file
176    bdio_path -- path to the shared bdio library libbdio.so (default ./libbdio.so)
177
178    Returns
179    -------
180    success : int
181        returns 0 is successful
182    """
183
184    for obs in obs_list:
185        if not hasattr(obs, 'e_names'):
186            raise Exception('Run the gamma method first for all obs.')
187
188    bdio = ctypes.cdll.LoadLibrary(bdio_path)
189
190    bdio_open = bdio.bdio_open
191    bdio_open.restype = ctypes.c_void_p
192
193    bdio_close = bdio.bdio_close
194    bdio_close.restype = ctypes.c_int
195    bdio_close.argtypes = [ctypes.c_void_p]
196
197    bdio_start_record = bdio.bdio_start_record
198    bdio_start_record.restype = ctypes.c_int
199    bdio_start_record.argtypes = [ctypes.c_size_t, ctypes.c_size_t, ctypes.c_void_p]
200
201    bdio_flush_record = bdio.bdio_flush_record
202    bdio_flush_record.restype = ctypes.c_int
203    bdio_flush_record.argytpes = [ctypes.c_void_p]
204
205    bdio_write_f64 = bdio.bdio_write_f64
206    bdio_write_f64.restype = ctypes.c_size_t
207    bdio_write_f64.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_void_p]
208
209    bdio_write_int32 = bdio.bdio_write_int32
210    bdio_write_int32.restype = ctypes.c_size_t
211    bdio_write_int32.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_void_p]
212
213    b_path = file_path.encode('utf-8')
214    write = 'w'
215    b_write = write.encode('utf-8')
216    form = 'pyerrors ADerror export'
217    b_form = form.encode('utf-8')
218
219    fbdio = bdio_open(ctypes.c_char_p(b_path), ctypes.c_char_p(b_write), b_form)
220
221    for obs in obs_list:
222        # mean = obs.value
223        neid = len(obs.e_names)
224        vrep = [[obs.shape[o] for o in sl] for sl in list(obs.e_content.values())]
225        vrep_write = [item for sublist in vrep for item in sublist]
226        ndata = [np.sum(o) for o in vrep]
227        nrep = [len(o) for o in vrep]
228        print('ndata', ndata)
229        print('nrep', nrep)
230        print('vrep', vrep)
231        keys = list(obs.e_content.keys())
232        ids = []
233        for key in keys:
234            try:  # Try to convert key to integer
235                ids.append(int(key))
236            except Exception:  # If not possible construct a hash
237                ids.append(int(hashlib.sha256(key.encode('utf-8')).hexdigest(), 16) % 10 ** 8)
238        print('ids', ids)
239        nt = []
240        for e, e_name in enumerate(obs.e_names):
241
242            r_length = []
243            for r_name in obs.e_content[e_name]:
244                r_length.append(len(obs.deltas[r_name]))
245
246            # e_N = np.sum(r_length)
247            nt.append(max(r_length) // 2)
248        print('nt', nt)
249        zero = neid * [0.0]
250        four = neid * [4.0]
251        print('zero', zero)
252        print('four', four)
253        delta = np.concatenate([item for sublist in [[obs.deltas[o] for o in sl] for sl in list(obs.e_content.values())] for item in sublist])
254
255        bdio_start_record(0x00, 8, fbdio)
256
257        def write_c_double(double):
258            pd_buf = ctypes.c_double(double)
259            ppd_buf = ctypes.c_void_p(ctypes.addressof(pd_buf))
260            bdio_write_f64(ppd_buf, ctypes.c_size_t(8), ctypes.c_void_p(fbdio))
261
262        def write_c_size_t(int32):
263            pd_buf = ctypes.c_size_t(int32)
264            ppd_buf = ctypes.c_void_p(ctypes.addressof(pd_buf))
265            bdio_write_int32(ppd_buf, ctypes.c_size_t(4), ctypes.c_void_p(fbdio))
266
267        write_c_double(obs.value)
268        write_c_size_t(neid)
269
270        for element in ndata:
271            write_c_size_t(element)
272        for element in nrep:
273            write_c_size_t(element)
274        for element in vrep_write:
275            write_c_size_t(element)
276        for element in ids:
277            write_c_size_t(element)
278        for element in nt:
279            write_c_size_t(element)
280
281        for element in zero:
282            write_c_double(element)
283        for element in four:
284            write_c_double(element)
285
286        for element in delta:
287            write_c_double(element)
288
289    bdio_close(fbdio)
290    return 0
291
292
293def _get_kwd(string, key):
294    return (string.split(key, 1)[1]).split(" ", 1)[0]
295
296
297def _get_corr_name(string, key):
298    return (string.split(key, 1)[1]).split(' NDIM=', 1)[0]
299
300
301def read_mesons(file_path, bdio_path='./libbdio.so', **kwargs):
302    """ Extract mesons data from a bdio file and return it as a dictionary
303
304    The dictionary can be accessed with a tuple consisting of (type, source_position, kappa1, kappa2)
305
306    read_mesons requires bdio to be compiled into a shared library. This can be achieved by
307    adding the flag -fPIC to CC and changing the all target to
308
309    all:		bdio.o $(LIBDIR)
310                gcc -shared -Wl,-soname,libbdio.so -o $(BUILDDIR)/libbdio.so $(BUILDDIR)/bdio.o
311                cp $(BUILDDIR)/libbdio.so $(LIBDIR)/
312
313    Parameters
314    ----------
315    file_path : str
316        path to the bdio file
317    bdio_path : str
318        path to the shared bdio library libbdio.so (default ./libbdio.so)
319    start : int
320        The first configuration to be read (default 1)
321    stop : int
322        The last configuration to be read (default None)
323    step : int
324        Fixed step size between two measurements (default 1)
325    alternative_ensemble_name : str
326        Manually overwrite ensemble name
327
328    Returns
329    -------
330    data : dict
331        Extracted meson data
332    """
333
334    start = kwargs.get('start', 1)
335    stop = kwargs.get('stop', None)
336    step = kwargs.get('step', 1)
337
338    bdio = ctypes.cdll.LoadLibrary(bdio_path)
339
340    bdio_open = bdio.bdio_open
341    bdio_open.restype = ctypes.c_void_p
342
343    bdio_close = bdio.bdio_close
344    bdio_close.restype = ctypes.c_int
345    bdio_close.argtypes = [ctypes.c_void_p]
346
347    bdio_seek_record = bdio.bdio_seek_record
348    bdio_seek_record.restype = ctypes.c_int
349    bdio_seek_record.argtypes = [ctypes.c_void_p]
350
351    bdio_get_rlen = bdio.bdio_get_rlen
352    bdio_get_rlen.restype = ctypes.c_int
353    bdio_get_rlen.argtypes = [ctypes.c_void_p]
354
355    bdio_get_ruinfo = bdio.bdio_get_ruinfo
356    bdio_get_ruinfo.restype = ctypes.c_int
357    bdio_get_ruinfo.argtypes = [ctypes.c_void_p]
358
359    bdio_read = bdio.bdio_read
360    bdio_read.restype = ctypes.c_size_t
361    bdio_read.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.c_void_p]
362
363    bdio_read_f64 = bdio.bdio_read_f64
364    bdio_read_f64.restype = ctypes.c_size_t
365    bdio_read_f64.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_void_p]
366
367    b_path = file_path.encode('utf-8')
368    read = 'r'
369    b_read = read.encode('utf-8')
370    form = 'Generic Correlator Format 1.0'
371    b_form = form.encode('utf-8')
372
373    ensemble_name = ''
374    volume = []  # lattice volume
375    boundary_conditions = []
376    corr_name = []  # Contains correlator names
377    corr_type = []  # Contains correlator data type (important for reading out numerical data)
378    corr_props = []  # Contanis propagator types (Component of corr_kappa)
379    d0 = 0  # tvals
380    d1 = 0  # nnoise
381    prop_kappa = []  # Contains propagator kappas (Component of corr_kappa)
382    prop_source = []  # Contains propagator source positions
383    # Check noise type for multiple replica?
384    corr_no = -1
385    data = []
386    idl = []
387
388    fbdio = bdio_open(ctypes.c_char_p(b_path), ctypes.c_char_p(b_read), ctypes.c_char_p(b_form))
389
390    print('Reading of bdio file started')
391    while True:
392        bdio_seek_record(fbdio)
393        ruinfo = bdio_get_ruinfo(fbdio)
394        if ruinfo < 0:
395            # EOF reached
396            break
397        rlen = bdio_get_rlen(fbdio)
398        if ruinfo == 5:
399            d_buf = ctypes.c_double * (2 + d0 * d1 * 2)
400            pd_buf = d_buf()
401            ppd_buf = ctypes.c_void_p(ctypes.addressof(pd_buf))
402            bdio_read_f64(ppd_buf, ctypes.c_size_t(rlen), ctypes.c_void_p(fbdio))
403            if corr_type[corr_no] == 'complex':
404                tmp_mean = np.mean(np.asarray(np.split(np.asarray(pd_buf[2 + 2 * d1:-2 * d1:2]), d0 - 2)), axis=1)
405            else:
406                tmp_mean = np.mean(np.asarray(np.split(np.asarray(pd_buf[2 + d1:-d0 * d1 - d1]), d0 - 2)), axis=1)
407
408            data[corr_no].append(tmp_mean)
409            corr_no += 1
410        else:
411            alt_buf = ctypes.create_string_buffer(1024)
412            palt_buf = ctypes.c_char_p(ctypes.addressof(alt_buf))
413            iread = bdio_read(palt_buf, ctypes.c_size_t(rlen), ctypes.c_void_p(fbdio))
414            if rlen != iread:
415                print('Error')
416            for i, item in enumerate(alt_buf):
417                if item == b'\x00':
418                    alt_buf[i] = b' '
419            tmp_string = (alt_buf[:].decode("utf-8")).rstrip()
420            if ruinfo == 0:
421                ensemble_name = _get_kwd(tmp_string, 'ENSEMBLE=')
422                volume.append(int(_get_kwd(tmp_string, 'L0=')))
423                volume.append(int(_get_kwd(tmp_string, 'L1=')))
424                volume.append(int(_get_kwd(tmp_string, 'L2=')))
425                volume.append(int(_get_kwd(tmp_string, 'L3=')))
426                boundary_conditions.append(_get_kwd(tmp_string, 'BC0='))
427                boundary_conditions.append(_get_kwd(tmp_string, 'BC1='))
428                boundary_conditions.append(_get_kwd(tmp_string, 'BC2='))
429                boundary_conditions.append(_get_kwd(tmp_string, 'BC3='))
430
431            if ruinfo == 1:
432                corr_name.append(_get_corr_name(tmp_string, 'CORR_NAME='))
433                corr_type.append(_get_kwd(tmp_string, 'DATATYPE='))
434                corr_props.append([_get_kwd(tmp_string, 'PROP0='), _get_kwd(tmp_string, 'PROP1=')])
435                if d0 == 0:
436                    d0 = int(_get_kwd(tmp_string, 'D0='))
437                else:
438                    if d0 != int(_get_kwd(tmp_string, 'D0=')):
439                        print('Error: Varying number of time values')
440                if d1 == 0:
441                    d1 = int(_get_kwd(tmp_string, 'D1='))
442                else:
443                    if d1 != int(_get_kwd(tmp_string, 'D1=')):
444                        print('Error: Varying number of random sources')
445            if ruinfo == 2:
446                prop_kappa.append(_get_kwd(tmp_string, 'KAPPA='))
447                prop_source.append(_get_kwd(tmp_string, 'x0='))
448            if ruinfo == 4:
449                cnfg_no = int(_get_kwd(tmp_string, 'CNFG_ID='))
450                if stop:
451                    if cnfg_no > kwargs.get('stop'):
452                        break
453                idl.append(cnfg_no)
454                print('\r%s %i' % ('Reading configuration', cnfg_no), end='\r')
455                if len(idl) == 1:
456                    no_corrs = len(corr_name)
457                    data = []
458                    for c in range(no_corrs):
459                        data.append([])
460
461                corr_no = 0
462
463    bdio_close(fbdio)
464
465    print('\nEnsemble: ', ensemble_name)
466    if 'alternative_ensemble_name' in kwargs:
467        ensemble_name = kwargs.get('alternative_ensemble_name')
468        print('Ensemble name overwritten to', ensemble_name)
469    print('Lattice volume: ', volume)
470    print('Boundary conditions: ', boundary_conditions)
471    print('Number of time values: ', d0)
472    print('Number of random sources: ', d1)
473    print('Number of corrs: ', len(corr_name))
474    print('Number of configurations: ', len(idl))
475
476    corr_kappa = []  # Contains kappa values for both propagators of given correlation function
477    corr_source = []
478    for item in corr_props:
479        corr_kappa.append([float(prop_kappa[int(item[0])]), float(prop_kappa[int(item[1])])])
480        if prop_source[int(item[0])] != prop_source[int(item[1])]:
481            raise Exception('Source position do not match for correlator' + str(item))
482        else:
483            corr_source.append(int(prop_source[int(item[0])]))
484
485    if stop is None:
486        stop = idl[-1]
487    idl_target = range(start, stop + 1, step)
488
489    if set(idl) != set(idl_target):
490        try:
491            indices = [idl.index(i) for i in idl_target]
492        except ValueError as err:
493            raise Exception('Configurations in file do no match target list!', err)
494    else:
495        indices = None
496
497    result = {}
498    for c in range(no_corrs):
499        tmp_corr = []
500        tmp_data = np.asarray(data[c])
501        for t in range(d0 - 2):
502            if indices:
503                deltas = [tmp_data[:, t][index] for index in indices]
504            else:
505                deltas = tmp_data[:, t]
506            tmp_corr.append(Obs([deltas], [ensemble_name], idl=[idl_target]))
507        result[(corr_name[c], corr_source[c]) + tuple(corr_kappa[c])] = tmp_corr
508
509    # Check that all data entries have the same number of configurations
510    if len(set([o[0].N for o in list(result.values())])) != 1:
511        raise Exception('Error: Not all correlators have the same number of configurations. bdio file is possibly corrupted.')
512
513    return result
514
515
516def read_dSdm(file_path, bdio_path='./libbdio.so', **kwargs):
517    """ Extract dSdm data from a bdio file and return it as a dictionary
518
519    The dictionary can be accessed with a tuple consisting of (type, kappa)
520
521    read_dSdm requires bdio to be compiled into a shared library. This can be achieved by
522    adding the flag -fPIC to CC and changing the all target to
523
524    all:		bdio.o $(LIBDIR)
525                gcc -shared -Wl,-soname,libbdio.so -o $(BUILDDIR)/libbdio.so $(BUILDDIR)/bdio.o
526                cp $(BUILDDIR)/libbdio.so $(LIBDIR)/
527
528    Parameters
529    ----------
530    file_path : str
531        path to the bdio file
532    bdio_path : str
533        path to the shared bdio library libbdio.so (default ./libbdio.so)
534    start : int
535        The first configuration to be read (default 1)
536    stop : int
537        The last configuration to be read (default None)
538    step : int
539        Fixed step size between two measurements (default 1)
540    alternative_ensemble_name : str
541        Manually overwrite ensemble name
542    """
543
544    start = kwargs.get('start', 1)
545    stop = kwargs.get('stop', None)
546    step = kwargs.get('step', 1)
547
548    bdio = ctypes.cdll.LoadLibrary(bdio_path)
549
550    bdio_open = bdio.bdio_open
551    bdio_open.restype = ctypes.c_void_p
552
553    bdio_close = bdio.bdio_close
554    bdio_close.restype = ctypes.c_int
555    bdio_close.argtypes = [ctypes.c_void_p]
556
557    bdio_seek_record = bdio.bdio_seek_record
558    bdio_seek_record.restype = ctypes.c_int
559    bdio_seek_record.argtypes = [ctypes.c_void_p]
560
561    bdio_get_rlen = bdio.bdio_get_rlen
562    bdio_get_rlen.restype = ctypes.c_int
563    bdio_get_rlen.argtypes = [ctypes.c_void_p]
564
565    bdio_get_ruinfo = bdio.bdio_get_ruinfo
566    bdio_get_ruinfo.restype = ctypes.c_int
567    bdio_get_ruinfo.argtypes = [ctypes.c_void_p]
568
569    bdio_read = bdio.bdio_read
570    bdio_read.restype = ctypes.c_size_t
571    bdio_read.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.c_void_p]
572
573    bdio_read_f64 = bdio.bdio_read_f64
574    bdio_read_f64.restype = ctypes.c_size_t
575    bdio_read_f64.argtypes = [ctypes.c_void_p, ctypes.c_size_t, ctypes.c_void_p]
576
577    b_path = file_path.encode('utf-8')
578    read = 'r'
579    b_read = read.encode('utf-8')
580    form = 'Generic Correlator Format 1.0'
581    b_form = form.encode('utf-8')
582
583    ensemble_name = ''
584    volume = []  # lattice volume
585    boundary_conditions = []
586    corr_name = []  # Contains correlator names
587    corr_type = []  # Contains correlator data type (important for reading out numerical data)
588    corr_props = []  # Contains propagator types (Component of corr_kappa)
589    d0 = 0  # tvals
590    # d1 = 0  # nnoise
591    prop_kappa = []  # Contains propagator kappas (Component of corr_kappa)
592    # Check noise type for multiple replica?
593    corr_no = -1
594    data = []
595    idl = []
596
597    fbdio = bdio_open(ctypes.c_char_p(b_path), ctypes.c_char_p(b_read), ctypes.c_char_p(b_form))
598
599    print('Reading of bdio file started')
600    while True:
601        bdio_seek_record(fbdio)
602        ruinfo = bdio_get_ruinfo(fbdio)
603        if ruinfo < 0:
604            # EOF reached
605            break
606        rlen = bdio_get_rlen(fbdio)
607        if ruinfo == 5:
608            d_buf = ctypes.c_double * (2 + d0)
609            pd_buf = d_buf()
610            ppd_buf = ctypes.c_void_p(ctypes.addressof(pd_buf))
611            bdio_read_f64(ppd_buf, ctypes.c_size_t(rlen), ctypes.c_void_p(fbdio))
612            tmp_mean = np.mean(np.asarray(pd_buf[2:]))
613
614            data[corr_no].append(tmp_mean)
615            corr_no += 1
616        else:
617            alt_buf = ctypes.create_string_buffer(1024)
618            palt_buf = ctypes.c_char_p(ctypes.addressof(alt_buf))
619            iread = bdio_read(palt_buf, ctypes.c_size_t(rlen), ctypes.c_void_p(fbdio))
620            if rlen != iread:
621                print('Error')
622            for i, item in enumerate(alt_buf):
623                if item == b'\x00':
624                    alt_buf[i] = b' '
625            tmp_string = (alt_buf[:].decode("utf-8")).rstrip()
626            if ruinfo == 0:
627                creator = _get_kwd(tmp_string, 'CREATOR=')
628                ensemble_name = _get_kwd(tmp_string, 'ENSEMBLE=')
629                volume.append(int(_get_kwd(tmp_string, 'L0=')))
630                volume.append(int(_get_kwd(tmp_string, 'L1=')))
631                volume.append(int(_get_kwd(tmp_string, 'L2=')))
632                volume.append(int(_get_kwd(tmp_string, 'L3=')))
633                boundary_conditions.append(_get_kwd(tmp_string, 'BC0='))
634                boundary_conditions.append(_get_kwd(tmp_string, 'BC1='))
635                boundary_conditions.append(_get_kwd(tmp_string, 'BC2='))
636                boundary_conditions.append(_get_kwd(tmp_string, 'BC3='))
637
638            if ruinfo == 1:
639                corr_name.append(_get_corr_name(tmp_string, 'CORR_NAME='))
640                corr_type.append(_get_kwd(tmp_string, 'DATATYPE='))
641                corr_props.append(_get_kwd(tmp_string, 'PROP0='))
642                if d0 == 0:
643                    d0 = int(_get_kwd(tmp_string, 'D0='))
644                else:
645                    if d0 != int(_get_kwd(tmp_string, 'D0=')):
646                        print('Error: Varying number of time values')
647            if ruinfo == 2:
648                prop_kappa.append(_get_kwd(tmp_string, 'KAPPA='))
649            if ruinfo == 4:
650                cnfg_no = int(_get_kwd(tmp_string, 'CNFG_ID='))
651                if stop:
652                    if cnfg_no > kwargs.get('stop'):
653                        break
654                idl.append(cnfg_no)
655                print('\r%s %i' % ('Reading configuration', cnfg_no), end='\r')
656                if len(idl) == 1:
657                    no_corrs = len(corr_name)
658                    data = []
659                    for c in range(no_corrs):
660                        data.append([])
661
662                corr_no = 0
663    bdio_close(fbdio)
664
665    print('\nCreator: ', creator)
666    print('Ensemble: ', ensemble_name)
667    print('Lattice volume: ', volume)
668    print('Boundary conditions: ', boundary_conditions)
669    print('Number of random sources: ', d0)
670    print('Number of corrs: ', len(corr_name))
671    print('Number of configurations: ', cnfg_no + 1)
672
673    corr_kappa = []  # Contains kappa values for both propagators of given correlation function
674    for item in corr_props:
675        corr_kappa.append(float(prop_kappa[int(item)]))
676
677    if stop is None:
678        stop = idl[-1]
679    idl_target = range(start, stop + 1, step)
680    try:
681        indices = [idl.index(i) for i in idl_target]
682    except ValueError as err:
683        raise Exception('Configurations in file do no match target list!', err)
684
685    result = {}
686    for c in range(no_corrs):
687        deltas = [np.asarray(data[c])[index] for index in indices]
688        result[(corr_name[c], str(corr_kappa[c]))] = Obs([deltas], [ensemble_name], idl=[idl_target])
689
690    # Check that all data entries have the same number of configurations
691    if len(set([o.N for o in list(result.values())])) != 1:
692        raise Exception('Error: Not all correlators have the same number of configurations. bdio file is possibly corrupted.')
693
694    return result