示例#1
0
文件: fiac_util.py 项目: ofenlab/nipy
def test_sanity():
    from nipy.modalities.fmri import design, hrf
    import nipy.modalities.fmri.fmristat.hrf as fshrf
    from nipy.modalities.fmri.fmristat.tests import FIACdesigns
    from nipy.modalities.fmri.fmristat.tests.test_FIAC import matchcol
    from nipy.algorithms.statistics import formula
    from nose.tools import assert_true
    """
    Single subject fitting of FIAC model
    """

    # Based on file
    # subj3_evt_fonc1.txt
    # subj3_bloc_fonc3.txt

    for subj, run, design_type in [(3, 1, 'event'), (3, 3, 'block')]:
        nvol = 191
        TR = 2.5
        Tstart = 1.25

        volume_times = np.arange(nvol) * TR + Tstart
        volume_times_rec = formula.make_recarray(volume_times, 't')

        path_dict = {'subj': subj, 'run': run}
        if exists(
                pjoin(DATADIR, "fiac_%(subj)02d", "block",
                      "initial_%(run)02d.csv") % path_dict):
            path_dict['design'] = 'block'
        else:
            path_dict['design'] = 'event'

        experiment = csv2rec(
            pjoin(DATADIR, "fiac_%(subj)02d", "%(design)s",
                  "experiment_%(run)02d.csv") % path_dict)
        initial = csv2rec(
            pjoin(DATADIR, "fiac_%(subj)02d", "%(design)s",
                  "initial_%(run)02d.csv") % path_dict)

        X_exper, cons_exper = design.event_design(experiment,
                                                  volume_times_rec,
                                                  hrfs=fshrf.spectral)
        X_initial, _ = design.event_design(initial,
                                           volume_times_rec,
                                           hrfs=[hrf.glover])
        X, cons = design.stack_designs((X_exper, cons_exper), (X_initial, {}))

        # Get original fmristat design
        Xf = FIACdesigns.fmristat[design_type]
        # Check our new design can be closely matched to the original
        for i in range(X.shape[1]):
            # Columns can be very well correlated negatively or positively
            assert_true(abs(matchcol(X[:, i], Xf)[1]) > 0.999)
示例#2
0
def test_block_amplitudes():
    # Test event design helper function
    # An event design with one event type
    onsets = np.array([0, 20, 40, 60])
    durations = np.array([2, 3, 4, 5])
    offsets = onsets + durations
    amplitudes = [3, 2, 1, 4]
    t = np.arange(0, 100, 2.5)

    def mk_blk_tc(amplitudes=None, hrf=glover):
        func_amp = blocks(zip(onsets, offsets), amplitudes)
        # Make real time course for block onset / offsets / amplitudes
        term = convolve_functions(func_amp, hrf(T),
                                  (-5, 70),  # step func support
                                  (0, 30.),  # conv kernel support
                                  0.02)  # dt
        return lambdify_t(term)(t)

    no_amps = make_recarray(zip(onsets, offsets), ('start', 'end'))
    amps = make_recarray(zip(onsets, offsets, amplitudes),
                         ('start', 'end', 'amplitude'))
    X, contrasts = block_amplitudes('ev0', no_amps, t)
    assert_almost_equal(X, mk_blk_tc())
    assert_dict_almost_equal(contrasts, {'ev0_0': 1})
    # Same thing as 2D array
    X, contrasts = block_amplitudes('ev0', np.c_[onsets, offsets], t)
    assert_almost_equal(X, mk_blk_tc())
    assert_dict_almost_equal(contrasts, {'ev0_0': 1})
    # Now as list
    X, contrasts = block_amplitudes('ev0', list(zip(onsets, offsets)), t)
    assert_almost_equal(X, mk_blk_tc())
    assert_dict_almost_equal(contrasts, {'ev0_0': 1})
    # Add amplitudes
    X_a, contrasts_a = block_amplitudes('ev1', amps, t)
    assert_almost_equal(X_a, mk_blk_tc(amplitudes=amplitudes))
    assert_dict_almost_equal(contrasts_a, {'ev1_0': 1})
    # Same thing as 2D array
    X_a, contrasts_a = block_amplitudes('ev1',
                                        np.c_[onsets, offsets, amplitudes],
                                        t)
    assert_almost_equal(X_a, mk_blk_tc(amplitudes=amplitudes))
    assert_dict_almost_equal(contrasts_a, {'ev1_0': 1})
    # Add another HRF
    X_2, contrasts_2 = block_amplitudes('ev0', no_amps, t, (glover, dglover))
    assert_almost_equal(X_2, np.c_[mk_blk_tc(), mk_blk_tc(hrf=dglover)])
    assert_dict_almost_equal(contrasts_2,
                             {'ev0_0': [1, 0], 'ev0_1': [0, 1]})
    # Errors on bad input
    no_start = make_recarray(zip(onsets, offsets), ('begin', 'end'))
    assert_raises(ValueError, block_amplitudes, 'ev0', no_start, t)
    no_end = make_recarray(zip(onsets, offsets), ('start', 'finish'))
    assert_raises(ValueError, block_amplitudes, 'ev0', no_end, t)
    funny_amp = make_recarray(zip(onsets, offsets, amplitudes),
                              ('start', 'end', 'intensity'))
    assert_raises(ValueError, block_amplitudes, 'ev0', funny_amp, t)
    funny_extra = make_recarray(zip(onsets, offsets, amplitudes, onsets),
                              ('start', 'end', 'amplitude', 'extra_field'))
    assert_raises(ValueError, block_amplitudes, 'ev0', funny_extra, t)
