Raise an error if `lightconer.cosmo != inputs.cosmo_params.cosmo`

[Klarajons1228]

I aim to vary cosmological parameters for inference, such as Omega_m, but when doing so I have come to the realization that the output fields are not obtained in the requested redshift range (zmin,zmax) for extreme omega_m.

Example:
z min: 3.6519546435033474 z max: 6.115043211898531 Omega m = 0.21
z min: 4.413734994173905 z max: 8.190620077801478 Omega m = 0.27
z min: 4.276968023137314 z max: 7.795646887915723 Omega m = 0.26
z min: 4.015662168524921 z max: 7.0687066375098295 Omega m = 0.24
z min: 3.8908066698121253 z max: 6.733851929344507 Omega m = 0.23
z min: 3.5376842962431434 z max: 5.828864570704496 Omega m = 0.2
z min: 3.7696175535864285 z max: 6.416350594784393 Omega m = 0.22
z min: 4.144331163376727 z max: 7.422178440708719 Omega m = 0.25

These printed redshifts are now min and max from lightcone.lightcone_redshifts and the inputed zmin,zmax is (5.0,10.0).

Why is that? Is it possible to strictly get light cones in the range I want?

I also have another, related, question. I have also found some realizations that that has the lightcone_redshifts in the wanted range, but below some threshold value, seed dependent, have the output fields never been filled but just goes to 0...

Example:

halo_sfr
z min/max in file: 5.0 12.001959
first nonzero z: 7.384826
last nonzero z : 12.001959
halo_mass
z min/max in file: 5.0 12.001959
first nonzero z: 7.384826
last nonzero z : 12.001959
brightness_temp
z min/max in file: 5.0 12.001959
first nonzero z: 7.384826
last nonzero z : 12.001959
neutral_fraction
z min/max in file: 5.0 12.001959
first nonzero z: 7.384826
last nonzero z : 12.001959

this is with the following set-up: {'M_TURN': 9.585523679998476, 'F_ESC10': -2.8209379003515362, 'F_STAR10': -2.1009746734330954, 'ALPHA_ESC': -0.6802421636474193, 'ALPHA_STAR': 0.05482920328295837, 'OMm': 0.21446160450707033}

Why would this have happened? Is there some parameter combination that triggers some type of "early stopping" in the field population process so they are initialized to be 0 but never populated below some redshift threshold?...

[steven-murray]

Thanks for the issues @Klarajons1228. Could you provide the script you ran to get these results? And the version of 21cmFAST?

[Klarajons1228]

Hi, yes, this is the script for the second "issue" when all the fields go to 0 below 7.38:

box_len = 200 #300
hii_dim = 128 #200
dim = 3*hii_dim #3xhii_dim
halo_min_mass = 10**8

### Simulation options
config["EXTRA_HALOBOX_FIELDS"] = True
from py21cmfast.wrapper import classy_interface as p21c_classy
p21c_classy.classy_params_default["matter_source_in_current_gauge"] = "yes"

USE_TS_FLUCT = False  ### CHANGE
zmin = 5.0
zmax = 12.0
zstep_factor = 1.1

BASE_SEED = 42

### Quantities to calculate
lightcone_quantities = (
    "brightness_temp",
    "halo_mass",
    "halo_sfr",
    "density",
    "count",
    "neutral_fraction",
    "kinetic_temperature"
)

lightcone_dir = Path("SBI_database/lightcones")

nr_of_lightcones = 1  ### CHANGE

sim_num = 102

cache_dict = f"SBI_database/sim={sim_num}"

print(f"Running batch {sim_num}")

