class_docstr: Raw object from KIT SQD file.
  
  Parameters
  ----------
  input_fname : path-like
      Path to the SQD file.
  %(kit_mrk)s
  %(kit_elp)s
  %(kit_hsp)s
  %(kit_stim)s
  %(kit_slope)s
  %(kit_stimthresh)s
  %(preload)s
  %(kit_stimcode)s
  allow_unknown_format : bool
      Force reading old data that is not officially supported. Alternatively,
      read and re-save the data with the KIT MEG Laboratory application.
  %(standardize_names)s
  %(verbose)s
  
  Notes
  -----
  ``elp`` and ``hsp`` are usually the exported text files (*.txt) from the
  Polhemus FastScan system. ``hsp`` refers to the headshape surface points.
  ``elp`` refers to the points in head-space that corresponds to the HPI
  points.
  
  If ``mrk``\, ``hsp`` or ``elp`` are :term:`array_like` inputs, then the
  numbers in xyz coordinates should be in units of meters.
  
  See Also
  --------
  mne.io.Raw : Documentation of attributes and methods.
docstr: Read a chunk of raw data.
code: def _read_segment_file(self, data, idx, fi, start, stop, cals, mult):
      """Read a chunk of raw data."""
      sqd = self._raw_extras[fi]
      nchan = sqd["nchan"]
      data_left = (stop - start) * nchan
      conv_factor = sqd["conv_factor"]
  
      n_bytes = sqd["dtype"].itemsize
      assert n_bytes in (2, 4)
      # Read up to 100 MB of data at a time.
      blk_size = min(data_left, (100000000 // n_bytes // nchan) * nchan)
      with open(self._filenames[fi], "rb", buffering=0) as fid:
          # extract data
          pointer = start * nchan * n_bytes
          fid.seek(
              sqd["dirs"][KIT.DIR_INDEX_RAW_DATA]["offset"] + pointer
          )
          stim = sqd["stim"]
          for blk_start in np.arange(0, data_left, blk_size) // nchan:
              blk_size = min(blk_size, data_left - blk_start * nchan)
              block = np.fromfile(
                  fid, dtype=sqd["dtype"], count=blk_size
              )
              block = block.reshape(nchan, -1, order="F").astype(float)
              blk_stop = blk_start + block.shape[1]
              data_view = data[:, blk_start:blk_stop]
              block *= conv_factor
  
              # Create a synthetic stim channel
              if stim is not None:
                  stim_ch = _make_stim_channel(
                      block[stim, :],
                      sqd["slope"],
                      sqd["stimthresh"],
                      sqd["stim_code"],
                      stim,
                  )
                  block = np.vstack((block, stim_ch))
  
              _mult_cal_one(data_view, block, idx, cals, mult)
  
imports: from collections import OrderedDict, defaultdict
  from math import cos, sin
  from os import SEEK_CUR, PathLike
  from os import path
  from pathlib import Path
  import numpy
  from ..._fiff.constants import FIFF
  from ..._fiff.meas_info import _empty_info
  from ..._fiff.pick import pick_types
  from ..._fiff.utils import _mult_cal_one
  from ...epochs import BaseEpochs
  from ...event import read_events
  from ...transforms import als_ras_trans, apply_trans
  from ...utils import _check_fname, _check_option, _stamp_to_dt, fill_doc, logger, verbose, warn
  from ..base import BaseRaw
  from .constants import KIT, LEGACY_AMP_PARAMS
  from .coreg import _set_dig_kit, read_mrk
label_desc: Use image node_id 3 for calling the RawKIT obj's underlying member method code with example usage: obj._read_segment_file(data, idx, fi, start, stop, cals, mult) without return types