def parse_radic_file(filename, settings, selection_mode="after",
                     reciprocal=None):
    """Import one result file as produced by the SIP256c SIP measuring device
    (Radic Research)

    Full settings dictionary: ::

        settings = {
            'filter_skip': (integer) skip dipoles we are interested in
            'quadrupole_mode': ['after'|'between'|'before'| 'all']
                               which dipoles to use from the file
        }


    Parameters
    ----------
    filename: string
        input filename, usually with the ending ".RES"
    settings: dict
        Settings for the data import, see code snippet above
    selection_mode: dict
        which voltage dipoles should be returned. Possible choices:
        "all"|"before"|"after"
    reciprocal: int|None
        If this is an integer, then assume this was a reciprocal measurement
        and the number denotes the largest RU number, N. Electrode numbers
        (a,b,m,n) will then be transformed to (N1 - a, N1 - b, N1 - m, N1 - n),
        with N1 = N + 1

    Returns
    -------
    sip_data: :py:pandas:`pandas.DataFrame`
        The data contained in a data frame
    electrodes : None
        No electrode positions are imported
    topography : None
        No topography is imported

    """
    try:
        with open(filename, 'r', encoding='latin-1') as fid:
            lines = fid.readlines()
    except:
        print('file not found', filename)
        import pdb
        pdb.set_trace()

    groups = itertools.groupby(
        lines,
        lambda line: line.startswith('Reading:')
    )

    # parse header
    group = next(groups)
    header_data = _parse_radic_header(group, dipole_mode='between')

    # parse readings
    reading_blocks = {}
    for key, group in groups:
        # determine reading number
        line = next(group)
        reading_nr = int(line[8: line.find('/')].strip())
        # print('reading nr', reading_nr)
        reading_blocks[reading_nr] = [x for x in next(groups)[1]]
        # print reading_blocks[reading_nr]

    # print(sorted(reading_blocks.keys()))
    # now parse the readings
    print('number of readings', len(reading_blocks))
    print('keys', sorted(reading_blocks.keys()))
    readings = {}
    for key in sorted(reading_blocks):
        # print('KEY/Reading', key)
        reading = reading_blocks[key]
        tmp = parse_reading(reading)
        # except Exception as e:
        #     print('Parsing of reading failed')
        #     print(''.join(reading))
        #     print('error message')
        #     print(e)
        #     exit()
        readings[key] = tmp
    # print('reading keys', sorted(readings.keys()))

    logging.debug('removing calibration reading')
    # remove calibration reading
    if 0 in readings:
        del(readings[0])

    # print('readings', readings)
    sip_data_raw = compute_quadrupoles(header_data, readings, settings)

    sip_data = pd.concat(sip_data_raw)

    if reciprocal is not None and isinstance(reciprocal, int):
        sip_data['a'] = (reciprocal + 1) - sip_data['a']
        sip_data['b'] = (reciprocal + 1) - sip_data['b']
        sip_data['m'] = (reciprocal + 1) - sip_data['m']
        sip_data['n'] = (reciprocal + 1) - sip_data['n']

    return sip_data, None, None