示例#3
0
def test_sanity():
    from nipy.modalities.fmri import design, hrf
    import nipy.modalities.fmri.fmristat.hrf as fshrf
    from nipy.modalities.fmri.fmristat.tests import FIACdesigns
    from nipy.modalities.fmri.fmristat.tests.test_FIAC import matchcol
    from nipy.algorithms.statistics import formula
    from nose.tools import assert_true

    """
    Single subject fitting of FIAC model
    """

    # Based on file
    # subj3_evt_fonc1.txt
    # subj3_bloc_fonc3.txt

    for subj, run, design_type in [(3, 1, 'event'), (3, 3, 'block')]:
        nvol = 191
        TR = 2.5
        Tstart = 1.25

        volume_times = np.arange(nvol)*TR + Tstart
        volume_times_rec = formula.make_recarray(volume_times, 't')

        path_dict = {'subj':subj, 'run':run}
        if exists(pjoin(DATADIR, "fiac_%(subj)02d",
                        "block", "initial_%(run)02d.csv") % path_dict):
            path_dict['design'] = 'block'
        else:
            path_dict['design'] = 'event'

        experiment = csv2rec(pjoin(DATADIR, "fiac_%(subj)02d", "%(design)s", "experiment_%(run)02d.csv")
                             % path_dict)
        initial = csv2rec(pjoin(DATADIR, "fiac_%(subj)02d", "%(design)s", "initial_%(run)02d.csv")
                                % path_dict)

        X_exper, cons_exper = design.event_design(experiment,
                                                  volume_times_rec,
                                                  hrfs=fshrf.spectral)
        X_initial, _ = design.event_design(initial,
                                           volume_times_rec,
                                           hrfs=[hrf.glover])
        X, cons = design.stack_designs((X_exper, cons_exper), (X_initial, {}))

        # Get original fmristat design
        Xf = FIACdesigns.fmristat[design_type]
        # Check our new design can be closely matched to the original
        for i in range(X.shape[1]):
            # Columns can be very well correlated negatively or positively
            assert_true(abs(matchcol(X[:,i], Xf)[1]) > 0.999)
示例#4
0
文件: model.py 项目: Hiccup/nipy
def model_generator(formula, data, volume_start_times, iterable=None,
                    slicetimes=None, model_type=OLSModel,
                    model_params = lambda x: ()):
    """
    Generator for the models for a pass of fmristat analysis.
    """
    volume_start_times = make_recarray(volume_start_times.astype(float), 't')
    # Generator for slices of the data with time as first axis
    axis0_gen = fmri_generator(data, iterable=iterable)
    # Iterate over 2D slices of the data
    for indexer, indexed_data in matrix_generator(axis0_gen):
        model_args = model_params(indexer) # model may depend on i
        # Get the design for these volume start times
        design = formula.design(volume_start_times, return_float=True)
        # Make the model from the design
        rmodel = model_type(design, *model_args)
        yield indexer, indexed_data, rmodel