def sample_priors(rng, fiducial=False):
    """ 
    Definition of priors.

    """
    if not fiducial:
        params = {
                # EoR Params
                "M_TURN" : rng.uniform(8,10), # log-uniform prior
                "F_ESC10" : rng.uniform(-3,0), # log-uniform prior
                "F_STAR10" : rng.uniform(-3,0), # log-uniform prior
                "ALPHA_ESC" : rng.uniform(-0.8, 0.5), # linear prior
                "ALPHA_STAR" : rng.uniform(-0.3, 0.9), # linear prior
                "OMm": rng.uniform(0.2, 0.4), # linear prior
            }
    else:
        params = {
            "M_TURN": 9.0,
            "F_ESC10": -1.3,
            "F_STAR10": -1.0,
            "ALPHA_ESC": -0.5,
            "ALPHA_STAR": 0.5,
            "OMm": 0.308,
        }
    return params

# ===============================================================
# 0️⃣ CREATES CACHE
# ===============================================================
def create_cache(lightcone_ID,cache_dict):
    sim_num = datetime.now().strftime("%Y%m%d_%H%M%S")
    cache_dir = f"/remote/gpu04/jons/_cache/{cache_dict}/w{sim_num}_{lightcone_ID}"

    if not os.path.exists(cache_dir):
        os.makedirs(cache_dir)
    p21c.config['direc'] = cache_dir

    cache = p21c.OutputCache(cache_dir)

    cache_dir = Path(cache_dir)

    return cache, cache_dir

# ===============================================================
# 1️⃣ INPUT PARAMETERS
# ===============================================================
def input_params(params, hii_dim,box_len,dim,halo_min_mass,USE_TS_FLUCT,zmin, zmax, zstep_factor,cache,seed):
    inputs = p21c.InputParameters(
        node_redshifts = p21c.wrapper.inputs.get_logspaced_redshifts(
            min_redshift=zmin,
            z_step_factor=zstep_factor,
            max_redshift=zmax,
        ),
        random_seed=seed,
        simulation_options={"HII_DIM": hii_dim, "BOX_LEN": box_len, "DIM" :dim,"SAMPLER_MIN_MASS":halo_min_mass}, 
        matter_options={"POWER_SPECTRUM":"CLASS", "PERTURB_ON_HIGH_RES":True, "USE_RELATIVE_VELOCITIES":True, "SOURCE_MODEL":"CHMF-SAMPLER","KEEP_3D_VELOCITIES":True},
        astro_options = {"USE_TS_FLUCT": USE_TS_FLUCT, "USE_UPPER_STELLAR_TURNOVER":True, "USE_EXP_FILTER":True,"INHOMO_RECO":False}, #spherical-tophat
        astro_params = {"F_ESC10": params["F_ESC10"], 
                        "F_STAR10": params["F_STAR10"], 
                        "ALPHA_ESC": params["ALPHA_ESC"], 
                        "ALPHA_STAR": params["ALPHA_STAR"], 
                        "M_TURN": params["M_TURN"],
                        },
        cosmo_params = {"OMm": params["OMm"],
                        "A_s":2.105e-9},
    )

    return inputs

# ===============================================================
# 3️⃣ RUNS LIGHTCONE SIMULATION
# ===============================================================
def run_lightcone(inputs,lightcone_quantities,cache,zmin,zmax):

    lcn = p21c.RectilinearLightconer.between_redshifts(
        min_redshift=zmin,
        max_redshift=zmax,
        quantities=lightcone_quantities,
        resolution=inputs.simulation_options.cell_size,
    )

    lightcone_fid = p21c.run_lightcone(
        lightconer=lcn,
        inputs=inputs,
        cache=cache,
        write=True,
        regenerate=True,
        progressbar=True
    )

    # save lightcone redshifts
    lc_z = np.array(lcn.lc_redshifts)

    return lightcone_fid, lc_z

# ------------------------------------------ run lightcones --------------------------------- #

# Memory monitoring helper
def get_memory_usage():
    """Get current memory usage of the process in GB."""
    process = psutil.Process()
    mem_info = process.memory_info()
    return mem_info.rss / (1024**3)  # Convert bytes to GB

