Table of contents

1. Running Cosmolike projects (Basic instructions)
2. Baryonic feedback on EXAMPLE_EVALUATE1
3. Running Hybrid Cosmolike-ML emulators
4. Unit tests
5. Minimum accuracy parameters
6. Computing covariances
7. Exploring notebooks
8. Appendix: Which accuracy settings are available?

Running Cosmolike projects (Basic instructions)

Warning

CLI for production; notebook wrappers for exploration.

Run production and HPC calculations from YAML through the optimized _interface bindings. Notebook _wrapper APIs expose intermediate quantities for exploration; copying and rearranging their arrays adds overhead. Both routes call the same C kernels.

In a matched LSST Y1 covariance test on an M2 Pro with eight threads, the CLI averaged 50.23 s (three runs); one wrapper run took 173.38 s. The CLI was 3.45× faster, with bitwise-identical covariance components. See the production covariance CLI.

From Cocoa/Readme instructions:

Note

setup_cocoa.sh and compile_cocoa.sh install the cosmolike projects that set_installation_options.sh selects: a commented IGNORE_*_CODE key enables a project, and an active key skips it. The shipped file skips roman_fourier; comment out its export IGNORE_COSMOLIKE_ROMAN_FOURIER_CODE=1 line to enable it:

[Adapted from Cocoa/set_installation_options.sh shell script]
#export IGNORE_COSMOLIKE_LSST_Y1_CODE=1
export IGNORE_COSMOLIKE_DES_Y3_CODE=1
#export IGNORE_COSMOLIKE_DESXPLANCK_CODE=1
export IGNORE_COSMOLIKE_ROMAN_FOURIER_CODE=1
#export IGNORE_COSMOLIKE_ROMAN_REAL_CODE=1
export IGNORE_COSMOLIKE_ROMAN_KL_CODE=1
(...)
export ROMAN_FOURIER_URL="https://github.com/CosmoLike/cocoa_roman_fourier.git"
export ROMAN_FOURIER_NAME="roman_fourier"
export ROMAN_FOURIER_GIT_TAG="v5.05"

Each released project is pinned to a tag. To select another revision, set only one of its GIT_COMMIT, GIT_BRANCH or GIT_TAG keys: a commit takes precedence over a branch, and a branch over a tag.

Note

If users want to recompile cosmolike, there is no need to rerun the Cocoa general scripts. Instead, run the following three commands:

 source start_cocoa.sh

and

 source ./installation_scripts/setup_cosmolike_projects.sh

and

  source ./installation_scripts/compile_all_projects.sh

or (in case users just want to compile roman_fourier project)

  source ./projects/roman_fourier/scripts/compile_roman_fourier.sh

Tip

Assuming Cocoa is installed on a local (not remote!) machine, type the command below after step 2️⃣ to run Jupyter Notebooks.

jupyter notebook --no-browser --port=8888

The project roman_fourier contains jupyter notebook examples located at projects/roman_fourier (covariance) and projects/roman_fourier/notebooks (data vector).

To run the example

Step 1️⃣: activate the cocoa Conda environment, and the private Python environment

  conda activate cocoa

and

  source start_cocoa.sh

Step 2️⃣: Select the number of OpenMP cores (below, we set it to 8).

• Linux

  export OMP_NUM_THREADS=8; export OMP_PROC_BIND=close; \
  export OMP_PLACES=cores; export OMP_DYNAMIC=FALSE; \
  export OPENBLAS_NUM_THREADS=1; export MKL_NUM_THREADS=1
  

• macOS (arm)

  export OMP_NUM_THREADS=8; export OMP_PROC_BIND=disabled; \
  export OMP_PLACES=cores; export OMP_DYNAMIC=FALSE; \
  export OPENBLAS_NUM_THREADS=1; export MKL_NUM_THREADS=1
  

Step 3️⃣: The folder projects/roman_fourier contains examples. So, run the cobaya-run on the first example following the commands below.

Warning

(Linux only) In some HPC nodes, numa can cause you problems. If that is the case, replace numa with slot

