orpheus-npcf 0.1.11__cp39-cp39-macosx_14_0_arm64.whl

orpheus/patchutils.py

@@ -0,0 +1,356 @@
+# Here we collect some utils for mapping the a full-sky survey to a set of overlapping patches
+# In the middle term much of this functionality should be included in the orpheus code
+
+from astropy.coordinates import SkyCoord
+from healpy import ang2pix, pix2vec, nside2pixarea, nside2resol, query_disc, Rotator, nside2npix
+import numpy as np
+from pathlib import Path
+import pickle
+import os
+import sys
+from time import time
+
+from sklearn.cluster import KMeans
+
+def pickle_save(data, filename):
+    
+    file_path = Path(filename)
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    try:
+        with open(filename, 'wb') as file:
+            pickle.dump(data, file)
+    except Exception as e:
+        print(f"An error occurred while saving the dictionary: {e}")
+        
+def pickle_load(filename):
+    
+    try:
+        with open(filename, 'rb') as file:
+            data = pickle.load(file)
+        return data
+    except Exception as e:
+        pass
+
+def frompatchindices_preparerot(index, patchindices, ra, dec, rotsignflip):
+
+    inds_inner = patchindices["patches"][index]["inner"]
+    inds_outer = patchindices["patches"][index]["outer"]
+    inds_extpatch = np.append(inds_inner,inds_outer)
+    ngal_patch = len(inds_extpatch)
+    patch_isinner = np.zeros(ngal_patch,dtype=bool)
+    patch_isinner[:len(inds_inner)] = True
+    patch_isinner[len(inds_inner):] = False
+    # Note that we fix the rotangle at this instance as this is required when computing patches
+    # across multiple catalogs. In that case the patchcenters are by definition the com of the
+    # joint catalog. For a single catalog this does not matter. The signs match the (theta,phi)
+    # conventions in healpy -- see the toorigin function for details.
+    rotangle = [+patchindices['info']['patchcenters'][index][0]*np.pi/180.,
+                -patchindices['info']['patchcenters'][index][1]*np.pi/180.]
+    nextrotres = toorigin(ra[inds_extpatch], 
+                          dec[inds_extpatch], 
+                          isinner=patch_isinner, 
+                          rotangle=rotangle, 
+                          inv=False, 
+                          rotsignflip=rotsignflip,
+                          radec_units="deg")
+    rotangle, ra_rot, dec_rot, rotangle_polars = nextrotres
+
+    return inds_extpatch, patch_isinner, rotangle, ra_rot, dec_rot, rotangle_polars
+    
+def gen_cat_patchindices(ra_deg, dec_deg, npatches, patchextend_arcmin, nside_hash=128, verbose=False, method='kmeans_healpix',
+                         kmeanshp_maxiter=1000, kmeanshp_tol=1e-10, kmeanshp_randomstate=42, healpix_nside=8):
+    """ Decomposes a spherical catalog in ~equal-area patches with a buffer region
+    
+    Parameters
+    ----------
+    ra_deg: numpy.ndarray
+        The ra of the catalog, given in units of degree.
+    dec_deg: numpy.ndarray
+        The dec of the catalog, given in units of degree.
+    npatches: int
+        The number of patches in which the catalog shall be decomposed.
+    patchextend_arcmin: float
+        The buffer region that extends around each patch, given in units of arcmin.
+    nside_hash: int
+        The healpix resolution used for hashing subareas of the patches.
+    verbose: bool
+        Flag setting on whether output is printed to the console.
+        
+    Returns
+    -------
+    cat_patchindices: dict
+        A dictionary containing information about the individual patches,
+        as well as the galaxy indices that are assigned to the inner region
+        and to the buffer region of each individual patch
+    
+    Notes
+    -----
+    Choosing a small value of nside_hash will result in a larger extension of 
+    the patches then neccessary while choosing a large value increases the 
+    runtime. A good compromise is to choose nside_hash such that its resolution 
+    is a few times smaller than the buffer region of the patches    
+    """
+    
+    def build_indexhash(arr):
+        """Returns a hash for indices of repeated values in a 1D array"""
+        sort_indices = np.argsort(arr)
+        arr = np.asarray(arr)[sort_indices]
+        vals, first_indices = np.unique(arr, return_index=True)
+        indices = np.split(sort_indices, first_indices[1:])
+        indhash = {}
+        for elval,val in enumerate(vals):
+            indhash[val] = indices[elval]
+        return indhash    
+    
+    if verbose:
+        print("Computing inner region of patches")
+        t1 = time()
+    
+    # Run treecorrs k-means implementation
+    if method=='kmeans_treecorr':
+        try:
+            import treecorr
+            cat = treecorr.Catalog(ra=ra_deg, dec=dec_deg, 
+                               ra_units="deg", dec_units="deg", 
+                               npatch=npatches)
+            patchinds = cat.patch
+        except ImportError:
+            if method=='kmeans_treecorr':
+                print('Treecorr not availbale...switching to patch creation via KMeans')
+                method = 'kmeans_healpix'
+        
+    # Run standard k-means on catalog reduced to healpix pixels
+    elif method=='kmeans_healpix':
+        # Step 1: Reduce discrete ra/dec to unique healpix pixels and transform those to to 3D positions
+        nside_kmeans = 2048 # I keep this fixed for now as it will most likely work well for all reasonable cases.
+        eq = SkyCoord(ra_deg, dec_deg, frame='galactic', unit='deg')
+        l, b = eq.galactic.l.value, eq.galactic.b.value
+        theta = np.radians(90. - b)
+        phi = np.radians(l)
+        hpx_inds = ang2pix(nside_kmeans, theta, phi)
+        hpx_uinds = np.unique(hpx_inds)
+        # Step 2: Run standard kmeans algorithm on the healpix pixels
+        # Note that each pixel carries the same (unity) weight. This implies
+        # that we make the patches have approximately equal area, but neglect
+        # depth variations on a patch sized scale. To me this seems to be a
+        # sensible choice as the flat-sky approximation only cares about the
+        # extent of the patches. If one wants to use the patches as Jackknife
+        # samples for an internal covariance matrix estimate this choice might
+        # need to be revisited (but as of now I do not see a clear point against
+        # continuing to use the current setup as long as the patchsize is in a
+        # domain where the contributions to the covariance that are containing 
+        # shapenoise are expected to be subdominant).
+        clust = KMeans(n_clusters=npatches,
+                init='k-means++', 
+                n_init='auto', 
+                max_iter=kmeanshp_maxiter, 
+                tol=kmeanshp_tol,
+                verbose=0, 
+                random_state=kmeanshp_randomstate, 
+                copy_x=True, 
+                algorithm='lloyd')
+        X = np.array(pix2vec(nside=nside_kmeans,ipix=hpx_uinds,nest=False)).T
+        clustinds = clust.fit_predict(X, y=None, sample_weight=None)
+        # Step 3: Map the pixel centers back to the galaxy indices
+        hashmap = np.vectorize({upix: center for upix, center in zip(hpx_uinds, clustinds)}.get)
+        patchinds = hashmap(hpx_inds)
+    # Simply assign to healpix pixel. Fast and stable, but patchareas might strongly vary in size.
+    elif method == "healpix":
+        eq = SkyCoord(ra_deg, dec_deg, frame='galactic', unit='deg')
+        l, b = eq.galactic.l.value, eq.galactic.b.value
+        theta = np.radians(90. - b)
+        phi = np.radians(l)
+        patchinds = ang2pix(healpix_nside, theta, phi).astype(int)
+    else:
+        raise NotImplementedError
+        
+    if verbose:
+        t2=time()
+        print("Took %.3f seconds"%(t2-t1))
+    
+    # Assign galaxy positions to healpix pixels
+    if verbose:
+        print("Mapping catalog to healpix grid")
+        t1=time()
+    eq = SkyCoord(ra_deg, dec_deg, frame='galactic', unit='deg')
+    l, b = eq.galactic.l.value, eq.galactic.b.value
+    theta = np.radians(90. - b)
+    phi = np.radians(l)
+    cat_indices = ang2pix(nside_hash, theta, phi)
+    if verbose:
+        t2=time()
+        print("Took %.3f seconds"%(t2-t1))
+    
+    # Build a hash connecting the galaxies residing in each healpix pixel
+    if verbose:
+        t1=time()
+        print("Building index hash")
+    cat_indhash = build_indexhash(cat_indices)
+    if verbose:
+        t2=time()
+        print("Took %.3f seconds"%(t2-t1))
+    
+    # Construct buffer region around patches
+    if verbose:
+        print("Building buffer around patches")
+        t1=time()
+    _pixarea = nside2pixarea(nside_hash,degrees=True)
+    _pixreso = nside2resol(nside_hash,arcmin=True)
+    if method == 'kmeans_treecorr':
+        _patchcenters = cat.patch_centers
+    elif method == 'kmeans_healpix' or method=='healpix':
+        _patchcenters = np.array([[np.mean(ra_deg[ patchinds==patchind]), np.mean(dec_deg[ patchinds==patchind])] for patchind in range(npatches)])
+    else:
+        raise NotImplementedError
+        
+    cat_patchindices = {}
+    cat_patchindices["info"] = {}
+    cat_patchindices["info"]["patchcenters"] = _patchcenters
+    cat_patchindices["info"]["patchareas"] = np.zeros(npatches,dtype=float)
+    cat_patchindices["info"]["patch_ngalsinner"] = np.zeros(npatches,dtype=int)
+    cat_patchindices["info"]["patch_ngalsouter"] = np.zeros(npatches,dtype=int)
+    cat_patchindices["patches"] = {}
+    ext_buffer = (patchextend_arcmin+_pixreso)*np.pi/180./60.
+    for elpatch in range(npatches):
+        if verbose:
+            sys.stdout.write("\r%i/%i"%(elpatch+1,npatches))
+        patchsel = patchinds==elpatch
+        cat_patchindices["patches"][elpatch] = {}
+
+        # Get indices of gals within inner patch
+        galinds_inner = np.argwhere(patchsel).flatten().astype(int)
+
+        # Find healpix pixels in extended patch
+        patch_indices = np.unique(ang2pix(nside_hash, theta[patchsel], phi[patchsel]))
+        extpatch_indices = set()
+        for pix in patch_indices:
+            nextset = set(query_disc(nside=nside_hash, 
+                                        vec=pix2vec(nside_hash,pix),
+                                        radius=ext_buffer))
+            extpatch_indices.update(nextset)
+
+        # Assign galaxies to extended patch
+        galinds_ext = set()
+        for pix in extpatch_indices:
+            try:
+                galinds_ext.update(set(cat_indhash[pix]))
+            except:
+                pass
+        galinds_outer = np.array(list(galinds_ext-set(galinds_inner)),dtype=int)
+        cat_patchindices["info"]["patchareas"][elpatch] = _pixarea*len(patch_indices)
+        cat_patchindices["info"]["patch_ngalsinner"][elpatch] = len(galinds_inner)
+        cat_patchindices["info"]["patch_ngalsouter"][elpatch] = len(galinds_outer)
+        cat_patchindices["patches"][elpatch]["inner"] = galinds_inner
+        cat_patchindices["patches"][elpatch]["outer"] = galinds_outer
+    if verbose:
+        t2=time()
+        print("Took %.3f seconds"%(t2-t1))
+    
+    return cat_patchindices
+
+def toorigin(ras, decs, isinner=None, rotangle=None, inv=False, rotsignflip=False, radec_units="deg"):
+    """ Rotates survey patch s.t. its center of mass lies in the origin. """
+    import healpy as hp
+    assert(radec_units in ["rad", "deg"])
+    
+    if isinner is None:
+        isinner = np.ones(len(ras), dtype=bool)
+    
+    # Map (ra, dec) --> (theta, phi)
+    if radec_units=="deg":
+        decs_rad = decs*np.pi/180.
+        ras_rad = ras*np.pi/180.
+    thetas = np.pi/2. + decs_rad
+    phis = ras_rad
+    
+    # Compute rotation angle
+    if rotangle is None:
+        rotangle = [np.mean(phis[isinner]),np.pi/2.-np.mean(thetas[isinner])]
+    thisrot = Rotator(rot=rotangle, deg=False, inv=inv)
+    rotatedthetas, rotatedphis = thisrot(thetas,phis,inv=False)
+    rotangle_polars = np.exp((-1)**rotsignflip*1J * 2 * thisrot.angle_ref(rotatedthetas, rotatedphis,inv=True))
+    
+    # Transform back to (ra,dec)
+    ra_rot = rotatedphis
+    dec_rot = rotatedthetas - np.pi/2.
+    if radec_units=="deg":
+        dec_rot *= 180./np.pi
+        ra_rot *= 180./np.pi
+    
+    return rotangle, ra_rot, dec_rot, rotangle_polars
+    
+def cat2hpx(lon, lat, nside, radec=True, do_counts=False, return_idx=False, return_indices=False, weights=None):
+    """
+    Convert a catalogue to a HEALPix map of number counts per resolution
+    element.
+
+    Parameters
+    ----------
+    lon, lat : (ndarray, ndarray)
+        Coordinates of the sources in degree. If radec=True, assume input is in the icrs
+        coordinate system. Otherwise assume input is glon, glat
+    nside : int
+        HEALPix nside of the target map
+    radec : bool
+        Switch between R.A./Dec and glon/glat as input coordinate system.
+    do_counts : bool
+        Return the number of counts per HEALPix pixel
+    return_idx : bool
+        Return the set of non-empty HEALPix pixel indices
+    return_indices : bool
+        Returns the per-object HEALPix pixel indices
+    weights: None or ndarray
+        Needs to be given if each point carries an individual weight
+
+    Return
+    ------
+    hpx_map : ndarray
+        HEALPix map of the catalogue number counts in Galactic coordinates
+        
+    Notes
+    -----
+    This functions is a generalised version of https://stackoverflow.com/a/50495134
+    """
+
+    npix = nside2npix(nside)
+
+    if radec:
+        eq = SkyCoord(lon, lat, frame='galactic', unit='deg')
+        l, b = eq.galactic.l.value, eq.galactic.b.value
+    else:
+        l, b = lon, lat
+
+    # conver to theta, phi
+    theta = np.radians(90. - b)
+    phi = np.radians(l)
+
+    # convert to HEALPix indices
+    indices = ang2pix(nside, theta, phi)
+    
+    if do_counts:
+        idx, counts = np.unique(indices, return_counts=True)
+    if weights is not None:
+        idx, inv = np.unique(indices,return_inverse=True)
+        weights_pix = np.bincount(inv,weights.reshape(-1))
+    else:
+        idx = np.asarray(list(set(list(indices)))).astype(int)
+
+    # fill the fullsky map
+    hpx_map = np.zeros(npix, dtype=int)
+    #counts[counts>1] = 1
+    if do_counts:
+        hpx_map[idx] = counts
+    else:
+        hpx_map[idx] = np.ones(len(idx), dtype=int)
+    
+    res = ()
+    if return_idx:
+        res +=  (idx, )
+    res += (hpx_map.astype(int)), 
+    if weights is not None:
+        res += (weights_pix), 
+    if return_indices:
+        res += (indices), 
+        
+    return res