for lightcone_ID in range(nr_of_lightcones):

    start_time = time.time()

    # Skip if already completed
    lightcone_dir.mkdir(parents=True, exist_ok=True)
    lname = lightcone_dir / f"lightcone_INHOMORECO_FALSE_TB_FLUCT_FALSE_zmax=12_{sim_num}_{lightcone_ID}.h5" ### CHANGE
    if lname.exists():
        print(f"lightcone_{sim_num}_{lightcone_ID} already exists, skipping", flush=True)
        continue

    # Memory tracking
    mem_start = get_memory_usage()
    mem_peak = mem_start

    # Deterministic seed unique to this batch and local_id
    seed = BASE_SEED + lightcone_ID * 1000000 + sim_num

    run_rng = np.random.default_rng(seed)
    params = sample_priors(run_rng, fiducial=False)

    print(f" running lightcone_{lightcone_ID} with params: {params}")
    print(f" lightcone_{lightcone_ID}: Memory at start: {mem_start:.2f} GB", flush=True)

    # Create Cache
    cache, cache_dir = create_cache(lightcone_ID, cache_dict)

    # input parameters
    inputs = input_params(params, hii_dim,box_len,dim,halo_min_mass,USE_TS_FLUCT,zmin, zmax, zstep_factor,cache,seed)

    try:
        lightcone, lc_z = run_lightcone(inputs,lightcone_quantities,cache,zmin,zmax)
        # Track memory after lightcone generation
        mem_after_lightcone = get_memory_usage()
        mem_peak = max(mem_peak, mem_after_lightcone)
        print(f"lightcone_{lightcone_ID}: Memory after lightcone: {mem_after_lightcone:.2f} GB", flush=True)

        # Save only essential data to minimize file size
        lightcone_path = lname

        with h5py.File(lightcone_path, 'w') as f:
            # Create InputParameters group with node_redshifts only
            inp_grp = f.create_group("InputParameters")
            inp_grp.create_dataset("node_redshifts", data=inputs.node_redshifts, compression="gzip")
            
            # Save sampled parameters and random seed
            inp_grp.attrs['random_seed'] = seed
            inp_grp.attrs['M_TURN'] = params['M_TURN']
            inp_grp.attrs['F_ESC10'] = params['F_ESC10']
            inp_grp.attrs['F_STAR10'] = params['F_STAR10']
            inp_grp.attrs['ALPHA_ESC'] = params['ALPHA_ESC']
            inp_grp.attrs['ALPHA_STAR'] = params['ALPHA_STAR']
            inp_grp.attrs['OMm'] = params['OMm']
            inp_grp.attrs['batch_number'] = sim_num
            inp_grp.attrs['local_id'] = lightcone_ID
            inp_grp.attrs['BOX_LEN'] = box_len
            inp_grp.attrs['HII_DIM'] = hii_dim
            
            # Create global_quantities group with only brightness_temp and neutral_fraction
            global_grp = f.create_group("global_quantities")
            global_grp.create_dataset("brightness_temp", 
                                     data=lightcone.global_quantities['brightness_temp'],
                                     compression="gzip", dtype="f4")
            global_grp.create_dataset("neutral_fraction", 
                                 data=lightcone.global_quantities['neutral_fraction'],
                                 compression="gzip", dtype="f4")
            
            # Create lightcones group with only brightness_temp
            lc_grp = f.create_group("lightcones")
            lc_grp.create_dataset("brightness_temp", 
                                 data=lightcone.lightcones['brightness_temp'],
                                 compression="gzip", dtype="f4")
            lc_grp.create_dataset("halo_mass", 
                                 data=lightcone.lightcones['halo_mass'],
                                 compression="gzip", dtype="f4")
            lc_grp.create_dataset("halo_sfr", 
                                 data=lightcone.lightcones['halo_sfr'],
                                 compression="gzip", dtype="f4")
            lc_grp.create_dataset("density", 
                                 data=lightcone.lightcones['density'],
                                 compression="gzip", dtype="f4")
            lc_grp.create_dataset("count", 
                                 data=lightcone.lightcones['count'],
                                 compression="gzip", dtype="f4")
            lc_grp.create_dataset("neutral_fraction", 
                                 data=lightcone.lightcones['neutral_fraction'],
                                 compression="gzip", dtype="f4")
            lc_grp.create_dataset("kinetic_temperature", 
                                 data=lightcone.lightcones['kinetic_temperature'],
                                 compression="gzip", dtype="f4")

            # Add lightcone_redshifts as top-level dataset
            f.create_dataset('lightcone_redshifts', data=lc_z, compression="gzip", dtype="f4")
        
        print(f"lightcone_{sim_num}_{lightcone_ID}: saved {lightcone_path.stat().st_size / (1024**3):.2f} GB", flush=True)
        
        # Clean up entire cache directory for this run
        if cache_dir.exists():
            shutil.rmtree(cache_dir)
            print(f"lightcone_{sim_num}_{lightcone_ID}: cache cleaned", flush=True)
            del lightcone, inputs, cache
            gc.collect()

        # Track memory after cleanup
        mem_end = get_memory_usage()
        mem_peak = max(mem_peak, mem_end)
        
        end_time = time.time()
        elapsed_time = end_time - start_time
        
        # Report performance metrics
        print(f"lightcone_{sim_num}_{lightcone_ID} completed in {elapsed_time/60:.2f} minutes", flush=True)
        print(f"lightcone_{sim_num}_{lightcone_ID}: Memory - Start: {mem_start:.2f} GB, Peak: {mem_peak:.2f} GB, End: {mem_end:.2f} GB", flush=True)
        print(f"lightcone_{sim_num}_{lightcone_ID}: Peak memory usage: {mem_peak:.2f} GB", flush=True)
    
    except Exception as e:
        print(f"lightcone_{sim_num}_{lightcone_ID} failed: {e}", flush = True)
        # Clean up cache even on failure
        if cache_dir.exists():
            try:
                shutil.rmtree(cache_dir)
            except Exception as cleanup_error:
                print(f"lightcone_{sim_num}_{lightcone_ID}: cache cleanup failed: {cleanup_error}", flush=True)
        continue

