Add new ICs (#59)

* edit IC paths

* Remove import

* Edit path

* Change naming

* Add __main__

* Script to match everything

* Edit docs

* Remove test statement

* Move import

* Update nb

scripts/cluster_crosspk.py

@@ -51,7 +51,7 @@ MAS = "CIC"  # mass asignment scheme
 paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
 box = csiborgtools.read.BoxUnits(paths)
 reader = csiborgtools.read.ParticleReader(paths)
-ics = paths.get_ics(tonew=False)
+ics = paths.get_ics()
 nsims = len(ics)
 
 # File paths

scripts/cluster_knn_auto.py

@@ -50,7 +50,7 @@ with open("../scripts/knn_auto.yml", "r") as file:
 Rmax = 155 / 0.705  # Mpc (h = 0.705) high resolution region radius
 totvol = 4 * numpy.pi * Rmax**3 / 3
 paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
-ics = paths.get_ics(False)
+ics = paths.get_ics()
 knncdf = csiborgtools.clustering.kNN_CDF()
 
 ###############################################################################

scripts/cluster_knn_cross.py

@@ -49,7 +49,7 @@ with open("../scripts/knn_cross.yml", "r") as file:
 
 Rmax = 155 / 0.705  # Mpc (h = 0.705) high resolution region radius
 paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
-ics = paths.get_ics(False)
+ics = paths.get_ics()
 knncdf = csiborgtools.clustering.kNN_CDF()
 
 ###############################################################################

scripts/cluster_tcpf_auto.py

@@ -48,7 +48,7 @@ with open("../scripts/tpcf_auto.yml", "r") as file:
 
 Rmax = 155 / 0.705  # Mpc (h = 0.705) high resolution region radius
 paths = csiborgtools.read.CSiBORGPaths()
-ics = paths.get_ics(False)
+ics = paths.get_ics()
 tpcf = csiborgtools.clustering.Mock2PCF()
 
 ###############################################################################

scripts/field_density.py

@@ -46,7 +46,7 @@ args = parser.parse_args()
 paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
 
 if args.ics is None or args.ics[0] == -1:
-    ics = paths.get_ics(tonew=False)
+    ics = paths.get_ics()
 else:
     ics = args.ics
 

scripts/fit_halos.py

@@ -47,7 +47,7 @@ partreader = csiborgtools.read.ParticleReader(paths)
 nfwpost = csiborgtools.fits.NFWPosterior()
 
 if args.ics is None or args.ics[0] == -1:
-    ics = paths.get_ics(tonew=False)
+    ics = paths.get_ics()
 else:
     ics = args.ics
 

scripts/fit_init.py

@@ -49,7 +49,7 @@ paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
 partreader = csiborgtools.read.ParticleReader(paths)
 
 if args.ics is None or args.ics[0] == -1:
-    ics = paths.get_ics(tonew=True)
+    ics = paths.get_ics()
 else:
     ics = args.ics
 

scripts/fit_profiles.py

@@ -20,7 +20,6 @@ from argparse import ArgumentParser
 from datetime import datetime
 from gc import collect
 
-import h5py
 import numpy
 from mpi4py import MPI
 from tqdm import trange
@@ -49,7 +48,7 @@ if nproc > 1:
 paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
 cols_collect = [("r", numpy.float32), ("M", numpy.float32)]
 if args.ics is None or args.ics == -1:
-    nsims = paths.get_ics(tonew=False)
+    nsims = paths.get_ics()
 else:
     nsims = args.ics
 

scripts/match_all.py

@@ -0,0 +1,79 @@
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 3 of the License, or (at your
+# option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
+# Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+"""
+Script to match all pairs of CSiBORG simulations. Mathches main haloes whose
+mass is above 1e12 solar masses.
+"""
+from argparse import ArgumentParser
+from datetime import datetime
+from distutils.util import strtobool
+from itertools import combinations
+from random import Random
+
+from mpi4py import MPI
+
+try:
+    import csiborgtools
+except ModuleNotFoundError:
+    import sys
+
+    sys.path.append("../")
+    import csiborgtools
+
+from taskmaster import master_process, worker_process
+
+from match_singlematch import pair_match
+
+# Argument parser
+parser = ArgumentParser()
+parser.add_argument("--sigma", type=float, default=None)
+parser.add_argument("--smoothen", type=lambda x: bool(strtobool(x)),
+                    default=None)
+parser.add_argument("--verbose", type=lambda x: bool(strtobool(x)),
+                    default=False)
+args = parser.parse_args()
+
+comm = MPI.COMM_WORLD
+rank = comm.Get_rank()
+nproc = comm.Get_size()
+
+
+def get_combs():
+    """
+    Get the list of all pairs of simulations, then permute them with a known
+    seed to minimise loading the same files simultaneously.
+    """
+    paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
+    ics = paths.get_ics()
+    combs = list(combinations(ics, 2))
+    Random(42).shuffle(combs)
+    return combs
+
+
+def do_work(comb):
+    nsim0, nsimx = comb
+    pair_match(nsim0, nsimx, args.sigma, args.smoothen, args.verbose)
+
+
+if nproc > 1:
+    if rank == 0:
+        combs = get_combs()
+        master_process(combs, comm, verbose=True)
+    else:
+        worker_process(do_work, comm, verbose=False)
+else:
+    combs = get_combs()
+    for comb in combs:
+        print(f"{datetime.now()}: completing task `{comb}`.", flush=True)
+        do_work(comb)

scripts/match_singlematch.py

@@ -27,88 +27,94 @@ except ModuleNotFoundError:
 
     sys.path.append("../")
     import csiborgtools
+
+
+def pair_match(nsim0, nsimx, sigma, smoothen, verbose):
     from csiborgtools.read import HaloCatalogue, read_h5
 
-# Argument parser
-parser = ArgumentParser()
-parser.add_argument("--nsim0", type=int)
-parser.add_argument("--nsimx", type=int)
-parser.add_argument("--nmult", type=float)
-parser.add_argument("--sigma", type=float, default=None)
-parser.add_argument("--smoothen", type=lambda x: bool(strtobool(x)),
-                    default=None)
-parser.add_argument("--verbose", type=lambda x: bool(strtobool(x)),
-                    default=False)
-args = parser.parse_args()
-paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
-smooth_kwargs = {"sigma": args.sigma, "mode": "constant", "cval": 0.0}
-overlapper = csiborgtools.match.ParticleOverlap()
-matcher = csiborgtools.match.RealisationsMatcher()
+    paths = csiborgtools.read.CSiBORGPaths(**csiborgtools.paths_glamdring)
+    smooth_kwargs = {"sigma": sigma, "mode": "constant", "cval": 0.0}
+    overlapper = csiborgtools.match.ParticleOverlap()
+    matcher = csiborgtools.match.RealisationsMatcher()
 
-# Load the raw catalogues (i.e. no selection) including the initial CM
-# positions and the particle archives.
-cat0 = HaloCatalogue(args.nsim0, paths, load_initial=True,
-                     minmass=("totpartmass", 1e12), with_lagpatch=True,
-                     load_clumps_cat=True)
-catx = HaloCatalogue(args.nsimx, paths, load_initial=True,
-                     minmass=("totpartmass", 1e12), with_lagpatch=True,
-                     load_clumps_cat=True)
+    # Load the raw catalogues (i.e. no selection) including the initial CM
+    # positions and the particle archives.
+    cat0 = HaloCatalogue(nsim0, paths, load_initial=True,
+                         minmass=("totpartmass", 1e12), with_lagpatch=True,
+                         load_clumps_cat=True)
+    catx = HaloCatalogue(nsimx, paths, load_initial=True,
+                         minmass=("totpartmass", 1e12), with_lagpatch=True,
+                         load_clumps_cat=True)
 
-clumpmap0 = read_h5(paths.particles_path(args.nsim0))["clumpmap"]
-parts0 = read_h5(paths.initmatch_path(args.nsim0, "particles"))["particles"]
-clid2map0 = {clid: i for i, clid in enumerate(clumpmap0[:, 0])}
+    clumpmap0 = read_h5(paths.particles_path(nsim0))["clumpmap"]
+    parts0 = read_h5(paths.initmatch_path(nsim0, "particles"))["particles"]
+    clid2map0 = {clid: i for i, clid in enumerate(clumpmap0[:, 0])}
 
-clumpmapx = read_h5(paths.particles_path(args.nsimx))["clumpmap"]
-partsx = read_h5(paths.initmatch_path(args.nsimx, "particles"))["particles"]
-clid2mapx = {clid: i for i, clid in enumerate(clumpmapx[:, 0])}
+    clumpmapx = read_h5(paths.particles_path(nsimx))["clumpmap"]
+    partsx = read_h5(paths.initmatch_path(nsimx, "particles"))["particles"]
+    clid2mapx = {clid: i for i, clid in enumerate(clumpmapx[:, 0])}
+
+    # We generate the background density fields. Loads halos's particles one by
+    # one from the archive, concatenates them and calculates the NGP density
+    # field.
+    if verbose:
+        print(f"{datetime.now()}: generating the background density fields.",
+              flush=True)
+    delta_bckg = overlapper.make_bckg_delta(parts0, clumpmap0, clid2map0, cat0,
+                                            verbose=verbose)
+    delta_bckg = overlapper.make_bckg_delta(partsx, clumpmapx, clid2mapx, catx,
+                                            delta=delta_bckg, verbose=verbose)
+
+    # We calculate the overlap between the NGP fields.
+    if verbose:
+        print(f"{datetime.now()}: crossing the simulations.", flush=True)
+    match_indxs, ngp_overlap = matcher.cross(cat0, catx, parts0, partsx,
+                                             clumpmap0, clumpmapx, delta_bckg,
+                                             verbose=verbose)
+    # We wish to store the halo IDs of the matches, not their array positions
+    # in the catalogues
+    match_hids = deepcopy(match_indxs)
+    for i, matches in enumerate(match_indxs):
+        for j, match in enumerate(matches):
+            match_hids[i][j] = catx["index"][match]
+
+    fout = paths.overlap_path(nsim0, nsimx, smoothed=False)
+    numpy.savez(fout, ref_hids=cat0["index"], match_hids=match_hids,
+                ngp_overlap=ngp_overlap)
+    if verbose:
+        print(f"{datetime.now()}: calculated NGP overlap, saved to {fout}.",
+              flush=True)
+
+    if not smoothen:
+        quit()
+
+    # We now smoothen up the background density field for the smoothed overlap
+    # calculation.
+    if verbose:
+        print(f"{datetime.now()}: smoothing the background field.", flush=True)
+    gaussian_filter(delta_bckg, output=delta_bckg, **smooth_kwargs)
+
+    # We calculate the smoothed overlap for the pairs whose NGP overlap is > 0.
+    smoothed_overlap = matcher.smoothed_cross(cat0, catx, parts0, partsx,
+                                              clumpmap0, clumpmapx, delta_bckg,
+                                              match_indxs, smooth_kwargs)
+
+    fout = paths.overlap_path(nsim0, nsimx, smoothed=True)
+    numpy.savez(fout, smoothed_overlap=smoothed_overlap, sigma=sigma)
+    if verbose:
+        print(f"{datetime.now()}: calculated smoothing, saved to {fout}.",
+              flush=True)
 
 
-# We generate the background density fields. Loads halos's particles one by one
-# from the archive, concatenates them and calculates the NGP density field.
-if args.verbose:
-    print(f"{datetime.now()}: generating the background density fields.",
-          flush=True)
-delta_bckg = overlapper.make_bckg_delta(parts0, clumpmap0, clid2map0, cat0,
-                                        verbose=args.verbose)
-delta_bckg = overlapper.make_bckg_delta(partsx, clumpmapx, clid2mapx, catx,
-                                        delta=delta_bckg, verbose=args.verbose)
+if __name__ == "__main__":
+    parser = ArgumentParser()
+    parser.add_argument("--nsim0", type=int)
+    parser.add_argument("--nsimx", type=int)
+    parser.add_argument("--sigma", type=float, default=None)
+    parser.add_argument("--smoothen", type=lambda x: bool(strtobool(x)),
+                        default=None)
+    parser.add_argument("--verbose", type=lambda x: bool(strtobool(x)),
+                        default=False)
+    args = parser.parse_args()
 
-# We calculate the overlap between the NGP fields.
-if args.verbose:
-    print(f"{datetime.now()}: crossing the simulations.", flush=True)
-match_indxs, ngp_overlap = matcher.cross(cat0, catx, parts0, partsx, clumpmap0,
-                                         clumpmapx, delta_bckg,
-                                         verbose=args.verbose)
-# We wish to store the halo IDs of the matches, not their array positions in
-# the catalogues
-match_hids = deepcopy(match_indxs)
-for i, matches in enumerate(match_indxs):
-    for j, match in enumerate(matches):
-        match_hids[i][j] = catx["index"][match]
-
-fout = paths.overlap_path(args.nsim0, args.nsimx, smoothed=False)
-numpy.savez(fout, ref_hids=cat0["index"], match_hids=match_hids,
-            ngp_overlap=ngp_overlap)
-if args.verbose:
-    print(f"{datetime.now()}: calculated NGP overlap, saved to {fout}.",
-          flush=True)
-
-if not args.smoothen:
-    quit()
-
-# We now smoothen up the background density field for the smoothed overlap
-# calculation.
-if args.verbose:
-    print(f"{datetime.now()}: smoothing the background field.", flush=True)
-gaussian_filter(delta_bckg, output=delta_bckg, **smooth_kwargs)
-
-# We calculate the smoothed overlap for the pairs whose NGP overlap is > 0.
-smoothed_overlap = matcher.smoothed_cross(cat0, catx, parts0, partsx,
-                                          clumpmap0, clumpmapx, delta_bckg,
-                                          match_indxs, smooth_kwargs)
-
-fout = paths.overlap_path(args.nsim0, args.nsimx, smoothed=True)
-numpy.savez(fout, smoothed_overlap=smoothed_overlap, sigma=args.sigma)
-if args.verbose:
-    print(f"{datetime.now()}: calculated smoothed overlap, saved to {fout}.",
-          flush=True)
+    pair_match(args.nsim0, args.nsimx, args.sigma, args.smoothen, args.verbose)

scripts/pre_dumppart.py

@@ -55,7 +55,7 @@ partreader = csiborgtools.read.ParticleReader(paths)
 pars_extract = ['x', 'y', 'z', 'vx', 'vy', 'vz', 'M', "ID"]
 
 if args.ics is None or args.ics[0] == -1:
-    ics = paths.get_ics(tonew=False)
+    ics = paths.get_ics()
 else:
     ics = args.ics
 

scripts/pre_mmain.py

@@ -51,12 +51,12 @@ def do_mmain(nsim):
 
 if nproc > 1:
     if rank == 0:
-        tasks = list(paths.get_ics(tonew=False))
+        tasks = list(paths.get_ics())
         master_process(tasks, comm, verbose=True)
     else:
         worker_process(do_mmain, comm, verbose=False)
 else:
-    tasks = paths.get_ics(tonew=False)
+    tasks = paths.get_ics()
     for task in tasks:
         print(f"{datetime.now()}: completing task `{task}`.", flush=True)
         do_mmain(task)

scripts/pre_sortinit.py

@@ -50,7 +50,7 @@ partreader = csiborgtools.read.ParticleReader(paths)
 pars_extract = ["x", "y", "z", "M", "ID"]
 
 if args.ics is None or args.ics[0] == -1:
-    ics = paths.get_ics(tonew=True)
+    ics = paths.get_ics()
 else:
     ics = args.ics