docs: def observableFractionCMDX(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?
          """
          mass_init_array,mass_pdf_array,mass_act_array,mag_1_array,mag_2_array = self.sample(mass_min=mass_min,full_data_range=False)
          mag = mag_1_array if self.band_1_detection else mag_2_array
          color = mag_1_array - mag_2_array
  
          # ADW: Only calculate observable fraction over interior pixels...
          pixels = mask.roi.pixels_interior
          mag_1_mask = mask.mask_1.mask_roi_sparse[mask.roi.pixel_interior_cut]
          mag_2_mask = mask.mask_2.mask_roi_sparse[mask.roi.pixel_interior_cut]
  
          # 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_array*cmd_cut
  
          # Create 2D arrays of cuts for each pixel
          mask_1_cut = (mag_1_array+distance_modulus)[:,np.newaxis] < mag_1_mask
          mask_2_cut = (mag_2_array+distance_modulus)[:,np.newaxis] < mag_2_mask
          mask_cut_repeat = mask_1_cut & mask_2_cut
  
          observable_fraction = (mass_pdf_cut[:,np.newaxis]*mask_cut_repeat).sum(axis=0)
          return observable_fraction