And when varying Omega m for the first results this is the set-up:

import os
import sys
sys.path.append("/remote/gpu04/jons")
from tempfile import mkdtemp
import tempfile
import gc

import numpy as np
import matplotlib
from matplotlib import cm
from matplotlib import pyplot as plt
from matplotlib.colors import LogNorm, Normalize
import matplotlib.colors as mcolors

from functools import partial
from scipy.ndimage import gaussian_filter1d

import py21cmfast as p21c
from py21cmfast.wrapper import classy_interface as p21c_classy

from timeit import default_timer as timer

#we use the HMF package (github.com/halomod/hmf) to verify our outputs
from hmf import MassFunction
from py21cmfast import config
config["EXTRA_HALOBOX_FIELDS"] = True
p21c_classy.classy_params_default["matter_source_in_current_gauge"] = "yes"
from pathlib import Path
import re

from datetime import datetime

import importlib

from astropy import units as u

### Inputparameter values
box_len = 200 #300
hii_dim = 128 #200
dim = 3*hii_dim #3xhii_dim
halo_min_mass = 10**8

### Simulation options
config["EXTRA_HALOBOX_FIELDS"] = True
USE_TS_FLUCT = False
zmin = 5.0
zmax = 10.0
zstep_factor = 1.1

### Quantities to calculate
lightcone_quantities = (
    "brightness_temp",
    "halo_mass",
    "count",
    "halo_sfr",
    "halo_stars",
    "density",
    "neutral_fraction",
    "kinetic_temperature"
)

cache_dict = "varying_OMm_test"

