get a dataframe the posterior uncertainty
        as a result of losing some observations

        Parameters
        ----------
        obslist_dict : dict
            dictionary of groups of observations
            that are to be treated as lost.  key values become
            row labels in returned dataframe. If None, then test every
            (nonzero weight - see reset_zero_weight) observation
        reset_zero_weight : bool or float
            a flag to reset observations with zero weight in obslist_dict.
            If the value of reset_zero_weights can be cast to a float,
            then that value will be assigned to zero weight obs.  Otherwise,
            zero weight obs will be given a weight of 1.0

        Returns
        -------
        pandas.DataFrame : pandas.DataFrame
            a dataframe with index of obslist_dict.keys() and columns
            of forecast names.  The values in the dataframe are the posterior
            variances of the forecasts resulting from losing the information
            contained in obslist_dict[key value]

        Note
        ----
        all observations listed in obslist_dict with zero
        weights will be dropped unless reset_zero_weight is set

        Example
        -------
        ``>>>import pyemu``

        ``>>>sc = pyemu.Schur(jco="pest.jcb")``

        ``df = sc.get_removed_obs_importance()``

def get_removed_obs_importance(self,obslist_dict=None,
                                   reset_zero_weight=False):
        """get a dataframe the posterior uncertainty
        as a result of losing some observations

        Parameters
        ----------
        obslist_dict : dict
            dictionary of groups of observations
            that are to be treated as lost.  key values become
            row labels in returned dataframe. If None, then test every
            (nonzero weight - see reset_zero_weight) observation
        reset_zero_weight : bool or float
            a flag to reset observations with zero weight in obslist_dict.
            If the value of reset_zero_weights can be cast to a float,
            then that value will be assigned to zero weight obs.  Otherwise,
            zero weight obs will be given a weight of 1.0

        Returns
        -------
        pandas.DataFrame : pandas.DataFrame
            a dataframe with index of obslist_dict.keys() and columns
            of forecast names.  The values in the dataframe are the posterior
            variances of the forecasts resulting from losing the information
            contained in obslist_dict[key value]

        Note
        ----
        all observations listed in obslist_dict with zero
        weights will be dropped unless reset_zero_weight is set

        Example
        -------
        ``>>>import pyemu``

        ``>>>sc = pyemu.Schur(jco="pest.jcb")``

        ``df = sc.get_removed_obs_importance()``

        """


        if obslist_dict is not None:
            if type(obslist_dict) == list:
                obslist_dict = dict(zip(obslist_dict,obslist_dict))

        elif reset_zero_weight is False and self.pst.nnz_obs == 0:
            raise Exception("not resetting weights and there are no non-zero weight obs to remove")

        reset = False
        if reset_zero_weight is not False:
            if not self.obscov.isdiagonal:
                raise NotImplementedError("cannot reset weights for non-"+\
                                          "diagonal obscov")
            reset = True
            try:
                weight = float(reset_zero_weight)
            except:
                weight = 1.0
            self.logger.statement("resetting zero weights to {0}".format(weight))
            # make copies of the original obscov and pst
            org_obscov = self.obscov.get(self.obscov.row_names)
            org_pst = self.pst.get()

        self.log("calculating importance of observations")
        if reset and obslist_dict is None:
            obs = self.pst.observation_data
            onames = [name for name in self.pst.zero_weight_obs_names
                      if name in self.jco.obs_names and name in self.obscov.row_names]
            obs.loc[onames,"weight"] = weight

        if obslist_dict is None:
            obslist_dict = dict(zip(self.pst.nnz_obs_names,
                                        self.pst.nnz_obs_names))


        elif reset:
            self.pst.observation_data.index = self.pst.observation_data.obsnme
            for name,obslist in obslist_dict.items():
                self.log("resetting weights in obs in group {0}".format(name))
                self.pst._adjust_weights_by_list(obslist,weight)
                self.log("resetting weights in obs in group {0}".format(name))

        for case,obslist in obslist_dict.items():
            if not isinstance(obslist,list):
                obslist = [obslist]
            obslist_dict[case] = obslist


        if reset:
            self.log("resetting self.obscov")
            self.reset_obscov(self.pst)
            self.log("resetting self.obscov")

        results = {}
        names = ["base"]
        for forecast,pt in self.posterior_forecast.items():
            results[forecast] = [pt]
        for case_name,obslist in obslist_dict.items():
            if not isinstance(obslist,list):
                obslist = [obslist]
            names.append(case_name)
            self.log("calculating importance of observations by removing: " +
                     str(obslist) + '\n')
            # check for missing names
            missing_onames = [oname for oname in obslist if oname not in self.jco.obs_names]
            if len(missing_onames) > 0:
                raise Exception("case {0} has observation names ".format(case_name) + \
                                "not found: " + ','.join(missing_onames))
            # find the set difference between obslist and jco obs names
            #diff_onames = [oname for oname in self.jco.obs_names if oname not in obslist]
            diff_onames = [oname for oname in self.nnz_obs_names if oname not in obslist and oname not in self.forecast_names]


            # calculate the increase in forecast variance by not using the obs
            # in obslist
            case_post = self.get(par_names=self.jco.par_names,
                                 obs_names=diff_onames).posterior_forecast

            for forecast,pt in case_post.items():
                results[forecast].append(pt)
        df = pd.DataFrame(results,index=names)
        self.log("calculating importance of observations by removing: " +
                     str(obslist) + '\n')

        if reset:
            self.reset_obscov(org_obscov)
            self.reset_pst(org_pst)
        return df