MeasureIALightcone

class MeasureIALightcone(MeasureWLightcone, MeasureMultipolesLightcone, MeasureWLightconeJackknife,
						 MeasureMultipolesLightconeJackknife, MeasureJackknife, CheckInput):
	r"""Manages the IA correlation function measurement methods used in the MeasureIA package based on speed and input.
	This class is used to call the methods that measure w_gg, w_g+ and multipoles for simulations (and observations),
	with lightcone data.
	Depending on the input parameters, various correlations incl covariance estimates are measured for given data.

	Attributes
	----------
	data_dir : dict or NoneType
		Temporary storage space for added data directory to allow for flexibility in passing data or randoms to internal
		methods.
	num_samples : dict or NoneType
		Dictionary containing the numbers of objects for each sample for lightcone-type measurements. Filled internally,
		no input needed.

	Methods
	-------
	measure_xi_w()
		Compute projected correlations $w_{gg}$ and/or $w_{g+}$.
	measure_xi_multipoles()
		Compute multipoles of the correlation functions, $\tilde{\xi}_{gg,0}$ and/or $\tilde{\xi}_{g+,2}$.

	Notes
	-----
	Inherits attributes from 'SimInfo', where none are used in this class.
	Inherits attributes from 'MeasureIABase', where 'data', 'output_file_name', 'Num_position',
	'Num_shape', 'r_min', 'r_max', 'num_bins_r', 'num_bins_pi', 'r_bins', 'pi_bins', 'mu_r_bins' are used.

	"""

	def __init__(
			self,
			data,
			randoms_data,
			output_file_name,
			separation_limits=[0.1, 20.0],
			num_bins_r=8,
			num_bins_pi=20,
			pi_max=None,
			num_nodes=1,
			RA_density_sample_name="RA",
			RA_shape_sample_name="RA_shape_sample",
			DEC_density_sample_name="DEC",
			DEC_shape_sample_name="DEC_shape_sample",
			redshift_density_sample_name="Redshift",
			redshift_shape_sample_name="Redshift_shape_sample",
			e1_name="e1",
			e2_name="e2",
			e1_density_sample_name="e1_density_sample",
			e2_density_sample_name="e2_density_sample",
			weight_density_sample_name="weight",
			weight_shape_sample_name="weight_shape_sample",
			binning="log",
	):
		"""
		The __init__ method of the MeasureIALightcone class.

		Parameters
		----------
		randoms_data : dict or NoneType
			Dictionary with data of the randoms needed for lightcone-type measurements.
			The keywords are:
			'Redshift' and 'Redshift_shape_sample': (N_p) and (N_s) ndarray with redshifts of position and shape samples.
			'RA' and 'RA_shape_sample': (N_p) and (N_s) ndarray with RA coordinate of position and shape samples.
			'DEC' and 'DEC_shape_sample': (N_p) and (N_s) ndarray with DEC coordinate of position and shape samples.
			If only 'Redshift', 'RA' and 'DEC' are added, the sample will be used for both position and shape sample randoms.
		num_nodes : int, optional
			Number of cores to be used in multiprocessing. Default is 1.
		RA_density_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the RA of the density sample.
		RA_shape_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the RA of the shape sample.
		DEC_density_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the DEC of the density sample.
		DEC_shape_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the DEC of the shape sample.
		redshift_density_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the redshift of the density sample.
		redshift_shape_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the redshift of the shape sample.
		e1_name : str, optional
			Name of the key in the data dictionary that contains the first ellipticity component of the shape sample.
		e2_name : str, optional
			Name of the key in the data dictionary that contains the second ellipticity component of the shape sample.
		e1_density_sample_name : str, optional
			Name of the key in the data dictionary that contains the first ellipticity component of the **density**
			sample. Only needed for shape-shape ('++') correlations, which require shapes on both members of a
			pair; leave it out for 'g+', 'gg' or 'both'. Must be supplied together with `e2_density_sample_name`.
		e2_density_sample_name : str, optional
			Name of the key in the data dictionary that contains the second ellipticity component of the
			**density** sample. See `e1_density_sample_name`.
		weight_density_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the weights of the density sample.
		weight_shape_sample_name : str, optional
			Name of the key in the data (and randoms) dictionary that contains the weights of the shape sample.
		binning : str, optional
			Spacing of the (projected) separation bins between the separation_limits: 'log' for logarithmically
			spaced bins or 'linear' for linearly spaced bins (e.g. around the BAO peak). Default is 'log'.

		Notes
		-----
		Constructor parameters 'data', 'output_file_name', 'separation_limits', 'num_bins_r',
		'num_bins_pi', 'pi_max' and 'binning' are passed to MeasureIABase.
		The data, randoms and mask dictionaries may use any key names; they are given through the *_name
		parameters and translated to the internal default names on input.

		"""
		self._input_name_map = {
			RA_density_sample_name: "RA",
			RA_shape_sample_name: "RA_shape_sample",
			DEC_density_sample_name: "DEC",
			DEC_shape_sample_name: "DEC_shape_sample",
			redshift_density_sample_name: "Redshift",
			redshift_shape_sample_name: "Redshift_shape_sample",
			e1_name: "e1",
			e2_name: "e2",
			e1_density_sample_name: "e1_density_sample",
			e2_density_sample_name: "e2_density_sample",
			weight_density_sample_name: "weight",
			weight_shape_sample_name: "weight_shape_sample",
		}
		if output_file_name is not None:
			self.check_paths([output_file_name])
		if data is not None:
			self.check_dict(data, [RA_density_sample_name, RA_shape_sample_name, DEC_density_sample_name,
								   DEC_shape_sample_name, redshift_density_sample_name, redshift_shape_sample_name,
								   e1_name, e2_name])
			self.check_type_input_data_lightcone(data, (RA_density_sample_name, RA_shape_sample_name,
														DEC_density_sample_name, DEC_shape_sample_name,
														redshift_density_sample_name, redshift_shape_sample_name,
														e1_name, e2_name))
			# optional, and only used by shape-shape correlations
			self.has_density_sample_shapes = self.check_density_sample_shapes(
				data, (RA_density_sample_name, e1_density_sample_name, e2_density_sample_name),
				"lightcone")
			data = self.rename_input_keys(data, self._input_name_map)
		else:
			self.has_density_sample_shapes = False
		if randoms_data is not None:
			self.check_dict(randoms_data,
							[RA_density_sample_name, DEC_density_sample_name, redshift_density_sample_name])
			randoms_data = self.rename_input_keys(randoms_data, self._input_name_map)
		super().__init__(data, output_file_name, False, None, separation_limits, num_bins_r, num_bins_pi,
						 pi_max, None, False, binning)
		if not (isinstance(num_nodes, (int, np.integer)) and not isinstance(num_nodes, bool) and num_nodes >= 1):
			raise ValueError(f"num_nodes must be an integer >= 1, got {num_nodes!r}.")
		self.num_nodes = num_nodes
		self.randoms_data = randoms_data
		self.data_dir = None
		self.num_samples = None

		return

	def _merged_masks(self, masks_position, masks_shape):
		"""Combines the masks for a pair-count pass where the position and shape slots of self.data may hold
		different samples (data or randoms). Each slot's mask is taken from the mask dictionary of the sample
		that occupies it. Must be called after self.data has been set for the pass.

		Parameters
		----------
		masks_position : dict or NoneType
			Mask dictionary of the sample occupying the position slots ('Redshift', 'RA', 'DEC', 'weight').
		masks_shape : dict or NoneType
			Mask dictionary of the sample occupying the shape slots ('*_shape_sample', 'e1', 'e2').

		Returns
		-------
		dict or NoneType
			Combined mask dictionary, or None if no mask applies to either slot. A missing dictionary means no
			selection (all True); missing keys default to the slot's coordinate mask so all fields of one
			sample stay aligned.

		"""
		if masks_position is None and masks_shape is None:
			return None
		if masks_position is None:
			masks_position = {}
		if masks_shape is None:
			masks_shape = {}
		pos_default = np.ones(len(self.data["RA"]), dtype=bool)
		shape_default = np.ones(len(self.data["RA_shape_sample"]), dtype=bool)
		pos_mask = masks_position.get("RA", pos_default)
		shape_mask = masks_shape.get("RA_shape_sample", shape_default)
		merged = {}
		for key in ("Redshift", "RA", "DEC", "weight"):
			merged[key] = masks_position.get(key, pos_mask)
		for key in ("Redshift_shape_sample", "RA_shape_sample", "DEC_shape_sample", "weight_shape_sample",
					"e1", "e2"):
			merged[key] = masks_shape.get(key, shape_mask)
		return merged

	@staticmethod
	def _field_mask(masks, key, coordinate_key, length):
		"""Selects the mask for one field, following the same defaulting rule as '_merged_masks': a missing
		mask dictionary means no selection, and a key that is absent from the dictionary falls back to its
		sample's coordinate mask so all fields of one sample stay aligned.

		Parameters
		----------
		masks : dict or NoneType
			Mask dictionary supplied by the user, or None for no selection.
		key : str
			Field whose mask is requested.
		coordinate_key : str
			Coordinate field of the sample that 'key' belongs to ('RA' or 'RA_shape_sample').
		length : int
			Length of the sample, used to build the all-True default.

		Returns
		-------
		ndarray
			Boolean mask for the requested field.

		"""
		if masks is None:
			return np.ones(length, dtype=bool)
		if key in masks:
			return masks[key]
		if coordinate_key in masks:
			return masks[coordinate_key]
		return np.ones(length, dtype=bool)

	def _sample_coordinates(self, masks, masks_randoms):
		"""Builds the masked (RA, DEC) coordinate pairs of the position and shape samples and the masked
		random sample sizes, used to work out the sample-size normalisation of the estimator.

		Parameters
		----------
		masks : dict or NoneType
			Mask dictionary for the data sample.
		masks_randoms : dict or NoneType
			Mask dictionary for the randoms.

		Returns
		-------
		ndarray, ndarray, int, int
			Position-sample coordinates, shape-sample coordinates, number of randoms in the position slot,
			number of randoms in the shape slot.

		"""
		n_D = len(self.data_dir["RA"])
		n_S = len(self.data_dir["RA_shape_sample"])
		coords_D = np.column_stack((self.data_dir["RA"][self._field_mask(masks, "RA", "RA", n_D)],
									self.data_dir["DEC"][self._field_mask(masks, "DEC", "RA", n_D)]))
		coords_S = np.column_stack((
			self.data_dir["RA_shape_sample"][
				self._field_mask(masks, "RA_shape_sample", "RA_shape_sample", n_S)],
			self.data_dir["DEC_shape_sample"][
				self._field_mask(masks, "DEC_shape_sample", "RA_shape_sample", n_S)]))
		n_RD = len(self.randoms_data["RA"])
		n_RS = len(self.randoms_data["RA_shape_sample"])
		num_R_D = len(self.randoms_data["RA"][self._field_mask(masks_randoms, "RA", "RA", n_RD)])
		num_R_S = len(self.randoms_data["RA_shape_sample"][
						  self._field_mask(masks_randoms, "RA_shape_sample", "RA_shape_sample", n_RS)])
		return coords_D, coords_S, num_R_D, num_R_S

	def _masked_jk_patches(self, jk_patches, masks, masks_randoms):
		"""Applies the sample masks to the jackknife patch labels, so the labels line up with the
		masked samples the pair counting runs over.

		Patch labels are given per object of the full (unmasked) catalogues, while every pair-count
		pass works on the masked samples. Each label array is masked with its sample's coordinate
		mask, the same selection '_merged_masks' makes for that slot.

		Parameters
		----------
		jk_patches : dict
			Patch labels with keys 'position', 'shape', 'randoms_position' and 'randoms_shape'.
		masks : dict or NoneType
			Mask dictionary for the data sample.
		masks_randoms : dict or NoneType
			Mask dictionary for the randoms.

		Returns
		-------
		dict
			The masked patch labels, under the same keys.

		"""
		def masked(labels, sample_masks, coordinate_key):
			labels = np.asarray(labels)
			return labels[self._field_mask(sample_masks, coordinate_key, coordinate_key, len(labels))]

		return {
			"position": masked(jk_patches["position"], masks, "RA"),
			"shape": masked(jk_patches["shape"], masks, "RA_shape_sample"),
			"randoms_position": masked(jk_patches["randoms_position"], masks_randoms, "RA"),
			"randoms_shape": masked(jk_patches["randoms_shape"], masks_randoms, "RA_shape_sample"),
		}

	def _sample_normalisation(self, masks, masks_randoms, jk_patches=None, num_jk=0):
		"""Weighted sample sizes the pair counts are normalised by, for the full sample and for each
		delete-one jackknife realisation.

		The pair counts are accumulated with the product of the two objects' weights, so each count is
		normalised by the product of the two samples' weight sums rather than their sizes (see
		'weight_sum'). This makes the estimators invariant under a constant rescaling of any sample's
		weights, and reduces to the plain sample sizes for unit weights. Objects present in both the
		position and the shape sample cannot pair with themselves, so 'D_S' is the weighted overlap: the
		sum of w_D * w_S over those objects.

		A delete-one realisation drops every pair with either member in the removed patch, so its weight
		sums exclude that patch's objects and its overlap keeps only the shared objects outside the
		patch in both samples.

		Parameters
		----------
		masks : dict or NoneType
			Mask dictionary for the data sample.
		masks_randoms : dict or NoneType
			Mask dictionary for the randoms.
		jk_patches : dict or NoneType, optional
			Masked patch labels, as returned by '_masked_jk_patches'. Default value = None
		num_jk : int, optional
			Number of jackknife patches. Default value = 0

		Returns
		-------
		dict, list of dict
			Normalisation for the full sample, with keys D, S, D_S, R_D, R_S, and one such dictionary
			per jackknife realisation (empty list when no patches are given).

		"""
		coords_D, coords_S, _, _ = self._sample_coordinates(masks, masks_randoms)
		n_D, n_S = len(self.data_dir["RA"]), len(self.data_dir["RA_shape_sample"])
		n_RD, n_RS = len(self.randoms_data["RA"]), len(self.randoms_data["RA_shape_sample"])
		# the weights of each slot are masked exactly as in the pair-count passes
		weights = {
			"D": self.data_dir["weight"][self._field_mask(masks, "weight", "RA", n_D)],
			"S": self.data_dir["weight_shape_sample"][
				self._field_mask(masks, "weight_shape_sample", "RA_shape_sample", n_S)],
			"R_D": self.randoms_data["weight"][self._field_mask(masks_randoms, "weight", "RA", n_RD)],
			"R_S": self.randoms_data["weight_shape_sample"][
				self._field_mask(masks_randoms, "weight_shape_sample", "RA_shape_sample", n_RS)],
		}
		weights = {key: np.asarray(w, dtype=np.float64) for key, w in weights.items()}
		D_S, ind_D, ind_S = overlap_weight(coords_D, coords_S, weights["D"], weights["S"])
		num_samples = {key: weight_sum(w) for key, w in weights.items()}
		num_samples["D_S"] = D_S

		num_samples_jk = []
		if jk_patches is not None:
			patch_keys = {"D": "position", "S": "shape", "R_D": "randoms_position", "R_S": "randoms_shape"}
			removed = {key: np.bincount(jk_patches[patch_keys[key]], weights=weights[key], minlength=num_jk)
					   for key in patch_keys}
			w_overlap = weights["D"][ind_D] * weights["S"][ind_S]
			p_D, p_S = jk_patches["position"][ind_D], jk_patches["shape"][ind_S]
			for i in range(num_jk):
				num_samples_i = {key: num_samples[key] - removed[key][i] for key in patch_keys}
				num_samples_i["D_S"] = float(np.sum(w_overlap[(p_D != i) & (p_S != i)]))
				num_samples_jk.append(num_samples_i)
		return num_samples, num_samples_jk

	def measure_xi_helper(self, method_count_pairs, method_shape_correlation, IA_estimator, dataset_name, corr_type,
						  masks=None, masks_randoms=None, cosmology=None, over_h=False, chunk_size=1000, num_nodes=1,
						  temp_file_path=None):
		# Shape-position combinations:
		# S+D (Cg+, Gg+)
		# S+R (Cg+, Gg+)
		if corr_type in ("g+", "both", "++", "all"):
			# S+D
			self.data = self.data_dir
			method_shape_correlation(masks=self._merged_masks(masks, masks), dataset_name=dataset_name,
									 over_h=over_h, data_suffix="_SplusD",
									 cosmology=cosmology, chunk_size=chunk_size, num_nodes=num_nodes,
									 temp_file_path=temp_file_path)
			# S+R -- randoms carry no shapes, so there is no shape-shape analogue of this
			# pass; a pure '++' run does not need it at all
			if corr_type != "++":
				self.data = {
					"Redshift": self.randoms_data["Redshift"],
					"Redshift_shape_sample": self.data_dir["Redshift_shape_sample"],
					"RA": self.randoms_data["RA"],
					"RA_shape_sample": self.data_dir["RA_shape_sample"],
					"DEC": self.randoms_data["DEC"],
					"DEC_shape_sample": self.data_dir["DEC_shape_sample"],
					"e1": self.data_dir["e1"],
					"e2": self.data_dir["e2"],
					"weight": self.randoms_data["weight"],
					"weight_shape_sample": self.data_dir["weight_shape_sample"]
				}
				# print(self.data)
				method_shape_correlation(masks=self._merged_masks(masks_randoms, masks), dataset_name=f"{dataset_name}",
										 over_h=over_h, data_suffix="_SplusR",
										 cosmology=cosmology, chunk_size=chunk_size, num_nodes=num_nodes,
										 temp_file_path=temp_file_path)

		# Position-position combinations:
		# SD (Cgg, Ggg)
		# SR (Cg+, Cgg, Ggg)
		# RD (Cgg, Ggg)
		# RR (Cgg, Gg+, Ggg)

		if corr_type == "gg":  # already have it for 'both'
			# SD (Cgg, Ggg)
			self.data = {
				"Redshift": self.data_dir["Redshift"],
				"Redshift_shape_sample": self.data_dir["Redshift_shape_sample"],
				"RA": self.data_dir["RA"],
				"RA_shape_sample": self.data_dir["RA_shape_sample"],
				"DEC": self.data_dir["DEC"],
				"DEC_shape_sample": self.data_dir["DEC_shape_sample"],
				"weight": self.data_dir["weight"],
				"weight_shape_sample": self.data_dir["weight_shape_sample"]
			}
			method_count_pairs(masks=self._merged_masks(masks, masks), dataset_name=dataset_name, over_h=over_h,
							   cosmology=cosmology,
							   data_suffix="_DD", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)

			# SR (Cg+, Cgg, Ggg) - watch name (Obs estimator) # if g+ or both, already have it
			self.data = {
				"Redshift": self.randoms_data["Redshift"],
				"Redshift_shape_sample": self.data_dir["Redshift_shape_sample"],
				"RA": self.randoms_data["RA"],
				"RA_shape_sample": self.data_dir["RA_shape_sample"],
				"DEC": self.randoms_data["DEC"],
				"DEC_shape_sample": self.data_dir["DEC_shape_sample"],
				"weight": self.randoms_data["weight"],
				"weight_shape_sample": self.data_dir["weight_shape_sample"]
			}
			method_count_pairs(masks=self._merged_masks(masks_randoms, masks), dataset_name=dataset_name,
							   over_h=over_h, cosmology=cosmology,
							   data_suffix="_SR", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)

		if corr_type in ("gg", "both", "all"):
			# RD (Cgg, Ggg)
			self.data = {
				"Redshift": self.data_dir["Redshift"],
				"Redshift_shape_sample": self.randoms_data["Redshift_shape_sample"],
				"RA": self.data_dir["RA"],
				"RA_shape_sample": self.randoms_data["RA_shape_sample"],
				"DEC": self.data_dir["DEC"],
				"DEC_shape_sample": self.randoms_data["DEC_shape_sample"],
				"weight": self.data_dir["weight"],
				"weight_shape_sample": self.randoms_data["weight_shape_sample"]
			}
			method_count_pairs(masks=self._merged_masks(masks, masks_randoms), dataset_name=dataset_name,
							   over_h=over_h, cosmology=cosmology,
							   data_suffix="_RD", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)

		if IA_estimator == "galaxies" or corr_type in ("gg", "both", "all", "++"):
			# RR (Cgg, Gg+, Ggg)
			self.data = {
				"Redshift": self.randoms_data["Redshift"],
				"Redshift_shape_sample": self.randoms_data["Redshift_shape_sample"],
				"RA": self.randoms_data["RA"],
				"RA_shape_sample": self.randoms_data["RA_shape_sample"],
				"DEC": self.randoms_data["DEC"],
				"DEC_shape_sample": self.randoms_data["DEC_shape_sample"],
				"weight": self.randoms_data["weight"],
				"weight_shape_sample": self.randoms_data["weight_shape_sample"]
			}
			method_count_pairs(masks=self._merged_masks(masks_randoms, masks_randoms), dataset_name=dataset_name,
							   over_h=over_h, cosmology=cosmology,
							   data_suffix="_RR", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)
		return

	def measure_xi_jk_helper(self, method_count_pairs, method_shape_correlation, IA_estimator, dataset_name,
							 corr_type, jk_patches=None, masks=None, masks_randoms=None, cosmology=None, over_h=False,
							 chunk_size=1000, num_nodes=1, temp_file_path=None):
		num_jk = max(jk_patches["shape"]) - min(jk_patches["shape"]) + 1
		# the counting passes run over the masked samples, so their patch labels must be masked too
		jk_patches = self._masked_jk_patches(jk_patches, masks, masks_randoms)
		# Shape-position combinations:
		# S+D (Cg+, Gg+)
		# S+R (Cg+, Gg+)
		if corr_type in ("g+", "both", "++", "all"):
			# S+D
			self.data = self.data_dir
			method_shape_correlation(jackknife_region_indices_pos=jk_patches["position"],
									 jackknife_region_indices_shape=jk_patches["shape"],
									 masks=self._merged_masks(masks, masks),
									 dataset_name=dataset_name,
									 jk_group_name=f"{dataset_name}_jk{num_jk}",
									 over_h=over_h, data_suffix="_SplusD",
									 cosmology=cosmology, chunk_size=chunk_size, num_nodes=num_nodes,
									 temp_file_path=temp_file_path)
			# S+R -- randoms carry no shapes, so there is no shape-shape analogue of this
			# pass; a pure '++' run does not need it at all
			if corr_type != "++":
				self.data = {
					"Redshift": self.randoms_data["Redshift"],
					"Redshift_shape_sample": self.data_dir["Redshift_shape_sample"],
					"RA": self.randoms_data["RA"],
					"RA_shape_sample": self.data_dir["RA_shape_sample"],
					"DEC": self.randoms_data["DEC"],
					"DEC_shape_sample": self.data_dir["DEC_shape_sample"],
					"e1": self.data_dir["e1"],
					"e2": self.data_dir["e2"],
					"weight": self.randoms_data["weight"],
					"weight_shape_sample": self.data_dir["weight_shape_sample"]
				}
				method_shape_correlation(jackknife_region_indices_pos=jk_patches["randoms_position"],
										 jackknife_region_indices_shape=jk_patches["shape"],
										 masks=self._merged_masks(masks_randoms, masks),
										 dataset_name=f"{dataset_name}", data_suffix="_SplusR",
										 over_h=over_h, jk_group_name=f"{dataset_name}_jk{num_jk}",
										 cosmology=cosmology, chunk_size=chunk_size, num_nodes=num_nodes,
										 temp_file_path=temp_file_path)

		# Position-position combinations:
		# SD (Cgg, Ggg)
		# SR (Cg+, Cgg, Ggg)
		# RD (Cgg, Ggg)
		# RR (Cgg, Gg+, Ggg)

		if corr_type == "gg":  # already have it for 'both'
			# SD (Cgg, Ggg)
			self.data = {
				"Redshift": self.data_dir["Redshift"],
				"Redshift_shape_sample": self.data_dir["Redshift_shape_sample"],
				"RA": self.data_dir["RA"],
				"RA_shape_sample": self.data_dir["RA_shape_sample"],
				"DEC": self.data_dir["DEC"],
				"DEC_shape_sample": self.data_dir["DEC_shape_sample"],
				"weight": self.data_dir["weight"],
				"weight_shape_sample": self.data_dir["weight_shape_sample"]
			}
			method_count_pairs(jackknife_region_indices_pos=jk_patches["position"],
							   jackknife_region_indices_shape=jk_patches["shape"],
							   masks=self._merged_masks(masks, masks), dataset_name=dataset_name, over_h=over_h,
							   cosmology=cosmology,
							   jk_group_name=f"{dataset_name}_jk{num_jk}",
							   data_suffix="_DD", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)

			# SR (Cg+, Cgg, Ggg) - watch name (Obs estimator) # if g+ or both, already have it
			self.data = {
				"Redshift": self.randoms_data["Redshift"],
				"Redshift_shape_sample": self.data_dir["Redshift_shape_sample"],
				"RA": self.randoms_data["RA"],
				"RA_shape_sample": self.data_dir["RA_shape_sample"],
				"DEC": self.randoms_data["DEC"],
				"DEC_shape_sample": self.data_dir["DEC_shape_sample"],
				"weight": self.randoms_data["weight"],
				"weight_shape_sample": self.data_dir["weight_shape_sample"]
			}
			method_count_pairs(jackknife_region_indices_pos=jk_patches["randoms_position"],
							   jackknife_region_indices_shape=jk_patches["shape"],
							   masks=self._merged_masks(masks_randoms, masks), dataset_name=dataset_name,
							   over_h=over_h, cosmology=cosmology,
							   jk_group_name=f"{dataset_name}_jk{num_jk}",
							   data_suffix="_SR", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)

		if corr_type in ("gg", "both", "all"):
			# RD (Cgg, Ggg)
			self.data = {
				"Redshift": self.data_dir["Redshift"],
				"Redshift_shape_sample": self.randoms_data["Redshift_shape_sample"],
				"RA": self.data_dir["RA"],
				"RA_shape_sample": self.randoms_data["RA_shape_sample"],
				"DEC": self.data_dir["DEC"],
				"DEC_shape_sample": self.randoms_data["DEC_shape_sample"],
				"weight": self.data_dir["weight"],
				"weight_shape_sample": self.randoms_data["weight_shape_sample"]
			}
			method_count_pairs(jackknife_region_indices_pos=jk_patches["position"],
							   jackknife_region_indices_shape=jk_patches["randoms_shape"],
							   masks=self._merged_masks(masks, masks_randoms), dataset_name=dataset_name,
							   over_h=over_h, cosmology=cosmology,
							   jk_group_name=f"{dataset_name}_jk{num_jk}",
							   data_suffix="_RD", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)

		if IA_estimator == "galaxies" or corr_type in ("gg", "both", "all", "++"):
			# RR (Cgg, Gg+, Ggg)
			self.data = {
				"Redshift": self.randoms_data["Redshift"],
				"Redshift_shape_sample": self.randoms_data["Redshift_shape_sample"],
				"RA": self.randoms_data["RA"],
				"RA_shape_sample": self.randoms_data["RA_shape_sample"],
				"DEC": self.randoms_data["DEC"],
				"DEC_shape_sample": self.randoms_data["DEC_shape_sample"],
				"weight": self.randoms_data["weight"],
				"weight_shape_sample": self.randoms_data["weight_shape_sample"]
			}
			method_count_pairs(jackknife_region_indices_pos=jk_patches["randoms_position"],
							   jackknife_region_indices_shape=jk_patches["randoms_shape"],
							   masks=self._merged_masks(masks_randoms, masks_randoms), dataset_name=dataset_name,
							   over_h=over_h, cosmology=cosmology,
							   jk_group_name=f"{dataset_name}_jk{num_jk}",
							   data_suffix="_RR", chunk_size=chunk_size, num_nodes=num_nodes,
							   temp_file_path=temp_file_path)

		return

	@worker_pool.pooled
	def measure_xi_w(self, IA_estimator, dataset_name, corr_type, jk_patches=None, num_jk=None,
					 masks=None, masks_randoms=None, cosmology=None, over_h=False, tree=True,
					 chunk_size=1000, temp_file_path=None, seed=None, responsivity=False):
		"""Measures xi_gg, xi_g+ and w_gg, w_g+ including jackknife covariance if desired for lightcone data.
		Manages the various _measure_xi_rp_pi_obs and _measure_jackknife_covariance options in MeasureWObservations
		and MeasureJackknife.

		Parameters
		----------
		IA_estimator : str
			Choose which type of xi estimator is used. Choose from "clusters" or "galaxies".
		dataset_name : str
			Name of the dataset in the output file.
		corr_type : str
			Type of correlation to be measured. Choose from [g+, gg, both].
		jk_patches : dict or NoneType, optional
			Dictionary with entries of the jackknife patch numbers (ndarray) for each sample, named "position", "shape"
			and "random". Default is None.
		num_jk : int, optional
			Number of jackknife patches to be generated internally. Default is None (no covariance).
			The jackknife covariance is measured whenever jk_patches is given, or num_jk is greater
			than 0; pass neither (or num_jk=0) to skip it.
		masks : dict or NoneType, optional
			Dictionary of mask information in the same form as the data dictionary, where the masks are placed over
			the data to apply selections. Default is None.
		masks_randoms : dict or NoneType, optional
			Dictionary of mask information for the randoms data in the same form as the data dictionary,
			where the masks are placed over the data to apply selections. Default is None.
		cosmology : pyccl cosmology object or NoneType, optional
			Pyccl cosmology to use in the calculation. If None (default), the cosmology is used:
			ccl.Cosmology(Omega_c=0.225, Omega_b=0.045, sigma8=0.8, h=0.7, n_s=1.0)
		over_h : bool, optional
			If True, the units are assumed to be in not-over-h and converted to over-h units. Default is False.
		tree : bool, optional
			If True (default), pair counts use a KDTree backend; if False, a brute-force pair count is used.
			Default is True.
		chunk_size: int, optional
			Size of the chunks of data sent to each multiprocessing node. If larger, more RAM is needed per node.
			Default is 1000.
		temp_file_path : str or NoneType, optional
			Path to where the data is temporarily stored during multiprocessing [file name generated
			automatically]. Default is None.
		seed : int or NoneType, optional
			Seed for the internal jackknife patch generation (used only when num_jk is given), making the patch
			assignment reproducible. Default is None.
		responsivity : bool, optional
			If True, the g+ shape signal is calibrated by dividing by the responsivity factor 2R, with
			R = <w (1 - e^2 / 2)> / <w> the weighted shear responsivity. Default is False, appropriate when the
			input e1/e2 are already calibrated shears (e.g. from a shear catalogue); set to True for raw
			distortions. Only the g+ correlations are affected; the clustering (gg) signal is unchanged.
			Default is False.

		"""
		if IA_estimator == "clusters":
			if self.randoms_data == None:
				print("No randoms given, correlation defined as S+D/DD")
				raise KeyError("This version does not work yet, add randoms.")
			else:
				print("xi_g+ defined as S+D/SD - S+R/SR, xi_gg as (SD - RD - SR)/RR + 1")
				if masks != None and masks_randoms == None:
					print("Warning, masks given for data vector but not for randoms.")
		elif IA_estimator == "galaxies":
			if self.randoms_data == None:
				raise KeyError("No randoms given. Please provide input.")
			else:
				print("xi_g+ defined as (S+D - S+R)/RR, xi_gg as (SD - RD - SR)/RR + 1")
				if masks != None and masks_randoms == None:
					print("Warning, masks given for data vector but not for randoms.")
		else:
			raise KeyError("Unknown input for IA_estimator, choose from [clusters, galaxies].")

		if corr_type not in CORR_TYPES:
			raise ValueError(f"Unknown corr_type {corr_type!r}. Choose from {sorted(CORR_TYPES)}.")
		if corr_type in SHAPE_SHAPE_CORR_TYPES:
			if not getattr(self, "has_density_sample_shapes", False):
				raise ValueError(
					f"corr_type={corr_type!r} correlates the shapes of both samples, so the "
					f"density sample needs shapes of its own. Supply 'e1_density_sample' and "
					f"'e2_density_sample' (or the names you gave the constructor).")
			if IA_estimator == "clusters":
				# xi_++ = S+S+/RR has no published 'clusters' analogue: that estimator
				# normalises by the clustering counts, and inventing a form for it here
				# would be our own definition rather than a documented one.
				raise ValueError(
					f"IA_estimator='clusters' is not defined for corr_type={corr_type!r}. "
					f"Use IA_estimator='galaxies' for shape-shape correlations.")
		# tells pair_kernel (via the backends) to accumulate the shape-shape products; an
		# attribute rather than an argument because the mp backends pickle `self` into
		# their workers and read their options off it the same way
		self._shape_mode = "both" if corr_type in SHAPE_SHAPE_CORR_TYPES else True

		self.responsivity_correction = responsivity
		masks = self.rename_input_keys(masks, self._input_name_map)
		masks_randoms = self.rename_input_keys(masks_randoms, self._input_name_map)
		# todo: Expand to include methods with trees and internal multiproc
		# todo: Checks to see if data directories include everything they need
		data = self.data  # temporary save so it can be restored at the end of the calculation

		try:  # Are there one or two random samples given?
			random_shape = self.randoms_data["RA_shape_sample"]
			one_random_sample = False
		except (KeyError, TypeError):  # TypeError: randoms_data is None
			one_random_sample = True
			self.randoms_data["RA_shape_sample"] = self.randoms_data["RA"]
			self.randoms_data["DEC_shape_sample"] = self.randoms_data["DEC"]
			self.randoms_data["Redshift_shape_sample"] = self.randoms_data["Redshift"]
		if "weight" not in self.randoms_data:
			self.randoms_data["weight"] = np.ones(len(self.randoms_data["RA"]))
		if "weight_shape_sample" not in self.randoms_data:
			if one_random_sample:
				self.randoms_data["weight_shape_sample"] = self.randoms_data["weight"]  # in case weights are given
			else:
				self.randoms_data["weight_shape_sample"] = np.ones(len(self.randoms_data["RA_shape_sample"]))

		# Covariance is requested by supplying patches or a positive patch count; num_jk=0/None
		# with no jk_patches means "no covariance", matching MeasureIABox's num_jk=0.
		measure_cov = jk_patches is not None or (num_jk is not None and num_jk > 0)
		if measure_cov:
			if jk_patches is None:
				jk_patches = self.assign_jackknife_patches(data, self.randoms_data, num_jk, seed=seed)
			else:
				if one_random_sample:
					jk_patches["randoms_position"] = jk_patches["randoms"]
					jk_patches["randoms_shape"] = jk_patches["randoms"]
			min_patch = min(jk_patches["shape"])
			max_patch = max(jk_patches["shape"])
			num_jk = max_patch - min_patch + 1
			if min_patch != 0:
				raise ValueError(
					f"Jackknife patch indices must start at 0 (minimum patch index found: {min_patch}). "
					"Renumber jk_patches, e.g. patches -= patches.min().")

		self.data_dir = data
		if "weight" not in self.data_dir:
			self.data_dir["weight"] = np.ones(len(self.data_dir["RA"]))
		if "weight_shape_sample" not in self.data_dir:
			self.data_dir["weight_shape_sample"] = np.ones(len(self.data_dir["RA_shape_sample"]))

		# Weighted sample sizes, needed to correct for a different number (and total weight) of randoms and
		# galaxies/clusters in the data. Masks are resolved per field, defaulting to the sample's coordinate
		# mask (see _field_mask); the patch labels are masked to match.
		num_samples, num_samples_jk = self._sample_normalisation(
			masks, masks_randoms,
			jk_patches=self._masked_jk_patches(jk_patches, masks, masks_randoms) if measure_cov else None,
			num_jk=num_jk if measure_cov else 0)

		if measure_cov:
			if self.num_nodes == 1:
				if tree:
					self.measure_xi_jk_helper(self._count_pairs_xi_rp_pi_lightcone_jk_tree,
											  self._measure_xi_rp_pi_lightcone_jk_tree, IA_estimator, dataset_name,
											  corr_type, jk_patches=jk_patches, masks=masks,
											  masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
											  chunk_size=chunk_size, num_nodes=self.num_nodes,
											  temp_file_path=temp_file_path)
				else:
					self.measure_xi_jk_helper(self._count_pairs_xi_rp_pi_lightcone_jk_brute,
											  self._measure_xi_rp_pi_lightcone_jk_brute, IA_estimator, dataset_name,
											  corr_type, jk_patches=jk_patches, masks=masks,
											  masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
											  chunk_size=chunk_size, num_nodes=self.num_nodes,
											  temp_file_path=temp_file_path)
			else:
				self.measure_xi_jk_helper(self._count_pairs_xi_rp_pi_lightcone_jk_multiprocessing,
										  self._measure_xi_rp_pi_lightcone_jk_multiprocessing, IA_estimator,
										  dataset_name, corr_type, jk_patches=jk_patches, masks=masks,
										  masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
										  chunk_size=chunk_size, num_nodes=self.num_nodes,
										  temp_file_path=temp_file_path)
			self._obs_estimator([corr_type, "w"], IA_estimator, dataset_name, num_samples)
			self._measure_w_g_i(corr_type=corr_type, dataset_name=dataset_name, return_output=False)
			for i in np.arange(num_jk):
				num_samples_i = num_samples_jk[i]
				self._obs_estimator([corr_type, "w"], IA_estimator, f"{dataset_name}_{i}",
									num_samples_i, jk_group_name=f"{dataset_name}_jk{num_jk}")

				self._measure_w_g_i(corr_type=corr_type, dataset_name=f"{dataset_name}_{i}",
									jk_group_name=f"{dataset_name}_jk{num_jk}", return_output=False)
			corr_group = [w_name for _, w_name in W_PRODUCTS[corr_type]]
			self._combine_jackknife_information(dataset_name=dataset_name, jk_group_name=f"{dataset_name}_jk{num_jk}",
												corr_group=corr_group, num_box=num_jk)
		else:
			if self.num_nodes > 1:
				# Full-sample multiprocessing. This branch did not exist before
				# 0.5.0: num_nodes was accepted, passed down, and then ignored,
				# because only the jackknife path had an mp implementation
				# (benchmarks/FINDINGS.md F4). tree/brute is not consulted here
				# because the mp backend is the tree algorithm by construction.
				self.measure_xi_helper(self._count_pairs_xi_rp_pi_lightcone_multiprocessing,
									   self._measure_xi_rp_pi_lightcone_multiprocessing,
									   IA_estimator, dataset_name, corr_type, masks=masks,
									   masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
									   chunk_size=chunk_size, num_nodes=self.num_nodes,
									   temp_file_path=temp_file_path)
			elif tree:
				self.measure_xi_helper(self._count_pairs_xi_rp_pi_lightcone_tree,
									   self._measure_xi_rp_pi_lightcone_tree,
									   IA_estimator, dataset_name, corr_type, masks=masks,
									   masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
									   chunk_size=chunk_size, num_nodes=self.num_nodes,
									   temp_file_path=temp_file_path)
			else:
				self.measure_xi_helper(self._count_pairs_xi_rp_pi_lightcone_brute,
									   self._measure_xi_rp_pi_lightcone_brute,
									   IA_estimator, dataset_name, corr_type, masks=masks,
									   masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
									   chunk_size=chunk_size, num_nodes=self.num_nodes,
									   temp_file_path=temp_file_path)
			self._obs_estimator([corr_type, "w"], IA_estimator, dataset_name, num_samples)
			self._measure_w_g_i(corr_type=corr_type, dataset_name=dataset_name, return_output=False)

		self.data = data
		return

	@worker_pool.pooled
	def measure_xi_multipoles(self, IA_estimator, dataset_name, corr_type, jk_patches=None, num_jk=None,
							  masks=None, masks_randoms=None, cosmology=None, over_h=False,
							  tree=True, chunk_size=1000, temp_file_path=None, seed=None, responsivity=False):
		"""Measures xi_gg, xi_g+ and multipoles including jackknife covariance if desired for lightcone data.
		Manages the various _measure_xi_rp_pi_obs and _measure_jackknife_covariance options in MeasureWObservations
		and MeasureJackknife.

		Parameters
		----------
		IA_estimator : str
			Choose which type of xi estimator is used. Choose from "clusters" or "galaxies".
		dataset_name : str
			Name of the dataset in the output file.
		corr_type : str
			Type of correlation to be measured. Choose from [g+, gg, both].
		jk_patches : dict or NoneType, optional
			Dictionary with entries of the jackknife patch numbers (ndarray) for each sample, named "position", "shape"
			and "random". Default is None.
		num_jk : int, optional
			Number of jackknife patches to be generated internally. Default is None (no covariance).
			The jackknife covariance is measured whenever jk_patches is given, or num_jk is greater
			than 0; pass neither (or num_jk=0) to skip it.
		masks : dict or NoneType, optional
			Dictionary of mask information in the same form as the data dictionary, where the masks are placed over
			the data to apply selections. Default is None.
		masks_randoms : dict or NoneType, optional
			Dictionary of mask information for the randoms data in the same form as the data dictionary,
			where the masks are placed over the data to apply selections. Default is None.
		cosmology : pyccl cosmology object or NoneType, optional
			Pyccl cosmology to use in the calculation. If None (default), the cosmology is used:
			ccl.Cosmology(Omega_c=0.225, Omega_b=0.045, sigma8=0.8, h=0.7, n_s=1.0)
		over_h : bool, optional
			If True, the units are assumed to be in not-over-h and converted to over-h units. Default is False.
		tree : bool, optional
			If True (default), pair counts use a KDTree backend; if False, a brute-force pair count is used.
			Default is True.
		chunk_size: int, optional
			Size of the chunks of data sent to each multiprocessing node. If larger, more RAM is needed per node.
			Default is 1000.
		temp_file_path : str or NoneType, optional
			Path to where the data is temporarily stored during multiprocessing [file name generated
			automatically]. Default is None.
		seed : int or NoneType, optional
			Seed for the internal jackknife patch generation (used only when num_jk is given), making the patch
			assignment reproducible. Default is None.
		responsivity : bool, optional
			If True, the g+ shape signal is calibrated by dividing by the responsivity factor 2R, with
			R = <w (1 - e^2 / 2)> / <w> the weighted shear responsivity. Default is False, appropriate when the
			input e1/e2 are already calibrated shears (e.g. from a shear catalogue); set to True for raw
			distortions. Only the g+ correlations are affected; the clustering (gg) signal is unchanged.
			Default is False.

		"""
		if IA_estimator == "clusters":
			if self.randoms_data == None:
				print("No randoms given, correlation defined as S+D/DD")
				raise KeyError("This version does not work yet, add randoms.")
			else:
				print("xi_g+ defined as S+D/SD - S+R/SR, xi_gg as (SD - RD - SR)/RR + 1")
				if masks != None and masks_randoms == None:
					print("Warning, masks given for data vector but not for randoms.")
		elif IA_estimator == "galaxies":
			if self.randoms_data == None:
				raise KeyError("No randoms given. Please provide input.")
			else:
				print("xi_g+ defined as (S+D - S+R)/RR, xi_gg as (SD - RD - SR)/RR + 1")
				if masks != None and masks_randoms == None:
					print("Warning, masks given for data vector but not for randoms.")
		else:
			raise KeyError("Unknown input for IA_estimator, choose from [clusters, galaxies].")

		if corr_type not in CORR_TYPES:
			raise ValueError(f"Unknown corr_type {corr_type!r}. Choose from {sorted(CORR_TYPES)}.")
		if corr_type in SHAPE_SHAPE_CORR_TYPES:
			if not getattr(self, "has_density_sample_shapes", False):
				raise ValueError(
					f"corr_type={corr_type!r} correlates the shapes of both samples, so the "
					f"density sample needs shapes of its own. Supply 'e1_density_sample' and "
					f"'e2_density_sample' (or the names you gave the constructor).")
			if IA_estimator == "clusters":
				# xi_++ = S+S+/RR has no published 'clusters' analogue: that estimator
				# normalises by the clustering counts, and inventing a form for it here
				# would be our own definition rather than a documented one.
				raise ValueError(
					f"IA_estimator='clusters' is not defined for corr_type={corr_type!r}. "
					f"Use IA_estimator='galaxies' for shape-shape correlations.")
		# tells pair_kernel (via the backends) to accumulate the shape-shape products; an
		# attribute rather than an argument because the mp backends pickle `self` into
		# their workers and read their options off it the same way
		self._shape_mode = "both" if corr_type in SHAPE_SHAPE_CORR_TYPES else True

		self.responsivity_correction = responsivity
		masks = self.rename_input_keys(masks, self._input_name_map)
		masks_randoms = self.rename_input_keys(masks_randoms, self._input_name_map)
		# todo: Expand to include methods with trees and internal multiproc
		# todo: Checks to see if data directories include everything they need
		data = self.data  # temporary save so it can be restored at the end of the calculation

		try:  # Are there one or two random samples given?
			random_shape = self.randoms_data["RA_shape_sample"]
			one_random_sample = False
		except (KeyError, TypeError):  # TypeError: randoms_data is None
			one_random_sample = True
			self.randoms_data["RA_shape_sample"] = self.randoms_data["RA"]
			self.randoms_data["DEC_shape_sample"] = self.randoms_data["DEC"]
			self.randoms_data["Redshift_shape_sample"] = self.randoms_data["Redshift"]
		if "weight" not in self.randoms_data:
			self.randoms_data["weight"] = np.ones(len(self.randoms_data["RA"]))
		if "weight_shape_sample" not in self.randoms_data:
			if one_random_sample:
				self.randoms_data["weight_shape_sample"] = self.randoms_data["weight"]  # in case weights are given
			else:
				self.randoms_data["weight_shape_sample"] = np.ones(len(self.randoms_data["RA_shape_sample"]))

		# Covariance is requested by supplying patches or a positive patch count; num_jk=0/None
		# with no jk_patches means "no covariance", matching MeasureIABox's num_jk=0.
		measure_cov = jk_patches is not None or (num_jk is not None and num_jk > 0)
		if measure_cov:
			if jk_patches is None:
				jk_patches = self.assign_jackknife_patches(data, self.randoms_data, num_jk, seed=seed)
			else:
				if one_random_sample:
					jk_patches["randoms_position"] = jk_patches["randoms"]
					jk_patches["randoms_shape"] = jk_patches["randoms"]
			min_patch = min(jk_patches["shape"])
			max_patch = max(jk_patches["shape"])
			num_jk = max_patch - min_patch + 1
			if min_patch != 0:
				raise ValueError(
					f"Jackknife patch indices must start at 0 (minimum patch index found: {min_patch}). "
					"Renumber jk_patches, e.g. patches -= patches.min().")

		self.data_dir = data
		if "weight" not in self.data_dir:
			self.data_dir["weight"] = np.ones(len(self.data_dir["RA"]))
		if "weight_shape_sample" not in self.data_dir:
			self.data_dir["weight_shape_sample"] = np.ones(len(self.data_dir["RA_shape_sample"]))

		# Weighted sample sizes, needed to correct for a different number (and total weight) of randoms and
		# galaxies/clusters in the data. Masks are resolved per field, defaulting to the sample's coordinate
		# mask (see _field_mask); the patch labels are masked to match.
		num_samples, num_samples_jk = self._sample_normalisation(
			masks, masks_randoms,
			jk_patches=self._masked_jk_patches(jk_patches, masks, masks_randoms) if measure_cov else None,
			num_jk=num_jk if measure_cov else 0)

		if measure_cov:
			if self.num_nodes == 1:
				if tree:
					self.measure_xi_jk_helper(self._count_pairs_xi_r_mur_lightcone_jk_tree,
											  self._measure_xi_r_mur_lightcone_jk_tree, IA_estimator, dataset_name,
											  corr_type, jk_patches=jk_patches, masks=masks,
											  masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
											  chunk_size=chunk_size, num_nodes=self.num_nodes,
											  temp_file_path=temp_file_path)
				else:
					self.measure_xi_jk_helper(self._count_pairs_xi_r_mur_lightcone_jk_brute,
											  self._measure_xi_r_mur_lightcone_jk_brute, IA_estimator, dataset_name,
											  corr_type, jk_patches=jk_patches, masks=masks,
											  masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
											  chunk_size=chunk_size, num_nodes=self.num_nodes,
											  temp_file_path=temp_file_path)
			else:
				self.measure_xi_jk_helper(self._count_pairs_xi_r_mur_lightcone_jk_multiprocessing,
										  self._measure_xi_r_mur_lightcone_jk_multiprocessing, IA_estimator,
										  dataset_name, corr_type, jk_patches=jk_patches, masks=masks,
										  masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h,
										  chunk_size=chunk_size, num_nodes=self.num_nodes,
										  temp_file_path=temp_file_path)
			self._obs_estimator([corr_type, "multipoles"], IA_estimator, dataset_name, num_samples)
			self._measure_multipoles(corr_type=corr_type, dataset_name=dataset_name, return_output=False)
			for i in np.arange(num_jk):
				num_samples_i = num_samples_jk[i]
				self._obs_estimator([corr_type, "multipoles"], IA_estimator, f"{dataset_name}_{i}",
									num_samples_i, jk_group_name=f"{dataset_name}_jk{num_jk}")

				self._measure_multipoles(corr_type=corr_type, dataset_name=f"{dataset_name}_{i}",
										 jk_group_name=f"{dataset_name}_jk{num_jk}", return_output=False)
			corr_group = [m_name for _, m_name, _ in M_PRODUCTS[corr_type]]
			self._combine_jackknife_information(dataset_name=dataset_name, jk_group_name=f"{dataset_name}_jk{num_jk}",
												corr_group=corr_group, num_box=num_jk)
		else:
			if self.num_nodes > 1:
				# See the matching comment in measure_xi_w: full-sample
				# multiprocessing for the lightcone is new in 0.5.0.
				self.measure_xi_helper(self._count_pairs_xi_r_mur_lightcone_multiprocessing,
									   self._measure_xi_r_mur_lightcone_multiprocessing,
									   IA_estimator, dataset_name, corr_type, masks=masks,
									   temp_file_path=temp_file_path,
									   chunk_size=chunk_size, num_nodes=self.num_nodes,
									   masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h)
			elif tree:
				self.measure_xi_helper(self._count_pairs_xi_r_mur_lightcone_tree,
									   self._measure_xi_r_mur_lightcone_tree,
									   IA_estimator, dataset_name, corr_type, masks=masks,
									   temp_file_path=temp_file_path,
									   chunk_size=chunk_size, num_nodes=self.num_nodes,
									   masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h)
			else:
				self.measure_xi_helper(self._count_pairs_xi_r_mur_lightcone_brute,
									   self._measure_xi_r_mur_lightcone_brute,
									   IA_estimator, dataset_name, corr_type, masks=masks,
									   temp_file_path=temp_file_path,
									   chunk_size=chunk_size, num_nodes=self.num_nodes,
									   masks_randoms=masks_randoms, cosmology=cosmology, over_h=over_h)
			self._obs_estimator([corr_type, "multipoles"], IA_estimator, dataset_name, num_samples)
			self._measure_multipoles(corr_type=corr_type, dataset_name=dataset_name, return_output=False)

		self.data = data
		return