• One model evaluation:

  • Linux

    "${CONDA_PREFIX}"/bin/mpirun -n 1 --oversubscribe \
      --mca pml ob1 --mca btl vader,tcp,self \
      --bind-to core:overload-allowed --report-bindings \
      --rank-by slot --map-by numa:pe=${OMP_NUM_THREADS} \
      cobaya-run ./projects/roman_fourier/EXAMPLE_EVALUATE1.yaml -f
    

  • macOS (arm)

    mpirun -n 1 --oversubscribe \
      cobaya-run ./projects/roman_fourier/EXAMPLE_EVALUATE1.yaml -f
    

• MCMC (Metropolis-Hastings Algorithm):

  • Linux

    "${CONDA_PREFIX}"/bin/mpirun -n 4 --oversubscribe \
      --mca pml ob1 --mca btl vader,tcp,self \
      --bind-to core:overload-allowed --report-bindings \
      --rank-by slot --map-by numa:pe=${OMP_NUM_THREADS} \
      cobaya-run ./projects/roman_fourier/EXAMPLE_MCMC2.yaml -f
    

  • macOS (arm)

    mpirun -n 4 --oversubscribe \
      cobaya-run ./projects/roman_fourier/EXAMPLE_MCMC2.yaml -f
    

Warning

CosmoLike supports the optimized strict-IEEE default build and COSMOLIKE_DEBUG_MODE. The compiler mode COSMOLIKE_AGGRESSIVE_MODE is retired because its fast-math configuration produced incorrect covariance inverses. Unset that variable before compiling. Do not enable -ffast-math, -Ofast, -funsafe-math-optimizations, -fassociative-math, -ffinite-math-only, -freciprocal-math, -fno-signed-zeros, or -fno-trapping-math in CosmoLike builds. This does not change Cocoa's separate --aggressive download option.

Baryonic feedback on EXAMPLE_EVALUATE1

EXAMPLE_EVALUATE1.yaml can apply an external baryonic feedback suppression to the matter power spectrum via the bfmt theory block (SP(k), BCEmu, Flamingo, BACCOemu, or BCemu2025). By default, the example runs without feedback.

Step 1️⃣: ensure the lines below are commented out in set_installation_options.sh before running setup_cocoa.sh and compile_cocoa.sh. By default, these lines should be commented out, but it is worth checking.

  [Adapted from Cocoa/set_installation_options.sh shell script]
  #export IGNORE_PYSPK_CODE=1     # SP(k)
  #export IGNORE_BCEMU_CODE=1     # BCEmu
  #export IGNORE_FBRE_CODE=1      # FlamingoBaryonResponseEmulator
  #export IGNORE_BACCOEMU_CODE=1  # BACCOemu
  #export IGNORE_BFMT_CODE=1      # Baryon Feedback Theory Block

Step 2️⃣: in EXAMPLE_EVALUATE1.yaml, uncomment the bfmt theory block and select the model:

  theory:
    bfmt:
      baryon_model: 2 # 1 = SP(k), 2 = BCEmu, 3 = FlamingoEmulator, 4 = BACCOemu, 5 = BCemu2025

Step 3️⃣: set external_baryon_suppression: True on the roman_fourier.cosmic_shear likelihood block.

Step 4️⃣: uncomment the selected model's parameters in the params block and in the sampler: evaluate: override block (the example carries a commented block for each model).

Tip

For the sampled parameters of each model, their validity ranges, and the bfmt options, see Cocoa/external_modules/code/baryon_suppression/README.md.

Note

The section Baryonic feedback from the bfmt theory block of notebooks/RomanFourierDataVector.ipynb runs six of these methods (the three SP(k) relations, BCEmu, Flamingo and BCemu2025) through the bfmt block on the 3x2pt band powers. It needs the packages of the first step above; see Exploring notebooks.

Running Hybrid Cosmolike-ML emulators

Note

These hybrid examples remain experimental. The checks below verify the workflow; assess emulator accuracy and posterior convergence for your analysis.

The EXAMPLE_EMUL2 examples emulate the background expansion and matter power spectra. CosmoLike still computes the survey projections, bias and intrinsic-alignment contributions. Changing n(z) or nuisance parameters does not require retraining a survey data-vector network.

The shared theory networks live in external_modules/data/emultrf. Install them through the main Cocoa emulator recipe. These networks assume mnu = 0.06 eV; do not sample neutrino mass. Their cold-matter power approximation is not a calibrated massive-neutrino halo model. Check their training range before widening cosmological priors.