param_to_vary = "OMm"
OMEGA_M_GRID = np.array([0.21,0.22,0.23,0.24,0.25,0.26,0.27,0.28,0.29])  #default=Planck18.Om0
run_it(param_to_vary,OMEGA_M_GRID,cache_dict)

# ===============================================================
# 1️⃣ INPUT PARAMETERS
# ===============================================================
def input_params(param_to_vary, param_val, hii_dim,box_len,dim,halo_min_mass,USE_TS_FLUCT,zmin, zmax, zstep_factor,cache):
    if param_to_vary == "OMm":
        inputs = p21c.InputParameters(
            random_seed = 31,
            simulation_options={"HII_DIM": hii_dim, "BOX_LEN": box_len, "DIM" :dim,"SAMPLER_MIN_MASS":halo_min_mass}, 
            matter_options={"POWER_SPECTRUM":"CLASS", "PERTURB_ON_HIGH_RES":True, "USE_RELATIVE_VELOCITIES":True, "SOURCE_MODEL":"CHMF-SAMPLER","KEEP_3D_VELOCITIES":True},
            astro_options = {"USE_TS_FLUCT": USE_TS_FLUCT, "USE_UPPER_STELLAR_TURNOVER":True, "USE_EXP_FILTER":True,"INHOMO_RECO":False}, #spherical-tophat
            cosmo_params= {param_to_vary: param_val, "A_s":2.105e-9},
        )
    else:
        inputs = p21c.InputParameters(
            random_seed = 31,
            simulation_options={"HII_DIM": hii_dim, "BOX_LEN": box_len, "DIM" :dim,"SAMPLER_MIN_MASS":halo_min_mass}, 
            matter_options={"POWER_SPECTRUM":"CLASS", "PERTURB_ON_HIGH_RES":True, "USE_RELATIVE_VELOCITIES":True, "SOURCE_MODEL":"CHMF-SAMPLER","KEEP_3D_VELOCITIES":True},
            astro_options = {"USE_TS_FLUCT": USE_TS_FLUCT, "USE_UPPER_STELLAR_TURNOVER":True, "USE_EXP_FILTER":True,"INHOMO_RECO":False}, #spherical-tophat
            cosmo_params= {"A_s":2.105e-9},
            astro_params= {param_to_vary: param_val},
        )

    inputs = inputs.with_logspaced_redshifts(zmin, zmax, zstep_factor)

    return inputs

# ===============================================================
# 2️⃣ COMPUTES INITIAL CONDITIONS
# ===============================================================
def compute_IC(inputs,cache):
    initial_conditions = p21c.compute_initial_conditions(
        inputs=inputs, cache=cache, write=True
    )
    return initial_conditions

# ===============================================================
# 3️⃣ RUNS LIGHTCONE SIMULATION
# ===============================================================
def run_lightcone(inputs,lightcone_quantities,cache,file_name,zmin,zmax):

    initial_conditions = compute_IC(inputs,cache)

    lcn = p21c.RectilinearLightconer.between_redshifts(
        min_redshift=zmin,
        max_redshift=zmax,
        quantities=lightcone_quantities,
        resolution=inputs.simulation_options.cell_size,
    )

    print("requested:", zmin, zmax)
    print("lightconer lc_redshifts min/max:", np.min(lcn.lc_redshifts), np.max(lcn.lc_redshifts))

    lightcone_fid = p21c.run_lightcone(
        lightconer=lcn,
        inputs=inputs,
        initial_conditions=initial_conditions,
        cache=cache,
        write=True,
        regenerate=True,
        progressbar=True
    )

    lightcone_fid.save(cache.direc / f"fiducial-lightcone_{file_name}.h5")

    print("final lightcone redshifts min/max:",
    np.min(lightcone_fid.lightcone_redshifts),
    np.max(lightcone_fid.lightcone_redshifts))
    
    return lightcone_fid

