flipcosmo 1.0.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

flipcosmo-1.2.1.dist-info/RECORD

@@ -0,0 +1,109 @@
+docs/conf.py,sha256=oQH2FVsFdgs7Z2z0qyORgjUz1Wn35TS-oyd3GaQ8Uos,4694
+flip/__init__.py,sha256=nvvWo-nfwNPaATqooXCW0p6EPun32rOQ385ilNb2H_A,419
+flip/_config.py,sha256=wf09C_i7q-G8v3ADk63WtrSEZyXQhy4zNzQ9AY3Qq9U,19
+flip/utils.py,sha256=mkLEW-qDWYRSpycnF6MxWUtTOAqogKZb708I8ys14p0,5462
+flip/covariance/__init__.py,sha256=bzxPuQOFUX7YfFb5WmoWE-ykQWK7sLh_zQHyRuvF2ng,233
+flip/covariance/contraction.py,sha256=p3PyF_YufUxxC3ZqBe0OUPGXRWGOMUrdXXCaVpD4R2g,14085
+flip/covariance/cov_utils.py,sha256=uYbrtlLs8-NJTfmdNgyywvo96et8ukyhztGfhbCy9zo,14797
+flip/covariance/covariance.py,sha256=-1grj42Bbq8x9OUitJFck4tPx8mKD7_ebjgkeRaOpCk,31553
+flip/covariance/fisher.py,sha256=0iu_jRcgfJYG3WnchaKP5QuhMPAOAwpaQ4AiHb_qS9o,10743
+flip/covariance/fit_utils.py,sha256=jeC2rMCzy3gcxFFgg1QpkKeh_uI6oB_LrdVbHUI6QcI,34513
+flip/covariance/fitter.py,sha256=xeHdoSN_jEOV-c6XJf-nsxFsdcWx2mX1SqRF0ekAbNM,18884
+flip/covariance/generator.py,sha256=WZ13KZMcfa1sCgqaAmpMrFF7INmoo05WD1Tb7Rihef8,25667
+flip/covariance/likelihood.py,sha256=jiGE0aGuKqnBkz8OXOV7z7IqHQGdXuWD_fpjv6oc4zo,28834
+flip/covariance/plot_utils.py,sha256=UZl5-JC862eKAfd8OxKSlDQmvuXEsUhuSyUP9QW60B0,20311
+flip/covariance/symbolic.py,sha256=xtbOjqXHweFiTCNEnDKgYaq7pW49WxEyLJJ1nVtJbgw,46150
+flip/covariance/analytical/__init__.py,sha256=FTyOWgE55JzfCgLIAI00zrGvnVUZiKoppqJ3WvMSsxw,175
+flip/covariance/analytical/adamsblake17/__init__.py,sha256=94NXeySXL0ZqT_-bBk_CmsB0-aOMm5qp8kG-r7UbrBI,148
+flip/covariance/analytical/adamsblake17/coefficients.py,sha256=OXVyHIdJz7xO8IjpL4G-O960LQklI8qdMY7oO7N7JZ4,972
+flip/covariance/analytical/adamsblake17/fisher_terms.py,sha256=L8p--sXm4SuwtfOl4a3DvdJUk8k1Z8Y51xN75Y0JZjo,8683
+flip/covariance/analytical/adamsblake17/flip_terms.py,sha256=OY_wyOA_l46o0J0nTyOMCUYGNR70jnrtFGHRIMkHA3U,1208
+flip/covariance/analytical/adamsblake17plane/__init__.py,sha256=94NXeySXL0ZqT_-bBk_CmsB0-aOMm5qp8kG-r7UbrBI,148
+flip/covariance/analytical/adamsblake17plane/coefficients.py,sha256=OXVyHIdJz7xO8IjpL4G-O960LQklI8qdMY7oO7N7JZ4,972
+flip/covariance/analytical/adamsblake17plane/fisher_terms.py,sha256=L8p--sXm4SuwtfOl4a3DvdJUk8k1Z8Y51xN75Y0JZjo,8683
+flip/covariance/analytical/adamsblake17plane/flip_terms.py,sha256=kuvD6CD4WHqP-V3stHJxvsaOdDz5InYso2EpvvPwQhs,1105
+flip/covariance/analytical/adamsblake17plane/generator.py,sha256=svprrN4mjqjcX5cDoDWJ8LgRjeOUQX2Vr7Edu1boMG4,10775
+flip/covariance/analytical/adamsblake20/__init__.py,sha256=TYS1sGySDUru6s5Wk4wd-3TnRa3PVjEsIQEuwOkXhr8,239
+flip/covariance/analytical/adamsblake20/coefficients.py,sha256=hJ8VMmHKF9BRuelqnaJvWPHuxxWn7f-boZa4Gah7f08,1837
+flip/covariance/analytical/adamsblake20/fisher_terms.py,sha256=-1sMM2Ydsb35hhH2xYDc9Itn7ElyGzBNSsyOyIe8EYM,27920
+flip/covariance/analytical/adamsblake20/flip_terms.py,sha256=45TFyFv0CRsmFjEfhvTbQz9BO0AWOAjwfSeOHlBZmLY,8069
+flip/covariance/analytical/carreres23/__init__.py,sha256=X8EBISybyz4sgkXE2q8dEkZjqGHi6oqgb6QU0_isM2Q,165
+flip/covariance/analytical/carreres23/coefficients.py,sha256=uw96hxCLDra_0qLFpKHITORb15ZcHQATX8rpxEHXpm0,433
+flip/covariance/analytical/carreres23/fisher_terms.py,sha256=CsPlO6gtnm0XwRkGoiM48HrPkduvikX_YC_A5p0UJIE,1453
+flip/covariance/analytical/carreres23/flip_terms.py,sha256=2taKNb4OjyszZ5g03bgGk1KIaDPrO5fA0S9erKtXaJY,770
+flip/covariance/analytical/carreres23/generator.py,sha256=FcegRe3rCXigsg_q1B19Jp67cTq-dLKrhyXZvrnDAh8,5882
+flip/covariance/analytical/genericzdep/__init__.py,sha256=xX5ncmn3AyUz8ReiC5Hb6v_qeeWXiu8c4ET7dtLNBSU,111
+flip/covariance/analytical/genericzdep/coefficients.py,sha256=9J0iPiOAfwjcojnhg_mpctUMaNRO-BoEshwlcD6Ymmo,1351
+flip/covariance/analytical/genericzdep/flip_terms.py,sha256=Xo_esbVyOr2aGuiAmaDa67rURTcucmwC__tMzwdQ3mI,1599
+flip/covariance/analytical/lai22/__init__.py,sha256=hnYxdGuS7nSAUuvpckk7VA_WCAUe6SHPYGz32tGLUWM,240
+flip/covariance/analytical/lai22/coefficients.py,sha256=MrZe1N85atAGGUKGckv-FUqfz-mrUdJSeWmBmybBisQ,3336
+flip/covariance/analytical/lai22/fisher_terms.py,sha256=nvvvwIL8w_jub_3mvkjSZmKuciWO9L5PFQMlZHjvhro,170032
+flip/covariance/analytical/lai22/flip_terms.py,sha256=fPi2nu38GI5S9Ie57zyRgXH-OyLoICg9jyNPZhuED4k,472248
+flip/covariance/analytical/lai22/generator.py,sha256=YqfJ4HLs5Kew0l0_P4ai6wNbVwEdeAlgtPKCdVGrE70,36164
+flip/covariance/analytical/lai22/h_terms.py,sha256=RWIAabFHhvaXQnz9QO9MCUKT0mVAsKTKAqcvH4ZKOcU,78216
+flip/covariance/analytical/lai22/symbolic.py,sha256=Unp_75EkUX2XN8Yxm_MVTXdwcIblKjFG5G7T7efZ6co,6074
+flip/covariance/analytical/ravouxcarreres/__init__.py,sha256=TYS1sGySDUru6s5Wk4wd-3TnRa3PVjEsIQEuwOkXhr8,239
+flip/covariance/analytical/ravouxcarreres/coefficients.py,sha256=hJ8VMmHKF9BRuelqnaJvWPHuxxWn7f-boZa4Gah7f08,1837
+flip/covariance/analytical/ravouxcarreres/fisher_terms.py,sha256=-1sMM2Ydsb35hhH2xYDc9Itn7ElyGzBNSsyOyIe8EYM,27920
+flip/covariance/analytical/ravouxcarreres/flip_terms.py,sha256=3o_xlQRU3Pfuw_gmxw9FJFYgadTTTV7WgxwUXnrY6k8,23089
+flip/covariance/analytical/ravouxcarreres/flip_terms_lmax.py,sha256=4parR15Q9oepgYN39rm3DGdnTmbw3Zi5SjmGhpUUqOo,100630
+flip/covariance/analytical/ravouxnoanchor25/__init__.py,sha256=AYe85mOOwW9pjQ4nSCeNPTj2IHJA8T_o9rFmVnFs53M,152
+flip/covariance/analytical/ravouxnoanchor25/coefficients.py,sha256=5JEXibojBvlIXUCq90sK_se27CM2Q-_-Va1gy65w8SY,1505
+flip/covariance/analytical/ravouxnoanchor25/fisher_terms.py,sha256=CsPlO6gtnm0XwRkGoiM48HrPkduvikX_YC_A5p0UJIE,1453
+flip/covariance/analytical/ravouxnoanchor25/flip_terms.py,sha256=PlyYRlNCnRT55piDdnunl7QIwEkNbGotOfo6kIGOqs0,780
+flip/covariance/analytical/rcrk24/__init__.py,sha256=_ebQvTeBW0pZAZ9KO7vHwdc1qTkMgOoNGr2ki_ahOUs,252
+flip/covariance/analytical/rcrk24/coefficients.py,sha256=XhPU_3-QzcBkJcakcmzThN3ZcZCeTXekqxWI6cwq0_g,6427
+flip/covariance/analytical/rcrk24/fisher_terms.py,sha256=tipukrVhe4s9y4CC6aPsPfhyxoIILTsLFt5jUKLrItA,3372
+flip/covariance/analytical/rcrk24/flip_terms.py,sha256=M4DkzboJBtYuGVFWqwG4-2ceWPrYHjDKE7pDFrwJ-D4,785
+flip/covariance/emulators/__init__.py,sha256=3izGJjEL-aBelpfUsuts1dWqha_JBaKDSUVnrNHootw,115
+flip/covariance/emulators/generator.py,sha256=Uvtz1DcpQVKBW3qJzHHm_XqrvqwRKe1-CssKCJGGgNU,12868
+flip/covariance/emulators/gpmatrix.py,sha256=INa1IkBjVOKKi44-GVVEYTVPcZzp2xf42KeKhK04cHQ,4748
+flip/covariance/emulators/nnmatrix.py,sha256=yzR3q1S5egvJ2IYCxlJvfPhO_i4clW7q3UaAtxSu8K8,9057
+flip/covariance/emulators/skgpmatrix.py,sha256=JGQiPvuVLN2oZkwwHaC3i1llzzqfWg5vwZWiEh3WI2U,3877
+flip/data/__init__.py,sha256=8OBjUqbJBny0jMSCxCyKVi4-MNjR6vg3ZTGCGX8Vgf4,72
+flip/data/data_density.parquet,sha256=_156O6Q05FQDqQj9QaStQBpiS1eWngTHN_QdBsfos2M,14061
+flip/data/data_velocity.parquet,sha256=m5WkL3LRzwHKl-AgxMVnhn_8IaB5extm1Fipo3fKR1c,181039
+flip/data/data_window_density.parquet,sha256=vSF7GGJzIkzGNTnhksFa-zJlEs9i5THugEzUl52si2o,40372
+flip/data/gridding.py,sha256=_3PHazY-KbxQyHKWxQguB4LGJ1yU-uHNcQqzQSk5O8c,30864
+flip/data/load_data_test.py,sha256=DmHn3gJTDtGqJCGObnpvhKm0YDGlhTM8kJuHIZUxZ9Q,2871
+flip/data/power_spectrum_mm.txt,sha256=TltaM8gxTnyUR3eLM1GHf6HCctRA1F6cHmuhjRYkj8M,50085
+flip/data/power_spectrum_mt.txt,sha256=S9fuSnNoW9qwJL7xuRUoVSz_EzmgEJENy3td8u9FkXU,50085
+flip/data/power_spectrum_tt.txt,sha256=Ws3b8XtzZJ0aNKT7g3PRb0NQWDtvpFBTU6nCi0G5ZXc,50085
+flip/data/style.mplstyle,sha256=2og3sSZU3SqBBB1Jm4alodk3jJF-PMyf7XZqCvItwdA,2341
+flip/data/test_covariance_reference_values.json,sha256=O6Z-QeDBMjWQUKpLqbhwilGfO-fQaGGRjAdfHuq_WvQ,3360
+flip/data/test_e2e_reference_values.json,sha256=qfqJDGL2CCiR4xiiYW6SX4_FdzawXQLodFXQREmT_Y0,256
+flip/data_vector/__init__.py,sha256=ZUGmpWl3D_PvZSmQNte4L-sW7trfL-SJj7jtzeysnwM,129
+flip/data_vector/basic.py,sha256=e5hsvSB19JA5QDeaNMdAQndLbDqcrNxx6zdCKeTTM5o,12362
+flip/data_vector/cosmo_utils.py,sha256=WvrQmWM0lPkdy1Ak8NMe3IzauRcBV9bubAQ3YGCdqQo,624
+flip/data_vector/galaxypv_vectors.py,sha256=VI897662S5s7g6iwAsQssvKK6ydBto1LBmvjBez6mfA,14890
+flip/data_vector/snia_vectors.py,sha256=IzM2nH7y1y9puWGugLfLUJURpRksBNg2w5XZxypoWPY,7978
+flip/data_vector/vector_utils.py,sha256=P0AfdyYUU5F6ClgrhyASmqs3ai6PsKmB_o_KnHlWVJY,6715
+flip/power_spectra/__init__.py,sha256=9XDOGCo4YFXg0QdQ6gEC66oVaB1Q_NtCmqMn8PZs30w,118
+flip/power_spectra/class_engine.py,sha256=MWKvSFKOK242JRpc4wNxbT_1ldH9c00umVW75A4px-A,5964
+flip/power_spectra/cosmoprimo_engine.py,sha256=tftCtZO1YTQTKie44qdRPzT3WNTpZmW5fbw66qnKchk,3005
+flip/power_spectra/generator.py,sha256=X6AAsuiYWXNjfJDdYGd0Pna1wgXH0_eNEZefGNcxZEM,6656
+flip/power_spectra/models.py,sha256=bRR5lIQHyoRtE0lqQKjiPxCdQNqwK1ZG5zrjMPQmzoo,3544
+flip/power_spectra/pyccl_engine.py,sha256=D8PTQaB43L6A0VhiQs55kuk8t6uOcDIxwLNW6i8Ja6w,3527
+flip/simulation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flipcosmo-1.2.1.dist-info/licenses/LICENSE,sha256=jQfEFGXoNPb52M0jMfnWZtz8reTMYXItOx9-wevuHWg,1071
+scripts/flip_compute_correlation_model.py,sha256=9IhGD2rctHIuE_FeOuTze22EEqGVWUqFzoTle1HNQ6k,1710
+scripts/flip_compute_power_spectra.py,sha256=Ez36BS8bmxPs0iSeHVGIhzXcohlRb8BG6NxsioN7S0Y,1298
+scripts/flip_fisher_forecast_velocity.py,sha256=coQ_YdsSouq-4AGXExwojr1fIC_tO0wz4-3HU9ZYTco,1838
+scripts/flip_fisher_rcrk24.py,sha256=NhfGJgxuzKnodl2tzl5YS3MD_Cs2MDqWKgCGirvH3Fk,4899
+scripts/flip_launch_minuit_density_fit.py,sha256=0sBaCGhvszBJ2_iwUPJh1LMT9duEe9jxEr_jWxuMQCU,2185
+scripts/flip_launch_minuit_full_fit.py,sha256=PJiyhP5Nrguu_oogRTjlRXcr_0RDBsUY5EOaAg1CR-w,3225
+scripts/flip_launch_minuit_velocity_fit.py,sha256=rcBa8CO04TVMeIRGdB_Oyp-RdFud_uU8tv9Wx_vuE24,1946
+scripts/flip_launch_minuit_velocity_fit_full.py,sha256=wzHp-cns2ADzp02vQVyySbpNMS2EPddBM5NX3S3O1ew,2537
+scripts/flip_launch_minuit_velocity_fit_interpolation.py,sha256=KAK7A_HU-FYorUEcPAXVCtBqRPEL3cugSUxcHVcEu24,2401
+test/refresh_reference_values.py,sha256=T5Fs5iiKpeWUIyC0OHBrnXoPjfdAyfXMjE-YVK-pXLY,1148
+test/test_covariance_assembly.py,sha256=kq8i9I6iYPwXAZ1zW9nHoxHL3e_3ppJ9dJ5Owy8OfQY,3601
+test/test_covariance_reference_values.py,sha256=jwL1aLVGwRm0UcIMf7vUSrlLrG50vrN_rdfCxOBwdlo,4104
+test/test_covariance_utils.py,sha256=mSd5FrjQI9HTtAUo_qJCO8XGdQl2TtG-0MPCqoZxtAU,1051
+test/test_e2e_density.py,sha256=vVaRphhfGdHxKknzVOYbH3YMGma7BUk7o2PCqebHSr0,1833
+test/test_e2e_joint.py,sha256=GfQkm2_NGPXiZWRxmbk1xX0Q8JXtfue59klDD6tHOBE,2386
+test/test_e2e_velocity.py,sha256=FebMsWwzqvfhkest5kkXTdkW6Me-q1gTypcU6Qc4Kh4,1796
+test/test_likelihood_inversions.py,sha256=RE2IiCtBPKJzlvEaFQysYh1nht9wTQo2Bfsfa0hChaY,830
+flipcosmo-1.2.1.dist-info/METADATA,sha256=WxnK7RJ3Nxyc0gaH7IipR1SepPDVo4AUaWsVuMZj8iE,3616
+flipcosmo-1.2.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+flipcosmo-1.2.1.dist-info/top_level.txt,sha256=9MRA5iw3NarUSIfyQLBZB_b_44iHdvuTW9CjqvMi8_4,44
+flipcosmo-1.2.1.dist-info/RECORD,,

