def process(self, cat1, cat2=None, metric=None, num_threads=None, comm=None, low_mem=False): """Compute the correlation function. If only 1 argument is given, then compute an auto-correlation function. If 2 arguments are given, then compute a cross-correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. Parameters: cat1 (Catalog): A catalog or list of catalogs for the first K field. cat2 (Catalog): A catalog or list of catalogs for the second K field, if any. (default: None) metric (str): Which metric to use. See `Metrics` for details. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) num_threads (int): How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) comm (mpi4py.Comm): If running MPI, an mpi4py Comm object to communicate between processes. If used, the rank=0 process will have the final computation. This only works if using patches. (default: None) low_mem (bool): Whether to sacrifice a little speed to try to reduce memory usage. This only works if using patches. (default: False) """ import math self.clear() if not isinstance(cat1, list): self.npatch1 = cat1._npatch cat1 = cat1.get_patches(low_mem=low_mem) if cat2 is None: self.npatch2 = self.npatch1 if cat2 is not None and not isinstance(cat2, list): self.npatch2 = cat2._npatch cat2 = cat2.get_patches(low_mem=low_mem) if cat2 is None: vark1 = treecorr.calculateVarK(cat1) vark2 = vark1 self.logger.info("vark = %f: sig_k = %f", vark1, math.sqrt(vark1)) self._process_all_auto(cat1, metric, num_threads, comm, low_mem) else: vark1 = treecorr.calculateVarK(cat1) vark2 = treecorr.calculateVarK(cat2) self.logger.info("vark1 = %f: sig_k = %f", vark1, math.sqrt(vark1)) self.logger.info("vark2 = %f: sig_k = %f", vark2, math.sqrt(vark2)) self._process_all_cross(cat1, cat2, metric, num_threads, comm, low_mem) self.finalize(vark1, vark2)
def process(self, cat1, cat2=None, cat3=None, metric=None, num_threads=None): """Accumulate the number of triangles of points between cat1, cat2, and cat3. - If only 1 argument is given, then compute an auto-correlation function. - If 2 arguments are given, then compute a cross-correlation function with the first catalog taking two corners of the triangles. (Not implemented yet.) - If 3 arguments are given, then compute a cross-correlation function. All arguments may be lists, in which case all items in the list are used for that element of the correlation. Note: For a correlation of multiple catalogs, it matters which corner of the triangle comes from which catalog. The final accumulation will have d1 > d2 > d3 where d1 is between two points in cat2,cat3; d2 is between points in cat1,cat3; and d3 is between points in cat1,cat2. To accumulate all the possible triangles between three catalogs, you should call this multiple times with the different catalogs in different positions. Parameters: cat1 (Catalog): A catalog or list of catalogs for the first N field. cat2 (Catalog): A catalog or list of catalogs for the second N field, if any. (default: None) cat3 (Catalog): A catalog or list of catalogs for the third N field, if any. (default: None) metric (str): Which metric to use. See `Metrics` for details. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) num_threads (int): How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) """ import math self.clear() if not isinstance(cat1,list): cat1 = [cat1] if cat2 is not None and not isinstance(cat2,list): cat2 = [cat2] if cat3 is not None and not isinstance(cat3,list): cat3 = [cat3] if cat2 is None and cat3 is None: vark1 = treecorr.calculateVarK(cat1) vark2 = vark1 vark3 = vark1 self.logger.info("vark = %f: sig_k = %f",vark1,math.sqrt(vark1)) self._process_all_auto(cat1, metric, num_threads) elif (cat2 is None) != (cat3 is None): raise NotImplementedError("No partial cross GGG yet.") else: assert cat2 is not None and cat3 is not None vark1 = treecorr.calculateVarK(cat1) vark2 = treecorr.calculateVarK(cat2) vark3 = treecorr.calculateVarK(cat3) self.logger.info("vark1 = %f: sig_k = %f",vark1,math.sqrt(vark1)) self.logger.info("vark2 = %f: sig_k = %f",vark2,math.sqrt(vark2)) self.logger.info("vark3 = %f: sig_k = %f",vark3,math.sqrt(vark3)) self._process_all_cross(cat1,cat2,cat3, metric, num_threads) self.finalize(vark1,vark2,vark3)
def process(self, cat1, cat2=None, metric=None, num_threads=None): """Compute the correlation function. If only 1 argument is given, then compute an auto-correlation function. If 2 arguments are given, then compute a cross-correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. :param cat1: A catalog or list of catalogs for the first K field. :param cat2: A catalog or list of catalogs for the second K field, if any. (default: None) :param metric: Which metric to use for distance measurements. Options are: - 'Euclidean' = straight line Euclidean distance between two points. For spherical coordinates (ra,dec without r), this is the chord distance between points on the unit sphere. - 'Rperp' = the perpendicular component of the distance. For two points with distance from Earth `r1, r2`, if `d` is the normal Euclidean distance and :math:`Rparallel = |r1-r2|`, then we define :math:`Rperp^2 = d^2 - Rparallel^2`. - 'Rlens' = the projected distance perpendicular to the first point in the pair (taken to be a lens) to the line of sight to the second point (e.g. a lensed source galaxy). - 'Arc' = the true great circle distance for spherical coordinates. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) :param num_threads: How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) Note that this won't work if the system's C compiler is clang prior to version 3.7. """ import math self.clear() if not isinstance(cat1, list): cat1 = [cat1] if cat2 is not None and not isinstance(cat2, list): cat2 = [cat2] if len(cat1) == 0: raise ValueError("No catalogs provided for cat1") if cat2 is None or len(cat2) == 0: vark1 = treecorr.calculateVarK(cat1) vark2 = vark1 self.logger.info("vark = %f: sig_k = %f", vark1, math.sqrt(vark1)) self._process_all_auto(cat1, metric, num_threads) else: vark1 = treecorr.calculateVarK(cat1) vark2 = treecorr.calculateVarK(cat2) self.logger.info("vark1 = %f: sig_k = %f", vark1, math.sqrt(vark1)) self.logger.info("vark2 = %f: sig_k = %f", vark2, math.sqrt(vark2)) self._process_all_cross(cat1, cat2, metric, num_threads) self.finalize(vark1, vark2)
def process(self, cat1, cat2=None, metric=None, num_threads=None): """Compute the correlation function. If only 1 argument is given, then compute an auto-correlation function. If 2 arguments are given, then compute a cross-correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. :param cat1: A catalog or list of catalogs for the first K field. :param cat2: A catalog or list of catalogs for the second K field, if any. (default: None) :param metric: Which metric to use for distance measurements. Options are: - 'Euclidean' = straight line Euclidean distance between two points. For spherical coordinates (ra,dec without r), this is the chord distance between points on the unit sphere. - 'Rperp' = the perpendicular component of the distance. For two points with distance from Earth `r1, r2`, if `d` is the normal Euclidean distance and :math:`Rparallel = |r1-r2|`, then we define :math:`Rperp^2 = d^2 - Rparallel^2`. - 'Rlens' = the projected distance perpendicular to the first point in the pair (taken to be a lens) to the line of sight to the second point (e.g. a lensed source galaxy). - 'Arc' = the true great circle distance for spherical coordinates. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) :param num_threads: How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) Note that this won't work if the system's C compiler is clang prior to version 3.7. """ import math self.clear() if not isinstance(cat1,list): cat1 = [cat1] if cat2 is not None and not isinstance(cat2,list): cat2 = [cat2] if len(cat1) == 0: raise ValueError("No catalogs provided for cat1") if cat2 is None or len(cat2) == 0: vark1 = treecorr.calculateVarK(cat1) vark2 = vark1 self.logger.info("vark = %f: sig_k = %f",vark1,math.sqrt(vark1)) self._process_all_auto(cat1,metric,num_threads) else: vark1 = treecorr.calculateVarK(cat1) vark2 = treecorr.calculateVarK(cat2) self.logger.info("vark1 = %f: sig_k = %f",vark1,math.sqrt(vark1)) self.logger.info("vark2 = %f: sig_k = %f",vark2,math.sqrt(vark2)) self._process_all_cross(cat1,cat2,metric,num_threads) self.finalize(vark1,vark2)
def process(self, cat1, cat2, metric=None, num_threads=None): """Compute the correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. :param cat1: A catalog or list of catalogs for the N field. :param cat2: A catalog or list of catalogs for the K field. :param metric: Which metric to use for distance measurements. Options are given in the doc string of :class:`~treecorr.BinnedCorr2`. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) :param num_threads: How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) Note that this won't work if the system's C compiler is clang prior to version 3.7. """ import math self.clear() if not isinstance(cat1, list): cat1 = [cat1] if not isinstance(cat2, list): cat2 = [cat2] vark = treecorr.calculateVarK(cat2) self.logger.info("vark = %f: sig_k = %f", vark, math.sqrt(vark)) self._process_all_cross(cat1, cat2, metric, num_threads) self.finalize(vark)
def process(self, cat1, cat2, metric=None, num_threads=None): """Compute the correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. Parameters: cat1 (Catalog): A catalog or list of catalogs for the K field. cat2 (Catalog): A catalog or list of catalogs for the G field. metric (str): Which metric to use. See `Metrics` for details. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) num_threads (int): How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) """ import math self.clear() if not isinstance(cat1, list): cat1 = [cat1] if not isinstance(cat2, list): cat2 = [cat2] vark = treecorr.calculateVarK(cat1) varg = treecorr.calculateVarG(cat2) self.logger.info("vark = %f: sig_k = %f", vark, math.sqrt(vark)) self.logger.info("varg = %f: sig_sn (per component) = %f", varg, math.sqrt(varg)) self._process_all_cross(cat1, cat2, metric, num_threads) self.finalize(vark, varg)
def process(self, cat1, cat2, metric=None, num_threads=None): """Compute the correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. Parameters: cat1 (Catalog): A catalog or list of catalogs for the K field. cat2 (Catalog): A catalog or list of catalogs for the G field. metric (str): Which metric to use. See `Metrics` for details. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) num_threads (int): How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) """ import math self.clear() if not isinstance(cat1,list): cat1 = [cat1] if not isinstance(cat2,list): cat2 = [cat2] vark = treecorr.calculateVarK(cat1) varg = treecorr.calculateVarG(cat2) self.logger.info("vark = %f: sig_k = %f",vark,math.sqrt(vark)) self.logger.info("varg = %f: sig_sn (per component) = %f",varg,math.sqrt(varg)) self._process_all_cross(cat1,cat2,metric,num_threads) self.finalize(vark,varg)
def process(self, cat1, cat2=None, metric=None, num_threads=None): """Compute the correlation function. If only 1 argument is given, then compute an auto-correlation function. If 2 arguments are given, then compute a cross-correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. Parameters: cat1 (Catalog): A catalog or list of catalogs for the first K field. cat2 (Catalog): A catalog or list of catalogs for the second K field, if any. (default: None) metric (str): Which metric to use. See `Metrics` for details. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) num_threads (int): How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) """ import math self.clear() if not isinstance(cat1, list): cat1 = [cat1] if cat2 is not None and not isinstance(cat2, list): cat2 = [cat2] if cat2 is None: vark1 = treecorr.calculateVarK(cat1) vark2 = vark1 self.logger.info("vark = %f: sig_k = %f", vark1, math.sqrt(vark1)) self._process_all_auto(cat1, metric, num_threads) else: vark1 = treecorr.calculateVarK(cat1) vark2 = treecorr.calculateVarK(cat2) self.logger.info("vark1 = %f: sig_k = %f", vark1, math.sqrt(vark1)) self.logger.info("vark2 = %f: sig_k = %f", vark2, math.sqrt(vark2)) self._process_all_cross(cat1, cat2, metric, num_threads) self.finalize(vark1, vark2)
def process(self, cat1, cat2=None, metric=None, num_threads=None): """Compute the correlation function. If only 1 argument is given, then compute an auto-correlation function. If 2 arguments are given, then compute a cross-correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. Parameters: cat1 (Catalog): A catalog or list of catalogs for the first K field. cat2 (Catalog): A catalog or list of catalogs for the second K field, if any. (default: None) metric (str): Which metric to use. See `Metrics` for details. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) num_threads (int): How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) """ import math self.clear() if not isinstance(cat1,list): cat1 = [cat1] if cat2 is not None and not isinstance(cat2,list): cat2 = [cat2] if cat2 is None: vark1 = treecorr.calculateVarK(cat1) vark2 = vark1 self.logger.info("vark = %f: sig_k = %f",vark1,math.sqrt(vark1)) self._process_all_auto(cat1,metric,num_threads) else: vark1 = treecorr.calculateVarK(cat1) vark2 = treecorr.calculateVarK(cat2) self.logger.info("vark1 = %f: sig_k = %f",vark1,math.sqrt(vark1)) self.logger.info("vark2 = %f: sig_k = %f",vark2,math.sqrt(vark2)) self._process_all_cross(cat1,cat2,metric,num_threads) self.finalize(vark1,vark2)
def process(self, cat1, cat2, metric=None, num_threads=None): """Compute the correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. :param cat1: A catalog or list of catalogs for the K field. :param cat2: A catalog or list of catalogs for the G field. :param metric: Which metric to use for distance measurements. Options are: - 'Euclidean' = straight line Euclidean distance between two points. For spherical coordinates (ra,dec without r), this is the chord distance between points on the unit sphere. - 'Rperp' = the perpendicular component of the distance. For two points with distance from Earth `r1, r2`, if `d` is the normal Euclidean distance and :math:`Rparallel = |r1-r2|`, then we define :math:`Rperp^2 = d^2 - Rparallel^2`. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) :param num_threads: How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) Note that this won't work if the system's C compiler is clang prior to version 3.7. """ import math self.clear() if not isinstance(cat1, list): cat1 = [cat1] if not isinstance(cat2, list): cat2 = [cat2] if len(cat1) == 0: raise ValueError("No catalogs provided for cat1") if len(cat2) == 0: raise ValueError("No catalogs provided for cat2") vark = treecorr.calculateVarK(cat1) varg = treecorr.calculateVarG(cat2) self.logger.info("vark = %f: sig_k = %f", vark, math.sqrt(vark)) self.logger.info("varg = %f: sig_sn (per component) = %f", varg, math.sqrt(varg)) self._process_all_cross(cat1, cat2, metric, num_threads) self.finalize(vark, varg)
def process(self, cat1, cat2, metric=None, num_threads=None): """Compute the correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. :param cat1: A catalog or list of catalogs for the N field. :param cat2: A catalog or list of catalogs for the K field. :param metric: Which metric to use for distance measurements. Options are: - 'Euclidean' = straight line Euclidean distance between two points. For spherical coordinates (ra,dec without r), this is the chord distance between points on the unit sphere. - 'Rperp' = the perpendicular component of the distance. For two points with distance from Earth `r1, r2`, if `d` is the normal Euclidean distance and :math:`Rparallel = |r1-r2|`, then we define :math:`Rperp^2 = d^2 - Rparallel^2`. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) :param num_threads: How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) Note that this won't work if the system's C compiler is clang prior to version 3.7. """ import math self.clear() if not isinstance(cat1, list): cat1 = [cat1] if not isinstance(cat2, list): cat2 = [cat2] if len(cat1) == 0: raise ValueError("No catalogs provided for cat1") if len(cat2) == 0: raise ValueError("No catalogs provided for cat2") vark = treecorr.calculateVarK(cat2) self.logger.info("vark = %f: sig_k = %f", vark, math.sqrt(vark)) self._process_all_cross(cat1, cat2, metric, num_threads) self.finalize(vark)
def process(self, cat1, cat2, metric='Euclidean', num_threads=None): """Compute the correlation function. Both arguments may be lists, in which case all items in the list are used for that element of the correlation. :param cat1: A catalog or list of catalogs for the K field. :param cat2: A catalog or list of catalogs for the G field. :param metric: Which metric to use for distance measurements. Options are: - 'Euclidean' = straight line Euclidean distance between two points. For spherical coordinates (ra,dec without r), this is the chord distance between points on the unit sphere. - 'Rperp' = the perpendicular component of the distance. For two points with distance from Earth r1,r2, if d is the normal Euclidean distance and Rparallel = |r1 - r2|, then Rperp^2 = d^2 - Rparallel^2. (default: 'Euclidean') :param num_threads: How many OpenMP threads to use during the calculation. (default: None, which means to first check for a num_threads parameter in self.config, then default to querying the number of cpu cores and try to use that many threads.) Note that this won't work if the system's C compiler is clang, such as on MacOS systems. """ import math self.clear() if not isinstance(cat1,list): cat1 = [cat1] if not isinstance(cat2,list): cat2 = [cat2] if len(cat1) == 0: raise ValueError("No catalogs provided for cat1") if len(cat2) == 0: raise ValueError("No catalogs provided for cat2") vark = treecorr.calculateVarK(cat1) varg = treecorr.calculateVarG(cat2) self.logger.info("vark = %f: sig_k = %f",vark,math.sqrt(vark)) self.logger.info("varg = %f: sig_sn (per component) = %f",varg,math.sqrt(varg)) self._process_all_cross(cat1,cat2,metric,num_threads) self.finalize(vark,varg)
def test_var(): nobj = 5000 rng = np.random.RandomState(8675309) # First without weights cats = [] allg1 = [] allg2 = [] allk = [] for i in range(10): x = rng.random_sample(nobj) y = rng.random_sample(nobj) g1 = rng.random_sample(nobj) - 0.5 g2 = rng.random_sample(nobj) - 0.5 k = rng.random_sample(nobj) - 0.5 cat = treecorr.Catalog(x=x, y=y, g1=g1, g2=g2, k=k) varg = (np.sum(g1**2) + np.sum(g2**2)) / (2.*len(g1)) vark = np.sum(k**2) / len(k) assert np.isclose(cat.vark, vark) assert np.isclose(cat.varg, varg) assert np.isclose(treecorr.calculateVarK(cat), vark) assert np.isclose(treecorr.calculateVarK([cat]), vark) assert np.isclose(treecorr.calculateVarG(cat), varg) assert np.isclose(treecorr.calculateVarG([cat]), varg) cats.append(cat) allg1.extend(g1) allg2.extend(g2) allk.extend(k) allg1 = np.array(allg1) allg2 = np.array(allg2) allk = np.array(allk) varg = (np.sum(allg1**2) + np.sum(allg2**2)) / (2. * len(allg1)) vark = np.sum(allk**2) / len(allk) assert np.isclose(treecorr.calculateVarG(cats), varg) assert np.isclose(treecorr.calculateVarK(cats), vark) # Now with weights cats = [] allg1 = [] allg2 = [] allk = [] allw = [] for i in range(10): x = rng.random_sample(nobj) y = rng.random_sample(nobj) w = rng.random_sample(nobj) g1 = rng.random_sample(nobj) g2 = rng.random_sample(nobj) k = rng.random_sample(nobj) cat = treecorr.Catalog(x=x, y=y, w=w, g1=g1, g2=g2, k=k) varg = np.sum(w**2 * (g1**2 + g2**2)) / np.sum(w) / 2. vark = np.sum(w**2 * k**2) / np.sum(w) assert np.isclose(cat.varg, varg) assert np.isclose(cat.vark, vark) assert np.isclose(treecorr.calculateVarG(cat), varg) assert np.isclose(treecorr.calculateVarG([cat]), varg) assert np.isclose(treecorr.calculateVarK(cat), vark) assert np.isclose(treecorr.calculateVarK([cat]), vark) cats.append(cat) allg1.extend(g1) allg2.extend(g2) allk.extend(k) allw.extend(w) allg1 = np.array(allg1) allg2 = np.array(allg2) allk = np.array(allk) allw = np.array(allw) varg = np.sum(allw**2 * (allg1**2 + allg2**2)) / np.sum(allw) / 2. vark = np.sum(allw**2 * allk**2) / np.sum(allw) assert np.isclose(treecorr.calculateVarG(cats), varg) assert np.isclose(treecorr.calculateVarK(cats), vark)
def process(self, cat1, cat2=None, cat3=None, metric=None, num_threads=None): """Accumulate the number of triangles of points between cat1, cat2, and cat3. - If only 1 argument is given, then compute an auto-correlation function. - If 2 arguments are given, then compute a cross-correlation function with the first catalog taking two corners of the triangles. (Not implemented yet.) - If 3 arguments are given, then compute a cross-correlation function. All arguments may be lists, in which case all items in the list are used for that element of the correlation. Note: For a correlation of multiple catalogs, it matters which corner of the triangle comes from which catalog. The final accumulation will have d1 > d2 > d3 where d1 is between two points in cat2,cat3; d2 is between points in cat1,cat3; and d3 is between points in cat1,cat2. To accumulate all the possible triangles between three catalogs, you should call this multiple times with the different catalogs in different positions. :param cat1: A catalog or list of catalogs for the first N field. :param cat2: A catalog or list of catalogs for the second N field, if any. (default: None) :param cat3: A catalog or list of catalogs for the third N field, if any. (default: None) :param metric: Which metric to use for distance measurements. Options are: - 'Euclidean' = straight line Euclidean distance between two points. For spherical coordinates (ra,dec without r), this is the chord distance between points on the unit sphere. - 'Rperp' = the perpendicular component of the distance. For two points with distance from Earth `r1, r2`, if `d` is the normal Euclidean distance and :math:`Rparallel = |r1-r2|`, then we define :math:`Rperp^2 = d^2 - Rparallel^2`. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) :param num_threads: How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) Note that this won't work if the system's C compiler is clang prior to version 3.7. """ import math self.clear() if not isinstance(cat1,list): cat1 = [cat1] if cat2 is not None and not isinstance(cat2,list): cat2 = [cat2] if cat3 is not None and not isinstance(cat3,list): cat3 = [cat3] if len(cat1) == 0: raise ValueError("No catalogs provided for cat1") if cat2 is not None and len(cat2) == 0: cat2 = None if cat3 is not None and len(cat3) == 0: cat3 = None if cat2 is None and cat3 is not None: raise NotImplemented("No partial cross GGG yet.") if cat3 is None and cat2 is not None: raise NotImplemented("No partial cross GGG yet.") if cat2 is None and cat3 is None: varg1 = treecorr.calculateVarG(cat1) varg2 = varg1 varg3 = varg1 self.logger.info("varg = %f: sig_g = %f",varg1,math.sqrt(varg1)) self._process_all_auto(cat1, metric, num_threads) else: assert cat2 is not None and cat3 is not None varg1 = treecorr.calculateVarK(cat1) varg2 = treecorr.calculateVarK(cat2) varg3 = treecorr.calculateVarK(cat3) self.logger.info("varg1 = %f: sig_g = %f",varg1,math.sqrt(varg1)) self.logger.info("varg2 = %f: sig_g = %f",varg2,math.sqrt(varg2)) self.logger.info("varg3 = %f: sig_g = %f",varg3,math.sqrt(varg3)) self._process_all_cross(cat1,cat2,cat3, metric, num_threads) self.finalize(varg1,varg2,varg3)
def process(self, cat1, cat2=None, cat3=None, metric=None, num_threads=None): """Accumulate the number of triangles of points between cat1, cat2, and cat3. - If only 1 argument is given, then compute an auto-correlation function. - If 2 arguments are given, then compute a cross-correlation function with the first catalog taking two corners of the triangles. (Not implemented yet.) - If 3 arguments are given, then compute a cross-correlation function. All arguments may be lists, in which case all items in the list are used for that element of the correlation. Note: For a correlation of multiple catalogs, it matters which corner of the triangle comes from which catalog. The final accumulation will have d1 > d2 > d3 where d1 is between two points in cat2,cat3; d2 is between points in cat1,cat3; and d3 is between points in cat1,cat2. To accumulate all the possible triangles between three catalogs, you should call this multiple times with the different catalogs in different positions. :param cat1: A catalog or list of catalogs for the first N field. :param cat2: A catalog or list of catalogs for the second N field, if any. (default: None) :param cat3: A catalog or list of catalogs for the third N field, if any. (default: None) :param metric: Which metric to use for distance measurements. Options are: - 'Euclidean' = straight line Euclidean distance between two points. For spherical coordinates (ra,dec without r), this is the chord distance between points on the unit sphere. - 'Rperp' = the perpendicular component of the distance. For two points with distance from Earth `r1, r2`, if `d` is the normal Euclidean distance and :math:`Rparallel = |r1-r2|`, then we define :math:`Rperp^2 = d^2 - Rparallel^2`. (default: 'Euclidean'; this value can also be given in the constructor in the config dict.) :param num_threads: How many OpenMP threads to use during the calculation. (default: use the number of cpu cores; this value can also be given in the constructor in the config dict.) Note that this won't work if the system's C compiler is clang prior to version 3.7. """ import math self.clear() if not isinstance(cat1, list): cat1 = [cat1] if cat2 is not None and not isinstance(cat2, list): cat2 = [cat2] if cat3 is not None and not isinstance(cat3, list): cat3 = [cat3] if len(cat1) == 0: raise ValueError("No catalogs provided for cat1") if cat2 is not None and len(cat2) == 0: cat2 = None if cat3 is not None and len(cat3) == 0: cat3 = None if cat2 is None and cat3 is not None: raise NotImplemented("No partial cross GGG yet.") if cat3 is None and cat2 is not None: raise NotImplemented("No partial cross GGG yet.") if cat2 is None and cat3 is None: varg1 = treecorr.calculateVarG(cat1) varg2 = varg1 varg3 = varg1 self.logger.info("varg = %f: sig_g = %f", varg1, math.sqrt(varg1)) self._process_all_auto(cat1, metric, num_threads) else: assert cat2 is not None and cat3 is not None varg1 = treecorr.calculateVarK(cat1) varg2 = treecorr.calculateVarK(cat2) varg3 = treecorr.calculateVarK(cat3) self.logger.info("varg1 = %f: sig_g = %f", varg1, math.sqrt(varg1)) self.logger.info("varg2 = %f: sig_g = %f", varg2, math.sqrt(varg2)) self.logger.info("varg3 = %f: sig_g = %f", varg3, math.sqrt(varg3)) self._process_all_cross(cat1, cat2, cat3, metric, num_threads) self.finalize(varg1, varg2, varg3)
def test_var(): nobj = 5000 np.random.seed(8675309) # First without weights cats = [] allg1 = [] allg2 = [] allk = [] for i in range(10): x = np.random.random_sample(nobj) y = np.random.random_sample(nobj) g1 = np.random.random_sample(nobj) - 0.5 g2 = np.random.random_sample(nobj) - 0.5 k = np.random.random_sample(nobj) - 0.5 cat = treecorr.Catalog(x=x, y=y, g1=g1, g2=g2, k=k) varg = (np.sum(g1**2) + np.sum(g2**2)) / (2.*len(g1)) vark = np.sum(k**2) / len(k) assert np.isclose(cat.vark, vark) assert np.isclose(cat.varg, varg) assert np.isclose(treecorr.calculateVarK(cat), vark) assert np.isclose(treecorr.calculateVarK([cat]), vark) assert np.isclose(treecorr.calculateVarG(cat), varg) assert np.isclose(treecorr.calculateVarG([cat]), varg) cats.append(cat) allg1.extend(g1) allg2.extend(g2) allk.extend(k) allg1 = np.array(allg1) allg2 = np.array(allg2) allk = np.array(allk) varg = (np.sum(allg1**2) + np.sum(allg2**2)) / (2. * len(allg1)) vark = np.sum(allk**2) / len(allk) assert np.isclose(treecorr.calculateVarG(cats), varg) assert np.isclose(treecorr.calculateVarK(cats), vark) # Now with weights cats = [] allg1 = [] allg2 = [] allk = [] allw = [] for i in range(10): x = np.random.random_sample(nobj) y = np.random.random_sample(nobj) w = np.random.random_sample(nobj) g1 = np.random.random_sample(nobj) g2 = np.random.random_sample(nobj) k = np.random.random_sample(nobj) cat = treecorr.Catalog(x=x, y=y, w=w, g1=g1, g2=g2, k=k) varg = np.sum(w**2 * (g1**2 + g2**2)) / np.sum(w) / 2. vark = np.sum(w**2 * k**2) / np.sum(w) assert np.isclose(cat.varg, varg) assert np.isclose(cat.vark, vark) assert np.isclose(treecorr.calculateVarG(cat), varg) assert np.isclose(treecorr.calculateVarG([cat]), varg) assert np.isclose(treecorr.calculateVarK(cat), vark) assert np.isclose(treecorr.calculateVarK([cat]), vark) cats.append(cat) allg1.extend(g1) allg2.extend(g2) allk.extend(k) allw.extend(w) allg1 = np.array(allg1) allg2 = np.array(allg2) allk = np.array(allk) allw = np.array(allw) varg = np.sum(allw**2 * (allg1**2 + allg2**2)) / np.sum(allw) / 2. vark = np.sum(allw**2 * allk**2) / np.sum(allw) assert np.isclose(treecorr.calculateVarG(cats), varg) assert np.isclose(treecorr.calculateVarK(cats), vark)