docs: def plot_ratio_return(self, isox, isoy, deltax=True, deltay=True):
          '''
          This routine returns data isotopic data to plot from the
          filtered list of data.
  
          Parameters
          ----------
          isox : list
              Isotopes for x axis in standard format ['Si-28','Si-30'].
          isoy : list
              Same as isox but for y axis.
          deltax : boolean, optional
              If true then x-axis values are in delta format.  The default
              is True.
          deltay : boolean, optional
              Same as for x-axis but for y-axis.  The default is True.
  
          Returns
          -------
          grpl_xdata
              grain plot x-axis data.
          grpl_xerr
              x-axis error bars.
          grpl_ydata
              grain plot y-axis data.
          grpl_yerr
              y-axis error bars.
          grpl_style
              style data for the different symbols.
  
          '''
  
          # check availability
          index_x, delta_b_x, ratio_b_x = self.check_availability(isox)
          index_y, delta_b_y, ratio_b_y = self.check_availability(isoy)
          if index_x == -1 or index_y == -1:
              print('Following input data are not available in the database. Revise your input.')
              if index_x == -1:
                  print('x axis data not available')
              if index_y == -1:
                  print('y axis data not available')
              return None
  
          # create x and y data as 1d vectors, also error bars
          xdata_vec = np.zeros((len(self.data)))
          ydata_vec = np.zeros((len(self.data)))
          xdata_err = np.zeros((len(self.data)))
          ydata_err = np.zeros((len(self.data)))
          for it in range(len(self.data)):
              xdata_vec[it] = self.data[it][index_x]
              ydata_vec[it] = self.data[it][index_y]
              xdata_err[it] = self.data[it][index_x+1]
              ydata_err[it] = self.data[it][index_y+1]
  
          # index data that are nan
          index_nan = []
          for it in range(len(xdata_vec)):
              if np.isnan(xdata_vec[it]) or np.isnan(ydata_vec[it]):
                  index_nan.append(it)
  
          # make range of all incides
          index_filtered = list(range(len(xdata_vec)))
          for it in range(len(index_nan)):
              index_filtered.remove(index_nan[it])
  
          xdata_tmp = np.zeros((len(index_filtered)))
          ydata_tmp = np.zeros((len(index_filtered)))
          xerr_tmp  = np.zeros((len(index_filtered)))
          yerr_tmp  = np.zeros((len(index_filtered)))
          style_plt = np.zeros((len(index_filtered),len(self.header_style)),dtype='|S1024')
  
          for i in range(len(index_filtered)):
              xdata_tmp[i] = xdata_vec[index_filtered[i]]
              ydata_tmp[i] = ydata_vec[index_filtered[i]]
              xerr_tmp[i]  = xdata_err[index_filtered[i]]
              yerr_tmp[i]  = ydata_err[index_filtered[i]]
              for j in range(len(style_plt[i])):
                  style_plt[i][j] = self.style[index_filtered[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.
  
          # 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 + 1
                  start_stop.append([start,stop])
                  start = stop
          # last entry
          if start_stop == []:
              start_stop.append([0,len(xdata_vec)])
          else:
              start_stop.append([start_stop[len(start_stop)-1][1],len(xdata_vec)+1])
  
          # 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]