diff --git a/brainiak/reconstruct/__init__.py b/brainiak/reconstruct/__init__.py
new file mode 100644
index 000000000..4f5675fd5
--- /dev/null
+++ b/brainiak/reconstruct/__init__.py
@@ -0,0 +1,14 @@
+#  Copyright 2018 David Huberdeau & Peter Kok
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Inverted encoding model for recreating continuous representations."""
diff --git a/brainiak/reconstruct/iem.py b/brainiak/reconstruct/iem.py
new file mode 100644
index 000000000..6e89d7bb8
--- /dev/null
+++ b/brainiak/reconstruct/iem.py
@@ -0,0 +1,458 @@
+#  Copyright 2018 David Huberdeau & Peter Kok
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+"""Inverted Encoding Model (IEM)
+
+    Method to decode and reconstruct features from data.
+
+    The implementation is roughly based on the following publications:
+
+    [Kok2013] "1.Kok, P., Brouwer, G. J., Gerven, M. A. J. van &
+    Lange, F. P. de. Prior Expectations Bias Sensory Representations
+    in Visual Cortex. J. Neurosci. 33, 16275–16284 (2013).
+
+    [Brouwer2011] "2.Brouwer, G. J. & Heeger, D. J. Cross-orientation
+    suppression in human visual cortex. J. Neurophysiol. 106(5):
+    2108-2119 (2011).
+
+    [Brouwer2009] "3.Brouwer, G. J. & Heeger, D. J.
+    Decoding and Reconstructing Color from Responses in Human Visual
+    Cortex. J. Neurosci. 29, 13992–14003 (2009).
+
+    This implementation uses a set of sinusoidal
+    basis functions to represent the set of possible feature values.
+    A feature value is some characteristic of a stimulus, e.g. the
+    angular location of a target along a horizontal line. This code was
+    written to give some flexibility compared to the specific instances
+    in Kok, 2013 & in Brouwer, 2009. Users can set the number of basis
+    functions, or channels, and the range of possible feature values.
+"""
+
+# Authors: David Huberdeau (Yale University) &
+# Peter Kok (Yale University), 2018 &
+# Vy Vo (Intel Corp., UCSD), 2019
+
+import logging
+import warnings
+import numpy as np
+import scipy.stats
+from sklearn.base import BaseEstimator
+from ..utils.utils import circ_dist
+
+__all__ = [
+    "InvertedEncoding",
+]
+
+logger = logging.getLogger(__name__)
+MAX_CONDITION_CHECK = 9000
+
+
+class InvertedEncoding(BaseEstimator):
+    """Basis function-based reconstruction method
+
+    Inverted encoding models (alternatively known as forward
+    models) are used to reconstruct a feature, e.g. color of
+    a stimulus, from patterns across voxels in functional
+    data. The model uses n_channels number of idealized
+    basis functions and assumes that the transformation from
+    stimulus feature (e.g. color) to basis function is one-
+    to-one and invertible. The response of a voxel is
+    expressed as the weighted sum of basis functions.
+    In this implementation, basis functions were half-wave
+    rectified sinusoid functions raised to a power set by
+    the user (e.g. 6).
+
+    The model:
+    Inverted encoding models reconstruct a stimulus feature from
+    patterns of BOLD activity by relating the activity in each
+    voxel, B, to the values of hypothetical channels (or basis
+    functions), C, according to Equation 1 below.
+
+    (1)     B = W*C
+
+    where W is a weight matrix that represents the relationship
+    between BOLD activity and Channels. W must be estimated from
+    training data; this implementation (and most described in the
+    literature) uses linear regression to estimate W as in Equation
+    2 below [note: inv() represents matrix inverse or
+    pseudo-inverse].
+
+    (2)     W_est = B_train*inv(C_train)
+
+    The weights in W_est (short for "estimated") represent the
+    contributions of each channel to the response of each voxel.
+    Estimated channel responses can be computed given W_est and
+    new voxel activity represented in matrix B_exp (short for
+    "experiment") through inversion of Equation 1:
+
+    (3)     C_est = inv(W_est)*B_exp
+
+    Given estimated channel responses, C_est, it is straighforward
+    to obtain the reconstructed feature value by summing over
+    channels multiplied by their channel responses and taking the
+    argmax (i.e. the feature associated with the maximum value).
+
+    Using this model:
+    Use fit() to estimate the weights of the basis functions given
+    input data (e.g. beta values from fMRI data). This function
+    will execute equation 2 above.
+
+    Use predict() to compute predicted stimulus values
+    from new functional data. This function computes estimated
+    channel responses, as in equation 3, then computes summed
+    channel output and finds the argmax (within the stimulus
+    feature space) associated with those responses.
+
+    Use score() to compute a measure of the error of the prediction
+    based on known stimuli.
+
+    This implementation assumes a circular (or half-
+    circular) feature domain. Future implementations might
+    generalize the feature input space, and increase the
+    possible dimensionality.
+
+    Parameters
+    ----------
+    n_channels: int, default 5. Number of channels
+        The number of channels, or basis functions, to be used in
+        the inverted encoding model.
+
+    channel_exp: int, default 6. Basis function exponent.
+        The exponent of the sinuoidal basis functions, which
+        establishes the width of the functions.
+
+    stimulus_mode: str, default 'halfcircular' (other option is
+        'circular'). Describes the feature domain.
+
+    range_start: double, default 0. Lowest value of domain.
+        Beginning value of range of independent variable
+        (usually degrees).
+
+    range_stop: double, default 180. Highest value of domain.
+        Ending value of range of independent variable
+        (usually degrees).
+
+    channel_density: int, default 180. Number of points in the
+        feature domain.
+
+    stimulus_resolution: double, default None will set the stimulus
+        resolution to be identical to the channel density. This sets
+        the resolution at which the stimuli were presented (e.g. a
+        spatial position with some width has a lower stimulus
+        resolution).
+
+    Attributes
+    ----------
+    channels_: [n_channels, channel density] NumPy 2D array
+        matrix defining channel values
+
+    W_: sklearn.linear_model model containing weight matrix that
+        relates estimated channel responses to response amplitude
+        data
+    """
+    def __init__(self, n_channels=6, channel_exp=5,
+                 stimulus_mode='halfcircular', range_start=0.,
+                 range_stop=180., channel_density=180,
+                 stimulus_resolution=None):
+        self.n_channels = n_channels
+        self.channel_exp = channel_exp
+        self.stimulus_mode = stimulus_mode
+        self.range_start = range_start
+        self.range_stop = range_stop
+        self.channel_density = channel_density
+        self.channel_domain = np.linspace(range_start, range_stop-1,
+                                          channel_density)
+        if stimulus_resolution is None:
+            self.stim_res = channel_density
+        else:
+            self.stim_res = stimulus_resolution
+        self._check_params()
+
+    def _check_params(self):
+        if self.range_start >= self.range_stop:
+            raise ValueError("range_start {} must be less than "
+                             "{} range_stop.".format(self.range_start,
+                                                     self.range_stop))
+        if self.stimulus_mode == 'halfcircular':
+            if (self.range_stop - self.range_start) != 180.:
+                raise ValueError("For half-circular feature spaces,"
+                                 "the range must be 180 degrees, "
+                                 "not {}".format(self.range_stop
+                                                 - self.range_start))
+        elif self.stimulus_mode == 'circular':
+            if (self.range_stop - self.range_start) != 360.:
+                raise ValueError("For circular feature spaces, the"
+                                 " range must be 360 degrees"
+                                 "not {}".format(self.range_stop
+                                                 - self.range_start))
+        if self.n_channels < 2:
+            raise ValueError("Insufficient number of channels.")
+        if not np.isin(self.stimulus_mode, ['circular',
+                                            'halfcircular']):
+            raise ValueError("Stimulus mode must be one of these: "
+                             "'circular', 'halfcircular'")
+
+    def fit(self, X, y):
+        """Use data and feature variable labels to fit an IEM
+
+        Parameters
+        ----------
+        X: numpy matrix of voxel activation data. [observations, voxels]
+            Should contain the beta values for each observation or
+            trial and each voxel of training data.
+        y: numpy array of response variable. [observations]
+            Should contain the feature for each observation in X.
+        """
+        # Check that data matrix is well conditioned:
+        if np.linalg.cond(X) > MAX_CONDITION_CHECK:
+            logger.error("Data is singular.")
+            raise ValueError("Data matrix is nearly singular.")
+        if X.shape[0] < self.n_channels:
+            logger.error("Not enough observations. Cannot calculate "
+                         "pseudoinverse.")
+            raise ValueError("Fewer observations (trials) than "
+                             "channels. Cannot compute pseudoinverse.")
+        # Check that the data matrix is the right size
+        shape_data = np.shape(X)
+        shape_labels = np.shape(y)
+        if len(shape_data) != 2:
+            raise ValueError("Data matrix has too many or too few "
+                             "dimensions.")
+        else:
+            if shape_data[0] != shape_labels[0]:
+                raise ValueError(
+                    "Mismatched data samples and label samples")
+
+        # Define the channels (or basis set)
+        self.channels_, channel_centers = self._define_channels()
+        logger.info("Defined channels centered at {} degrees."
+                    .format(np.rad2deg(channel_centers)))
+        # Create a matrix of channel activations for every observation.
+        # (i.e., C1 in Brouwer & Heeger 2009.)
+        C = self._define_trial_activations(y)
+        # Solve for W in B = WC
+        self.W_ = X.transpose() @ np.linalg.pinv(C.transpose())
+        if np.linalg.cond(self.W_) > MAX_CONDITION_CHECK:
+            logger.error("Weight matrix is nearly singular.")
+            raise ValueError("Weight matrix is nearly singular.")
+
+        return self
+
+    def predict(self, X):
+        """Use test data to predict the feature
+
+        Parameters
+        ----------
+            X: numpy matrix of voxel activation from test trials
+            [observations, voxels]. Used to predict feature
+            associated with the given observation.
+
+        Returns
+        -------
+            model_prediction: numpy array of estimated feature values.
+        """
+        # Check that the data matrix is the right size
+        shape_data = np.shape(X)
+        if len(shape_data) != 2:
+            raise ValueError("Data matrix has too many or too few "
+                             "dimensions.")
+
+        model_prediction = self._predict_features(X)
+
+        return model_prediction
+
+    def score(self, X, y):
+        """Calculate error measure of prediction. Default measurement
+        is R^2, the coefficient of determination.
+
+        Parameters
+        ----------
+            X: numpy matrix of voxel activation from new data
+                [observations,voxels]
+            y: numpy array of responses. [observations]
+
+        Returns
+        -------
+            score_value: the error measurement between the actual
+                feature and predicted features.
+        """
+        pred_features = self.predict(X)
+        if self.stimulus_mode == 'halfcircular':
+            # multiply features by 2. otherwise doesn't wrap properly
+            pred_features = pred_features * 2
+            y = y * 2
+
+        ssres = (circ_dist(np.deg2rad(y), np.deg2rad(pred_features))**2).sum()
+        sstot = (circ_dist(np.deg2rad(y),
+                           np.ones(y.size)*scipy.stats.circmean(np.deg2rad(y))
+                           ) ** 2).sum()
+        score_value = (1 - ssres/sstot)
+
+        return score_value
+
+    def get_params(self):
+        """Returns model parameters.
+
+        Returns
+        -------
+        params: parameter of this object
+        """
+        return{"n_channels": self.n_channels,
+               "channel_exp": self.channel_exp,
+               "stimulus_mode": self.stimulus_mode,
+               "range_start": self.range_start,
+               "range_stop": self.range_stop,
+               "channel_domain": self.channel_domain,
+               "stim_res": self.stim_res}
+
+    def set_params(self, **parameters):
+        """Sets model parameters after initialization.
+
+        Parameters
+        ----------
+            parameters: structure with parameters and change values
+        """
+        for parameter, value in parameters.items():
+            setattr(self, parameter, value)
+
+        setattr(self, "channel_domain",
+                np.linspace(self.range_start, self.range_stop - 1,
+                            self.channel_density))
+        self._check_params()
+        return self
+
+    def _define_channels(self):
+        """Define basis functions (aka channels).
+
+        Returns
+        -------
+            channels: numpy matrix of basis functions. dimensions are
+                [n_channels, function resolution].
+            channel_centers: numpy array of the centers of each channel
+        """
+        channel_centers = np.linspace(np.deg2rad(self.range_start),
+                                      np.deg2rad(self.range_stop),
+                                      self.n_channels + 1)
+        channel_centers = channel_centers[0:-1]
+        # make sure channels are not bimodal if using 360 deg space
+        if self.stimulus_mode == 'circular':
+            domain = self.channel_domain * 0.5
+            centers = channel_centers * 0.5
+        elif self.stimulus_mode == 'halfcircular':
+            domain = self.channel_domain
+            centers = channel_centers
+
+        # define exponentiated function
+        channels = np.asarray([np.cos(np.deg2rad(domain) - cx) **
+                               self.channel_exp
+                               for cx in centers])
+        # half-wave rectification preserving circularity
+        channels = abs(channels)
+
+        return channels, channel_centers
+
+    def _define_trial_activations(self, stimuli):
+        """Defines a numpy matrix of predicted channel responses for
+        each trial/observation.
+
+        Parameters
+
+            stimuli: numpy array of the feature values for each
+                observation (e.g., [0, 5, 15, 30, ...] degrees)
+
+        Returns
+        -------
+            C: matrix of predicted channel responses. dimensions are
+                number of observations by stimulus resolution
+        """
+        stim_axis = np.linspace(self.range_start, self.range_stop-1,
+                                self.stim_res)
+        if self.range_start > 0:
+            stimuli = stimuli + self.range_start
+        elif self.range_start < 0:
+            stimuli = stimuli - self.range_start
+        one_hot = np.eye(self.stim_res)
+        indices = [np.argmin(abs(stim_axis - x)) for x in stimuli]
+        stimulus_mask = one_hot[indices, :]
+        if self.channel_density != self.stim_res:
+            if self.channel_density % self.stim_res == 0:
+                stimulus_mask = np.repeat(stimulus_mask, self.channel_density /
+                                          self.stim_res)
+            else:
+                raise NotImplementedError("This code doesn't currently support"
+                                          " stimuli which are not square "
+                                          "functions in the feature domain, or"
+                                          " stimulus widths that are not even"
+                                          "divisors of the number of points in"
+                                          " the feature domain.")
+
+        C = stimulus_mask @ self.channels_.transpose()
+        # Check that C is full rank
+        if np.linalg.matrix_rank(C) < self.n_channels:
+            warnings.warn("Stimulus matrix is {}, not full rank. May cause "
+                          "issues with stimulus prediction/reconstruction."
+                          .format(np.linalg.matrix_rank(C)), RuntimeWarning)
+        return C
+
+    def _predict_channel_responses(self, X):
+        """Computes predicted channel responses from data
+        (e.g. C2 in Brouwer & Heeger 2009)
+
+        Parameters
+        ----------
+            X: numpy data matrix. [observations, voxels]
+
+        Returns
+        -------
+            channel_response: numpy matrix of channel responses
+        """
+        channel_response = np.matmul(np.linalg.pinv(self.W_),
+                                     X.transpose())
+        return channel_response
+
+    def _predict_feature_responses(self, X):
+        """Takes channel weights and transforms them into continuous
+        functions defined in the feature domain.
+
+        Parameters
+         ---------
+            X: numpy matrix of data. [observations, voxels]
+
+        Returns
+        -------
+            pred_response: predict response from all channels. Used
+                to predict feature (e.g. direction).
+        """
+        pred_response = np.matmul(self.channels_.transpose(),
+                                  self._predict_channel_responses(X))
+        return pred_response
+
+    def _predict_features(self, X):
+        """Predicts feature value (e.g. direction) from data in X.
+        Takes the maximum of the 'reconstructed' or predicted response
+        function.
+
+        Parameters
+         ---------
+            X: numpy matrix of data. [observations, voxels]
+
+        Returns
+        -------
+            pred_features: predicted feature from response across all
+                channels.
+        """
+        pred_response = self._predict_feature_responses(X)
+        feature_ind = np.argmax(pred_response, 0)
+        pred_features = self.channel_domain[feature_ind]
+
+        return pred_features
diff --git a/brainiak/utils/fmrisim.py b/brainiak/utils/fmrisim.py
index 5261f484c..8283a17b8 100644
--- a/brainiak/utils/fmrisim.py
+++ b/brainiak/utils/fmrisim.py
@@ -102,6 +102,8 @@
     "generate_stimfunction",
     "generate_noise",
     "mask_brain",
+    "generate_1d_gaussian_rfs",
+    "generate_1d_rf_responses",
 ]
 
 logger = logging.getLogger(__name__)
@@ -2960,3 +2962,121 @@ def compute_signal_change(signal_function,
 
     # Return the scaled time course
     return signal_function_scaled
+
+
+def generate_1d_gaussian_rfs(n_voxels, feature_resolution, feature_range,
+                             rf_size=15, random_tuning=True, rf_noise=0.):
+    """
+    Creates a numpy matrix of Gaussian-shaped voxel receptive fields (RFs)
+    along one dimension. Can specify whether they are evenly tiled or randomly
+    tuned along the axis. RF range will be between 0 and 1.
+
+    Parameters
+    ----------
+
+    n_voxels : int
+        Number of voxel RFs to create.
+
+    feature_resolution : int
+        Number of points along the feature axis.
+
+    feature_range : tuple (numeric)
+        A tuple indicating the start and end values of the feature range. e.g.
+        (0, 359) for motion directions.
+
+    rf_size : numeric
+        Width of the Gaussian receptive field. Should be given in units of the
+        feature dimension. e.g., 15 degrees wide in motion direction space.
+
+    random_tuning : boolean [default True]
+        Indicates whether or not the voxels are randomly tuned along the 1D
+        feature axis or whether tuning is evenly spaced.
+
+    rf_noise : float [default 0.]
+        Amount of uniform noise to add to the Gaussian RF. This will cause the
+        generated responses to be distorted by the same uniform noise for a
+        given voxel.
+
+    Returns
+    ----------
+
+    voxel_rfs : 2d numpy array (float)
+        The receptive fields in feature space. Dimensions are n_voxels by
+        feature_resolution.
+
+    voxel_tuning : 1d numpy array (float)
+        The centers of the voxel RFs, in feature space.
+
+    """
+    range_start, range_stop = feature_range
+    if random_tuning:
+        # Voxel selectivity is random
+        voxel_tuning = np.floor((np.random.rand(n_voxels) * range_stop)
+                                + range_start).astype(int)
+    else:
+        # Voxel selectivity is evenly spaced along the feature axis
+        voxel_tuning = np.linspace(range_start, range_stop, n_voxels + 1)
+        voxel_tuning = voxel_tuning[0:-1]
+        voxel_tuning = np.floor(voxel_tuning).astype(int)
+    gaussian = signal.gaussian(feature_resolution, rf_size)
+    voxel_rfs = np.zeros((n_voxels, feature_resolution))
+    for i in range(0, n_voxels):
+        voxel_rfs[i, :] = np.roll(gaussian, voxel_tuning[i] -
+                                  ((feature_resolution // 2) - 1))
+    voxel_rfs += np.random.rand(n_voxels, feature_resolution) * rf_noise
+    voxel_rfs = voxel_rfs / np.max(voxel_rfs, axis=1)[:, None]
+
+    return voxel_rfs, voxel_tuning
+
+
+def generate_1d_rf_responses(rfs, trial_list, feature_resolution,
+                             feature_range, trial_noise=0.25):
+    """
+    Generates trial-wise data for a given set of receptive fields (RFs) and
+    a 1d array of features presented across trials.
+
+    Parameters
+    ----------
+
+    voxel_rfs : 2d numpy array (float)
+        The receptive fields in feature space. Dimensions must be n_voxels
+        by feature_resolution.
+
+    trial_list : 1d numpy array (numeric)
+        The feature value of the stimulus presented on individual trials.
+        Array size be n_trials.
+
+    feature_resolution : int
+        Number of points along the feature axis.
+
+    feature_range : tuple (numeric)
+        A tuple indicating the start and end values of the feature range. e.g.
+        (0, 359) for motion directions.
+
+    trial_noise : float [default 0.25]
+        Amount of uniform noise to inject into the synthetic data. This is
+        generated independently for every trial and voxel.
+
+    Returns
+    ----------
+
+    trial_data : 2d numpy array (float)
+        The synthetic data for each voxel and trial. Dimensions are n_voxels by
+        n_trials.
+
+    """
+    range_start, range_stop = feature_range
+    stim_axis = np.linspace(range_start, range_stop,
+                            feature_resolution)
+    if range_start > 0:
+        trial_list = trial_list + range_start
+    elif range_start < 0:
+        trial_list = trial_list - range_start
+    one_hot = np.eye(feature_resolution)
+    indices = [np.argmin(abs(stim_axis - x)) for x in trial_list]
+    stimulus_mask = one_hot[:, indices]
+    trial_data = rfs @ stimulus_mask
+    trial_data += np.random.rand(rfs.shape[0], trial_list.size) * \
+        (trial_noise * np.max(trial_data))
+
+    return trial_data
diff --git a/brainiak/utils/utils.py b/brainiak/utils/utils.py
index 9d4de29a8..343887003 100644
--- a/brainiak/utils/utils.py
+++ b/brainiak/utils/utils.py
@@ -43,6 +43,27 @@
 ]
 
 
+def circ_dist(x, y):
+    """
+    Computes the pairwise circular distance between two arrays of
+    points (in radians).
+
+    Parameters
+    ----------
+        x: numpy vector of positions on a circle, in radians.
+        y: numpy vector of positions on a circle, in radians.
+
+    Returns
+    -------
+        r: numpy vector of distances between inputs.
+    """
+    if x.size != y.size:
+        raise ValueError("Input sizes must match to compute pairwise "
+                         "comparisons.")
+    r = np.angle(np.exp(x*1j) / np.exp(y*1j))
+    return r
+
+
 def from_tri_2_sym(tri, dim):
     """convert a upper triangular matrix in 1D format
        to 2D symmetric matrix
