flip.data_vector

Init file of the flip.data_vector package.

Submodules

• flip.data_vector.basic
• flip.data_vector.cosmo_utils
• flip.data_vector.galaxypv_vectors
• flip.data_vector.snia_vectors
• flip.data_vector.vector_utils

Attributes

__use_jax__
jax_installed
log

Classes

CovMatrix	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.
DataVector	Helper class that provides a standard way to create an ABC using
Dens	Helper class that provides a standard way to create an ABC using
DirectVel	Helper class that provides a standard way to create an ABC using
DensVel	Helper class that provides a standard way to create an ABC using
VelFromHDres	Helper class that provides a standard way to create an ABC using
FisherVelMesh	Helper class that provides a standard way to create an ABC using
FisherVelFromHDres	Helper class that provides a standard way to create an ABC using
FisherDens	Helper class that provides a standard way to create an ABC using
FisherDensVel	Helper class that provides a standard way to create an ABC using

Functions

create_log([log_level])

The create_log function creates a logger object that can be used to log messages.

Package Contents

class flip.data_vector.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.

model_name

Name of the covariance model.

Type:

str

model_kind

Type of covariance (‘density’, ‘velocity’, ‘density_velocity’, ‘full’).

Type:

str

free_par

Dictionary of free parameters for the model.

Type:

dict

los_definition

Definition of the line-of-sight.

Type:

str

covariance_dict

Dictionary containing covariance matrices.

Type:

dict

matrix_form

Indicates if covariance is in matrix form.

Type:

bool

redshift_dict

Dictionary of redshift information.

Type:

dict

variant

Variant of the model.

Type:

str

number_densities

Number of density bins.

Type:

int

number_velocities

Number of velocity bins.

Type:

int

coefficients

Imported module for model coefficients.

Type:

module

compute_covariance_sum

Function to compute covariance sum.

Type:

callable

compute_covariance_sum_jit

JIT-compiled function to compute covariance sum (if JAX is installed).

Type:

callable

__init__()

Initializes a CovMatrix instance.

init_from_flip()

Class method to initialize from the flip code generator.

init_from_generator()

Class method to initialize from a model-specific generator.

init_from_file()

Class method to initialize from a file (pickle, npz, parquet).

kind()

Property returning the kind of covariance model.

loaded()

Property indicating if the covariance matrix is loaded.

init_compute_covariance_sum()

Initializes functions for computing covariance sums.

compute_covariance_sum_eigenvalues()

Computes eigenvalues of the covariance sum.

compute_matrix_covariance()

Converts flat covariance to matrix form.

compute_flat_covariance()

Converts matrix covariance to flat form.

write()

Writes the covariance matrix to a file (pickle, npz, parquet).

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.

• NotImplementedError – If reading from unsupported file formats.

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

compute_covariance_sum = None

compute_covariance_sum_jit = None

number_densities = None

number_velocities = None

emulator_flag = False

classmethod 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)

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

Parameters:

• cls – Indicate that the function is a class method

• model_name – Determine which model to use for the covariance matrix

• model_kind – Determine the kind of model to be used

• power_spectrum_dict – Pass the power spectrum of the model

• coordinates_density – Specify the coordinates of the density field

• coordinates_velocity – Define the velocity coordinates of the covariance matrix

• additional_parameters_values – Pass the values of additional parameters to the flip code

• **kwargs – Pass a variable number of keyword arguments to the function

Returns:

A covariancematrix object

classmethod init_from_generator(model_name, model_kind, power_spectrum_dict, coordinates_velocity=None, coordinates_density=None, additional_parameters_values=None, variant=None, **kwargs)

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

Parameters:

• cls – Refer to the class itself

• model_name – Specify the kind of model used to generate the covariance matrix

• model_kind – Determine which model to use

• power_spectrum_dict – Pass the power spectrum to the generate_* functions

• coordinates_velocity – Generate the velocity covariance matrix

• coordinates_density – Generate the density field

• additional_parameters_values – Pass additional parameters to the generator function

• **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

classmethod init_from_emulator(emulator_model_name, model_kind, covariance_list, emulator_parameter_values, parameter_names, **kwargs)

classmethod init_from_file(filename, file_format)

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

Parameters:

self – Represent the instance of the class

Returns:

The kind of the model

property loaded

