CLASS (Cosmic Linear Anisotropy Solving System)

Each functional module in CLASS (e.g., background.c, thermodynamics.c) follows a consistent API pattern consisting of three types of functions:

1. module_init(...): Allocates and fills the module's specific structure. This must be called in the order of the seven-module hierarchy (Background $\rightarrow$ Thermodynamics $\rightarrow$ ... $\rightarrow$ Harmonic), as each subsequent module requires the data from the previous one.
2. module_free(): Deallocates the fields of the structure. Crucial for samplers: If embedding CLASS in a parameter sampler, you must call module_free() between executions and before calling module_init() again with new parameters to prevent memory leaks.
3. module_something_at_somevalue(...): Provides interpolation for the pre-computed tables. For example, background_at_eta(eta, * values) allows you to retrieve background quantities for any arbitrary conformal time $\eta$ from the tabulated values generated during background_init().

CLASS is organized into a ten-module backbone where each module performs a specific task in the cosmological calculation pipeline. The execution follows a strict dependency chain where each module's _init() function takes the results of previous modules as input and populates its own structure with new results.

Key characteristics of this architecture:

• Dependency Chain: Modules are initialized sequentially (e.g., background_init $\rightarrow$ thermodynamics_init $\rightarrow$ perturbations_init).
• Self-Contained Structures: Each module uses a specific structure (e.g., struct perturbations pt) that contains both its input parameters and its computed results (including array sizes for memory management).
• Memory Management: Each module has a corresponding _free() function (except for precision and output) that deallocates only the arrays owned by that specific module.
• Reduced Executables: For developers interested in intermediate steps (e.g., only background or only thermodynamics), CLASS provides reduced executables in the test/ directory (e.g., test_perturbations.c) which can be compiled via make test_<module_name>.

/* Example of the initialization sequence in main.c */
background_init(&pr, &ba);
thermodynamics_init(&pr, &ba, &th);
perturbations_init(&pr, &ba, &th, &pt);
// ... and so on

CLASS uses an integer-based error management system where functions return either _SUCCESS_ or _FAILURE_.

When a failure occurs, the error message is propagated upwards through a nested structure. Each module has an associated structure containing an error_message field (e.g., background.error_message, thermo.error_message). This allows the user to see the full call stack of errors, including the specific line numbers and the root cause.

For Developers: Using class_call()

To ensure errors are correctly propagated and nested, use the class_call() macro when calling module functions. This macro handles appending the local error message to the caller's error message.

Syntax with pointers to structures:

class_call(module_i_function(...,pi),
           pi->error_message,
           pj->error_message);

For Developers: Using class_test()

You can trigger a formatted error message using class_test(). This is useful for validating input parameters or constraints.

Example:

class_test(blabla >= 1,
           px->error_message,
           "your choice of input parameter blabla=%e is not consistent with the constraint blabla<%e",
           blabla, blablamax);

CLASS is built on a ten-module backbone where each module is responsible for a specific step in the cosmological computation pipeline.

The Computation Pipeline

1. Input: Set parameters (struct precision).
2. Background: Compute cosmological background (struct background).
3. Thermodynamics: Compute ionization fractions, etc. (struct thermodynamics).
4. Perturbations: Compute source functions $S(k, \tau)$ (struct perturbations).
5. Primordial: Compute primordial spectra (struct primordial).
6. Fourier: Compute 2-point statistics $P(k)$ (struct fourier).
7. Transfer: Compute transfer functions $\Delta_l(k)$ (struct transfer).
8. Harmonic: Compute harmonic power spectra $C_l$ (struct harmonic).
9. Lensing: Compute lensed CMB spectra (struct lensing).
10. Distortions: Compute CMB spectral distortions (struct distortions).

Data Communication

Communication between modules is handled by passing pointers to specific structures. Each structure contains:

• An array of tabulated values (e.g., background quantities as a function of time).
• Metadata regarding array size and physical quantity indices for interpolation.
• Derived quantities required by subsequent modules.

Module Interface

Each module (e.g., background.c, perturbations.c) typically implements three types of functions:

• module_init(...): Allocates and fills the module's structure. Calling this solves the specific step for the current parameters.
• module_free(...): Deallocates the structure's fields. Crucial: When interfacing CLASS with a sampler, you must call module_free between executions and before calling module_init again with new parameters.
• module_something_at_somevalue(...): Interpolates pre-computed tables (e.g., background_at_tau(tau, ...)). These are the only functions intended to be called by other modules.