{flipcosmo-1.0.0.dist-info → flipcosmo-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

flipcosmo-1.2.1.dist-info/top_level.txt

@@ -0,0 +1,7 @@
+dist
+docs
+flip
+notebook
+scripts
+slides
+test

scripts/flip_compute_correlation_model.py

@@ -0,0 +1,70 @@
+import os
+
+import numpy as np
+from flip.covariance import contraction
+from pkg_resources import resource_filename
+from scipy.interpolate import RegularGridInterpolator
+
+from flip import utils
+
+flip_base = resource_filename("flip", ".")
+data_path = os.path.join(flip_base, "data")
+
+sigmau_fiducial = 15.0
+sigmag_fiducial = 3.0
+
+r_array = np.linspace(10, 200, 100)
+mu_array = np.linspace(-1, 1, 100)
+
+r_reference = 10_000
+mu_reference = 0
+
+
+ktt, ptt = np.loadtxt(os.path.join(data_path, "power_spectrum_tt.txt"))
+kmt, pmt = np.loadtxt(os.path.join(data_path, "power_spectrum_mt.txt"))
+kmm, pmm = np.loadtxt(os.path.join(data_path, "power_spectrum_mm.txt"))
+
+
+power_spectrum_dict = {
+    "gg": [[kmm, pmm], [kmt, pmt], [ktt, ptt]],
+    "gv": [
+        [kmt, pmt * utils.Du(kmt, sigmau_fiducial)],
+        [ktt, ptt * utils.Du(kmt, sigmau_fiducial)],
+    ],
+    "vv": [[ktt, ptt * utils.Du(ktt, sigmau_fiducial) ** 2]],
+}
+
+
+correlation = contraction.Contraction.init_from_flip(
+    "adamsblake20",
+    "full",
+    power_spectrum_dict,
+    r_array,
+    mu_array,
+    r_reference,
+    mu_reference,
+    additional_parameters_values=(sigmag_fiducial,),
+    coordinate_type="rmu",
+    basis_definition="bisector",
+    number_worker=8,
+    hankel=True,
+    variant="nobeta",
+)
+
+
+parameter_dict = {
+    "fs8": 0.4,
+    "bs8": 1.8,
+}
+
+
+contraction_sum = correlation.compute_contraction_sum(parameter_dict)
+xi_vv_interp = RegularGridInterpolator(
+    (r_array, mu_array), contraction_sum["vv"], method="cubic"
+)
+xi_vg_interp = RegularGridInterpolator(
+    (r_array, mu_array), contraction_sum["gv"], method="cubic"
+)
+xi_gg_interp = RegularGridInterpolator(
+    (r_array, mu_array), contraction_sum["gg"], method="cubic"
+)

scripts/flip_compute_power_spectra.py

@@ -0,0 +1,50 @@
+from flip.power_spectra import generator
+
+power_spectrum_engine = "class_engine"
+
+power_spectrum_settings = {
+    "h": 0.6766,
+    "omega_b": 0.02242,
+    "omega_cdm": 0.11933,
+    "sigma8": 0.8102,
+    "n_s": 0.9665,
+}
+
+
+minimal_wavenumber = 0.0005
+maximal_wavenumber = 1.000
+number_points = 1000
+logspace = True
+redshift = 0.0
+
+# Can be changed by "growth_rate" (fsigma_8^fid normalization) or "no_normalization"
+# Here, it normalize by sigma_8^fid
+normalization_power_spectrum = "growth_amplitude"
+
+# If you want to add non linearity, what model to use
+power_spectrum_non_linear_model = "halofit"
+
+# Model used to compute matter and velocity divergence power spectra
+power_spectrum_model = "linearbel"
+
+save_path = "./"  # If not None, will save all calculated power spectra in this folder
+
+(
+    wavenumber,
+    power_spectrum_mm,
+    power_spectrum_mt,
+    power_spectrum_tt,
+    fiducial,
+) = generator.compute_power_spectra(
+    power_spectrum_engine,
+    power_spectrum_settings,
+    redshift,
+    minimal_wavenumber,
+    maximal_wavenumber,
+    number_points,
+    logspace=logspace,
+    normalization_power_spectrum=normalization_power_spectrum,
+    power_spectrum_non_linear_model=power_spectrum_non_linear_model,
+    power_spectrum_model=power_spectrum_model,
+    save_path=save_path,
+)

scripts/flip_fisher_forecast_velocity.py

@@ -0,0 +1,70 @@
+import os
+
+import numpy as np
+import pandas as pd
+from flip.covariance import covariance, fisher
+from pkg_resources import resource_filename
+
+from flip import data_vector, utils
+
+flip_base = resource_filename("flip", ".")
+data_path = os.path.join(flip_base, "data")
+
+### Load data
+sn_data = pd.read_parquet(os.path.join(data_path, "data_velocity.parquet"))
+
+coordinates_velocity = np.array([sn_data["ra"], sn_data["dec"], sn_data["rcom_zobs"]])
+
+data_velocity = sn_data.to_dict("list")
+for key in data_velocity.keys():
+    data_velocity[key] = np.array(data_velocity[key])
+data_velocity["velocity"] = data_velocity.pop("vpec")
+data_velocity["velocity_error"] = np.zeros_like(data_velocity["velocity"])
+
+data_velocity_object = data_vector.DirectVel(data_velocity)
+
+ktt, ptt = np.loadtxt(os.path.join(data_path, "power_spectrum_tt.txt"))
+kmt, pmt = np.loadtxt(os.path.join(data_path, "power_spectrum_mt.txt"))
+kmm, pmm = np.loadtxt(os.path.join(data_path, "power_spectrum_mm.txt"))
+
+sigmau_fiducial = 15
+
+power_spectrum_dict = {"vv": [[ktt, ptt * utils.Du(ktt, sigmau_fiducial) ** 2]]}
+
+### Compute covariance
+size_batch = 10_000
+number_worker = 16
+
+covariance_fit = covariance.CovMatrix.init_from_flip(
+    "carreres23",
+    "velocity",
+    power_spectrum_dict,
+    coordinates_velocity=coordinates_velocity,
+    size_batch=size_batch,
+    number_worker=number_worker,
+)
+
+
+### Load fitter
+
+fisher_properties = {
+    "inversion_method": "inverse",
+    "velocity_type": "scatter",
+}
+
+variant = None  # can be replaced by growth_index
+
+parameter_dict = {
+    "fs8": 0.4,
+    "sigv": 200,
+    "sigma_M": 0.12,
+}
+
+Fisher = fisher.FisherMatrix.init_from_covariance(
+    covariance_fit,
+    data_velocity_object,
+    parameter_dict,
+    fisher_properties=fisher_properties,
+)
+
+parameter_name_list, fisher_matrix = Fisher.compute_fisher_matrix()

scripts/flip_fisher_rcrk24.py

@@ -0,0 +1,164 @@
+import os
+
+import numpy as np
+import pandas as pd
+from flip.covariance import covariance, fisher
+from pkg_resources import resource_filename
+
+from flip import data_vector, utils
+
+
+def main(parameter_dict=None, variant="growth_rate"):
+    flip_base = resource_filename("flip", ".")
+    data_path = os.path.join(flip_base, "data")
+
+    ### Load data
+    sn_data = pd.read_parquet(os.path.join(data_path, "data_velocity.parquet"))
+
+    coordinates_velocity = np.array(
+        [sn_data["ra"], sn_data["dec"], sn_data["rcom_zobs"]]
+    )
+
+    data_velocity = sn_data.to_dict("list")
+    for key in data_velocity.keys():
+        data_velocity[key] = np.array(data_velocity[key])
+    data_velocity["velocity"] = data_velocity.pop("vpec")
+    data_velocity["velocity_error"] = np.zeros_like(data_velocity["velocity"])
+
+    data_velocity_object = data_vector.DirectVel(data_velocity)
+
+    ktt, ptt = np.loadtxt(os.path.join(data_path, "power_spectrum_tt.txt"))
+
+    sigmau_fiducial = 15
+
+    power_spectrum_dict = {"vv": [[ktt, ptt * utils.Du(ktt, sigmau_fiducial) ** 2]]}
+
+    size_batch = 10_000
+    number_worker = 16
+
+    covariance_fit = covariance.CovMatrix.init_from_flip(
+        "rcrk24",
+        "velocity",
+        power_spectrum_dict,
+        coordinates_velocity=coordinates_velocity,
+        size_batch=size_batch,
+        number_worker=number_worker,
+        variant=variant,
+    )
+
+    ### Load fitter
+
+    fisher_properties = {
+        "inversion_method": "inverse",
+        "velocity_type": "scatter",
+    }
+
+    Fisher = fisher.FisherMatrix.init_from_covariance(
+        covariance_fit,
+        data_velocity_object,
+        parameter_dict,
+        fisher_properties=fisher_properties,
+        covariance_prefactor_dict={"redshift_velocity": data_velocity["zobs"]},
+    )
+
+    parameter_name_list, fisher_matrix = Fisher.compute_fisher_matrix(
+        covariance_prefactor_dict={"redshift_velocity": np.array(data_velocity["zobs"])}
+    )
+    return parameter_name_list, fisher_matrix
+
+
+def lnD(a, parameter_values_dict):
+    f0 = parameter_values_dict["Om0"] ** parameter_values_dict["gamma"]
+    return np.log(a) * (
+        f0
+        + f0 * 3 * parameter_values_dict["gamma"] * (1 - parameter_values_dict["Om0"])
+    ) + (1 - a) * f0 * 3 * parameter_values_dict["gamma"] * (
+        1 - parameter_values_dict["Om0"]
+    )
+
+
+def dlnDdOm0(a, parameter_values_dict):
+    lna = np.log(a)
+    return (
+        parameter_values_dict["gamma"]
+        * parameter_values_dict["Om0"] ** (parameter_values_dict["gamma"] - 1)
+        * (
+            3
+            * parameter_values_dict["gamma"]
+            * (parameter_values_dict["Om0"] - 1)
+            * (a - lna - 1)
+            + 3 * (a - 1) * parameter_values_dict["Om0"]
+            - 3 * np.log(a) * parameter_values_dict["Om0"]
+            + lna
+        )
+    )
+
+
+def dlnDdgamma(a, parameter_values_dict):
+    lna = np.log(a)
+    f0 = parameter_values_dict["Om0"] ** parameter_values_dict["gamma"]
+    return f0 * (
+        np.log(parameter_values_dict["Om0"])
+        * (
+            3
+            * parameter_values_dict["gamma"]
+            * (parameter_values_dict["Om0"] - 1)
+            * (a - lna - 1)
+            + lna
+        )
+        + 3 * (parameter_values_dict["Om0"] - 1) * (a - lna - 1)
+    )
+
+
+if __name__ == "__main__":
+
+    # dictionary that describes the fiducial power spectrum
+    # should be specified by the
+    #
+    # parameters of the model
+    # s8 of the fiducial power spectrum
+    # z of the fiduccial power spectrum
+
+    # for now the dictionaries conflate the two models.
+    # Really should be for one model
+
+    parameter_dict = {
+        "gamma": 0.55,
+        "Om0": 0.3,
+        "s80": 0.832,
+        "fs8": 0.3**0.55 * 0.832,
+        "s8_cmb": 0.832 * 0.001176774706956903,
+        "sigv": 200,
+        "sigma_M": 0.12,
+    }
+
+    Om0_prior = 0.1
+
+    # growth index
+    parameter_name_list, fisher_matrix = main(
+        parameter_dict=parameter_dict, variant="growth_index"
+    )
+    cov = np.linalg.inv(fisher_matrix + np.array([[1 / Om0_prior**2, 0], [0, 0]]))
+    partials = parameter_dict["s80"] * np.array(
+        [
+            parameter_dict["gamma"]
+            * parameter_dict["Om0"] ** (parameter_dict["gamma"] - 1),
+            np.log(parameter_dict["Om0"])
+            * parameter_dict["Om0"] ** parameter_dict["gamma"],
+        ]
+    )
+    partials = partials + parameter_dict["Om0"] ** parameter_dict[
+        "gamma"
+    ] * parameter_dict["s80"] * np.array(
+        [dlnDdOm0(1.0, parameter_dict), dlnDdgamma(1.0, parameter_dict)]
+    )
+    print(
+        parameter_dict["Om0"] ** parameter_dict["gamma"] * parameter_dict["s80"],
+        np.sqrt(partials.T @ cov @ partials),
+    )
+
+    # growth rate
+    parameter_name_list, fisher_matrix = main(
+        parameter_dict=parameter_dict, variant="growth_rate"
+    )
+    print(parameter_dict["fs8"], 1 / np.sqrt(fisher_matrix))

scripts/flip_launch_minuit_density_fit.py

@@ -0,0 +1,91 @@
+import os
+
+import numpy as np
+import pandas as pd
+from flip.covariance import covariance, fitter
+from pkg_resources import resource_filename
+
+from flip import data_vector
+
+flip_base = resource_filename("flip", ".")
+data_path = os.path.join(flip_base, "data")
+
+### Load data
+grid = pd.read_parquet(os.path.join(data_path, "data_density.parquet"))
+grid_window = pd.read_parquet(os.path.join(data_path, "data_window_density.parquet"))
+
+coordinates_density = np.array([grid["ra"], grid["dec"], grid["rcom_zobs"]])
+data_density = {
+    "density": np.array(grid["density"]),
+    "density_error": np.array(grid["density_error"]),
+}
+
+data_density_object = data_vector.Dens(data_density)
+
+
+ktt, ptt = np.loadtxt(os.path.join(data_path, "power_spectrum_tt.txt"))
+kmt, pmt = np.loadtxt(os.path.join(data_path, "power_spectrum_mt.txt"))
+kmm, pmm = np.loadtxt(os.path.join(data_path, "power_spectrum_mm.txt"))
+
+sigmag_fiducial = 3.0
+
+
+power_spectrum_dict_bias = {
+    "gg": [[kmm, pmm * np.array(grid_window["window_mm"]) ** 2]]
+}
+power_spectrum_dict = {
+    "gg": [
+        [kmm, pmm * np.array(grid_window["window_mm"]) ** 2],
+        [kmt, pmt * np.array(grid_window["window_mt"])],
+        [ktt, ptt],
+    ]
+}
+
+
+### Compute covariance
+size_batch = 500_000
+number_worker = 8
+
+covariance_fit = covariance.CovMatrix.init_from_flip(
+    "adamsblake20",
+    "density",
+    power_spectrum_dict,
+    coordinates_density=coordinates_density,
+    size_batch=size_batch,
+    number_worker=number_worker,
+    additional_parameters_values=(sigmag_fiducial,),
+    variant="nobeta",
+)
+
+
+### Load fitter
+likelihood_type = "multivariate_gaussian"
+likelihood_properties = {"inversion_method": "cholesky_inverse"}
+
+parameter_dict = {
+    "bs8": {
+        "value": 1.0,
+        "limit_low": 0.0,
+        "limit_up": 3.0,
+        "fixed": False,
+    },
+    "fs8": {
+        "value": 0.4,
+        "limit_low": 0.0,
+        "limit_up": 1.0,
+        "fixed": False,
+    },
+}
+
+
+minuit_fitter = fitter.FitMinuit.init_from_covariance(
+    covariance_fit,
+    data_density_object,
+    parameter_dict,
+    likelihood_type=likelihood_type,
+    likelihood_properties=likelihood_properties,
+)
+
+
+### Fit
+minuit_fitter.run()