示例#5
0
def model_generator(formula, data, volume_start_times, iterable=None,
                    slicetimes=None, model_type=OLSModel,
                    model_params = lambda x: ()):
    """
    Generator for the models for a pass of fmristat analysis.
    """
    volume_start_times = make_recarray(volume_start_times.astype(float), 't')
    # Generator for slices of the data with time as first axis
    axis0_gen = axis0_generator(data, slicers=iterable)
    # Iterate over 2D slices of the data
    for indexer, indexed_data in matrix_generator(axis0_gen):
        model_args = model_params(indexer) # model may depend on i
        # Get the design for these volume start times
        design = formula.design(volume_start_times, return_float=True)
        # Make the model from the design
        rmodel = model_type(design, *model_args)
        yield indexer, indexed_data, rmodel
示例#6
0
文件: test_design.py 项目: cni/nipy
 def mk_blk_spec(factors, names):
     names = ('start', 'end') + tuple(names)
     return make_recarray(zip(onsets, offsets, *factors), names)
示例#7
0
文件: test_design.py 项目: cni/nipy
 def mk_ev_spec(factors, names):
     names = ('time',) + tuple(names)
     if len(factors) == 0:
         return make_recarray(onsets, names)
     return make_recarray(zip(onsets, *factors), names)
示例#8
0
文件: test_design.py 项目: cni/nipy
def test_event_design():
    # Test event design helper function
    # An event design with one event type
    onsets = np.array([0, 20, 40, 60])
    durations = np.array([2, 3, 4, 5])
    offsets = onsets + durations
    c_fac = np.array([1, 1, 1, 1])  # constant factor (one level)
    fac_1 = np.array([0, 1, 0, 1])  # factor 1, two levels
    fac_2 = np.array([0, 0, 1, 1])  # factor 2, two levels
    t = np.arange(0, 100, 2)

    def mk_ev_spec(factors, names):
        names = ('time',) + tuple(names)
        if len(factors) == 0:
            return make_recarray(onsets, names)
        return make_recarray(zip(onsets, *factors), names)

    def mk_blk_spec(factors, names):
        names = ('start', 'end') + tuple(names)
        return make_recarray(zip(onsets, offsets, *factors), names)

    def mk_ev_tc(ev_inds):
        # Make real time course for given event onsets
        return lambdify_t(events(onsets[ev_inds], f=glover))(t)

    def mk_blk_tc(ev_inds):
        # Make real time course for block onset / offsets
        B = blocks(zip(onsets[ev_inds], offsets[ev_inds]))
        term = convolve_functions(B, glover(T),
                                  (-5, 70),  # step func support
                                  (0, 30.),  # conv kernel support
                                  0.02)  # dt
        return lambdify_t(term)(t)

    for d_maker, spec_maker, tc_maker, null_name in (
        (event_design, mk_ev_spec, mk_ev_tc, '_event_'),
        (block_design, mk_blk_spec, mk_blk_tc, '_block_')):
        # Event spec with no event factor -> single column design, no contrasts
        spec_0 = spec_maker((), ())
        X_0, contrasts_0 = d_maker(spec_0, t)
        exp_x_0 = tc_maker(onsets==onsets)
        assert_almost_equal(X_0, exp_x_0)
        assert_dict_almost_equal(contrasts_0, dict(constant_0=1))
        X_0, contrasts_0 = d_maker(spec_0, t, level_contrasts=True)
        assert_almost_equal(X_0, exp_x_0)
        assert_dict_almost_equal(contrasts_0,
                                 {'constant_0': 1,
                                  null_name + '_1_0': 1})
        # Event spec with single factor, but only one level
        spec_1c = spec_maker((c_fac,), ('smt',))
        X_1c, contrasts_1c = d_maker(spec_1c, t)
        assert_almost_equal(X_1c, exp_x_0)
        assert_dict_almost_equal(contrasts_1c, dict(constant_0=1))
        X_1c, contrasts_1c = d_maker(spec_1c, t, level_contrasts=True)
        assert_dict_almost_equal(contrasts_1c, dict(constant_0=1, smt_1_0=1))
        # Event spec with single factor, two levels
        spec_1d = spec_maker((fac_1,), ('smt',))
        exp_x_0 = tc_maker(fac_1 == 0)
        exp_x_1 = tc_maker(fac_1 == 1)
        X_1d, contrasts_1d = d_maker(spec_1d, t)
        assert_almost_equal(X_1d, np.c_[exp_x_0, exp_x_1])
        assert_dict_almost_equal(contrasts_1d,
                                 dict(constant_0=[1, 1], smt_0=[1, -1]))
        X_1d, contrasts_1d = d_maker(spec_1d, t, level_contrasts=True)
        assert_dict_almost_equal(contrasts_1d,
                                 dict(constant_0=1,
                                      smt_0=[1, -1],  # main effect
                                      smt_0_0=[1, 0],  # level 0, hrf 0
                                      smt_1_0=[0, 1]))  # level 1, hrf 0
        # Event spec with two factors, one with two levels, another with one
        spec_2dc = spec_maker((fac_1, c_fac), ('smt', 'smte'))
        X_2dc, contrasts_2dc = d_maker(spec_2dc, t)
        assert_almost_equal(X_2dc, np.c_[exp_x_0, exp_x_1])
        assert_dict_almost_equal(contrasts_2dc,
                                {'constant_0': [1, 1],
                                'smt_0': [1, -1],  # main effect
                                'smt:smte_0': [1, -1],  # interaction
                                })
        X_2dc, contrasts_2dc = d_maker(spec_2dc, t, level_contrasts=True)
        assert_dict_almost_equal(contrasts_2dc,
                                {'constant_0': [1, 1],
                                'smt_0': [1, -1],  # main effect
                                'smt:smte_0': [1, -1],  # interaction
                                'smt_0*smte_1_0': [1, 0], # smt 0, smte 0, hrf 0
                                'smt_1*smte_1_0': [0, 1], # smt 1, smte 0, hrf 0
                                })
        # Event spec with two factors, both with two levels
        spec_2dd = spec_maker((fac_1, fac_2), ('smt', 'smte'))
        exp_x_0 = tc_maker((fac_1 == 0) & (fac_2 == 0))
        exp_x_1 = tc_maker((fac_1 == 0) & (fac_2 == 1))
        exp_x_2 = tc_maker((fac_1 == 1) & (fac_2 == 0))
        exp_x_3 = tc_maker((fac_1 == 1) & (fac_2 == 1))
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t)
        assert_almost_equal(X_2dd, np.c_[exp_x_0, exp_x_1, exp_x_2, exp_x_3])
        exp_cons = {'constant_0': [1, 1, 1, 1],
                    'smt_0': [1, 1, -1, -1],  # main effect fac_1
                    'smte_0': [1, -1, 1, -1],  # main effect fac_2
                    'smt:smte_0': [1, -1, -1, 1],  # interaction
                }
        assert_dict_almost_equal(contrasts_2dd, exp_cons)
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t, level_contrasts=True)
        level_cons = exp_cons.copy()
        level_cons.update({
            'smt_0*smte_0_0': [1, 0, 0, 0],  # smt 0, smte 0, hrf 0
            'smt_0*smte_1_0': [0, 1, 0, 0],  # smt 0, smte 1, hrf 0
            'smt_1*smte_0_0': [0, 0, 1, 0],  # smt 1, smte 0, hrf 0
            'smt_1*smte_1_0': [0, 0, 0, 1],  # smt 1, smte 1, hrf 0
        })
        assert_dict_almost_equal(contrasts_2dd, level_cons)
        # Test max order >> 2, no error
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t, order=100)
        assert_almost_equal(X_2dd, np.c_[exp_x_0, exp_x_1, exp_x_2, exp_x_3])
        assert_dict_almost_equal(contrasts_2dd, exp_cons)
        # Test max order = 1
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t, order=1)
        assert_almost_equal(X_2dd, np.c_[exp_x_0, exp_x_1, exp_x_2, exp_x_3])
        # No interaction
        assert_dict_almost_equal(contrasts_2dd,
                                {'constant_0': [1, 1, 1, 1],
                                'smt_0': [1, 1, -1, -1],  # main effect fac_1
                                'smte_0': [1, -1, 1, -1],  # main effect fac_2
                                })
    # events : test field called "time" is necessary
    spec_1d = make_recarray(zip(onsets, fac_1), ('brighteyes', 'smt'))
    assert_raises(ValueError, event_design, spec_1d, t)
    # blocks : test fields called "start" and "end" are necessary
    spec_1d = make_recarray(zip(onsets, offsets, fac_1),
                            ('mister', 'brighteyes', 'smt'))
    assert_raises(ValueError, block_design, spec_1d, t)
    spec_1d = make_recarray(zip(onsets, offsets, fac_1),
                            ('start', 'brighteyes', 'smt'))
    assert_raises(ValueError, block_design, spec_1d, t)
    spec_1d = make_recarray(zip(onsets, offsets, fac_1),
                            ('mister', 'end', 'smt'))
    assert_raises(ValueError, block_design, spec_1d, t)