I am running on version: 4.1.2.dev8+g2daebb054

[steven-murray]

Thank you @Klarajons1228. Could I get you to trim those scripts down to an MWE (minimum working example)? It helps immensely if we have something as small as possible that we can run to reproduce the bug.

[Klarajons1228]

Hi, yes of course! Here is a stripped-down version of the set-up that gives rise to the problem with fields becoming 0 below some threshold redshift. I would most like to know what changes the redshift range from the one I give with zmin and zmax since I need to change my prior ranges for the sampling if there are some values that are responsible for shifting the redshift range...

import numpy as np
import py21cmfast as p21c
from py21cmfast import config

# --------------------------------------------------
# BASIC SETTINGS (small + fast!)
# --------------------------------------------------
config["EXTRA_HALOBOX_FIELDS"] = True

hii_dim = 64           # smaller = faster debugging
box_len = 100          # smaller box
dim = 3 * hii_dim
zmin = 5.0
zmax = 10.0
zstep_factor = 1.2


def sample_priors(rng, fiducial=False):
    """ 
    Definition of priors.

    """

seed = 42 + 102

params = {
    "M_TURN": 9.585523679998476,
    "F_ESC10": -2.8209379003515362,
    "F_STAR10": -2.1009746734330954,
    "ALPHA_ESC": -0.6802421636474193,
    "ALPHA_STAR": 0.05482920328295837,
    "OMm": 0.21446160450707033,
}

# --------------------------------------------------
# INPUT PARAMETERS (single case!)
# --------------------------------------------------
    inputs = p21c.InputParameters(
        node_redshifts = p21c.wrapper.inputs.get_logspaced_redshifts(
            min_redshift=zmin,
            z_step_factor=zstep_factor,
            max_redshift=zmax,
        ),
        random_seed=seed,
        simulation_options={"HII_DIM": hii_dim, "BOX_LEN": box_len, "DIM" :dim,"SAMPLER_MIN_MASS":halo_min_mass}, 
        matter_options={"POWER_SPECTRUM":"CLASS", "PERTURB_ON_HIGH_RES":True, "USE_RELATIVE_VELOCITIES":True, "SOURCE_MODEL":"CHMF-SAMPLER","KEEP_3D_VELOCITIES":True},
        astro_options = {"USE_TS_FLUCT": USE_TS_FLUCT, "USE_UPPER_STELLAR_TURNOVER":True, "USE_EXP_FILTER":True,"INHOMO_RECO":False}, #spherical-tophat},
    cosmo_params={
        "OMm": params["OMm"],
        "A_s": 2.105e-9,
    },
    astro_params={
        "M_TURN": params["M_TURN"],
        "F_ESC10": params["F_ESC10"],
        "F_STAR10": params["F_STAR10"],
        "ALPHA_ESC": params["ALPHA_ESC"],
        "ALPHA_STAR": params["ALPHA_STAR"],
    },
)


# enforce redshift grid
inputs = inputs.with_logspaced_redshifts(zmin, zmax, zstep_factor)

# --------------------------------------------------
# INITIAL CONDITIONS
# --------------------------------------------------
init = p21c.compute_initial_conditions(inputs=inputs)

# --------------------------------------------------
# LIGHTCONER
# --------------------------------------------------
lcn = p21c.RectilinearLightconer.between_redshifts(
    min_redshift=zmin,
    max_redshift=zmax,
    resolution=inputs.simulation_options.cell_size,
    quantities=("brightness_temp",),  # keep minimal!
)

# --------------------------------------------------
# RUN LIGHTCONE
# --------------------------------------------------
lc = p21c.run_lightcone(
    lightconer=lcn,
    inputs=inputs,
    initial_conditions=init,
    progressbar=True,
)

[jordanflitter]

Hi @Klarajons1228, thanks for the MWE. From what I'm seeing there are no printouts in that script. Could you please provide a short script with printouts that clearly demonstrates the problem, and let us know what you expected to see?

