flip.covariance =============== .. py:module:: flip.covariance .. autoapi-nested-parse:: Init file of the flip.covariance package. Submodules ---------- .. toctree:: :maxdepth: 1 /autoapi/flip/covariance/adamsblake17/index /autoapi/flip/covariance/adamsblake17plane/index /autoapi/flip/covariance/adamsblake20/index /autoapi/flip/covariance/carreres23/index /autoapi/flip/covariance/contraction/index /autoapi/flip/covariance/cov_utils/index /autoapi/flip/covariance/covariance/index /autoapi/flip/covariance/emulators/index /autoapi/flip/covariance/generator/index /autoapi/flip/covariance/lai22/index /autoapi/flip/covariance/ravouxcarreres/index /autoapi/flip/covariance/ravouxnoanchor25/index /autoapi/flip/covariance/rcrk24/index /autoapi/flip/covariance/symbolic/index Classes ------- .. autoapisummary:: flip.covariance.CovMatrix Package Contents ---------------- .. py:class:: CovMatrix(model_name=None, model_kind=None, free_par=None, los_definition=None, covariance_dict=None, matrix_form=False, redshift_dict=None, variant=None, coefficients=None, number_densities=None, number_velocities=None, emulator_flag=False) CovMatrix is a class for managing and manipulating covariance matrices used in cosmological analyses, particularly for models involving density and velocity fields. It provides methods for initialization from various sources, conversion between flat and matrix forms, masking, and file I/O operations. .. attribute:: model_name Name of the covariance model. :type: str .. attribute:: model_kind Type of covariance ('density', 'velocity', 'density_velocity', 'full'). :type: str .. attribute:: free_par Dictionary of free parameters for the model. :type: dict .. attribute:: los_definition Definition of the line-of-sight. :type: str .. attribute:: covariance_dict Dictionary containing covariance matrices. :type: dict .. attribute:: matrix_form Indicates if covariance is in matrix form. :type: bool .. attribute:: redshift_dict Dictionary of redshift information. :type: dict .. attribute:: variant Variant of the model. :type: str .. attribute:: number_densities Number of density bins. :type: int .. attribute:: number_velocities Number of velocity bins. :type: int .. attribute:: coefficients Imported module for model coefficients. :type: module .. attribute:: compute_covariance_sum Function to compute covariance sum. :type: callable .. attribute:: compute_covariance_sum_jit JIT-compiled function to compute covariance sum (if JAX is installed). :type: callable .. method:: __init__ Initializes a CovMatrix instance. .. method:: init_from_flip Class method to initialize from the flip code generator. .. method:: init_from_generator Class method to initialize from a model-specific generator. .. method:: init_from_file Class method to initialize from a file (pickle, npz, parquet). .. method:: kind Property returning the kind of covariance model. .. method:: loaded Property indicating if the covariance matrix is loaded. .. method:: init_compute_covariance_sum Initializes functions for computing covariance sums. .. method:: compute_covariance_sum_eigenvalues Computes eigenvalues of the covariance sum. .. method:: compute_matrix_covariance Converts flat covariance to matrix form. .. method:: compute_flat_covariance Converts matrix covariance to flat form. .. method:: write Writes the covariance matrix to a file (pickle, npz, parquet). .. method:: mask Returns a masked CovMatrix instance based on provided masks for density and velocity. Usage: CovMatrix can be instantiated directly or via class methods for loading from generators or files. It supports conversion between flat and matrix forms, masking, and saving/loading to disk. :raises ValueError: If variants or mask sizes are invalid. :raises NotImplementedError: If reading from unsupported file formats. .. py:attribute:: model_name :value: None .. py:attribute:: model_kind :value: None .. py:attribute:: free_par :value: None .. py:attribute:: los_definition :value: None .. py:attribute:: covariance_dict :value: None .. py:attribute:: matrix_form :value: False .. py:attribute:: redshift_dict :value: None .. py:attribute:: variant :value: None .. py:attribute:: coefficients :value: None .. py:attribute:: compute_covariance_sum :value: None .. py:attribute:: compute_covariance_sum_jit :value: None .. py:attribute:: number_densities :value: None .. py:attribute:: number_velocities :value: None .. py:attribute:: emulator_flag :value: False .. py:method:: init_from_flip(model_name, model_kind, power_spectrum_dict, coordinates_density=None, coordinates_velocity=None, additional_parameters_values=None, los_definition='bisector', variant=None, **kwargs) :classmethod: The init_from_flip function is a function that initializes the covariance matrix from the flip code. It takes as input: - model_name: name of the model used to generate the covariance matrix (e.g., 'lai22') - model_kind: kind of data used to generate the covariance matrix (e.g., 'density' or 'velocity') - power_spectrum_dict: dictionary containing all information about power spectrum, including k and P(k) values, redshift, etc... It is generated by calling getPowerSpectrumDict() in :param cls: Indicate that the function is a class method :param model_name: Determine which model to use for the covariance matrix :param model_kind: Determine the kind of model to be used :param power_spectrum_dict: Pass the power spectrum of the model :param coordinates_density: Specify the coordinates of the density field :param coordinates_velocity: Define the velocity coordinates of the covariance matrix :param additional_parameters_values: Pass the values of additional parameters to the flip code :param \*\*kwargs: Pass a variable number of keyword arguments to the function :returns: A covariancematrix object .. py:method:: init_from_generator(model_name, model_kind, power_spectrum_dict, coordinates_velocity=None, coordinates_density=None, additional_parameters_values=None, variant=None, **kwargs) :classmethod: The init_from_generator function is a helper function that allows the user to initialize a Covariance object from a generator. The init_from_generator function takes in as arguments: - cls: the class of the object being initialized (Covariance) - model_name: name of covariance model used to generate covariance matrix (e.g., 'lai22') - model_kind: kind of covariance matrix generated ('density' or 'velocity') - power spectrum dictionary containing keys for each redshift bin and values corresponding to power spectra at those red :param cls: Refer to the class itself :param model_name: Specify the kind of model used to generate the covariance matrix :param model_kind: Determine which model to use :param power_spectrum_dict: Pass the power spectrum to the generate_* functions :param coordinates_velocity: Generate the velocity covariance matrix :param coordinates_density: Generate the density field :param additional_parameters_values: Pass additional parameters to the generator function :param \*\*kwargs: Pass a variable number of keyword arguments to the function :param : Generate the covariance matrix from a given model :returns: An object of the class covariancematrix .. py:method:: init_from_emulator(emulator_model_name, model_kind, covariance_list, emulator_parameter_values, parameter_names, **kwargs) :classmethod: .. py:method:: init_from_file(filename, file_format) :classmethod: .. py:property:: kind The kind function is used to determine the kind of covariance model that will be computed. The options are: - velocity: The covariance model is computed for velocity only. - density: The covariance model is computed for density only. - density_velocity: The covariance model is computed for both velocity and density, without cross-term (i.e., the covariances between velocities and densities are zero). This option should be used when computing a full 3D tomography in which we want to compute a separate 1D tomography along each axis (x, y, z :param self: Represent the instance of the class :returns: The kind of the model .. py:property:: loaded The loaded function checks if the covariance matrix is loaded. :param self: Refer to the object itself :returns: A boolean .. py:method:: init_compute_covariance_sum() .. py:method:: compute_covariance_sum_eigenvalues(parameter_values_dict, vector_variance) .. py:method:: compute_matrix_covariance(verbose=True) The compute_matrix_covariance function takes the covariance matrix and fills in all of the missing values. :param self: Bind the method to the object :returns: A dictionary with the full covariance matrices for each redshift bin .. py:method:: compute_flat_covariance(verbose=True) .. py:method:: write(filename, file_format) The write function writes the covariance matrix to a file. :param self: Represent the instance of the class :param filename: Specify the name of the file to be written :param : Specify the name of the file in which we want to save our covariance matrix :returns: Nothing .. py:method:: mask(mask_vel=None, mask_dens=None)