orpheus/utils.py

@@ -0,0 +1,152 @@
+import numpy as np
+from itertools import combinations_with_replacement
+import os
+import site
+
+def convertunits(unit_in, unit_target):
+    '''unit can be '''
+    vals = {'rad': 180./np.pi, 
+            'deg': 1.,
+            'arcmin': 1./60.,
+            'arcsec': 1./60./60.}
+    assert((unit_in in vals.keys()) and (unit_target in vals.keys()))
+    return vals[unit_in]/vals[unit_target]
+
+def flatlist(A):
+    rt = []
+    for i in A:
+        if isinstance(i,list): rt.extend(flatlist(i))
+        else: rt.append(i)
+    return rt
+
+def get_site_packages_dir():
+        return [p for p  in site.getsitepackages()
+                if p.endswith(("site-packages", "dist-packages"))][0]
+
+def search_file_in_site_package(directory, package):
+    for root, dirs, files in os.walk(directory):
+        for file in files:
+            if file.startswith(package):
+                return os.path.join(root, file)
+    return None
+
+def gen_thetacombis_fourthorder(nbinsr, nthreads, batchsize, batchsize_max, ordered=True, custom=None, verbose=False):
+        
+        # Allocate selector for custom bins
+        if custom is None:
+            customsel = np.ones(nbinsr*nbinsr*nbinsr, dtype=bool)
+        else:
+            custom = custom.astype(int)
+            assert(np.max(custom)<nbinsr*nbinsr*nbinsr)
+            assert(np.min(custom)>=0)
+            customsel = np.zeros(nbinsr*nbinsr*nbinsr, dtype=bool)
+            customsel[custom] = True
+            
+        # Build the bins    
+        allelbs = []
+        thetacombis_batches = []
+        nbinsr3 = 0
+        cutlo_2 = 0
+        cutlo_3 = 0
+        tmpind = 0
+        for elb1 in range(nbinsr):
+            for elb2 in range(nbinsr):
+                for elb3 in range(nbinsr):
+                    valid = True
+                    if ordered:
+                        if elb1>elb2 or elb1>elb3 or elb2>elb3:
+                            valid = False
+                    if valid and customsel[tmpind]:
+                        thetacombis_batches.append([tmpind])
+                        allelbs.append([elb1,elb2,elb3])
+                        nbinsr3 += 1
+                    tmpind += 1
+        thetacombis_batches = np.asarray(thetacombis_batches,dtype=np.int32)
+        allelbs = np.asarray(allelbs,dtype=np.int32)
+        if batchsize is None:
+            batchsize = min(nbinsr3,min(batchsize_max,nbinsr3/nthreads))
+            if verbose:
+                print("Using batchsize of %i for radial bins"%batchsize)
+        if batchsize==batchsize_max:
+            nbatches = np.int32(np.ceil(nbinsr3/batchsize))
+        else:
+            nbatches = np.int32(nbinsr3/batchsize)
+        #thetacombis_batches = np.arange(nbinsr3).astype(np.int32)
+        cumnthetacombis_batches = (np.arange(nbatches+1)*nbinsr3/(nbatches)).astype(np.int32)
+        nthetacombis_batches = (cumnthetacombis_batches[1:]-cumnthetacombis_batches[:-1]).astype(np.int32)
+        cumnthetacombis_batches[-1] = nbinsr3
+        nthetacombis_batches[-1] = nbinsr3-cumnthetacombis_batches[-2]
+        thetacombis_batches = thetacombis_batches.flatten().astype(np.int32)
+        nbatches = len(nthetacombis_batches)
+        
+        return nbinsr3, allelbs, thetacombis_batches, cumnthetacombis_batches, nthetacombis_batches, nbatches
+
+def gen_n2n3indices_Upsfourth(nmax):
+        """ List of flattened indices corresponding to selection """
+        nmax_alloc = 2*nmax+1
+        reconstructed = np.zeros((2*nmax_alloc+1,2*nmax_alloc+1),dtype=int)
+        for _n2 in range(-nmax-1,nmax+2):
+            for _n3 in range(-nmax-1,nmax+2):
+                reconstructed[nmax_alloc+_n2,nmax_alloc+_n3] += 1
+        for _n3 in range(-2*nmax,-nmax-1):
+            for _n2 in range(-nmax-1-_n3,nmax+2):
+                reconstructed[nmax_alloc+_n2,nmax_alloc+_n3] += 1
+        for _n2 in range(-2*nmax-1,-nmax-1):
+            for _n3 in range(-nmax-1-_n2,nmax+2):
+                reconstructed[nmax_alloc+_n2,nmax_alloc+_n3] += 1
+        for _n3 in range(nmax+2,2*nmax+1):
+            for _n2 in range(-nmax-1,nmax+2-_n3):
+                reconstructed[nmax_alloc+_n2,nmax_alloc+_n3] += 1
+        for _n2 in range(nmax+2,2*nmax+2):
+            for _n3 in range(-nmax-1,nmax+2-_n2):
+                reconstructed[nmax_alloc+_n2,nmax_alloc+_n3] += 1
+        _shape = reconstructed.shape
+        _inds = np.argwhere((reconstructed>0).flatten())[:,0].astype(np.int32)
+        _n2s = np.argwhere(reconstructed>0)[:,0].astype(np.int32)-nmax_alloc
+        _n3s = np.argwhere(reconstructed>0)[:,1].astype(np.int32)-nmax_alloc
+        return _shape, _inds, _n2s, _n3s
+
+def symmetrize_map3_multiscale(map3, return_list=False):
+    """
+    Symmetrizes third-order aperture mass over tomographic bin combinations
+    and radial bin combinations
+    Assumes map3 to be of shape (8, nbinsz**3, nbinsr**3)
+    """
+    
+    nbinsz = int(round((map3.shape[1])**(1/3)))
+    nbinsr = int(round((map3.shape[2])**(1/3)))
+
+    # Get unique combinations of indices (e.g., r1 <= r2 <= r3)
+    r_combs = np.array(list(combinations_with_replacement(range(nbinsr), 3)))
+    z_combs = np.array(list(combinations_with_replacement(range(nbinsz), 3)))
+    indr3, indz3 = r_combs.shape[0], z_combs.shape[0]
+
+    # Get permutations for each unique combination
+    perm_map = np.array([[0, 1, 2], [1, 2, 0], [2, 0, 1],
+                         [1, 0, 2], [2, 1, 0], [0, 2, 1]])
+    
+    # Create arrays of permuted 3D indices
+    # Shape is (6, n_combinations, 3)
+    r_perms_3d = r_combs[:, perm_map].transpose(1, 0, 2)
+    z_perms_3d = z_combs[:, perm_map].transpose(1, 0, 2)
+
+    # Convert 3D permuted indices to flat indices
+    r_powers = np.array([nbinsr**2, nbinsr, 1])
+    sel_foots = np.dot(r_perms_3d, r_powers) # Shape: (6, indr3)
+    z_powers = np.array([nbinsz**2, nbinsz, 1])
+    zcombis = np.dot(z_perms_3d, z_powers) # Shape: (6, indz3)
+
+    # Do the averaging
+    # Shape is (8, 6_z_perms, indz3, 6_r_perms, indr3)
+    all_perms_data = map3[:, zcombis][:, :, :, sel_foots]
+    map3_symm = np.mean(all_perms_data, axis=(1, 3))
+
+    # Allocate final result
+    res = (map3_symm,)
+    if return_list:
+        # Rearrange and split the data to match original list format
+        list_data = all_perms_data.transpose(3, 0, 1, 4, 2)
+        map3_list = [arr.squeeze(axis=-1) for arr in np.split(list_data, indz3, axis=-1)]
+        res += (map3_list,)
+        
+    return res

