get a dataframe fo the posterior uncertainty
        as a results of added some observations

        Parameters
        ----------
        obslist_dict : dict
            a nested dictionary-list of groups of observations
            that are to be treated as gained.  key values become
            row labels in returned dataframe. If None, then every zero-weighted
            observation is tested sequentially. Default is None
        base_obslist : list
            observation names to treat as the "existing" observations.
            The values of obslist_dict will be added to this list during
            each test.  If None, then the values in obslist_dict will
            be treated as the entire calibration dataset.  That is, there
            are no existing data. Default is None.  Standard practice would
            be to pass this argument as Schur.pst.nnz_obs_names.
        reset_zero_weight : (boolean or float)
            a flag to reset observations with zero weight in either
            obslist_dict or base_obslist. 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.  Default is False.

        Returns
        -------
        pandas.DataFrame : pandas.DataFrame
            dataframe with row labels (index) of obslist_dict.keys() and
            columns of forecast_name.  The values in the dataframe are the
            posterior variance of the forecasts resulting from notional inversion
            using the observations in obslist_dict[key value] plus the observations
            in base_obslist (if any)

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

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

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

        ``>>>df = sc.get_added_obs_importance(base_obslist=sc.pst.nnz_obs_names,reset_zero=True)``

def get_added_obs_importance(self,obslist_dict=None,base_obslist=None,
                                 reset_zero_weight=False):
        """get a dataframe fo the posterior uncertainty
        as a results of added some observations

        Parameters
        ----------
        obslist_dict : dict
            a nested dictionary-list of groups of observations
            that are to be treated as gained.  key values become
            row labels in returned dataframe. If None, then every zero-weighted
            observation is tested sequentially. Default is None
        base_obslist : list
            observation names to treat as the "existing" observations.
            The values of obslist_dict will be added to this list during
            each test.  If None, then the values in obslist_dict will
            be treated as the entire calibration dataset.  That is, there
            are no existing data. Default is None.  Standard practice would
            be to pass this argument as Schur.pst.nnz_obs_names.
        reset_zero_weight : (boolean or float)
            a flag to reset observations with zero weight in either
            obslist_dict or base_obslist. 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.  Default is False.

        Returns
        -------
        pandas.DataFrame : pandas.DataFrame
            dataframe with row labels (index) of obslist_dict.keys() and
            columns of forecast_name.  The values in the dataframe are the
            posterior variance of the forecasts resulting from notional inversion
            using the observations in obslist_dict[key value] plus the observations
            in base_obslist (if any)

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

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

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

        ``>>>df = sc.get_added_obs_importance(base_obslist=sc.pst.nnz_obs_names,reset_zero=True)``


        """

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

        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_obscov = self.obscov.copy()
            org_pst = self.pst.get()

        obs = self.pst.observation_data
        obs.index = obs.obsnme

        # if we don't care about grouping obs, then just reset all weights at once
        if base_obslist is None and obslist_dict is None and reset:
            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 needed reset the zero-weight obs in base_obslist
        if base_obslist is not None and reset:
            # check for zero
            self.log("resetting zero weight obs in base_obslist")
            self.pst._adjust_weights_by_list(base_obslist, weight)
            self.log("resetting zero weight obs in base_obslist")

        if base_obslist is None:
            base_obslist = []
        else:
            if type(base_obslist) != list:
                self.logger.lraise("Schur.get_added_obs)_importance: base_obslist must be" +
                                   " type 'list', not {0}".format(str(type(base_obslist))))
        # if needed reset the zero-weight obs in obslist_dict
        if obslist_dict is not None and reset:
            z_obs = []
            for case,obslist in obslist_dict.items():
                if not isinstance(obslist,list):
                    obslist_dict[case] = [obslist]
                    obslist = [obslist]
                inboth = set(base_obslist).intersection(set(obslist))
                if len(inboth) > 0:
                    raise Exception("observation(s) listed in both "+\
                                    "base_obslist and obslist_dict: "+\
                                    ','.join(inboth))
                z_obs.extend(obslist)
            self.log("resetting zero weight obs in obslist_dict")
            self.pst._adjust_weights_by_list(z_obs, weight)
            self.log("resetting zero weight obs in obslist_dict")

        # for a comprehensive obslist_dict
        if obslist_dict is None and reset:
            obs = self.pst.observation_data
            obs.index = obs.obsnme
            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 = {name:name for name in self.pst.nnz_obs_names if name\
                            in self.jco.obs_names and name in self.obscov.row_names}

        # reset the obs cov from the newly adjusted weights
        if reset:
            self.log("resetting self.obscov")
            self.reset_obscov(self.pst)
            self.log("resetting self.obscov")

        results = {}
        names = ["base"]

        if base_obslist is None or len(base_obslist) == 0:
            self.logger.statement("no base observation passed, 'base' case"+
                                  " is just the prior of the forecasts")
            for forecast,pr in self.prior_forecast.items():
                results[forecast] = [pr]
            # reset base obslist for use later
            base_obslist = []

        else:
            base_posterior = self.get(par_names=self.jco.par_names,
                                      obs_names=base_obslist).posterior_forecast
            for forecast,pt in base_posterior.items():
                results[forecast] = [pt]

        for case_name,obslist in obslist_dict.items():
            names.append(case_name)
            if not isinstance(obslist,list):
                obslist = [obslist]
            self.log("calculating importance of observations by adding: " +
                     str(obslist) + '\n')
            # this case is the combination of the base obs plus whatever unique
            # obs names in obslist
            case_obslist = list(base_obslist)
            dedup_obslist = [oname for oname in obslist if oname not in case_obslist]
            case_obslist.extend(dedup_obslist)
            #print(self.pst.observation_data.loc[case_obslist,:])
            case_post = self.get(par_names=self.jco.par_names,
                                 obs_names=case_obslist).posterior_forecast
            for forecast,pt in case_post.items():
                results[forecast].append(pt)
            self.log("calculating importance of observations by adding: " +
                     str(obslist) + '\n')
        df = pd.DataFrame(results,index=names)


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

        return df