We assume Cocoa and this project are installed, the Cocoa Conda environment is active, the shell is Bash, and the current folder is cocoa/Cocoa/.

Step 1️⃣: activate Cocoa.

source start_cocoa.sh

Step 2️⃣: select the OpenMP threads per process.

export OMP_NUM_THREADS=4

Step 3️⃣: remove GPU access on Linux; these examples use the CPU.

export CUDA_VISIBLE_DEVICES=""

Step 4️⃣: evaluate the first hybrid example.

• Linux

  "${CONDA_PREFIX}"/bin/mpirun -n 1 --oversubscribe \
    --mca pml ob1 --mca btl vader,tcp,self \
    --bind-to core:overload-allowed --report-bindings \
    --rank-by slot --map-by numa:pe=${OMP_NUM_THREADS} \
    cobaya-run ./projects/roman_fourier/EXAMPLE_EMUL2_EVALUATE1.yaml --force
  

• macOS (arm)

  mpirun -n 1 --oversubscribe \
    cobaya-run ./projects/roman_fourier/EXAMPLE_EMUL2_EVALUATE1.yaml --force
  

The YAML selects the CPU for the distance emulator. Keep BLAS at one thread per MPI rank (OPENBLAS_NUM_THREADS=1, MKL_NUM_THREADS=1); on macOS also use VECLIB_MAXIMUM_THREADS=1. The Python sampler entry points set these BLAS limits before importing numerical libraries.

Example	Configuration 1	Configuration 2
Fixed evaluation	EXAMPLE_EMUL2_EVALUATE1.yaml	EXAMPLE_EMUL2_EVALUATE2.yaml
Cobaya MCMC	EXAMPLE_EMUL2_MCMC1.yaml	EXAMPLE_EMUL2_MCMC2.yaml
Annealed minimization	EXAMPLE_EMUL2_MINIMIZE1.py	EXAMPLE_EMUL2_MINIMIZE2.py
Parameter profile	EXAMPLE_EMUL2_PROFILE1.py	EXAMPLE_EMUL2_PROFILE2.py
Nautilus sampling	EXAMPLE_EMUL2_NAUTILUS1.py	EXAMPLE_EMUL2_NAUTILUS2.py

Configuration 1 uses roman_fourier.cosmic_shear, NLA, and roman_example.dataset. Configuration 2 uses roman_fourier.combo_3x2pt, NLA, and roman_example.dataset.

The minimization, profile and Nautilus scripts read the corresponding EXAMPLE_EMUL2_EVALUATE1.yaml or 2.yaml; --input selects another evaluate YAML. They require cocoa_hybrid_sampling.py from the matching shared core revision. They do not maintain separate embedded cosmologies. --check evaluates the specified fiducial and prints the sampled parameter order without sampling. Use a new --outroot for each run; these scripts refuse to overwrite results.

Cobaya MCMC

With the same CPU environment, run the first MCMC example. Use configuration 2 for the second likelihood listed above. Check chain convergence before interpreting posterior constraints.

Step 1️⃣: start Cobaya's hybrid MCMC.

• Linux

  "${CONDA_PREFIX}"/bin/mpirun -n 2 --oversubscribe \
    --mca pml ob1 --mca btl vader,tcp,self \
    --bind-to core:overload-allowed --report-bindings \
    --rank-by slot --map-by numa:pe=${OMP_NUM_THREADS} \
    cobaya-run ./projects/roman_fourier/EXAMPLE_EMUL2_MCMC1.yaml
  

• macOS (arm)

  mpirun -n 2 --oversubscribe \
    cobaya-run ./projects/roman_fourier/EXAMPLE_EMUL2_MCMC1.yaml
  

Minimization, profiles and Nautilus

We assume Cocoa and this project are installed, the Cocoa Conda environment is active, the shell is Bash, and the current folder is cocoa/Cocoa/.

Step 1️⃣: check the hybrid setup before a long run.

python ./projects/roman_fourier/EXAMPLE_EMUL2_MINIMIZE1.py --check

Step 2️⃣: search for a minimum with two MPI ranks.