The loaded function checks if the covariance matrix is loaded.

Parameters:

self – Refer to the object itself

Returns:

A boolean

init_compute_covariance_sum()

compute_covariance_sum_eigenvalues(parameter_values_dict, vector_variance)

compute_matrix_covariance(verbose=True)

The compute_matrix_covariance function takes the covariance matrix and fills in all of the missing values.

Parameters:

self – Bind the method to the object

Returns:

A dictionary with the full covariance matrices for each redshift bin

compute_flat_covariance(verbose=True)

write(filename, file_format)

The write function writes the covariance matrix to a file.

Parameters:

• self – Represent the instance of the class

• 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

mask(mask_vel=None, mask_dens=None)

flip.data_vector.create_log(log_level='info')

The create_log function creates a logger object that can be used to log messages. The function takes one argument, the log_level, which is set to "info" by default. The function returns a Logger object with the specified logging level.

Parameters:

log_level – Set the logging level

Returns:

A logger object

flip.data_vector.__use_jax__ = True

flip.data_vector.jax_installed = True

flip.data_vector.log

class flip.data_vector.DataVector(data, covariance_observation=None, **kwargs)

Bases: abc.ABC

Helper class that provides a standard way to create an ABC using inheritance.

_free_par = []

_kind = ''

property conditional_free_par

property free_par

property kind

property conditional_needed_keys

property needed_keys

property data

abstract give_data_and_variance(**kwargs)

_check_keys(data)

_covariance_observation = None

_data

_kwargs

__call__(*args)

get_masked_data_and_cov(bool_mask)

compute_covariance(model, power_spectrum_dict, **kwargs)

class flip.data_vector.Dens(data, covariance_observation=None, **kwargs)

Bases: DataVector

Helper class that provides a standard way to create an ABC using inheritance.

_kind = 'density'

_needed_keys = ['density', 'density_error']

give_data_and_variance(*args)

class flip.data_vector.DirectVel(data, covariance_observation=None)

Bases: DataVector

Helper class that provides a standard way to create an ABC using inheritance.

_kind = 'velocity'

_needed_keys = ['velocity']

property conditional_needed_keys

give_data_and_variance(*args)

class flip.data_vector.DensVel(density_vector, velocity_vector)

Bases: DataVector

Helper class that provides a standard way to create an ABC using inheritance.

_kind = 'cross'

property needed_keys

property free_par

give_data_and_variance(*args)

densities

velocities

compute_covariance(model, power_spectrum_dict, **kwargs)

class flip.data_vector.VelFromHDres(data, covariance_observation=None, velocity_estimator='full', **kwargs)

Bases: DirectVel

Helper class that provides a standard way to create an ABC using inheritance.

_needed_keys = ['dmu', 'zobs']

_free_par = ['M_0']

property conditional_needed_keys

give_data_and_variance(parameter_values_dict)

velocity_estimator = 'full'

class flip.data_vector.FisherVelMesh(data, velocity_estimator='full', **kwargs)

Bases: DataVector

Helper class that provides a standard way to create an ABC using inheritance.

_kind = 'velocity'

_needed_keys = ['zobs', 'ra', 'dec', 'rcom_zobs']

give_data_and_variance(parameter_values_dict)

_distance_modulus_difference_to_velocity

class flip.data_vector.FisherVelFromHDres(data, velocity_estimator='full')

Bases: DataVector

Helper class that provides a standard way to create an ABC using inheritance.

_kind = 'velocity'

_needed_keys = ['zobs', 'ra', 'dec', 'rcom_zobs']

_free_par = ['sigma_M']

give_data_and_variance(parameter_values_dict)

velocity_estimator = 'full'

class flip.data_vector.FisherDens(data, velocity_estimator='full', **kwargs)

Bases: DataVector

Helper class that provides a standard way to create an ABC using inheritance.

_kind = 'density'

_needed_keys = ['ra', 'dec', 'rcom_zobs']

_free_par = []

give_data_and_variance(parameter_values_dict)

class flip.data_vector.FisherDensVel(fisher_density, fisher_velocity)

Bases: DataVector

Helper class that provides a standard way to create an ABC using inheritance.

_kind = 'cross'

give_data_and_variance(*args)

densities

velocities

compute_covariance(model, power_spectrum_dict, **kwargs)