docs: def get_step_numbers(self, steptype='charge', allctypes=True, pdtype=False,
                           cycle_number=None, dataset_number=None,
                           steptable=None):
          # TODO: @jepe - include sub_steps here
          """Get the step numbers of selected type.
  
          Returns the selected step_numbers for the  elected type of step(s).
  
          Args:
              steptype (string): string identifying type of step.
              allctypes (bool): get all types of charge (or discharge).
              pdtype (bool): return results as pandas.DataFrame
              cycle_number (int): selected cycle, selects all if not set.
              dataset_number (int): test number (default first)
                  (usually not used).
              steptable (pandas.DataFrame): optional steptable
  
          Returns:
              A dictionary containing a list of step numbers corresponding
                  to the selected steptype for the cycle(s).
              Returns a pandas.DataFrame instead of a dict of lists if pdtype is
                  set to True. The frame is a sub-set of the step-table frame
                  (i.e. all the same columns, only filtered by rows).
  
          Example:
              >>> my_charge_steps = CellpyData.get_step_numbers(
              >>>    "charge",
              >>>    cycle_number = 3
              >>> )
              >>> print my_charge_steps
              {3: [5,8]}
  
          """
          # self.logger.debug("Trying to get step-types")
          if steptable is None:
              dataset_number = self._validate_dataset_number(dataset_number)
              if dataset_number is None:
                  self._report_empty_dataset()
                  return
  
              if not self.datasets[dataset_number].step_table_made:
                  self.logger.debug("step_table is not made")
  
                  if self.force_step_table_creation or self.force_all:
                      self.logger.debug("creating step_table for")
                      self.logger.debug(self.datasets[dataset_number].loaded_from)
                      # print "CREAING STEP-TABLE"
                      self.make_step_table(dataset_number=dataset_number)
  
                  else:
                      self.logger.info("ERROR! Cannot use get_steps: "
                                       "create step_table first")
                      self.logger.info(" you could use find_step_numbers"
                                       " method instead")
                      self.logger.info(" (but I don't recommend it)")
                      return None
  
          # check if steptype is valid
          steptype = steptype.lower()
          steptypes = []
          helper_step_types = ['ocv', 'charge_discharge']
          valid_step_type = True
          if steptype in self.list_of_step_types:
              steptypes.append(steptype)
          else:
              txt = "%s is not a valid core steptype" % steptype
              if steptype in helper_step_types:
                  txt = "but a helper steptype"
                  if steptype == 'ocv':
                      steptypes.append('ocvrlx_up')
                      steptypes.append('ocvrlx_down')
                  elif steptype == 'charge_discharge':
                      steptypes.append('charge')
                      steptypes.append('discharge')
              else:
                  valid_step_type = False
              self.logger.debug(txt)
          if not valid_step_type:
              return None
  
          # in case of selection allctypes, then modify charge, discharge
          if allctypes:
              add_these = []
              for st in steptypes:
                  if st in ['charge', 'discharge']:
                      st1 = st + '_cv'
                      add_these.append(st1)
                      st1 = 'cv_' + st
                      add_these.append(st1)
              for st in add_these:
                  steptypes.append(st)
  
          # self.logger.debug("Your steptypes:")
          # self.logger.debug(steptypes)
  
          if steptable is None:
              st = self.datasets[dataset_number].step_table
          else:
              st = steptable
          shdr = self.headers_step_table
  
          # retrieving cycle numbers
          if cycle_number is None:
              cycle_numbers = self.get_cycle_numbers(
                  dataset_number,
                  steptable=steptable
              )
  
          else:
              if isinstance(cycle_number, (list, tuple)):
                  cycle_numbers = cycle_number
              else:
                  cycle_numbers = [cycle_number, ]
  
          if pdtype:
              self.logger.debug("return pandas dataframe")
              out = st[st[shdr.type].isin(steptypes) &
                       st[shdr.cycle].isin(cycle_numbers)]
              return out
  
          # if not pdtype, return a dict instead
          # self.logger.debug("out as dict; out[cycle] = [s1,s2,...]")
          # self.logger.debug("(same behaviour as find_step_numbers)")
          self.logger.debug("return dict of lists")
          out = dict()
          for cycle in cycle_numbers:
              steplist = []
              for s in steptypes:
                  step = st[(st[shdr.type] == s) &
                            (st[shdr.cycle] == cycle)][shdr.step].tolist()
                  for newstep in step:
                      steplist.append(int(newstep))
                      # int(step.iloc[0])
                      # self.is_empty(steps)
              if not steplist:
                  steplist = [0]
              out[cycle] = steplist
          return out