'Evaluate this model using the given input(s) and the parameter values
that were specified when the model was instantiated.'

def __call__(self, *inputs, **kwargs):

    (inputs, format_info) = self.prepare_inputs(*inputs, **kwargs)
    inputs_are_quantity = any([isinstance(i, Quantity) for i in inputs])
    parameters = self._param_sets(raw=True, units=True)
    with_bbox = kwargs.pop(u'with_bounding_box', False)
    fill_value = kwargs.pop(u'fill_value', np.nan)
    bbox = None
    if with_bbox:
        try:
            bbox = self.bounding_box
        except NotImplementedError:
            bbox = None
        if ((self.n_inputs > 1) and (bbox is not None)):
            bbox = bbox[::(-1)]
        if (bbox is None):
            outputs = self.evaluate(*chain(inputs, parameters))
        else:
            if (self.n_inputs == 1):
                bbox = [bbox]
            nan_ind = np.zeros(inputs[0].shape, dtype=np.bool)
            for (ind, inp) in enumerate(inputs):
                axis_ind = np.zeros(inp.shape, dtype=np.bool)
                axis_ind = np.logical_or((inp < bbox[ind][0]), (inp > bbox[ind][1]), out=axis_ind)
                nan_ind[axis_ind] = 1
            valid_ind = np.logical_not(nan_ind).nonzero()
            args = []
            for input in inputs:
                if (not input.shape):
                    if nan_ind:
                        outputs = [fill_value for a in args]
                    else:
                        args.append(input)
                else:
                    args.append(input[valid_ind])
            valid_result = self.evaluate(*chain(args, parameters))
            if (self.n_outputs == 1):
                valid_result = [valid_result]
            result = [(np.zeros(inputs[0].shape) + fill_value) for i in range(len(valid_result))]
            for (ind, r) in enumerate(valid_result):
                if (not result[ind].shape):
                    result[ind] = r
                else:
                    result[ind][valid_ind] = r
            if (self.n_outputs == 1):
                outputs = np.asarray(result[0])
            else:
                outputs = [np.asarray(r) for r in result]
    else:
        outputs = self.evaluate(*chain(inputs, parameters))
    if (self.n_outputs == 1):
        outputs = (outputs,)
    outputs = self.prepare_outputs(format_info, *outputs, **kwargs)
    if (self.return_units and inputs_are_quantity):
        if ((self.n_outputs == 1) and (not isiterable(self.return_units))):
            return_units = {self.outputs[0]: self.return_units}
        else:
            return_units = self.return_units
        outputs = tuple([Quantity(out, return_units[out_name], subok=True) for (out, out_name) in zip(outputs, self.outputs)])
    if (self.n_outputs == 1):
        return outputs[0]
    else:
        return outputs
