docs: def plot_pattern_return(self, isos, delta=True):
          '''
          This routine returns data isotopic data to plot from the
          filtered list of data.
  
          Parameters
          ----------
          isos : list
              Isotopes for x axis in standard format
              [['Si-30','Si-28'],['Si-29','Si-30'],...]
          isoy : list
              Same as isox but for y axis.
          deltay: boolean, optional
              Same as for x-axis but for y-axis.  The default is True.
  
          Returns
          -------
          grpl_data
              grain plot x-axis data.
          grpl_err
              x-axis error bars.
          grpl_style
              style data for the different symbols.
  
          '''
          # check availability
          index = []
          delta_b = []
          ratio_b = []
          for i in range(len(isos)):
              tmpi,tmpd,tmpr = self.check_availability(isos[i])
              index.append(tmpi)
              delta_b.append(tmpd)
              ratio_b.append(tmpd)
  
          for i in range(len(index)):
              if index[i] == -1:
                  print('Input not available for: ' + isos[i] + '. Revise!')
                  return None
  
          # create x and y data as 1d vectors, also error bars
          data_vec = np.zeros((len(self.data),len(isos)))
          data_err = np.zeros((len(self.data),len(isos)))
          for it in range(len(self.data)):
              for jt in range(len(isos)):
                  data_vec[it][jt] = self.data[it][index[jt]]
                  data_err[it][jt] = self.data[it][index[jt]+1]
  
          # index data that are nan
          index_nan = []
          for it in range(len(data_vec)):
              for jt in range(len(data_vec[it])):
                  if np.isnan(data_vec[it][jt]):
                      index_nan.append(it)
  
          # make range of all incides
          index_filtered = list(range(len(data_vec)))
          for it in range(len(index_nan)):
              index_filtered.remove(index_nan[it])
  
          data_tmp = np.zeros((len(index_filtered),len(isos)))
          err_tmp  = np.zeros((len(index_filtered),len(isos)))
          style_plt = np.zeros((len(index_filtered),len(self.header_style)),dtype='|S1024')
  
          for i in range(len(index_filtered)):
              data_tmp[i] = data_vec[index_filtered[i]]
              err_tmp[i]  = data_err[index_filtered[i]]
              for j in range(len(style_plt[i])):
                  style_plt[i][j] = self.style[i][j]
          xdata_vec = xdata_tmp
          ydata_vec = ydata_tmp
          xdata_err = xerr_tmp
          ydata_err = yerr_tmp
  
          # loop through error and set nans to 0
          for i in range(len(xdata_err)):
              if np.isnan(xdata_err[i]):
                  xdata_err[i] = 0.
              if np.isnan(ydata_err[i]):
                  ydata_err[i] = 0.
          # FIXME here
          # make start stop index for groups
          start_stop = []
          start = 0
          for it in range(len(xdata_vec)-1):
              if (style_plt[it] == style_plt[it+1]).all():
                  continue
              else:
                  stop = it
                  start_stop.append([start,stop])
                  start = stop+1
          # last entry
          if start_stop == []:
              start_stop.append([0,len(xdata_vec)])
          else:
              start_stop.append([start_stop[len(start_stop)-1][1]+1,len(xdata_vec)])
  
          # now append things to return variables
          grain_plt_xdata = []
          grain_plt_ydata = []
          grain_plt_xerr  = []
          grain_plt_yerr  = []
          grain_plt_style = []
          for i in range(len(start_stop)):
  
              grain_plt_xdata.append(xdata_vec[start_stop[i][0]:start_stop[i][1]])
              grain_plt_ydata.append(ydata_vec[start_stop[i][0]:start_stop[i][1]])
              grain_plt_xerr.append(xdata_err[start_stop[i][0]:start_stop[i][1]])
              grain_plt_yerr.append(ydata_err[start_stop[i][0]:start_stop[i][1]])
              grain_plt_style.append(style_plt[start_stop[i][0]])
  
  
          return [grain_plt_xdata,grain_plt_xerr,grain_plt_ydata,grain_plt_yerr,grain_plt_style]