docs: def get_emodulus(area_um, deform, medium="CellCarrier",
                   channel_width=20.0, flow_rate=0.16, px_um=0.34,
                   temperature=23.0, copy=True):
      """Compute apparent Young's modulus using a look-up table
  
      Parameters
      ----------
      area_um: float or ndarray
          Apparent (2D image) area [µm²] of the event(s)
      deform: float or ndarray
          The deformation (1-circularity) of the event(s)
      medium: str or float
          The medium to compute the viscosity for. If a string
          in ["CellCarrier", "CellCarrier B"] is given, the viscosity
          will be computed. If a float is given, this value will be
          used as the viscosity in mPa*s.
      channel_width: float
          The channel width [µm]
      flow_rate: float
          Flow rate [µl/s]
      px_um: float
          The detector pixel size [µm] used for pixelation correction.
          Set to zero to disable.
      temperature: float or ndarray
          Temperature [°C] of the event(s)
      copy: bool
          Copy input arrays. If set to false, input arrays are
          overridden.
  
      Returns
      -------
      elasticity: float or ndarray
          Apparent Young's modulus in kPa
  
      Notes
      -----
      - The look-up table used was computed with finite elements methods
        according to :cite:`Mokbel2017`.
      - The computation of the Young's modulus takes into account
        corrections for the viscosity (medium, channel width, flow rate,
        and temperature) :cite:`Mietke2015` and corrections for
        pixelation of the area and the deformation which are computed
        from a (pixelated) image :cite:`Herold2017`.
  
      See Also
      --------
      dclab.features.emodulus_viscosity.get_viscosity: compute viscosity
          for known media
      """
      # copy input arrays so we can use in-place calculations
      deform = np.array(deform, copy=copy, dtype=float)
      area_um = np.array(area_um, copy=copy, dtype=float)
      # Get lut data
      lut_path = resource_filename("dclab.features", "emodulus_lut.txt")
      with pathlib.Path(lut_path).open("rb") as lufd:
          lut = np.loadtxt(lufd)
      # These meta data are the simulation parameters of the lut
      lut_channel_width = 20.0
      lut_flow_rate = 0.04
      lut_visco = 15.0
      # Compute viscosity
      if isinstance(medium, (float, int)):
          visco = medium
      else:
          visco = get_viscosity(medium=medium, channel_width=channel_width,
                                flow_rate=flow_rate, temperature=temperature)
      # Corrections
      # We correct the lut, because it contains less points than
      # the event data. Furthermore, the lut could be cached
      # in the future, if this takes up a lot of time.
      convert(area_um=lut[:, 0],
              deform=lut[:, 1],
              emodulus=lut[:, 2],
              channel_width_in=lut_channel_width,
              channel_width_out=channel_width,
              flow_rate_in=lut_flow_rate,
              flow_rate_out=flow_rate,
              viscosity_in=lut_visco,
              viscosity_out=visco,
              inplace=True)
  
      if px_um:
          # Correct deformation for pixelation effect (subtract ddelt).
          ddelt = corrpix_deform_delta(area_um=area_um, px_um=px_um)
          deform -= ddelt
  
      # Normalize interpolation data such that the spacing for
      # area and deformation is about the same during interpolation.
      area_norm = lut[:, 0].max()
      normalize(lut[:, 0], area_norm)
      normalize(area_um, area_norm)
  
      defo_norm = lut[:, 1].max()
      normalize(lut[:, 1], defo_norm)
      normalize(deform, defo_norm)
  
      # Perform interpolation
      emod = spint.griddata((lut[:, 0], lut[:, 1]), lut[:, 2],
                            (area_um, deform),
                            method='linear')
      return emod