• Linux

  "${CONDA_PREFIX}"/bin/mpirun -n 2 --oversubscribe \
    --mca pml ob1 --mca btl vader,tcp,self \
    --bind-to core:overload-allowed --report-bindings \
    --rank-by slot --map-by numa:pe=${OMP_NUM_THREADS} \
    python ./projects/roman_fourier/EXAMPLE_EMUL2_MINIMIZE1.py --nstw 200 --outroot hybrid_min1
  

• macOS (arm)

  mpirun -n 2 --oversubscribe \
    python ./projects/roman_fourier/EXAMPLE_EMUL2_MINIMIZE1.py --nstw 200 --outroot hybrid_min1
  

Step 3️⃣: profile the first sampled parameter using that saved minimum.

• Linux

  "${CONDA_PREFIX}"/bin/mpirun -n 2 --oversubscribe \
    --mca pml ob1 --mca btl vader,tcp,self \
    --bind-to core:overload-allowed --report-bindings \
    --rank-by slot --map-by numa:pe=${OMP_NUM_THREADS} \
    python ./projects/roman_fourier/EXAMPLE_EMUL2_PROFILE1.py --profile 0 --nstw 200 --numpts 11 --factor 1 --minfile ./projects/roman_fourier/chains/hybrid_min1.json --outroot hybrid_profile1
  

• macOS (arm)

  mpirun -n 2 --oversubscribe \
    python ./projects/roman_fourier/EXAMPLE_EMUL2_PROFILE1.py --profile 0 --nstw 200 --numpts 11 --factor 1 --minfile ./projects/roman_fourier/chains/hybrid_min1.json --outroot hybrid_profile1
  

Step 4️⃣: run Nautilus as an independent sampling example.

• Linux

  "${CONDA_PREFIX}"/bin/mpirun -n 2 --oversubscribe \
    --mca pml ob1 --mca btl vader,tcp,self \
    -x PATH -x LD_LIBRARY_PATH -x PYTHONPATH -x CONDA_PREFIX -x ROOTDIR \
    -x OMP_NUM_THREADS -x OMP_PROC_BIND -x OMP_PLACES -x OMP_DYNAMIC \
    -x OPENBLAS_NUM_THREADS -x MKL_NUM_THREADS -x CLIK_PATH -x CLIK_DATA \
    -x CLIK_PLUGIN --mca mpi_yield_when_idle 1 \
    --mca btl_tcp_if_exclude lo,docker0,virbr0,ib0 \
    --bind-to core:overload-allowed --report-bindings \
    --rank-by slot --map-by numa:pe=${OMP_NUM_THREADS} \
    python ./projects/roman_fourier/EXAMPLE_EMUL2_NAUTILUS1.py --nlive 1000 --neff 10000 --maxfeval 100000 --outroot hybrid_nautilus1
  

• macOS (arm)

  mpirun -n 2 --oversubscribe \
    python ./projects/roman_fourier/EXAMPLE_EMUL2_NAUTILUS1.py --nlive 1000 --neff 10000 --maxfeval 100000 --outroot hybrid_nautilus1
  

The annealed Emcee search follows the DES × Planck template. Its objective is −2 log posterior, including nuisance and cosmological priors; the profile is therefore a penalized profile, not a pure likelihood profile. --nstw sets steps per walker per temperature. More steps and independent starts are needed to assess whether a minimum is reliable.

--profile accepts a sampled-parameter name or its printed zero-based index. --factor gives the half-width in proposal standard deviations, clipped to the prior bounds. --cov accepts a covariance whose header lists the sampled parameters in order; without it, the prior covariance sets the proposal. The minimum JSON must come from the same evaluate YAML and parameter order. Older plain-text minimum files are not accepted. Set any additional priors in the input YAML; these scripts do not insert hidden cosmological priors.

Nautilus writes weighted GetDist-compatible rows and a JSON convergence record. Reaching --maxfeval is not convergence. If the budget ends before any posterior samples are retained, only the checkpoint and a JSON record with converged: false are saved. Its prior transform uses Cobaya's one-dimensional prior distributions; external prior factors enter once as additional log weight. Evidence with unnormalized external priors has that normalization limitation. These examples do not certify emulator accuracy or posterior convergence.

MPI across nodes

The two-rank commands above disable MPI binding for a portable local run. For a cluster allocation, use the explicit binding and placement below.

Note