示例#9
0
 def mk_blk_spec(factors, names):
     names = ('start', 'end') + tuple(names)
     return make_recarray(zip(onsets, offsets, *factors), names)
示例#10
0
 def mk_ev_spec(factors, names):
     names = ('time',) + tuple(names)
     if len(factors) == 0:
         return make_recarray(onsets, names)
     return make_recarray(zip(onsets, *factors), names)
示例#11
0
def test_event_design():
    # Test event design helper function
    # An event design with one event type
    onsets = np.array([0, 20, 40, 60])
    durations = np.array([2, 3, 4, 5])
    offsets = onsets + durations
    c_fac = np.array([1, 1, 1, 1])  # constant factor (one level)
    fac_1 = np.array([0, 1, 0, 1])  # factor 1, two levels
    fac_2 = np.array([0, 0, 1, 1])  # factor 2, two levels
    t = np.arange(0, 100, 2)

    def mk_ev_spec(factors, names):
        names = ('time',) + tuple(names)
        if len(factors) == 0:
            return make_recarray(onsets, names)
        return make_recarray(zip(onsets, *factors), names)

    def mk_blk_spec(factors, names):
        names = ('start', 'end') + tuple(names)
        return make_recarray(zip(onsets, offsets, *factors), names)

    def mk_ev_tc(ev_inds):
        # Make real time course for given event onsets
        return lambdify_t(events(onsets[ev_inds], f=glover))(t)

    def mk_blk_tc(ev_inds):
        # Make real time course for block onset / offsets
        B = blocks(zip(onsets[ev_inds], offsets[ev_inds]))
        term = convolve_functions(B, glover(T),
                                  (-5, 70),  # step func support
                                  (0, 30.),  # conv kernel support
                                  0.02)  # dt
        return lambdify_t(term)(t)

    for d_maker, spec_maker, tc_maker, null_name in (
        (event_design, mk_ev_spec, mk_ev_tc, '_event_'),
        (block_design, mk_blk_spec, mk_blk_tc, '_block_')):
        # Event spec with no event factor -> single column design, no contrasts
        spec_0 = spec_maker((), ())
        X_0, contrasts_0 = d_maker(spec_0, t)
        exp_x_0 = tc_maker(onsets==onsets)
        assert_almost_equal(X_0, exp_x_0)
        assert_dict_almost_equal(contrasts_0, dict(constant_0=1))
        X_0, contrasts_0 = d_maker(spec_0, t, level_contrasts=True)
        assert_almost_equal(X_0, exp_x_0)
        assert_dict_almost_equal(contrasts_0,
                                 {'constant_0': 1,
                                  null_name + '_1_0': 1})
        # Event spec with single factor, but only one level
        spec_1c = spec_maker((c_fac,), ('smt',))
        X_1c, contrasts_1c = d_maker(spec_1c, t)
        assert_almost_equal(X_1c, exp_x_0)
        assert_dict_almost_equal(contrasts_1c, dict(constant_0=1))
        X_1c, contrasts_1c = d_maker(spec_1c, t, level_contrasts=True)
        assert_dict_almost_equal(contrasts_1c, dict(constant_0=1, smt_1_0=1))
        # Event spec with single factor, two levels
        spec_1d = spec_maker((fac_1,), ('smt',))
        exp_x_0 = tc_maker(fac_1 == 0)
        exp_x_1 = tc_maker(fac_1 == 1)
        X_1d, contrasts_1d = d_maker(spec_1d, t)
        assert_almost_equal(X_1d, np.c_[exp_x_0, exp_x_1])
        assert_dict_almost_equal(contrasts_1d,
                                 dict(constant_0=[1, 1], smt_0=[1, -1]))
        X_1d, contrasts_1d = d_maker(spec_1d, t, level_contrasts=True)
        assert_dict_almost_equal(contrasts_1d,
                                 dict(constant_0=1,
                                      smt_0=[1, -1],  # main effect
                                      smt_0_0=[1, 0],  # level 0, hrf 0
                                      smt_1_0=[0, 1]))  # level 1, hrf 0
        # Event spec with two factors, one with two levels, another with one
        spec_2dc = spec_maker((fac_1, c_fac), ('smt', 'smte'))
        X_2dc, contrasts_2dc = d_maker(spec_2dc, t)
        assert_almost_equal(X_2dc, np.c_[exp_x_0, exp_x_1])
        assert_dict_almost_equal(contrasts_2dc,
                                {'constant_0': [1, 1],
                                'smt_0': [1, -1],  # main effect
                                'smt:smte_0': [1, -1],  # interaction
                                })
        X_2dc, contrasts_2dc = d_maker(spec_2dc, t, level_contrasts=True)
        assert_dict_almost_equal(contrasts_2dc,
                                {'constant_0': [1, 1],
                                'smt_0': [1, -1],  # main effect
                                'smt:smte_0': [1, -1],  # interaction
                                'smt_0*smte_1_0': [1, 0], # smt 0, smte 0, hrf 0
                                'smt_1*smte_1_0': [0, 1], # smt 1, smte 0, hrf 0
                                })
        # Event spec with two factors, both with two levels
        spec_2dd = spec_maker((fac_1, fac_2), ('smt', 'smte'))
        exp_x_0 = tc_maker((fac_1 == 0) & (fac_2 == 0))
        exp_x_1 = tc_maker((fac_1 == 0) & (fac_2 == 1))
        exp_x_2 = tc_maker((fac_1 == 1) & (fac_2 == 0))
        exp_x_3 = tc_maker((fac_1 == 1) & (fac_2 == 1))
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t)
        assert_almost_equal(X_2dd, np.c_[exp_x_0, exp_x_1, exp_x_2, exp_x_3])
        exp_cons = {'constant_0': [1, 1, 1, 1],
                    'smt_0': [1, 1, -1, -1],  # main effect fac_1
                    'smte_0': [1, -1, 1, -1],  # main effect fac_2
                    'smt:smte_0': [1, -1, -1, 1],  # interaction
                }
        assert_dict_almost_equal(contrasts_2dd, exp_cons)
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t, level_contrasts=True)
        level_cons = exp_cons.copy()
        level_cons.update({
            'smt_0*smte_0_0': [1, 0, 0, 0],  # smt 0, smte 0, hrf 0
            'smt_0*smte_1_0': [0, 1, 0, 0],  # smt 0, smte 1, hrf 0
            'smt_1*smte_0_0': [0, 0, 1, 0],  # smt 1, smte 0, hrf 0
            'smt_1*smte_1_0': [0, 0, 0, 1],  # smt 1, smte 1, hrf 0
        })
        assert_dict_almost_equal(contrasts_2dd, level_cons)
        # Test max order >> 2, no error
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t, order=100)
        assert_almost_equal(X_2dd, np.c_[exp_x_0, exp_x_1, exp_x_2, exp_x_3])
        assert_dict_almost_equal(contrasts_2dd, exp_cons)
        # Test max order = 1
        X_2dd, contrasts_2dd = d_maker(spec_2dd, t, order=1)
        assert_almost_equal(X_2dd, np.c_[exp_x_0, exp_x_1, exp_x_2, exp_x_3])
        # No interaction
        assert_dict_almost_equal(contrasts_2dd,
                                {'constant_0': [1, 1, 1, 1],
                                'smt_0': [1, 1, -1, -1],  # main effect fac_1
                                'smte_0': [1, -1, 1, -1],  # main effect fac_2
                                })
    # events : test field called "time" is necessary
    spec_1d = make_recarray(zip(onsets, fac_1), ('brighteyes', 'smt'))
    assert_raises(ValueError, event_design, spec_1d, t)
    # blocks : test fields called "start" and "end" are necessary
    spec_1d = make_recarray(zip(onsets, offsets, fac_1),
                            ('mister', 'brighteyes', 'smt'))
    assert_raises(ValueError, block_design, spec_1d, t)
    spec_1d = make_recarray(zip(onsets, offsets, fac_1),
                            ('start', 'brighteyes', 'smt'))
    assert_raises(ValueError, block_design, spec_1d, t)
    spec_1d = make_recarray(zip(onsets, offsets, fac_1),
                            ('mister', 'end', 'smt'))
    assert_raises(ValueError, block_design, spec_1d, t)