orpheus_npcf-0.1.11.dist-info/METADATA

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: orpheus-npcf
+Version: 0.1.11
+Summary: Compute N-point correlation functions of spin-s fields.
+Home-page: https://github.com/lporth93/orpheus
+Author: Lucas Porth
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astropy>=6
+Requires-Dist: healpy>=1.17
+Requires-Dist: coverage>=7.6.1
+Requires-Dist: numba<=0.62.1,>=0.58
+Requires-Dist: numpy<1.27,>=1.22
+Requires-Dist: scipy>=1.15
+Requires-Dist: scikit-learn
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <img src="docs/orpheus_logov1.png" alt="Orpheus logo" width="500"/>
+</p>
+
+Orpheus is python package for the calculation of second- third- and fourth-order correlation functions of scalar and polar fields such as weak lensing shear. To efficiently perform the calculations, orpheus makes use of a mulitpole decomposition of the N>2 correlation functions and uses parallelized C code for the heavy lifting.
+
+## Installation, Documentation and Examples
+Installation steps, documentation and examples are provided at [orpheus.readthedocs.io](https://orpheus.readthedocs.io/).
+
+### Installation
+ First clone the directory via:
+```shell
+git clone git@github.com:lporth93/orpheus.git
+```
+or
+```shell
+git clone https://github.com/lporth/orpheus.git
+```
+Then navigate to the cloned directory
+```shell
+cd orpheus
+conda env create -f orpheus_env.yaml
+conda activate orpheus_env
+pip install .
+```
+
+### Documentation
+In the [documentation](https://orpheus.readthedocs.io/) you find more information about the algorithms and approximation schemes employed in orpheus, as well as a series of jupyter notebooks that give examples of how to use the different estimators implemented in orpheus.
+
+## Using the code
+As at this moment there is no dedicated orpheus paper, please cite the paper that introduced the functionality implemented in orpheus:
+ * If you use the three-point functionality, please cite [Porth+2024](https://doi.org/10.1051/0004-6361/202347987)
+ * If you use the four-point functionality, please cite [Porth+2025](https://arxiv.org/abs/2509.07974)
+ * If you use the direct estimator functionality, please cite [Porth & Smith 2022](https://doi.org/10.1093/mnras/stab2819)
+
+In each of the papers, you can find the main equations implemented in orpheus.

orpheus_npcf-0.1.11.dist-info/RECORD

@@ -0,0 +1,15 @@
+orpheus_npcf-0.1.11.dist-info/RECORD,,
+orpheus_npcf-0.1.11.dist-info/WHEEL,sha256=DhkyuvaF_ECzC6tOpvYO14C_ylOEhcIxq8q81VPjNdw,134
+orpheus_npcf-0.1.11.dist-info/top_level.txt,sha256=EGQN7bZMbZZGcbqsLDoUVjVl6glgjt9qmT6FZt5N-Yo,8
+orpheus_npcf-0.1.11.dist-info/METADATA,sha256=f7TnjM8cvAd42wBJ5SGCft23IOJ8czgFv2C63nhCIfw,2626
+orpheus_npcf-0.1.11.dist-info/licenses/LICENSE,sha256=ixuiBLtpoK3iv89l7ylKkg9rs2GzF9ukPH7ynZYzK5s,35148
+orpheus/catalog.py,sha256=AFPcQpK6QVf9Jf3ubyeNFDMz8XTdG2YxbBp5l3u73Wg,55815
+orpheus/flat2dgrid.py,sha256=1YSmUN1pt3036oKKqscmNmDp2UAUj4WL82IDULVmolU,1905
+orpheus/orpheus_clib.cpython-39-darwin.so,sha256=4Co8O--n-YLY9Kgbli1265w6xmnv1kAwtYvP7HE_exI,340704
+orpheus/npcf.py,sha256=P9O-mo-NsEjxLXPreQ1OfNfuY5ZCUS90hlLTB3G_bxI,204974
+orpheus/patchutils.py,sha256=5bjj3SIX48op88s_RlODIyvQ3oIowmZJkdcXjSNNF48,14259
+orpheus/covariance.py,sha256=iyjQ7fgPSNLbEMn400T02sGG0lML1yzTUkqOL6PoqeM,5660
+orpheus/__init__.py,sha256=yeLNi-zSAhmBvF9ptv4VK8obQNMDtwMPP6QLspoHMjI,137
+orpheus/utils.py,sha256=Aa_l20oGmWKgjZ1rYnp14Ctvao3o6hb85Xpg6PkyP-M,6362
+orpheus/direct.py,sha256=qYWXGXgmiHSFmYWCTrtC12NXfAPZ46xENi1lYleXbec,47734
+orpheus/.dylibs/libgomp.1.dylib,sha256=8Bw0CGsTlKIeJIEDIPtLaYGkEzK31ke8ZcLhCoOh0iA,441360

orpheus_npcf-0.1.11.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp39-cp39-macosx_14_0_arm64
+Generator: delocate 0.13.0
+