Running on more than one node. With the Open MPI 4 launcher used here, --mca pml ob1 --mca btl vader,tcp,self selects shared memory within a node and TCP between nodes. The same transport list works across nodes.

1. Network interface. TCP must use an interface routable between compute nodes. A common exclusion list is --mca btl_tcp_if_exclude lo,docker0,virbr0,ib0; adapt it to the cluster. Keep ib0 if routable IP-over-InfiniBand is the intended network. These examples exchange parameter vectors and scalar scores, so communication volume is small; actual scaling still depends on the machine.
2. Environment. Remote ranks need the same Cocoa paths and libraries: ROOTDIR, PATH, LD_LIBRARY_PATH, PYTHONPATH, CONDA_PREFIX, OpenMP and BLAS settings, and CLIK_PATH/CLIK_DATA/CLIK_PLUGIN when used. Slurm normally exports the submitting environment (--export=ALL). Explicit -x options also forward these variables with SSH launchers. Activate Cocoa before launching; build/download flags do not replace runtime paths. All nodes must see the same files at the same paths.
3. Slurm geometry. Keep ntasks-per-node × cpus-per-task within the allocated physical cores per node. Set OMP_NUM_THREADS to SLURM_CPUS_PER_TASK and use --map-by numa:pe=${OMP_NUM_THREADS}. The minimization, profile and Nautilus pool reserves one MPI rank as coordinator; the remaining ranks evaluate the model.

Open MPI 5 calls the shared-memory transport sm; use sm,tcp,self there. See the Open MPI transport guide, TCP interface guidance, and Slurm environment options.

Within a Slurm allocation, first activate Cocoa in Bash on the launch node. The following steps assume Open MPI 4 and shared installation/data paths. Omit optional CLIK exports if those variables are not set.

Step 1️⃣: match OpenMP threads to the scheduler allocation.

export OMP_NUM_THREADS="${SLURM_CPUS_PER_TASK}"

Step 2️⃣: bind each OpenMP team to its allocated cores.

export OMP_PROC_BIND=close

Step 3️⃣: select core placement.

export OMP_PLACES=cores

Step 4️⃣: disable dynamic team resizing.

export OMP_DYNAMIC=FALSE

Step 5️⃣: keep OpenBLAS serial.

export OPENBLAS_NUM_THREADS=1

Step 6️⃣: keep MKL serial.

export MKL_NUM_THREADS=1

Step 7️⃣: launch the hybrid minimizer across the allocated ranks.

"${CONDA_PREFIX}"/bin/mpirun -n "${SLURM_NTASKS}" \
  --mca pml ob1 --mca btl vader,tcp,self \
  --mca btl_tcp_if_exclude lo,docker0,virbr0 \
  --map-by numa:pe=${OMP_NUM_THREADS} --bind-to core --report-bindings \
  -x ROOTDIR -x PATH -x LD_LIBRARY_PATH -x PYTHONPATH -x CONDA_PREFIX \
  -x OMP_NUM_THREADS -x OMP_PROC_BIND -x OMP_PLACES -x OMP_DYNAMIC \
  -x OPENBLAS_NUM_THREADS -x MKL_NUM_THREADS -x CUDA_VISIBLE_DEVICES \
  python ./projects/roman_fourier/EXAMPLE_EMUL2_MINIMIZE1.py --nstw 200 --outroot hybrid_multinode

For a Planck likelihood add -x CLIK_PATH -x CLIK_DATA -x CLIK_PLUGIN when those variables are defined. Follow the cluster's MPI module and Slurm launch policy; do not oversubscribe a production allocation. Outside Slurm, supply the hosts and slots with the cluster's --hostfile or --host recipe.

Unit tests

The tests/ folder holds unit tests for the likelihoods of this project: they compare each likelihood against stored reference values, check for race conditions from OpenMP threading, and measure the numerical error of the default accuracy settings. The tests read nothing from the live project; tests/README.md describes every test, the tests' own data snapshot, and how to refresh it.

We assume users are in the Conda cocoa environment from a previous conda activate cocoa command, that the shell is bash, and that the current folder is the cocoa main folder cocoa/Cocoa.

Step 1️⃣: activate the private Python environment by sourcing the script start_cocoa.sh

source start_cocoa.sh

Step 2️⃣: run the tests of this project

python -m pytest ./projects/roman_fourier/tests/data_vector