diff --git a/examples/reconstruct/iem_example_synthetic_RF_data.ipynb b/examples/reconstruct/iem_example_synthetic_RF_data.ipynb
new file mode 100644
index 000000000..95c43f09c
--- /dev/null
+++ b/examples/reconstruct/iem_example_synthetic_RF_data.ipynb
@@ -0,0 +1,462 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "from brainiak.reconstruct import iem as IEM\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy.matlib as matlib\n",
+    "import scipy.signal"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this example, we will assume that the stimuli are patches of different motion directions. These stimuli span a 360-degree, circular feature space. We will build an encoding model that has 6 channels, or basis functions, which also span this feature space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up parameters\n",
+    "n_channels = 6\n",
+    "cos_exponent = 5\n",
+    "range_start = 0\n",
+    "\n",
+    "range_stop = 360\n",
+    "feature_resolution = 360\n",
+    "iem_obj = IEM.InvertedEncoding(n_channels, cos_exponent, stimulus_mode='circular', range_start=range_start, \n",
+    "                               range_stop=range_stop, channel_density=feature_resolution)\n",
+    "\n",
+    "# You can also try the half-circular space. Here's the associated code:\n",
+    "# range_stop = 180  # since 0 and 360 degrees are the same, we want to stop shy of 360\n",
+    "# feature_resolution = 180\n",
+    "# iem_obj = IEM.InvertedEncoding(n_channels, cos_exponent, stimulus_mode='halfcircular', range_start=range_start, \n",
+    "#                                range_stop=range_stop, channel_density=feature_resolution, verbose=True)\n",
+    "\n",
+    "stim_vals = np.linspace(0, feature_resolution - (feature_resolution/6), 6).astype(int)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we'll generate synthetic data. Ideally, each voxel that we measure from is roughly tuned to some part of the feature space (see Sprague, Boynton, Serences, 2019). So we will generate data that has a receptive field (RF). We can define the RF along the same feature axis as the channels that we generated above.\n",
+    "\n",
+    "The following two functions will generate the voxel RFs, and then generate several trials of that dataset. There are options to add uniform noise to either the RF or the trials."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate synthetic data s.t. each voxel has a Gaussian tuning function\n",
+    "\n",
+    "def generate_voxel_RFs(n_voxels, feature_resolution, random_tuning=True, RF_noise=0.):\n",
+    "    if random_tuning:\n",
+    "        # Voxel selectivity is random\n",
+    "        voxel_tuning = np.floor((np.random.rand(n_voxels) * range_stop) + range_start).astype(int)\n",
+    "    else:\n",
+    "        # Voxel selectivity is evenly spaced along the feature axis\n",
+    "        voxel_tuning = np.linspace(range_start, range_stop, n_voxels+1)\n",
+    "        voxel_tuning = voxel_tuning[0:-1]\n",
+    "        voxel_tuning = np.floor(voxel_tuning).astype(int)\n",
+    "    gaussian = scipy.signal.gaussian(feature_resolution, 15)\n",
+    "    voxel_RFs = np.zeros((n_voxels, feature_resolution))\n",
+    "    for i in range(0, n_voxels):\n",
+    "        voxel_RFs[i, :] = np.roll(gaussian, voxel_tuning[i] - ((feature_resolution//2)-1))\n",
+    "    voxel_RFs += np.random.rand(n_voxels, feature_resolution)*RF_noise  # add noise to voxel RFs\n",
+    "    voxel_RFs = voxel_RFs / np.max(voxel_RFs, axis=1)[:, None]\n",
+    "    \n",
+    "    return voxel_RFs, voxel_tuning\n",
+    "\n",
+    "\n",
+    "def generate_voxel_data(voxel_RFs, n_voxels, trial_list, feature_resolution, \n",
+    "                         trial_noise=0.25):\n",
+    "    one_hot = np.eye(feature_resolution)\n",
+    "    # Generate trial-wise responses based on voxel RFs\n",
+    "    if range_start > 0:\n",
+    "        trial_list = trial_list + range_start\n",
+    "    elif range_start < 0:\n",
+    "        trial_list = trial_list - range_start\n",
+    "    stim_X = one_hot[:, trial_list] #@ basis_set.transpose()\n",
+    "    trial_data = voxel_RFs @ stim_X\n",
+    "    trial_data += np.random.rand(n_voxels, trial_list.size)*(trial_noise*np.max(trial_data))\n",
+    "    \n",
+    "    return trial_data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now let's generate some training data and look at it. This code will create a plot that depicts the response of an example voxel for different trials."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "71.69981024125089\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0.98, 'Simulated data from each voxel')"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "np.random.seed(100)\n",
+    "n_voxels = 50\n",
+    "n_train_trials = 120\n",
+    "training_stim = np.repeat(stim_vals, n_train_trials/6)\n",
+    "voxel_RFs, voxel_tuning = generate_voxel_RFs(n_voxels, feature_resolution, random_tuning=False, RF_noise=0.1)\n",
+    "train_data = generate_voxel_data(voxel_RFs, n_voxels, training_stim, feature_resolution, trial_noise=0.25)\n",
+    "print(np.linalg.cond(train_data))\n",
+    "# print(\"Voxels are tuned to: \", voxel_tuning)\n",
+    "\n",
+    "# Generate plots to look at the RF of an example voxel.\n",
+    "voxi = 20\n",
+    "f = plt.figure()\n",
+    "plt.subplot(1, 2, 1)\n",
+    "plt.plot(train_data[voxi, :])\n",
+    "plt.xlabel(\"trial\")\n",
+    "plt.ylabel(\"activation\")\n",
+    "plt.title(\"Activation over trials\")\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.plot(voxel_RFs[voxi, :])\n",
+    "plt.xlabel(\"degrees (motion direction)\")\n",
+    "plt.axvline(voxel_tuning[voxi])\n",
+    "plt.title(\"Receptive field at {} deg\".format(voxel_tuning[voxi]))\n",
+    "plt.suptitle(\"Example voxel\")\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.imshow(train_data)\n",
+    "plt.ylabel('voxel')\n",
+    "plt.xlabel('trial')\n",
+    "plt.suptitle('Simulated data from each voxel')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Using this synthetic training data, we can fit the IEM."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Defined channels centered at [  0.  60. 120. 180. 240. 300.] degrees.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "InvertedEncoding(channel_exp=5, n_channels=6, range_start=0, range_stop=360)"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Fit an IEM\n",
+    "iem_obj.fit(train_data.transpose(), training_stim)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Calling the IEM fit method defines the channels, or the basis set, which span the feature domain. We can examine the channels and plot them to check that they look appropriate.\n",
+    "\n",
+    "Remember that the plot below is in circular space. Hence, the channels wrap around the x-axis. For example, the channel depicted in blue is centered at 0 degrees (far left of plot), which is the same as 360 degrees (far right of plot).\n",
+    "\n",
+    "We can check whether the channels properly tile the feature space by summing across all of them. This is shown on the right plot. It should be a straight horizontal line."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(6, 360)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Sum across channels')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 2 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Let's visualize the basis functions.\n",
+    "channels = iem_obj.channels_\n",
+    "feature_axis = iem_obj.channel_domain\n",
+    "print(channels.shape)\n",
+    "\n",
+    "plt.figure()\n",
+    "plt.subplot(1, 2, 1)\n",
+    "for i in range(0, channels.shape[0]):\n",
+    "    plt.plot(feature_axis, channels[i,:])\n",
+    "plt.title('Channels (i.e. basis functions)')\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.plot(np.sum(channels, 0))\n",
+    "plt.ylim(0, 2.5)\n",
+    "plt.title('Sum across channels')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can generate test data and see how well we can predict the test stimuli."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate test data\n",
+    "n_test_trials = 12\n",
+    "test_stim = np.repeat(stim_vals, n_test_trials/len(stim_vals))\n",
+    "np.random.seed(330)\n",
+    "test_data = generate_voxel_data(voxel_RFs, n_voxels, test_stim, feature_resolution, trial_noise=0.25)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Predicted features are: [  0.   5.  59.  60. 123. 120. 178. 181. 239. 239. 300. 300.] degrees.\n",
+      "Actual features are: [  0   0  60  60 120 120 180 180 240 240 300 300] degrees.\n",
+      "Test R^2 is 0.9996666666666667\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Predict test stim & get R^2 score\n",
+    "pred_feature = iem_obj.predict(test_data.transpose())\n",
+    "R2 = iem_obj.score(test_data.transpose(), test_stim)\n",
+    "\n",
+    "print(\"Predicted features are: {} degrees.\".format(pred_feature))\n",
+    "print(\"Actual features are: {} degrees.\".format(test_stim))\n",
+    "print(\"Test R^2 is {}\".format(R2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In addition to predicting the exact feature, we can examine the model-based reconstructions in the feature domain. That is, instead of getting single predicted values for each feature, we can look at a reconstructed function which peaks at the predicted feature.\n",
+    "\n",
+    "Below we will plot all of the reconstructions. There will be some variability because of the noise added during the synthetic data generation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Reconstructions of [  0  60 120 180 240 300] degrees')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Now get the model-based reconstructions, which are continuous\n",
+    "# functions that should peak at each test stimulus feature\n",
+    "recons = iem_obj._predict_feature_responses(test_data.transpose())\n",
+    "\n",
+    "f = plt.figure()\n",
+    "for i in range(0, n_test_trials-1):\n",
+    "    plt.plot(feature_axis, recons[:, i])\n",
+    "for i in stim_vals:\n",
+    "    plt.axvline(x=i, color='k', linestyle='--')\n",
+    "\n",
+    "plt.title(\"Reconstructions of {} degrees\".format(np.unique(test_stim)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For a sanity check, let's check how R^2 changes as the number of voxels increases. We can write a quick wrapper function to train and test on a given set of motion directions, as below."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "iem_obj.verbose = False\n",
+    "def train_and_test(nvox, ntrn, ntst, rfn, tn):\n",
+    "    vRFs, vox_tuning = generate_voxel_RFs(nvox, feature_resolution, random_tuning=True, RF_noise=rfn)\n",
+    "    trn = np.repeat(stim_vals, ntrn/6).astype(int)\n",
+    "    trnd = generate_voxel_data(vRFs, nvox, trn, feature_resolution, trial_noise=tn)\n",
+    "    tst = np.repeat(stim_vals, ntst/6).astype(int)\n",
+    "    tstd = generate_voxel_data(vRFs, nvox, tst, feature_resolution, trial_noise=tn)\n",
+    "    \n",
+    "    iem_obj.fit(trnd.transpose(), trn)\n",
+    "    recons = iem_obj._predict_feature_responses(tstd.transpose())\n",
+    "    pred_ori = iem_obj.predict(tstd.transpose())\n",
+    "    R2 = iem_obj.score(tstd.transpose(), tst)\n",
+    "\n",
+    "    return recons, pred_ori, R2, tst"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We'll iterate through the list and look at the resulting R^2 values."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "The R2 values for increasing numbers of voxels: \n",
+      "[0.2661696  0.69445782 0.99524836 0.99806822 0.99877928]\n"
+     ]
+    }
+   ],
+   "source": [
+    "np.random.seed(300)\n",
+    "vox_list = (5, 10, 15, 25, 50)\n",
+    "R2_list = np.zeros(len(vox_list))\n",
+    "for idx, nvox in enumerate(vox_list):\n",
+    "    recs, preds, R2_list[idx], test_features = train_and_test(nvox, 120, 30, 0.1, 0.25)\n",
+    "\n",
+    "print(\"The R2 values for increasing numbers of voxels: \")\n",
+    "print(R2_list)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/tests/reconstruct/test_iem.py b/tests/reconstruct/test_iem.py
new file mode 100644
index 000000000..4370dc827
--- /dev/null
+++ b/tests/reconstruct/test_iem.py
@@ -0,0 +1,234 @@
+#  Copyright 2018 David Huberdeau & Peter Kok
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import pytest
+import numpy as np
+import logging
+from brainiak.reconstruct.iem import InvertedEncoding
+from brainiak.utils.fmrisim import generate_1d_gaussian_rfs, \
+    generate_1d_rf_responses
+from scipy.stats import circmean
+
+logger = logging.getLogger(__name__)
+
+
+# Simple test: can an instance be instantiated?
+def test_can_instantiate():
+    s = InvertedEncoding()
+    assert s, "Invalid InvertedEncoding instance"
+
+
+# Simple test for checking range values.
+def test_instantiate_improper_range():
+    with pytest.raises(ValueError):
+        s = InvertedEncoding(6, 5, 'halfcircular', range_start=20,
+                             range_stop=0)
+        assert s, "Invalid InvertedEncoding instance"
+
+
+# Test to check stimulus resolution input
+def test_stimulus_resolution():
+    s = InvertedEncoding(6, 5, stimulus_resolution=360)
+    assert s.stim_res == 360
+
+
+# Provide invalid data so that channels cannot be created.
+def test_cannot_instantiate_channels():
+    with pytest.raises(ValueError):
+        s = InvertedEncoding(n_channels=0)
+        assert s, "Invalid InvertedEncoding instance"
+
+
+# Provide invalid stimulus mode
+def test_stimulus_mode():
+    with pytest.raises(ValueError):
+        s = InvertedEncoding(6, 5, 'random')
+        assert s, "Invalid InvertedEncoding instance"
+
+
+# Provide mismatching range and stimulus_mode input
+def test_range_stimulus_mode_circ():
+    with pytest.raises(ValueError):
+        s = InvertedEncoding(6, 5, 'circular', 0, 180)
+        assert s, "Invalid InvertedEncoding instance"
+
+
+# Provide mismatching range & stimulus mode, with half circular
+def test_range_stimulus_mode_halfcirc():
+    with pytest.raises(ValueError):
+        s = InvertedEncoding(6, 5, 'halfcircular', -10, 350)
+        assert s, "Invalid InvertedEncoding instance"
+
+
+# Test for n_observations < n_channels
+def test_data_amount():
+    x = np.random.rand(5, 1000)
+    s = InvertedEncoding()
+    with pytest.raises(ValueError):
+        s.fit(x, np.random.rand(5))
+        assert s, "Invalid data"
+
+
+# Test number of data dimensions
+def test_data_dimensions():
+    x = np.random.rand(5, 10, 2)
+    s = InvertedEncoding()
+    with pytest.raises(ValueError):
+        s.fit(x, np.random.rand(5))
+
+
+# Define some data to use in the following tests.
+n, dim = 297, 9
+n_ = n // dim
+y = np.repeat(np.linspace(0, 180-(180/dim), dim), n_)
+voxel_rfs, _ = generate_1d_gaussian_rfs(dim, 180, (0, 179),
+                                        random_tuning=False)
+X = generate_1d_rf_responses(voxel_rfs, y, 180, (0, 179),
+                             trial_noise=0.25).transpose()
+X2 = generate_1d_rf_responses(voxel_rfs, y, 180, (0, 179),
+                              trial_noise=0.25).transpose()
+
+
+# Test if valid data can be fit.
+def test_can_fit_data():
+    Invt_model = InvertedEncoding()
+    Invt_model.fit(X, y)
+
+
+# Test if valid data can be fit in circular space.
+def test_can_fit_circular_space():
+    s = InvertedEncoding(6, 5, 'circular', range_stop=360)
+    s.fit(X, y)
+
+
+# Show that a data matrix with improper format (dimensions) breaks the
+# algorithm.
+def test_cannot_fit_data():
+    with pytest.raises(ValueError):
+        Invt_model = InvertedEncoding()
+        Invt_model.fit(X.transpose(), y)
+
+
+def test_ill_conditioned_train_data():
+    Invt_model = InvertedEncoding()
+    with pytest.raises(ValueError):
+        X = np.array([[0, 0, 0], [1, 1, 1]])
+        Invt_model.fit(X, np.array([0, 0, 0]))
+
+
+# Test case if data dimensions are wrong
+def test_extra_data_dimensions():
+    with pytest.raises(ValueError):
+        n, dim1, dim2 = 300, 3, 3
+        X = np.random.rand(n//3, dim1, dim2)
+        Invt_model = InvertedEncoding()
+        Invt_model.fit(X, y)
+
+
+# Test case when # of observations are not matched btwn data & labels
+def test_mismatched_observations():
+    with pytest.raises(ValueError):
+        Invt_model = InvertedEncoding()
+        Invt_model.fit(X, y[:-50])
+
+
+# Test prediction capability from valid (fabricated) data
+def test_can_predict_from_data():
+    Invt_model = InvertedEncoding()
+    Invt_model.fit(X, y)
+    m_reconstruct = []
+    for j in np.arange(dim):
+        preds = Invt_model.predict(X2[n_*j:n_*(j+1), :])
+        tmp = circmean(np.deg2rad(preds))
+        m_reconstruct.append(np.rad2deg(tmp))
+    logger.info('Reconstructed angles: ' + str(m_reconstruct))
+
+
+# Show that prediction is invalid when input data is wrong size
+def test_cannot_predict_from_data():
+    Invt_model = InvertedEncoding()
+    Invt_model.fit(X, y)
+    with pytest.raises(ValueError):
+        _ = Invt_model.predict(X2[0:n_, :].transpose())
+
+
+# Show proper scoring function with valid (fabricated) test data
+def test_can_score():
+    Invt_model = InvertedEncoding()
+    Invt_model.fit(X, y)
+    score = Invt_model.score(X2, y)
+    logger.info('Scores: ' + str(score))
+
+
+# Test scoring with invalid data formatting
+def test_cannot_score():
+    with pytest.raises(ValueError):
+        Invt_model = InvertedEncoding()
+        Invt_model.fit(X, y)
+        score = Invt_model.score(X2.transpose(), y)
+        logger.info('Scores: ' + str(score))
+
+
+# Test stimulus resolution that is not even multiple
+def test_stimulus_resolution_odd():
+    Invt_model = InvertedEncoding(stimulus_resolution=59)
+    with pytest.raises(NotImplementedError):
+        Invt_model.fit(X, y)
+
+
+# Test stimulus masking
+def test_stimulus_mask():
+    Invt_model = InvertedEncoding(6, 5, range_start=-10,
+                                  range_stop=170,
+                                  stimulus_resolution=60)
+    chans, _ = Invt_model._define_channels()
+    Invt_model.set_params(channels_=chans)
+    with pytest.warns(RuntimeWarning):
+        C = Invt_model._define_trial_activations(np.array([50]))
+        tmp_C = np.repeat([0, 1, 0], 60) @ chans.transpose()
+        assert np.all((C - tmp_C) < 1e-7)
+
+
+# Test stimulus masking with different range
+def test_stimulus_mask_shift_positive():
+    Invt_model = InvertedEncoding(6, 5, range_start=10,
+                                  range_stop=190,
+                                  stimulus_resolution=60)
+    chans, _ = Invt_model._define_channels()
+    Invt_model.set_params(channels_=chans)
+    with pytest.warns(RuntimeWarning):
+        C = Invt_model._define_trial_activations(np.array([70]))
+        tmp_C = np.repeat([0, 1, 0], 60) @ chans.transpose()
+        assert np.all((C - tmp_C) < 1e-7)
+
+
+# Test ability to get model parameters from object
+def test_can_get_params():
+    s = InvertedEncoding()
+    param_out = s.get_params()
+    logger.info('Returned Parameters: ' +
+                str(param_out.get('n_channels')) +
+                ', ' + str(param_out.get('range_start')) +
+                ', ' + str(param_out.get('range_stop')))
+
+
+# Test ability to set model parameters of an object instance
+def test_can_set_params():
+    s = InvertedEncoding()
+    s.set_params(n_channels=10,
+                 stimulus_mode='circular',
+                 range_start=-90,
+                 range_stop=270,
+                 channel_exp=4,
+                 verbose=False)
diff --git a/tests/utils/test_fmrisim.py b/tests/utils/test_fmrisim.py
index 7c442661a..2cfb3b8e3 100644
--- a/tests/utils/test_fmrisim.py
+++ b/tests/utils/test_fmrisim.py
@@ -856,3 +856,39 @@ def test_calc_noise():
                                 sample_num=2,
                                 )
     assert len(arma) == 2, "Two outputs not given by ARMA"
+
+
+def test_gen_1D_gauss_shape():
+    n_vox = 10
+    res = 180
+    rfs, centers = sim.generate_1d_gaussian_rfs(n_vox, res, (0, res-1))
+    assert rfs.shape == (n_vox, res)
+    assert centers.size == n_vox
+
+    sim_data = sim.generate_1d_rf_responses(rfs, np.array([0, 10, 20]), res,
+                                            (0, res-1))
+    assert sim_data.shape == (n_vox, 3)
+
+
+def test_gen_1d_gauss_range():
+    res = 180
+    range_values = (-10, res-11)
+    rfs, centers = sim.generate_1d_gaussian_rfs(1, res, range_values,
+                                                random_tuning=False)
+    sim_data = sim.generate_1d_rf_responses(rfs, np.array([-10]), res,
+                                            range_values, 0)
+    assert sim_data[0, ] > 0
+    range_values = (10, res+10)
+    rfs, centers = sim.generate_1d_gaussian_rfs(1, res, range_values,
+                                                random_tuning=False)
+    sim_data = sim.generate_1d_rf_responses(rfs, np.array([10]), res,
+                                            range_values, 0)
+    assert sim_data[0, ] > 0
+
+
+def test_gen_1D_gauss_even_spacing():
+    n_vox = 9
+    res = 180
+    rfs, centers = sim.generate_1d_gaussian_rfs(n_vox, res, (0, res-1),
+                                                random_tuning=False)
+    assert np.all(centers == np.array([0, 19, 39, 59, 79, 99, 119, 139, 159]))