class_docstr: Parser for Elekta data acquisition settings.
  
  This class parses parameters (e.g. events and averaging categories) that
  are defined in the Elekta TRIUX/VectorView data acquisition software (DACQ)
  and stored in ``info['acq_pars']``. It can be used to reaverage raw data
  according to DACQ settings and modify original averaging settings if
  necessary.
  
  Parameters
  ----------
  %(info_not_none)s This is where the DACQ parameters will be taken from.
  
  Attributes
  ----------
  categories : list
      List of averaging categories marked active in DACQ.
  events : list
      List of events that are in use (referenced by some averaging category).
  reject : dict
      Rejection criteria from DACQ that can be used with mne.Epochs.
      Note that mne does not support all DACQ rejection criteria
      (e.g. spike, slope).
  flat : dict
      Flatness rejection criteria from DACQ that can be used with mne.Epochs.
  acq_dict : dict
      All DACQ parameters.
  
  See Also
  --------
  mne.io.Raw.acqparser : Access the parser through a Raw attribute.
  
  Notes
  -----
  Any averaging category (also non-active ones) can be accessed by indexing
  as ``acqparserfif['category_name']``.
docstr: Translate mne_events to epoch zero times (t0).
  
  First mne events (trigger transitions) are converted into DACQ events.
  Then the zero times for the epochs are obtained by considering the
  reference and conditional (required) events and the delay to stimulus.
docstr_tok: ["Translate","mne_events","to","epoch","zero","times","(","t0",")",".","First","mne","events","(","trigger","transitions",")","are","converted","into","DACQ","events",".","Then","the","zero","times","for","the","epochs","are","obtained","by","considering","the","reference","and","conditional","(","required",")","events","and","the","delay","to","stimulus","."]
code: def _mne_events_to_category_t0(self, cat, mne_events, sfreq):
      """Translate mne_events to epoch zero times (t0).
  
      First mne events (trigger transitions) are converted into DACQ events.
      Then the zero times for the epochs are obtained by considering the
      reference and conditional (required) events and the delay to stimulus.
      """
      cat_ev = cat["event"]
      cat_reqev = cat["reqevent"]
      # first convert mne events to dacq event list
      events = self._events_mne_to_dacq(mne_events)
      # next, take req. events and delays into account
      times = events[:, 0]
      # indices of times where ref. event occurs
      refEvents_inds = np.where(events[:, 2] & (1 << cat_ev - 1))[0]
      refEvents_t = times[refEvents_inds]
      if cat_reqev:
          # indices of times where req. event occurs
          reqEvents_inds = np.where(
              events[:, 2] & (1 << cat_reqev - 1)
          )[0]
          reqEvents_t = times[reqEvents_inds]
          # relative (to refevent) time window where req. event
          # must occur (e.g. [0 .2])
          twin = [0, (-1) ** (cat["reqwhen"]) * cat["reqwithin"]]
          win = np.round(np.array(sorted(twin)) * sfreq)  # to samples
          refEvents_wins = refEvents_t[:, None] + win
          req_acc = np.zeros(refEvents_inds.shape, dtype=bool)
          for t in reqEvents_t:
              # mark time windows where req. condition is satisfied
              reqEvent_in_win = np.logical_and(
                  t >= refEvents_wins[:, 0], t <= refEvents_wins[:, 1]
              )
              req_acc |= reqEvent_in_win
          # drop ref. events where req. event condition is not satisfied
          refEvents_inds = refEvents_inds[np.where(req_acc)]
          refEvents_t = times[refEvents_inds]
      # adjust for trigger-stimulus delay by delaying the ref. event
      refEvents_t += int(
          np.round(self._events[cat_ev]["delay"] * sfreq)
      )
      return refEvents_t
  
imports: from collections.abc import Sequence
  from pathlib import Path
  import numpy
  from ._fiff.constants import FIFF
  from ._fiff.open import fiff_open
  from ._fiff.pick import pick_channels
  from ._fiff.tag import read_tag
  from ._fiff.tree import dir_tree_find
  from ._fiff.write import end_block, start_and_end_file, start_block, write_int
  from .utils import _check_fname, _check_integer_or_list, _check_on_missing, _check_option, _get_stim_channel, _on_missing, _pl, _validate_type, check_fname, fill_doc, logger, verbose, warn
label_desc: Use image node_id 9 for calling the AcqParserFIF obj's underlying member method code with example usage: obj._mne_events_to_category_t0(cat, mne_events, sfreq) and returns: refEvents_t