Quick Reference

This page provides quick reference information for common tasks.

Command Line Reference

Building Documentation

# Build HTML documentation
cd docs
make html

# Build PDF documentation
make latexpdf

# Clean build files
make clean

# Rebuild everything
make clean html

Using the Emulator

# Activate environment
conda activate gal_goku

# Run Python scripts
python my_script.py

# Run with MPI
mpirun -np 16 python mpi_script.py

API Quick Reference

Initialize Emulators

from gal_goku import emus

# HMF emulator
hmf_emu = emus.Hmf(
    data_dir='path/to/data',
    y_log=True,
    fid='L2'
)

# Make predictions
predictions, variances = hmf_emu.predict(X_test)

Compute Linear Power

from gal_goku import gal

# Initialize
gal_model = gal.GalBase()

# Compute P(k)
cosmo_params = [0.3, 0.05, 0.7, 2.1e-9, 0.96,
                -1.0, 0.0, 3.046, 0.0, 0.06]
k, P_lin = gal_model.get_init_linear_power(
    cosmo_params,
    redshifts=[2.0]
)

Parameter Reference

Cosmological Parameters

Order: [Omega_m, Omega_b, h, A_s, n_s, w0, wa, N_ur, alpha_s, m_nu]

Index	Parameter	Typical Range
0	Omega_m	0.24 - 0.40
1	Omega_b	0.04 - 0.06
2	h	0.60 - 0.80
3	A_s	1.8e-9 - 2.4e-9
4	n_s	0.92 - 1.00
5	w0	-1.2 - -0.8
6	wa	-0.5 - 0.5
7	N_ur	2.5 - 3.5
8	alpha_s	-0.02 - 0.02
9	m_nu [eV]	0.0 - 0.15

Fiducial Cosmology (Planck-like)

fiducial = [0.3111, 0.0490, 0.6766, 2.1e-9, 0.9665,
            -1.0, 0.0, 3.046, 0.0, 0.06]

Common Patterns

Cross-Validation

# Leave-one-out
hmf_emu.loo_train_pred(savefile='loo_results.h5')

# Leave-bunch-out
X_test, Y_test, Y_pred, var = hmf_emu.leave_bunch_out(n_out=5)

Batch Predictions

import numpy as np

# Generate test cosmologies
n_samples = 100
X_test = np.random.uniform(
    low=[0.24, 0.04, 0.60, 1.8e-9, 0.92, -1.2, -0.5, 2.5, -0.02, 0.0],
    high=[0.40, 0.06, 0.80, 2.4e-9, 1.00, -0.8, 0.5, 3.5, 0.02, 0.15],
    size=(n_samples, 10)
)

# Predict
predictions, variances = hmf_emu.predict(X_test)

Error Handling

Common Errors and Solutions

ImportError: No module named ‘gal_goku’

Solution:

cd src/gal_goku
pip install -e .

FileNotFoundError: data directory not found

Solution: Update the data_dir path to point to your data.

MemoryError during prediction

Solution: Process in smaller batches:

batch_size = 10
for i in range(0, len(X_test), batch_size):
    batch = X_test[i:i+batch_size]
    pred, var = hmf_emu.predict(batch)
    # Process results

Plotting Templates

Basic Line Plot

import matplotlib.pyplot as plt

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2, label='Data')
plt.xlabel('X axis', fontsize=14)
plt.ylabel('Y axis', fontsize=14)
plt.title('Title', fontsize=16)
plt.legend(fontsize=12)
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('output.png', dpi=150)

Log-Log Plot

plt.figure(figsize=(10, 6))
plt.loglog(x, y, 'r-', linewidth=2)
plt.xlabel(r'$k$ [$h$/Mpc]', fontsize=14)
plt.ylabel(r'$P(k)$ [(Mpc/$h$)$^3$]', fontsize=14)
plt.grid(True, alpha=0.3)
plt.savefig('power_spectrum.png', dpi=150)

Plot with Error Bands

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', linewidth=2, label='Mean')
plt.fill_between(x, y - err, y + err,
                  alpha=0.3, color='blue',
                  label='±1σ')
plt.legend()
plt.grid(True, alpha=0.3)
plt.savefig('with_errors.png', dpi=150)

File Formats

HDF5 Structure

Reading HDF5 files:

import h5py

with h5py.File('data.h5', 'r') as f:
    # List all keys
    print(list(f.keys()))

    # Read datasets
    data = f['dataset_name'][:]

    # Read attributes
    metadata = f.attrs['metadata']

Writing HDF5 files:

with h5py.File('output.h5', 'w') as f:
    # Create dataset
    f.create_dataset('data', data=my_array)

    # Add attributes
    f.attrs['description'] = 'My data'

Useful Links

GitHub Repository: https://github.com/qezlou/private-gal-emu
GPflow Documentation: https://gpflow.github.io/
NumPy Documentation: https://numpy.org/doc/
SciPy Documentation: https://docs.scipy.org/
Matplotlib Gallery: https://matplotlib.org/stable/gallery/

Environment Variables

Useful environment variables:

# OpenMP threads (for parallel computations)
export OMP_NUM_THREADS=16

# MKL threads (if using Intel MKL)
export MKL_NUM_THREADS=16

# Disable TensorFlow warnings (if using GPflow)
export TF_CPP_MIN_LOG_LEVEL=2

Performance Tips

Use vectorized operations instead of loops
Pre-allocate arrays when possible
Use appropriate data types (float32 vs float64)
Profile your code to find bottlenecks
Cache expensive computations

# Example: Vectorized vs loop

# Slow
result = []
for x in X:
    result.append(expensive_function(x))

# Fast
result = np.vectorize(expensive_function)(X)
# or even better, if possible:
result = expensive_function(X)  # if it handles arrays

Keyboard Shortcuts

Jupyter Notebook

Shift + Enter: Run cell
Ctrl + Enter: Run cell, stay in cell
Alt + Enter: Run cell, insert below
A: Insert cell above
B: Insert cell below
DD: Delete cell
M: Change to Markdown
Y: Change to Code

IPython

?function: Get help
??function: Get source code
%timeit: Time execution
%prun: Profile code
%matplotlib inline: Inline plots

Troubleshooting Checklist

Before asking for help, check:

☐ Is the correct conda environment activated?
☐ Are all packages installed?
☐ Are file paths correct?
☐ Are parameter values in valid ranges?
☐ Is there enough memory available?
☐ Have you checked the error message carefully?
☐ Have you tried the examples in the tutorials?
☐ Have you checked the GitHub issues?