Minimum accuracy parameters

The advisory checks in tests/data_vector/test_accuracy.py measure the numerical error of the default accuracy settings: each setting is raised one at a time on the 3x2pt configuration, so a large $\Delta\chi^2$ can be attributed to the setting causing it, and then every setting at once.

Each check prints the $\Delta\chi^2$ between the high-accuracy and the default evaluations, to compare against the 0.2 band the reference tests allow. No measured values are quoted here: rerun the checks to measure them on the current code, and see tests/README.md for each check, the settings raised, and what each setting controls.

The default is accuracyboost: 2.0 with pk_z_refinement: 2, and the reason must not be lost. Two grids of this project need more than accuracyboost: 1 (measured 2026-10-01):

• The z nodes of the power-spectrum tables. cosmolike interpolates the tables linearly in z between their nodes, and at the band centers of this Fourier-space data vector that residual does not average out: the 3x2pt $\chi^2$ at the synthetic test point moves by 0.25, 0.030 and 0.002 from 1 to 2, 4 and 8 times the nodes of accuracyboost: 1. The default has 4 times the nodes: accuracyboost: 2 doubles them and pk_z_refinement: 2 doubles them again.
• The C-FAST-PT tables of the TATT and one-loop galaxy-bias terms. At accuracyboost: 1 the cfastpt vs FAST-PT comparison of the tests (tests 15 and 16) reaches $\Delta\chi^2$ = 0.25 (cosmic shear) and 0.31 (3x2pt), above the 0.2 band; at accuracyboost: 2 it is 0.11 and 0.14.

