diff --git a/scratch/lgoh/cov_config_test.yaml b/scratch/lgoh/cov_config_test.yaml new file mode 100644 index 00000000..ebe8462c --- /dev/null +++ b/scratch/lgoh/cov_config_test.yaml @@ -0,0 +1,27 @@ +fiducial: + version: SP_v1.4.6 + blind: A + min_sep: 1.0 + max_sep: 100.0 + nbins: 20 + npatch: 30 + mock_version: SP_v1.4.6 + gaussian: g + +probe_3x2pt: wl +glass_mocks: + version: "v0" + seed_range: [1, 350] + +covariance: + default_masked: True + +tools: + python_executable: /n23data1/n06data/lgoh/scratch/my_env_new/bin/python + onecov_executable: /n23data1/n06data/lgoh/scratch/UNIONS/OneCovariance/covariance.py + +SP_v1.4.6: + cov_th: + sigma_e: 0.28, 0.28 + n_e: 5.0, 5.0 + A: 1000 \ No newline at end of file diff --git a/workflow/common.py b/workflow/common.py index 3df3413b..c0f51e6b 100644 --- a/workflow/common.py +++ b/workflow/common.py @@ -9,15 +9,19 @@ # fresh tree without clobbering (or silently reusing) prior products. COSMO_VAL = Path( os.environ.get( - "COSMO_VAL", "/n17data/cdaley/unions/code/sp_validation/cosmo_val/output" + "COSMO_VAL", + "/n23data1/n06data/lgoh/scratch/UNIONS/sp_validation/results/cosmo_val", ) ) COSMO_INFERENCE = Path( os.environ.get( - "COSMO_INFERENCE", "/n17data/cdaley/unions/code/sp_validation/cosmo_inference" + "COSMO_INFERENCE", + "/n23data1/n06data/lgoh/scratch/UNIONS/sp_validation/cosmo_inference", ) ) -CAT_CONFIG = "/n17data/cdaley/unions/code/sp_validation/cosmo_val/cat_config.yaml" +CAT_CONFIG = ( + "/n23data1/n06data/lgoh/scratch/UNIONS/sp_validation/cosmo_val/cat_config.yaml" +) BLINDS = ["A", "B", "C"] BLOCK_PAIRS = [("++", "1"), ("--", "2"), ("+-", "3")] @@ -25,7 +29,7 @@ # Source of truth: cs_util.cosmo.PLANCK18 # Regenerate with: snakemake results/cosmology/planck18.json # Resolved relative to the run directory at configure() time. -COSMOLOGY_PARAMS = "results/cosmology/planck18.json" +COSMOLOGY_PARAMS = "/n23data1/n06data/lgoh/scratch/UNIONS/sp_validation/results/cosmology/planck18.json" # Wildcard constraints shared by every Snakefile that composes these rules. # Patterns must match all expected values; overly restrictive patterns cause @@ -37,6 +41,7 @@ "min_sep": r"[0-9.]+", "max_sep": r"[0-9.]+", "gaussian": r"(g|ng)", + "probe": r"(wl|ggl|3x2pt)", "block_pm": r"(\+\+|--|\+-)", "block_i": r"[123]", "mask_suffix": r"(_masked)?", @@ -46,15 +51,17 @@ FIDUCIAL = None DEFAULT_MASK_SUFFIX = "" +DEFAULT_PROBE = None CATALOG_CONFIG = None PLANCK18 = None def configure(workflow_config): """Install config-derived values after Snakemake has loaded configfiles.""" - global CATALOG_CONFIG, DEFAULT_MASK_SUFFIX, FIDUCIAL, PLANCK18 + global CATALOG_CONFIG, DEFAULT_MASK_SUFFIX, DEFAULT_PROBE, FIDUCIAL, PLANCK18 CATALOG_CONFIG = workflow_config FIDUCIAL = workflow_config["fiducial"] + DEFAULT_PROBE = "wl" DEFAULT_MASK_SUFFIX = ( "_masked" if workflow_config["covariance"].get("default_masked", False) else "" ) @@ -76,44 +83,78 @@ def resolve_covariance_version(version): return version +# Single source of truth for the covariance naming scheme. Rule outputs use +# this with wildcards left in braces; covariance_base() fills concrete values. +# Keep the two in sync by construction: covariance_base() formats this string. +COV_BASE_TEMPLATE = ( + "covariance_{version}_{blind}_{gaussian}" + "_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}_{probe}{mask_suffix}" +) + + +def cov_output(suffix): + """Wildcard-bearing output path under the covariance tree. + + E.g. cov_output(".ini") -> + /data/covariance//.ini + with {version}, {blind}, ... left as Snakemake wildcards. + """ + return str( + COSMO_INFERENCE + / f"data/covariance/{COV_BASE_TEMPLATE}/{COV_BASE_TEMPLATE}{suffix}" + ) + + +def cov_output_dirfile(filename): + """Wildcard-bearing path to a fixed-name file inside the covariance dir.""" + return str(COSMO_INFERENCE / f"data/covariance/{COV_BASE_TEMPLATE}/{filename}") + + def covariance_base( version, blind, - gaussian="ng", + gaussian=None, min_sep=None, max_sep=None, nbins=None, + probe=None, mask_suffix=None, resolve_version=True, fiducial=None, default_mask_suffix=None, ): - """Construct covariance base name.""" + """Construct covariance base name (concrete values, no wildcards).""" fiducial = fiducial or FIDUCIAL + gaussian = gaussian if gaussian is not None else fiducial["gaussian"] min_sep = min_sep if min_sep is not None else fiducial["min_sep"] max_sep = max_sep if max_sep is not None else fiducial["max_sep"] nbins = nbins if nbins is not None else fiducial["nbins"] - mask_suffix = ( - mask_suffix - if mask_suffix is not None - else ( + probe = probe if probe is not None else DEFAULT_PROBE + if mask_suffix is None: + mask_suffix = ( DEFAULT_MASK_SUFFIX if default_mask_suffix is None else default_mask_suffix ) - ) cov_version = resolve_covariance_version(version) if resolve_version else version - return ( - f"covariance_{cov_version}_{blind}_{gaussian}" - f"_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}" + return COV_BASE_TEMPLATE.format( + version=cov_version, + blind=blind, + gaussian=gaussian, + min_sep=min_sep, + max_sep=max_sep, + nbins=nbins, + probe=probe, + mask_suffix=mask_suffix, ) def covariance_dir( version, blind, - gaussian="ng", + gaussian=None, min_sep=None, max_sep=None, nbins=None, + probe=None, mask_suffix=None, resolve_version=True, ): @@ -125,6 +166,7 @@ def covariance_dir( min_sep, max_sep, nbins, + probe, mask_suffix, resolve_version=resolve_version, ) @@ -134,12 +176,13 @@ def covariance_dir( def covariance_path( version, blind, - gaussian="ng", + gaussian=None, min_sep=None, max_sep=None, nbins=None, + probe=None, mask_suffix=None, - suffix="_processed.txt", + suffix=".dat", resolve_version=True, ): """Construct covariance file path.""" @@ -150,22 +193,39 @@ def covariance_path( min_sep, max_sep, nbins, + probe, mask_suffix, resolve_version=resolve_version, ) return str(COSMO_INFERENCE / f"data/covariance/{base}/{base}{suffix}") -def build_redshift_path(version, blind): +def build_redshift_dir(version): """Construct n(z) filepath for given catalog version and blind.""" base_version = re.sub(r"_leak_corr$", "", version) base_version = re.sub(r"_ecut\d+", "", base_version) if "v1.4.11" in base_version: base_version = "SP_v1.4.6" version_dir = base_version.replace("SP_", "") - return ( - f"/n17data/sguerrini/UNIONS/WL/nz/{version_dir}/nz_{base_version}_{blind}.txt" - ) + return f"/n17data/sguerrini/UNIONS/WL/nz/{version_dir}/" + + +def build_redshift_path_lens(version, blind): + """Construct n(z) filepath for given catalog version and blind.""" + base_version = re.sub(r"_leak_corr$", "", version) + base_version = re.sub(r"_ecut\d+", "", base_version) + if "v1.4.11" in base_version: + base_version = "SP_v1.4.6" + return f"nz_{base_version}_{blind}.txt" + + +def build_redshift_path_source(version, blind): + """Construct n(z) filepath for given catalog version and blind.""" + base_version = re.sub(r"_leak_corr$", "", version) + base_version = re.sub(r"_ecut\d+", "", base_version) + if "v1.4.11" in base_version: + base_version = "SP_v1.4.6" + return f"nz_{base_version}_{blind}_source.txt" # TO DO: check lens and source file format def get_shear_catalog(wildcards): diff --git a/workflow/rules/covariance.smk b/workflow/rules/covariance.smk index 49e40201..1a991e30 100644 --- a/workflow/rules/covariance.smk +++ b/workflow/rules/covariance.smk @@ -1,14 +1,23 @@ # BLOCK_PAIRS, PLANCK18, COSMOLOGY_PARAMS defined in Snakefile - +import os def get_cat_params(version): - """Extract covariance parameters (area, n_e, sigma_e) from catalog config.""" + """Extract covariance parameters (sigma_e, n_eff, area) from catalog config. + + Returns (sigma_e, (n_e_lens, n_e_clust), (A_lens, A_ggl, A_clust)). + For probe == "wl" the clustering/ggl slots are empty strings. + """ base_version = version.replace("_leak_corr", "") if base_version not in config: raise KeyError(f"Catalog configuration not found for {base_version}") cov_th = config[base_version]["cov_th"] - return cov_th["A"], cov_th["n_e"], cov_th["sigma_e"] - + if config["probe_3x2pt"] == "wl": + return cov_th["sigma_e"], (cov_th["n_e"], ""), (cov_th["A"], "", "") + return ( + cov_th["sigma_e"], + (cov_th["n_e_lens"], cov_th["n_e_clust"]), + (cov_th["A_lens"], cov_th["A_ggl"], cov_th["A_clust"]), + ) # covariance_dir(), covariance_base(), covariance_path() defined in Snakefile # Additional wildcard constraints defined locally for pseudo-Cl rules (line 327) @@ -17,21 +26,43 @@ def get_cat_params(version): # Footprint mask power spectra (nside=4096, from comprehensive catalog with spatial cuts only) MASK_CLS_BASE = str(COSMO_INFERENCE / "data/mask") MASK_CLS_FILES = { - "footprint": f"{MASK_CLS_BASE}/mask_cls_footprint_nside_4096_norm.txt", - "footprint_starhalo": f"{MASK_CLS_BASE}/mask_cls_footprint_starhalo_nside_4096_norm.txt", + "footprint_lens": "mask_cls_footprint_nside_4096_norm.txt", + "footprint_ggl": "mask_cls_footprint_nside_4096_norm.txt", + "footprint_clust": "mask_cls_footprint_nside_4096_norm.txt", + "footprint_lens_starhalo": "mask_cls_footprint_starhalo_nside_4096_norm.txt", } # v1.4.8 uses the star-halo footprint; all other versions use the standard footprint STARHALO_VERSIONS = {"v1.4.8"} +def get_mask_cls_file(version, kind="lens"): + """Return the mask Cl *filename* (OneCov wants dir and file separately).""" + version_dir = version.replace("_leak_corr", "").replace("SP_", "") + version_dir = re.sub(r"_ecut\d+", "", version_dir) + if kind == "lens" and version_dir in STARHALO_VERSIONS: + return MASK_CLS_FILES["footprint_lens_starhalo"] + return MASK_CLS_FILES[f"footprint_{kind}"] -def get_mask_cls_path(version): - """Return absolute mask Cl path for the requested catalog version.""" - version_dir = version.replace('_leak_corr', '').replace('SP_', '') - version_dir = re.sub(r'_ecut\d+', '', version_dir) - key = "footprint_starhalo" if version_dir in STARHALO_VERSIONS else "footprint" - return MASK_CLS_FILES[key] +def _onecov_mask_params(w): + """Resolve OneCov mask settings for one job. + + Returns dict with keys: dir, lens, ggl, clust. Empty strings when the + job is unmasked or the probe doesn't use a given field. + """ + if w.mask_suffix != "_masked": + return {"dir": "", "lens": "", "ggl": "", "clust": ""} + out = { + "dir": MASK_CLS_BASE, + "lens": get_mask_cls_file(w.version, "lens"), + "ggl": "", + "clust": "", + } + if w.probe in ("ggl", "3x2pt"): + out["ggl"] = get_mask_cls_file(w.version, "ggl") + if w.probe == "3x2pt": + out["clust"] = get_mask_cls_file(w.version, "clust") + return out rule cosmology_params: """Generate cosmology parameters JSON from sp_validation. @@ -57,112 +88,199 @@ with open('{output}', 'w') as f: " """ - -rule covariance_ini: +rule covariance_ini_onecov: input: - nz_file=lambda w: build_redshift_path(w.version, w.blind), - mask=lambda w: [] if w.mask_suffix != "_masked" else [get_mask_cls_path(w.version)], + # Ensures planck18.json exists before get_planck18() is called below. + cosmo=COSMOLOGY_PARAMS, output: - str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}.ini") + cov_output(".ini"), params: outdir=lambda w: covariance_dir( - w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, w.mask_suffix, - resolve_version=False + w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, + w.probe, w.mask_suffix, resolve_version=False, ), - ng_value=lambda wildcards: "1" if wildcards.gaussian == "ng" else "0", + out_filename=lambda w: covariance_base( + w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, + w.probe, w.mask_suffix, resolve_version=False, + ) + ".dat", + out_plot_filename=lambda w: covariance_base( + w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, + w.probe, w.mask_suffix, resolve_version=False, + ) + "_corr_plot.pdf", + ng_value=lambda w: "1" if w.gaussian == "ng" else "0", + do_ggl=lambda w: str(w.probe in ("ggl", "3x2pt")), + do_clustering=lambda w: str(w.probe == "3x2pt"), omega_m=PLANCK18["Omega_m"], omega_v=PLANCK18["Omega_v"], sigma_8=PLANCK18["sigma_8"], n_s=PLANCK18["n_s"], h=PLANCK18["h"], omega_b=PLANCK18["Omega_b"], - area=lambda w: get_cat_params(w.version)[0], - n_e=lambda w: get_cat_params(w.version)[1], - sigma_e_param=lambda w: get_cat_params(w.version)[2], - mask=lambda w: get_mask_cls_path(w.version) if w.mask_suffix == "_masked" else "", + hmcode_logT_AGN=7.75, + sigma_e_param=lambda w: get_cat_params(w.version)[0], + n_e_lens_line=lambda w: ( + f"n_eff_lensing = {get_cat_params(w.version)[1][0]}"), + n_e_clust_line=lambda w: ("" + if w.probe == "wl" + else f"n_eff_clust = {get_cat_params(w.version)[1][1]}"), + area_lens_line=lambda w: ( + f"survey_area_lensing_in_deg2 = {get_cat_params(w.version)[2][0]}"), + area_ggl_line=lambda w: ( + "" + if w.probe == "wl" + else f"survey_area_ggl_in_deg2 = {get_cat_params(w.version)[2][1]}" + ), + area_clust_line=lambda w: ( + "" + if w.probe == "wl" + else f"survey_area_clust_in_deg2 = {get_cat_params(w.version)[2][2]}" + ), + mask_dir=lambda w: _onecov_mask_params(w)["dir"], + mask_lens=lambda w: _onecov_mask_params(w)["lens"], + mask_ggl=lambda w: _onecov_mask_params(w)["ggl"], + mask_clust=lambda w: _onecov_mask_params(w)["clust"], + nz_dir=lambda w: os.path.dirname(build_redshift_dir(w.version)), + nz_lens=lambda w: os.path.basename(build_redshift_path_lens(w.version, w.blind)), + nz_clust=lambda w: ( + "" if w.probe == "wl" + else os.path.basename(build_redshift_path_source(w.version, w.blind)) + ), threads: 1 shell: """ mkdir -p {params.outdir} - cat > {output} << 'EOF' -# -# Cosmological parameters -# -Omega_m : {params.omega_m} -Omega_v : {params.omega_v} -sigma_8 : {params.sigma_8} -n_spec : {params.n_s} -w0 : -1 -wa : 0 -omb : {params.omega_b} -h0 : {params.h} - - -# Survey and galaxy parameters -# -# area in degrees -# n_gal,lens_n_gal in gals/arcmin^2 - -area : {params.area} -sourcephotoz : multihisto -lensphotoz : multihisto -source_tomobins : 1 -lens_tomobins : 1 -sigma_e : {params.sigma_e_param} -source_n_gal : {params.n_e} -lens_n_gal : {params.n_e} - - -shear_REDSHIFT_FILE : {input.nz_file} -clustering_REDSHIFT_FILE : {input.nz_file} -c_footprint_file : {params.mask} - - -# IA parameters -IA : 1 -A_ia : 0.0 -eta_ia : 0.0 - - -# Covariance parameters -# -# tmin,tmax in arcminutes -tmin : {wildcards.min_sep} -tmax : {wildcards.max_sep} -ntheta : {wildcards.nbins} -ng : {params.ng_value} -cng : {params.ng_value} - - -outdir : ./ -filename : cov_tmp -ss : true -ls : false -ll : false + cat > "{output}" << 'EOF' +[covariance terms] +gauss = True +split_gauss = False +nongauss = {params.ng_value} +ssc = {params.ng_value} +sn_only = False + +[observables] +cosmic_shear = True +est_shear = xi_pm +clustering = {params.do_clustering} +ggl = {params.do_ggl} +est_ggl = gamma_t +est_clust = w + +[output settings] +directory = {params.outdir} +file = {params.out_filename} +style = matrix +save_configs = False +corrmatrix_plot = {params.out_plot_filename} + +[covTHETAspace settings] +theta_min = {wildcards.min_sep} +theta_max = {wildcards.max_sep} +theta_bins = {wildcards.nbins} +theta_type = log +xi_pp = True +xi_mm = True +theta_accuracy = 1e-3 +integration_intervals = 400 + +[survey specs] +mask_directory = {params.mask_dir} +mask_file_lensing = {params.mask_lens} +mask_file_clust = {params.mask_clust} +mask_file_ggl = {params.mask_ggl} +ellipticity_dispersion = {params.sigma_e_param} +{params.area_lens_line} +{params.area_clust_line} +{params.area_ggl_line} +{params.n_e_lens_line} +{params.n_e_clust_line} + +[redshift] +zlens_directory = {params.nz_dir} +zlens_file = {params.nz_lens} +zclust_file = {params.nz_clust} +value_loc_in_lensbin = mid +value_loc_in_clustbin = mid + +[cosmo] +sigma8 = {params.sigma_8} +h = {params.h} +omega_m = {params.omega_m} +omega_b = {params.omega_b} +omega_de = {params.omega_v} +w0 = -1.0 +wa = 0.0 +ns = {params.n_s} +neff = 3.046 +m_nu = 0.06 +tcmb0 = 2.725 + +[IA] +A_IA = 0.0 +eta_IA = 0.0 +z_pivot_IA = 0.3 + +[powspec evaluation] +non_linear_model = mead2020_feedback +HMCode_logT_AGN = {params.hmcode_logT_AGN} +log10k_bins = 300 +log10k_min = -3.46 +log10k_max = 3.15 + +[hod] +model_mor_cen = double_powerlaw +model_mor_sat = double_powerlaw +dpow_logm0_cen = 10.51 +dpow_logm1_cen = 11.38 +dpow_a_cen = 7.096 +dpow_b_cen = 0.2 +dpow_norm_cen = 1.0 +dpow_norm_sat = 0.56 +model_scatter_cen = lognormal +model_scatter_sat = modschechter +logn_sigma_c_cen = 0.35 +modsch_logmref_sat = 13.0 +modsch_alpha_s_sat = -0.858 +modsch_b_sat = -0.024, 1.149 + +[halomodel evaluation] +m_bins = 900 +log10m_min = 6 +log10m_max = 18 +hmf_model = Tinker10 +mdef_model = SOMean +mdef_params = overdensity, 200 +disable_mass_conversion = True +delta_c = 1.686 +transfer_model = CAMB +small_k_damping_for1h = damped + +[misc] +num_cores = 8 + EOF """ - -rule covariance_cosmocov: +rule covariance_onecov: input: - rules.covariance_ini.output, + rules.covariance_ini_onecov.output, output: - str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/cov_tmp_ssss_{block_pm}_cov_Ntheta{nbins}_Ntomo1_{block_i}") + # Matches `[output settings] file = cov_tmp_onecov.dat` in the ini. + cov_output(".dat") params: - block_i="{block_i}", outdir=lambda w: covariance_dir( - w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, w.mask_suffix, - resolve_version=False + w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, + w.probe, w.mask_suffix, resolve_version=False, ), ini_path=lambda w: covariance_path( - w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, w.mask_suffix, - suffix=".ini", resolve_version=False + w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, + w.probe, w.mask_suffix, suffix=".ini", resolve_version=False, ), - cosmocov=config["tools"]["cosmocov_executable"], + onecov=config["tools"]["onecov_executable"], + python_executable=config["tools"]["python_executable"], container: None - threads: 1 + threads: 8 shell: """ module unload gcc || true @@ -172,68 +290,73 @@ rule covariance_cosmocov: module load openmpi cd {params.outdir} - {params.cosmocov} {params.block_i} {params.ini_path} + {params.python_executable} {params.onecov} {params.ini_path} """ -rule covariance_cat: - input: - cov_block=lambda w: [ - f"{covariance_dir(w.version, w.blind, w.gaussian, w.min_sep, w.max_sep, w.nbins, w.mask_suffix, resolve_version=False)}" - f"/cov_tmp_ssss_{pm}_cov_Ntheta{w.nbins}_Ntomo1_{idx}" - for pm, idx in BLOCK_PAIRS - ], - threads: 1 - output: - str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}.txt") - shell: - """ - cat {input} > {output} - """ - +# Glass-mock roots. Env/config-overridable for the same reason as COSMO_*. +GLASS_MOCK_RESULTS = config.get("glass_mocks", {}).get( + "results_dir", "/n09data/guerrini/glass_mock_v1.4.6/results" +) +GLASS_MOCK_COV_DIR = config.get("glass_mocks", {}).get( + "covariance_dir", + "/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6", +) rule covariance_glass_mock: input: xi=expand( - "/n09data/guerrini/glass_mock_v1.4.6/results/xi_glass_mock_{seed:05d}_4096_nbins=20.fits", - seed=range(config["glass_mocks"]["seed_range"][0], config["glass_mocks"]["seed_range"][1] + 1), + GLASS_MOCK_RESULTS + "/xi_glass_mock_{seed:05d}_4096_nbins=20.fits", + seed=range( + config["glass_mocks"]["seed_range"][0], + config["glass_mocks"]["seed_range"][1] + 1, + ), ), cl=expand( - "/n09data/guerrini/glass_mock_v1.4.6/results/cl_glass_mock_{seed:05d}_4096.npy", - seed=range(config["glass_mocks"]["seed_range"][0], config["glass_mocks"]["seed_range"][1] + 1), + GLASS_MOCK_RESULTS + "/cl_glass_mock_{seed:05d}_4096.npy", + seed=range( + config["glass_mocks"]["seed_range"][0], + config["glass_mocks"]["seed_range"][1] + 1, + ), ), output: - xi_covariance="/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6/xi_covariance.npy", - cl_covariance="/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6/cl_covariance.npy", - combined_covariance="/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6/combined_covariance.npy", - correlation_plot="/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6/combined_correlation.png", - xi_mean="/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6/xi_mean.npy", - cl_mean="/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6/cl_mean.npy", - combined_mean="/automnt/n17data/cdaley/unions/pure_eb/results/covariance/glass_mock_v1.4.6/combined_mean.npy", + xi_covariance=f"{GLASS_MOCK_COV_DIR}/xi_covariance.npy", + cl_covariance=f"{GLASS_MOCK_COV_DIR}/cl_covariance.npy", + combined_covariance=f"{GLASS_MOCK_COV_DIR}/combined_covariance.npy", + correlation_plot=f"{GLASS_MOCK_COV_DIR}/combined_correlation.png", + xi_mean=f"{GLASS_MOCK_COV_DIR}/xi_mean.npy", + cl_mean=f"{GLASS_MOCK_COV_DIR}/cl_mean.npy", + combined_mean=f"{GLASS_MOCK_COV_DIR}/combined_mean.npy", script: "../scripts/compute_glass_mock_covariance.py" - -# fiducial_binning_suffix() defined in Snakefile - - rule generate_glass_mock_rhotau_samples: """Generate sampled tau statistics for glass mocks. Only tau is sampled; inference_prep_glass_mock uses real rho data. """ input: - cov_tau=str(COSMO_VAL / f"rho_tau_stats/cov_tau_{FIDUCIAL['mock_version']}{fiducial_binning_suffix()}_th.npy"), - ref_tau=str(COSMO_VAL / f"rho_tau_stats/tau_stats_{FIDUCIAL['mock_version']}{fiducial_binning_suffix()}.fits"), + cov_tau=str( + COSMO_VAL + / f"rho_tau_stats/cov_tau_{FIDUCIAL['mock_version']}{fiducial_binning_suffix()}_th.npy" + ), + ref_tau=str( + COSMO_VAL + / f"rho_tau_stats/tau_stats_{FIDUCIAL['mock_version']}{fiducial_binning_suffix()}.fits" + ), output: tau="results/glass_mock_rhotau_samples/{mock_id}/tau_stats_sampled.fits", params: mock_id="{mock_id}", output_dir="results/glass_mock_rhotau_samples", + # Resolved relative to this .smk file instead of a hard-coded checkout. + script=workflow.source_path( + "../scripts/generate_glass_mock_rhotau_samples.py" + ), threads: 1 shell: """ - python /n17data/cdaley/unions/pure_eb/code/sp_validation/workflow/scripts/generate_glass_mock_rhotau_samples.py \ + python {params.script} \ --cov-tau {input.cov_tau} \ --ref-tau {input.ref_tau} \ --output-dir {params.output_dir} \ @@ -241,55 +364,35 @@ rule generate_glass_mock_rhotau_samples: """ -rule covariance_process: - input: - str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}.txt") - output: - matrix=str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}_processed.txt"), - gaussian=str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}_processed_g.txt"), - plot=str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}_processed_plot.pdf") - params: - output_stub=str(COSMO_INFERENCE / "data/covariance/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}/covariance_{version}_{blind}_{gaussian}_minsep={min_sep}_maxsep={max_sep}_nbins={nbins}{mask_suffix}_processed") - threads: 1 - shell: - """ - python /n17data/cdaley/unions/pure_eb/code/sp_validation/cosmo_inference/scripts/cosmocov_process.py {input} {params.output_stub} - """ - - -def fiducial_covariance_outputs(mask_suffix=""): +def fiducial_covariance_outputs(mask_suffix="", probe=DEFAULT_PROBE): """Return processed covariance files for fiducial version/blind.""" - ng_path = covariance_path( - FIDUCIAL["version"], FIDUCIAL["blind"], "ng", - FIDUCIAL["min_sep"], FIDUCIAL["max_sep"], FIDUCIAL["nbins"], mask_suffix + path = covariance_path( + FIDUCIAL["version"], FIDUCIAL["blind"], FIDUCIAL["gaussian"], + FIDUCIAL["min_sep"], FIDUCIAL["max_sep"], FIDUCIAL["nbins"], + probe, mask_suffix, ) - g_path = covariance_path( - FIDUCIAL["version"], FIDUCIAL["blind"], "g", - FIDUCIAL["min_sep_int"], FIDUCIAL["max_sep_int"], FIDUCIAL["nbins_int"], mask_suffix - ) - return [ng_path, g_path] - + return path rule covariance: input: - fiducial_covariance_outputs(mask_suffix=DEFAULT_MASK_SUFFIX) - + fiducial_covariance_outputs(mask_suffix=DEFAULT_MASK_SUFFIX, probe=DEFAULT_PROBE), rule covariance_masked: input: - fiducial_covariance_outputs(mask_suffix="_masked") - + fiducial_covariance_outputs(mask_suffix="_masked", probe=DEFAULT_PROBE), rule covariance_unmasked: input: - fiducial_covariance_outputs(mask_suffix="") + fiducial_covariance_outputs(mask_suffix="", probe=DEFAULT_PROBE), +rule covariance_3x2pt: + input: + fiducial_covariance_outputs(mask_suffix="", + probe=config["probe_3x2pt"]), -ruleorder: covariance_ini > covariance_cosmocov > covariance_cat > covariance_process > covariance +# ruleorder: covariance_ini_onecov > covariance_onecov > covariance localrules: cosmology_params, - covariance_ini, - covariance_cat, - covariance_process, + covariance_ini_onecov, generate_glass_mock_rhotau_samples,