[Klarajons1228]

Hi, well the printouts looks like the one I sent above... I would just like to know why/how the redshift axis is being shifted from the input (zmin,zmax), if it is the value of omega_m and why the lightcone object cannot still be constrained to the input z-edges? Also, if some hardcoded limits on the EoR history makes the code not fill up the fields at all z etc. so I can choose my prior for my parameters in such a way that I get out lightcone objects in the redshift range I specify as input, and get fields that have been developed all the way down to zmin and not set to 0 before then...

[jordanflitter]

Okay, I think I understand now better the issue. Do you say that if you set zmin=5, zmax=10 for the lightconer, but OMm which is very different than the default Planck18 value (e.g. OMm=0.214, like in your script), the resulting lightcone/lightconer object extends outside of your zmin=5, zmax=10 range? Did I understand your issue correctly?

[Klarajons1228]

Yes exactly! Like these were all generated with zmin = 5.0, zmax = 10.0, but returns different z-ranges:
z min: 3.6519546435033474 z max: 6.115043211898531 Omega m = 0.21
z min: 4.413734994173905 z max: 8.190620077801478 Omega m = 0.27
z min: 4.276968023137314 z max: 7.795646887915723 Omega m = 0.26
z min: 4.015662168524921 z max: 7.0687066375098295 Omega m = 0.24
z min: 3.8908066698121253 z max: 6.733851929344507 Omega m = 0.23
z min: 3.5376842962431434 z max: 5.828864570704496 Omega m = 0.2
z min: 3.7696175535864285 z max: 6.416350594784393 Omega m = 0.22
z min: 4.144331163376727 z max: 7.422178440708719 Omega m = 0.25

So since I want lightcones between z 5-10 to do powerspectrum etc. I need all of them to cover z 6,7,8,9 but now they don't... and I have looked into the source code trying to understand why/when it gets shifted so much but I am not quite sure why it happens in the end.

[jordanflitter]

I think I may understand what's causing it. Note that between_redshifts accepts a cosmo argument which is absent in your script, and therefore takes the default cosmo=Planck18. The way that lightcone.lightcone_redshifts works is by converting the lightcone.lightcone_distances to redshifts via lightcone.cosmo_params.cosmo (which includes your updated OMm). However, lightcone.lightcone_distances is equal to lightconer.lc_distances, and the latter is determined from lightconer.cosmo, which is the default Planck18 in your script.

Could you try again running your script, but setting the lightconer in the following way?

lcn = p21c.RectilinearLightconer.between_redshifts(
    min_redshift=zmin,
    max_redshift=zmax,
    resolution=inputs.simulation_options.cell_size,
    quantities=("brightness_temp",),  # keep minimal!
    cosmo=inputs.cosmo_params.cosmo
)

[Klarajons1228]

Thanks! Looks like it's working now 🚀

Is there somewhere else I need to pass in cosmo to keep everything consistent, or is the rest using the Cosmo in the inputs? 🤔

[jordanflitter]

Great! Good to hear!

To answer your last question, run_ligthcone essentially needs only inputs (which contains your cosmological parameters) and lightconer (to understand how to construct the lightcone from the coeval boxes). So these are the only two places that you need to make sure that your cosmological model is consistent.

@steven-murray I think we should raise an error in Lightconer.validate_options that checks that self.cosmo == input.cosmo_params.cosmo. This could prevent similar issues in the future.

@Klarajons1228 Does this also solve your second issue? It somewhat makes sense to me that the lightcone wasn't constructed properly if there was a tension between lightconer.cosmo and inputs.cosmo_params.cosmo.

[Klarajons1228]

Okay nice then I think my set-up should work now, finally, thanks for all the help on my other issues as well! 🙏🏽

Yes it did solve the other issue as well 👍🏼

[steven-murray]

@jordanflitter yes, let's make that an issue and fix it