accuracyboost stays global: it multiplies every grid, these included, and pk_z_refinement refines the z nodes alone. Under NLA alone, accuracyboost: 1 with pk_z_refinement: 4 has the same z nodes and gives a data vector within $\delta^T C^{-1} \delta = 0.005$ of the default at a lower cost; the TATT tables are what need the boost. The CAMB request grid stays at 140 redshifts (under CAMB's 256-node cap), so only the cosmolike tables pay.

The project tag v5.01 shipped accuracyboost: 1 with pk_z_refinement: 4, which fails the TATT checks above; the default returned to accuracyboost: 2 on 2026-10-01.

Warning

Do not lower these settings to save computing time: with fewer than 4 times the z nodes of accuracyboost: 1, or with accuracyboost below 2 under TATT, the error exceeds the 0.2 accuracy budget of the reference tests. The likelihood yaml files repeat this next to the knobs.

Exploring notebooks

Armadillo was chosen to make a convenient Python API for notebook exploration. This C++ library provides vectors, matrices and three-dimensional arrays called cubes. A small interface layer connects them to NumPy through pybind11, with CARMA handling array conversion. The notebooks expose intermediate quantities; production calculations use the CLI interfaces.

We assume Cocoa and this project are installed, the Cocoa Conda environment is active, the shell is Bash, and the current folder is cocoa/Cocoa/.

Compile the project first; the covariance notebook also needs the optional covariance build described below.

Step 1️⃣: activate Cocoa.

source start_cocoa.sh

Step 2️⃣: select the OpenMP team.

export OMP_NUM_THREADS=8

Step 3️⃣: start Jupyter.

jupyter notebook --no-browser --port=8888

Step 4️⃣: open the printed URL and choose a notebook below.

Step 5️⃣: select Kernel → Restart Kernel and Run All Cells.

Notebook	Contents
notebooks/RomanFourierDataVector.ipynb	3x2pt band powers. A first part compares two $w_0w_a$CDM model vectors with ΛCDM against the diagonal errors of data/roman_example.cov. A second part computes the band powers at the fiducial point of EXAMPLE_EVALUATE2.yaml through the compiled interface, then applies six bfmt feedback methods and tabulates $\chi^2$, $\Delta\chi^2$ and the $\chi^2$ of each shift over the 1,359 entries the mask keeps.
EXAMPLE_EVALUATE_COVARIANCE.ipynb	G, SSC, cNG, total, separate 1h–4h matter trispectra and matrix diagnostics.

Note

The first part of RomanFourierDataVector.ipynb reads three model vectors that this project does not ship, through absolute paths of another machine. To run the computed part alone, restart the kernel, select the first cell of the section Compute the model band powers with the compiled interface and choose Run → Run Selected Cell and All Below. Its bfmt section needs the packages of the baryonic feedback section.

The computed part of the data-vector notebook mirrors the settings of EXAMPLE_EVALUATE2.yaml; the covariance notebook calls the survey adapter covariance/roman_fourier_covariance.py. Read the notebooks in this order:

flowchart TD
  A["RomanFourierDataVector: computed band powers"] --> B["bfmt feedback: chi2 table and figures"]
  A --> C["EXAMPLE_EVALUATE_COVARIANCE: G, SSC, cNG"]
  Y["EXAMPLE_EVALUATE2.yaml"] --> A
  S["roman_fourier_covariance.py"] --> C

Loading

Choose the Python kernel from the activated Cocoa environment and restart it after recompiling. The covariance guide explains the forecast files, figures and refinement workflow.

Computing covariances

The production CLI saves G, SSC, cNG and total before scale cuts. It reads the covariance evaluate YAML and calls the shared C kernels.

We assume Cocoa and this project are installed, the Cocoa Conda environment is active, the shell is Bash, and the current folder is cocoa/Cocoa/.

Step 1️⃣: enable this project in set_installation_options.sh by commenting out export IGNORE_COSMOLIKE_ROMAN_FOURIER_CODE=1 before activation.

Step 2️⃣: activate Cocoa.

source start_cocoa.sh

Step 3️⃣: enable covariance generation.

unset IGNORE_COSMOLIKE_ROMAN_FOURIER_COVARIANCE

Step 4️⃣: compile the project.

source ./projects/roman_fourier/scripts/compile_roman_fourier.sh

Step 5️⃣: set the OpenMP team size.

export OMP_NUM_THREADS=8

Step 6️⃣: compute the fixed YAML cosmology.

python ./projects/roman_fourier/covariance/compute_covariance.py ./projects/roman_fourier/EXAMPLE_EVALUATE_COVARIANCE.yaml

Use --output PATH for a separate output or --overwrite to replace an existing computed archive. Paths are relative to cocoa/Cocoa/. Threads come only from OMP_NUM_THREADS, never from the YAML; the runner fixes BLAS to one thread. Ordinary likelihoods read their supplied covariance and do not generate a new one.

Cobaya's YAML reader supplies the familiar theory, params and sampler: evaluate syntax. This runner evaluates one fixed cosmology and does not run MCMC. See the covariance guide for output ordering, physics, Gaussian non-Limber/IA limits, plots and test commands, and the accuracy FAQ for the separate numerical controls.

Appendix

FAQ: Which accuracy settings are available?

Data-vector options belong to the selected likelihood block. Covariance options belong to the evaluate YAML's covariance block. They use separate names and settings; changing one does not refine the other.

Data-vector setting	What it changes
accuracyboost	Overall interpolation-table resolution.
integration_accuracy	Quadrature resolution; refine independently of interpolation.
internal_accuracyboost	C-FAST-PT convolution grid.
nonlimber_accuracyboost	Non-Limber distance sampling.
pk_z_refinement	Nested redshift refinement of matter-power inputs.
lmax	Real-space angular-transform cutoff, where a real-space transform is used.
kmax_boltzmann	Requested Boltzmann power range; coordinate it with the theory settings.

adopt_limber_gg and adopt_limber_gs choose a projection approximation. photoz_interpolation_type chooses how n(z) is interpolated, while photoz_zmid_convention describes the input coordinates. These are modeling or input-convention choices, not interchangeable accuracy boosts.

The default data-vector power grid has 1,500 wavenumbers at boost 1. Covariance alone uses power_accuracyboost: 8 to prepare 11,993 nodes by natural cubic interpolation before C linear lookup. Its accuracy_boost refines tables and cutoffs; its integration_accuracy independently selects quadrature levels 0–4. See the complete covariance accuracy table.

CAMB's theory.camb.extra_args.AccuracyBoost controls CAMB, not CosmoLike. Check interpolation, quadrature, input-power sampling and transform cutoffs separately at fixed cosmology and measurement bins. Narrow n(z) overlaps particularly require a quadrature check; increasing accuracyboost alone is not that check. The data-vector test guide and covariance test guide state what each set of tests actually verifies. A passing regression or a larger boost is not a general claim of survey or Fisher convergence.