docs: def inspect_data(self, capacity=None, voltage=None,
                       err_est=False, diff_est=False):
          """check and inspect the data"""
  
          logging.debug("inspecting the data")
  
          if capacity is None:
              capacity = self.capacity
          if voltage is None:
              voltage = self.voltage
  
          if capacity is None or voltage is None:
              raise NullData
  
          self.len_capacity = len(capacity)
          self.len_voltage = len(voltage)
  
          if self.len_capacity <= 1:
              raise NullData
          if self.len_voltage <= 1:
              raise NullData
  
          self.min_capacity, self.max_capacity = value_bounds(capacity)
          self.start_capacity, self.end_capacity = index_bounds(capacity)
  
          self.number_of_points = len(capacity)
  
          if diff_est:
              d_capacity = np.diff(capacity)
              d_voltage = np.diff(voltage)
  
              self.d_capacity_mean = np.mean(d_capacity)
              self.d_voltage_mean = np.mean(d_voltage)
  
          if err_est:
  
              splits = int(self.number_of_points / self.points_pr_split)
              rest = self.number_of_points % self.points_pr_split
  
              if splits < self.minimum_splits:
                  txt = "no point in splitting, too little data"
                  logging.debug(txt)
                  self.errors.append("splitting: to few points")
              else:
                  if rest > 0:
                      _cap = capacity[:-rest]
                      _vol = voltage[:-rest]
                  else:
                      _cap = capacity
                      _vol = voltage
  
                  c_pieces = np.split(_cap, splits)
                  v_pieces = np.split(_vol, splits)
                  # c_middle = int(np.amax(c_pieces) / 2)
  
                  std_err = []
                  c_pieces_avg = []
                  for c, v in zip(c_pieces, v_pieces):
                      _slope, _intercept, _r_value, _p_value, _std_err = stats.linregress(c, v)
                      std_err.append(_std_err)
                      c_pieces_avg.append(np.mean(c))
  
                  self.std_err_median = np.median(std_err)
                  self.std_err_mean = np.mean(std_err)
  
          if not self.start_capacity == self.min_capacity:
              self.errors.append("capacity: start<>min")
  
          if not self.end_capacity == self.max_capacity:
              self.errors.append("capacity: end<>max")
  
          if self.normalizing_factor is None:
              self.normalizing_factor = self.end_capacity
  
          if self.normalizing_roof is not None:
              self.normalizing_factor = self.normalizing_factor * \
                                        self.end_capacity / self.normalizing_roof