docs: def update(self, all_in_memory=None):
          """Updates the selected datasets.
  
          Args:
              all_in_memory (bool): store the cellpydata in memory (default
              False)
  
          """
          logging.info("[update experiment]")
          if all_in_memory is not None:
              self.all_in_memory = all_in_memory
  
          pages = self.journal.pages
          summary_frames = dict()
          cell_data_frames = dict()
          number_of_runs = len(pages)
          counter = 0
          errors = []
  
          for indx, row in pages.iterrows():
              counter += 1
              h_txt = "[" + counter * "|" + (
                      number_of_runs - counter) * "." + "]"
              l_txt = "starting to process file # %i (index=%s)" % (counter, indx)
              logging.debug(l_txt)
              print(h_txt)
  
              if not row.raw_file_names and not self.force_cellpy:
                  logging.info("File(s) not found!")
                  logging.info(indx)
                  logging.debug("File(s) not found for index=%s" % indx)
                  errors.append(indx)
                  continue
  
              else:
                  logging.info(f"Processing {indx}")
  
              cell_data = cellreader.CellpyData()
              if not self.force_cellpy or self.force_recalc:
                  logging.info(
                      "setting cycle mode (%s)..." % row.cell_type)
                  cell_data.cycle_mode = row.cell_type
  
              logging.info("loading cell")
              if not self.force_cellpy:
                  logging.debug("not forcing to load cellpy-file instead of raw file.")
                  try:
                      cell_data.loadcell(
                          raw_files=row.raw_file_names,
                          cellpy_file=row.cellpy_file_names,
                          mass=row.masses,
                          summary_on_raw=True,
                          force_raw=self.force_raw_file,
                          use_cellpy_stat_file=prms.Reader.use_cellpy_stat_file
                      )
                  except Exception as e:
                      logging.info('Failed to load: ' + str(e))
                      errors.append("loadcell:" + str(indx))
                      if not self.accept_errors:
                          raise e
                      continue
  
              else:
                  logging.info("forcing")
                  try:
                      cell_data.load(row.cellpy_file_names,
                                     parent_level=self.parent_level)
                  except Exception as e:
                      logging.info(
                          f"Critical exception encountered {type(e)} "
                          "- skipping this file")
                      logging.debug(
                          'Failed to load. Error-message: ' + str(e))
                      errors.append("load:" + str(indx))
                      if not self.accept_errors:
                          raise e
                      continue
  
              if not cell_data.check():
                  logging.info("...not loaded...")
                  logging.debug(
                      "Did not pass check(). Could not load cell!")
                  errors.append("check:" + str(indx))
                  continue
  
              logging.info("...loaded successfully...")
  
              summary_tmp = cell_data.dataset.dfsummary
              logging.info("Trying to get summary_data")
  
              if cell_data.dataset.step_table is None or self.force_recalc:
                  logging.info(
                      "Running make_step_table"
                  )
  
                  cell_data.make_step_table()
  
              if summary_tmp is None or self.force_recalc:
                  logging.info(
                      "Running make_summary"
                  )
  
                  cell_data.make_summary(find_end_voltage=True,
                                         find_ir=True)
  
              if summary_tmp.index.name == b"Cycle_Index":
                  logging.debug("Strange: 'Cycle_Index' is a byte-string")
                  summary_tmp.index.name = 'Cycle_Index'
  
              if not summary_tmp.index.name == "Cycle_Index":
                  logging.debug("Setting index to Cycle_Index")
                  # check if it is a byte-string
                  if b"Cycle_Index" in summary_tmp.columns:
                      logging.debug(
                          "Seems to be a byte-string in the column-headers")
                      summary_tmp.rename(
                          columns={b"Cycle_Index": 'Cycle_Index'},
                          inplace=True)
                  summary_tmp.set_index("Cycle_Index", inplace=True)
  
              summary_frames[indx] = summary_tmp
  
              if self.all_in_memory:
                  cell_data_frames[indx] = cell_data
              else:
                  cell_data_frames[indx] = cellreader.CellpyData(initialize=True)
                  cell_data_frames[indx].dataset.step_table = \
                      cell_data.dataset.step_table
                  # cell_data_frames[indx].dataset.step_table_made = True
  
              if self.save_cellpy:
                  logging.info("saving to cellpy-format")
                  if not row.fixed:
                      logging.info("saving cell to %s" % row.cellpy_file_names)
                      cell_data.ensure_step_table = True
                      cell_data.save(row.cellpy_file_names)
                  else:
                      logging.debug(
                          "saving cell skipped (set to 'fixed' in info_df)")
  
              if self.export_raw or self.export_cycles:
                  export_text = "exporting"
                  if self.export_raw:
                      export_text += " [raw]"
                  if self.export_cycles:
                      export_text += " [cycles]"
                  logging.info(export_text)
                  cell_data.to_csv(
                      self.journal.raw_dir,
                      sep=prms.Reader.sep,
                      cycles=self.export_cycles,
                      shifted=self.shifted_cycles,
                      raw=self.export_raw,
                      last_cycle=self.last_cycle
                  )
  
              if self.export_ica:
                  logging.info("exporting [ica]")
                  try:
                      helper.export_dqdv(
                          cell_data,
                          savedir=self.journal.raw_dir,
                          sep=prms.Reader.sep,
                          last_cycle=self.last_cycle
                      )
                  except Exception as e:
                      logging.error(
                          "Could not make/export dq/dv data"
                      )
                      logging.debug(
                          "Failed to make/export "
                          "dq/dv data (%s): %s" % (indx, str(e))
                      )
                      errors.append("ica:" + str(indx))
  
          self.errors["update"] = errors
          self.summary_frames = summary_frames
          self.cell_data_frames = cell_data_frames