docs: def observableFractionCMD(self, mask, distance_modulus, mass_min=0.1):
          """
          Compute observable fraction of stars with masses greater than mass_min in each 
          pixel in the interior region of the mask.
  
          ADW: Careful, this function is fragile! The selection here should
               be the same as mask.restrictCatalogToObservable space. However,
               for technical reasons it is faster to do the calculation with
               broadcasting here.
          ADW: Could this function be even faster / more readable?
          ADW: Should this include magnitude error leakage?
          """
          if distance_modulus is None: distance_modulus = self.distance_modulus
          mass_init,mass_pdf,mass_act,mag_1,mag_2 = self.sample(mass_min=mass_min,full_data_range=False)
  
          mag = mag_1 if self.band_1_detection else mag_2
          color = mag_1 - mag_2
  
          # ADW: Only calculate observable fraction for unique mask values
          mag_1_mask,mag_2_mask = mask.mask_roi_unique.T
  
          # ADW: Restrict mag and color to range of mask with sufficient solid angle
          cmd_cut = ugali.utils.binning.take2D(mask.solid_angle_cmd,color,mag+distance_modulus,
                                               mask.roi.bins_color, mask.roi.bins_mag) > 0
          # Pre-apply these cuts to the 1D mass_pdf_array to save time
          mass_pdf_cut = mass_pdf*cmd_cut
  
          # Create 2D arrays of cuts for each pixel
          mask_1_cut = (mag_1+distance_modulus)[:,np.newaxis] < mag_1_mask
          mask_2_cut = (mag_2+distance_modulus)[:,np.newaxis] < mag_2_mask
          mask_cut_repeat = (mask_1_cut & mask_2_cut)
  
          # Condense back into one per digi
          observable_fraction = (mass_pdf_cut[:,np.newaxis]*mask_cut_repeat).sum(axis=0)
  
          # Expand to the roi and multiply by coverage fraction
          return observable_fraction[mask.mask_roi_digi[mask.roi.pixel_interior_cut]] * mask.frac_interior_sparse