Giter Club home page Giter Club logo

cmblensing.jl's Introduction

CMBLensing.jl

Gitter

Binder

CMBLensing.jl is a next-generation tool for analysis of the lensed Cosmic Microwave Background. It is written in Julia and transparently callable from Python.

At its heart, CMBLensing.jl maximizes, samples, or performs MUSE inference on the Bayesian posterior for the CMB lensing problem. It also contains tools to quickly manipulate and process CMB maps, set up modified posteriors with a probabilistic programming language, and take gradients using automatic differentiation.

Highlights

  • Fully Nvidia GPU compatible (1-2 orders of magnitude speedups over CPU, depending on the problem size and hardware).
  • Automatic differentiation (via Zygote.jl) provides for-free gradients of your custom posteriors.
  • Includes the following algorithms to lense a map:
  • Maximize and sample $\mathcal{P}(f,\phi,\theta,|,d)$, the joint maximum a posteriori estimate of the lensing potential, $\phi$, the temperature and/or polarization fields, $f$, and cosmological parameters, $\theta$ (Millea, Anderes, & Wandelt 2017, Millea, Anderes, & Wandelt 2020)
  • Maximize $\mathcal{P}(\phi,|,d,\theta)$, i.e. the marginal maximum a posteriori estimate of the lensing potential, $\phi$, at fixed cosmological parameters, $\theta$ (Carron & Lewis 2017)
  • Compute MUSE inferences of bandpowers of $\phi$ and unlensed $f$ via MuseInference.jl (Millea & Seljak, 2021).
  • Do basic quadratic estimation of $\phi$ (Hu & Okamoto 2003)

Documentation

The best place to get started is to read the documentation (which is a work-in-progress, but contains many useful examples).

Most of the pages in the documentation are Jupyter notebooks, and you can click the "launch binder" link at the top of each page to launch a Jupyterlab server running the notebook in your browser (courtesy of binder).

You can also clone the repository and open the notebooks in docs/src if you want to run them locally (which will usually lead to higher performance). The notebooks are stored as .md files rather than .ipynb format. Its recommended to install Jupytext (pip install jupytext) and then you can run these .md directly from Jupyterlab by right-clicking on them and selecting Open With -> Notebook. Otherwise, run the script docs/make_notebooks.sh to convert the .md files to .ipynb which you can then open as desired.

Installation

Requirements

  • Julia 1.8+
  • (recommended) An Nvidia GPU and CUDA.jl for GPU support
  • (recommended) Python 3 + matplotlib (used for plotting)
  • (recommended) pycamb to generate $C_\ell$'s (run pip install --user camb)
  • (recommended) JuliaMono font to ensure characters like f̃, ϕ, ∇, ℓ, etc... are rendered correctly

Native installation

To install the Julia package locally, run:

pkg> add CMBLensing

(type ] at the Julia REPL to reach the pkg> prompt)

(recommended) After installing, switch your Julia to use Intel MKL FFT libraries, which provide significantly faster FFTs when running on CPU. You can do so by running using CMBLensing.FFTW; FFTW.set_provider!("mkl") from the same environment in which you added CMBLensing. This only needs to be done once per-environment (see also here).

Docker installation

Also provided is a Docker container which includes a Jupyterlab server and all the recommended and optional dependencies to run and use CMBLensing.jl. Launch this container with:

git clone https://github.com/marius311/CMBLensing.jl.git
cd CMBLensing.jl
docker-compose pull main
docker-compose up main

The first time you run this, it will automatically download the (~1Gb) container from the Docker hub. The command will prompt you with the URL which you should open in a browser to access the notebook.

To run the notebook on a different port than the default 8888, do PORT=1234 docker-compose up main where 1234 is whatever port number you want.

You can also build the container locally by replacing docker-compose pull main with docker-compose build main.

cmblensing.jl's People

Contributors

cailmdaley avatar ethananderes avatar github-actions[bot] avatar juliatagbot avatar kimmywu avatar marius311 avatar rafaelarutjunjan avatar timholy avatar tsfloss avatar zhenpan avatar

Stargazers

avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar

Watchers

avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar avatar

Forkers

juliatagbot carlosal1015 chunyul3 gitter-badger rafaelarutjunjan ethananderes yuheng-guo tsfloss jaimerzp ashishxjha

cmblensing.jl's Issues

Support non-square flat-sky maps

I think the right (and also easiest) path is to have the Nside parameter in abstract type Flat{Nside,θpix,∂mode<:∂modes,D} <: Pix end just be a tuple of (Nx,Ny). This doesn't require changing any types. Then its just:

  • Update FFT planning to reflect rectangular maps
  • Have fieldinfo also return Nx and Ny keys which it unpacks out of Nside for you.
  • Search the code for references of Nside and make sure it makes sense.

One thing to decide is whether to still allow scalar Nside, which would imply a square map. This would make this change backwards compatible.

Gradient with respect to r gives error

When trying to compute the gradient of the logpdf with respect to r (A\phi works just fine), I get and error.
This problem then propagates to the sample_joint function as well.

e.g.:

(;f, f̃, ϕ, ds) = load_sim(
    seed = 2,
    storage=CuArray,
    fiducial_θ = (Aϕ=1.,r=0.04),
    μKarcminT=1., ℓknee=100., αknee = 3.,
    θpix = 2.,
    T = Float32,
    Nside = 256,
    pol = :IP,
    beamFWHM = 2.,
    bandpass_mask = LowPass(5000),
    pixel_mask_kwargs = (;apodization_deg=0.6,edge_padding_deg=0.4,num_ptsrcs=0)
)

(;Cf, Cϕ) = ds;

gradient(r -> logpdf(ds; f, ϕ, θ=(;r)), .05)

results in and error:

CanonicalIndexError: getindex not defined for BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}

Stacktrace:
  [1] error_if_canonical_getindex(::IndexCartesian, ::BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, ::Int64, ::Int64)
    @ Base ./abstractarray.jl:1313
  [2] getindex
    @ ./abstractarray.jl:1293 [inlined]
  [3] _getindex
    @ ./abstractarray.jl:1344 [inlined]
  [4] getindex
    @ ./abstractarray.jl:1294 [inlined]
  [5] iterate
    @ ./abstractarray.jl:1220 [inlined]
  [6] iterate
    @ ./abstractarray.jl:1218 [inlined]
  [7] dot(x::ChainRulesCore.Tangent{Any, NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Any, 2, Matrix{Any}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, y::BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}})
    @ LinearAlgebra /cvmfs/hpc.rug.nl/versions/2023.01/rocky8/x86_64/amd/zen3/software/Julia/1.9.2-linux-x86_64/share/julia/stdlib/v1.9/LinearAlgebra/src/generic.jl:849
  [8] (::ChainRules.var"#1499#1503"{ChainRulesCore.Tangent{Any, NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Any, 2, Matrix{Any}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, ChainRulesCore.ProjectTo{Float32, NamedTuple{(), Tuple{}}}})()
    @ ChainRules ~/.julia/packages/ChainRules/nnaVO/src/rulesets/Base/arraymath.jl:108
  [9] unthunk
    @ ~/.julia/packages/ChainRulesCore/0t04l/src/tangent_types/thunks.jl:204 [inlined]
 [10] wrap_chainrules_output
    @ ~/.julia/packages/Zygote/XJ8pP/src/compiler/chainrules.jl:110 [inlined]
 [11] map(f::typeof(Zygote.wrap_chainrules_output), t::Tuple{ChainRulesCore.NoTangent, ChainRulesCore.Thunk{ChainRules.var"#1499#1503"{ChainRulesCore.Tangent{Any, NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Any, 2, Matrix{Any}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, ChainRulesCore.ProjectTo{Float32, NamedTuple{(), Tuple{}}}}}, ChainRulesCore.InplaceableThunk{ChainRulesCore.Thunk{ChainRules.var"#1501#1505"{ChainRulesCore.Tangent{Any, NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Any, 2, Matrix{Any}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, Float32, ChainRulesCore.ProjectTo{BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, NamedTuple{(), Tuple{}}}}}, ChainRules.var"#1500#1504"{ChainRulesCore.Tangent{Any, NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Any, 2, Matrix{Any}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, Float32}}})
    @ Base ./tuple.jl:275
 [12] wrap_chainrules_output
    @ ~/.julia/packages/Zygote/XJ8pP/src/compiler/chainrules.jl:111 [inlined]
 [13] ZBack
    @ ~/.julia/packages/Zygote/XJ8pP/src/compiler/chainrules.jl:211 [inlined]
 [14] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/dataset.jl:273 [inlined]
 [15] (::Zygote.Pullback{Tuple{CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, Float64, Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}}, CMBLensing.var"#847#861"{CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, Float32}}, Tuple{Zygote.ZBack{Zygote.var"#Real_pullback#332"}, Zygote.ZBack{ChainRules.var"#times_pullback#1502"{Float32, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, ChainRulesCore.ProjectTo{BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, NamedTuple{(), Tuple{}}}, ChainRulesCore.ProjectTo{Float32, NamedTuple{(), Tuple{}}}}}, Zygote.var"#3621#back#1098"{Zygote.var"#1094#1097"}, Zygote.ZBack{ChainRules.var"#/_pullback#1340"{Float32, Float32, ChainRulesCore.ProjectTo{Float32, NamedTuple{(), Tuple{}}}, ChainRulesCore.ProjectTo{Float32, NamedTuple{(), Tuple{}}}}}, Zygote.var"#2184#back#303"{Zygote.var"#back#302"{:r₀, Zygote.Context{false}, CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, Float32}}, Zygote.var"#2184#back#303"{Zygote.var"#back#302"{:Cft, Zygote.Context{false}, CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}}}, Zygote.var"#2184#back#303"{Zygote.var"#back#302"{:T, Zygote.Context{false}, CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, DataType}}, Zygote.var"#2184#back#303"{Zygote.var"#back#302"{:Cfs, Zygote.Context{false}, CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}}}}})(Δ::NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Union{Nothing, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}, 2, Matrix{Union{Nothing, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}})
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [16] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/dataset.jl:273 [inlined]
 [17] (::Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:r,), Tuple{Float64}}, CMBLensing.var"#847#861"{CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, Float32}}, Any})(Δ::NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Union{Nothing, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}, 2, Matrix{Union{Nothing, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}})
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [18] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/specialops.jl:315 [inlined]
 [19] (::Zygote.Pullback{Tuple{ParamDependentOp{Float32, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, CMBLensing.var"#847#861"{CMBLensing.var"#847#848#862"{DataType, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, BlockDiagIEB{ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}, Diagonal{Float32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, Float32, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}}}, Float32}, Float32}}, NamedTuple{(:r,), Tuple{Float64}}}, Any})(Δ::NamedTuple{(:ΣTE, :ΣB), Tuple{StaticArraysCore.SizedMatrix{2, 2, Union{Nothing, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}, 2, Matrix{Union{Nothing, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}, Diagonal{ComplexF32, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}})
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [20] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/dataset.jl:61 [inlined]
 [21] (::Zygote.Pullback{Tuple{CMBLensing.var"##_#834", BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}, BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseDataSet, CMBLensing.Logpdf, Base.RefValue{Real}}, Any})(Δ::Nothing)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [22] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/dataset.jl:59 [inlined]
 [23] (::Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, BaseDataSet, CMBLensing.Logpdf, Base.RefValue{Real}}, Any})(Δ::Nothing)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [24] #291
    @ ~/.julia/packages/Zygote/XJ8pP/src/lib/lib.jl:206 [inlined]
 [25] (::Zygote.var"#2173#back#293"{Zygote.var"#291#292"{Tuple{NTuple{4, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, BaseDataSet, CMBLensing.Logpdf, Base.RefValue{Real}}, Any}}})(Δ::Nothing)
    @ Zygote ~/.julia/packages/ZygoteRules/OgCVT/src/adjoint.jl:71
 [26] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/simpleppl.jl:96 [inlined]
 [27] (::Zygote.Pullback{Tuple{CMBLensing.var"##loglikelihood#814", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, typeof(StatsAPI.loglikelihood), BaseDataSet}, Any})(Δ::Float32)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [28] #291
    @ ~/.julia/packages/Zygote/XJ8pP/src/lib/lib.jl:206 [inlined]
 [29] #2173#back
    @ ~/.julia/packages/ZygoteRules/OgCVT/src/adjoint.jl:71 [inlined]
 [30] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/simpleppl.jl:94 [inlined]
 [31] (::Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, typeof(StatsAPI.loglikelihood), BaseDataSet}, Tuple{Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.var"#2173#back#293"{Zygote.var"#291#292"{Tuple{Tuple{Nothing, Nothing, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{CMBLensing.var"##loglikelihood#814", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, typeof(StatsAPI.loglikelihood), BaseDataSet}, Any}}}, Zygote.var"#2370#back#419"{Zygote.var"#pairs_namedtuple_pullback#418"{(:f, :ϕ, :θ), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}}}})(Δ::Float32)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [32] #291
    @ ~/.julia/packages/Zygote/XJ8pP/src/lib/lib.jl:206 [inlined]
 [33] (::Zygote.var"#2173#back#293"{Zygote.var"#291#292"{Tuple{Tuple{Nothing, Nothing, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, typeof(StatsAPI.loglikelihood), BaseDataSet}, Tuple{Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.var"#2173#back#293"{Zygote.var"#291#292"{Tuple{Tuple{Nothing, Nothing, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{CMBLensing.var"##loglikelihood#814", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, typeof(StatsAPI.loglikelihood), BaseDataSet}, Any}}}, Zygote.var"#2370#back#419"{Zygote.var"#pairs_namedtuple_pullback#418"{(:f, :ϕ, :θ), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}}}}}})(Δ::Float32)
    @ Zygote ~/.julia/packages/ZygoteRules/OgCVT/src/adjoint.jl:71
 [34] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/simpleppl.jl:100 [inlined]
 [35] (::Zygote.Pullback{Tuple{CMBLensing.var"##logpdf#815", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, typeof(logpdf), BaseDataSet}, Any})(Δ::Float32)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [36] #291
    @ ~/.julia/packages/Zygote/XJ8pP/src/lib/lib.jl:206 [inlined]
 [37] #2173#back
    @ ~/.julia/packages/ZygoteRules/OgCVT/src/adjoint.jl:71 [inlined]
 [38] Pullback
    @ ~/PhD/CMB-delensing/CMBLensing.jl/src/simpleppl.jl:99 [inlined]
 [39] (::Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, typeof(logpdf), BaseDataSet}, Tuple{Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.var"#2173#back#293"{Zygote.var"#291#292"{Tuple{Tuple{Nothing, Nothing, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{CMBLensing.var"##logpdf#815", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, typeof(logpdf), BaseDataSet}, Any}}}, Zygote.var"#2370#back#419"{Zygote.var"#pairs_namedtuple_pullback#418"{(:f, :ϕ, :θ), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}}}})(Δ::Float32)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [40] Pullback
    @ ./In[14]:17 [inlined]
 [41] (::Zygote.Pullback{Tuple{var"#3#4", Float64}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:f, :ϕ, :θ)}}, Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, Tuple{Zygote.var"#2224#back#315"{Zygote.Jnew{NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, Nothing, true}}}}}}, Zygote.var"#1990#back#194"{Zygote.var"#190#193"{Zygote.Context{false}, GlobalRef, BaseDataSet}}, Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.Pullback{Tuple{Type{NamedTuple{(:r,)}}, Tuple{Float64}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:r,), Tuple{Float64}}}, Tuple{Float64}}, Tuple{Zygote.var"#2224#back#315"{Zygote.Jnew{NamedTuple{(:r,), Tuple{Float64}}, Nothing, true}}}}}}, Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, typeof(logpdf), BaseDataSet}, Tuple{Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.var"#2173#back#293"{Zygote.var"#291#292"{Tuple{Tuple{Nothing, Nothing, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{CMBLensing.var"##logpdf#815", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, typeof(logpdf), BaseDataSet}, Any}}}, Zygote.var"#2370#back#419"{Zygote.var"#pairs_namedtuple_pullback#418"{(:f, :ϕ, :θ), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}}}}, Zygote.var"#1990#back#194"{Zygote.var"#190#193"{Zygote.Context{false}, GlobalRef, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}}}, Zygote.var"#1990#back#194"{Zygote.var"#190#193"{Zygote.Context{false}, GlobalRef, BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}})(Δ::Float32)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface2.jl:0
 [42] (::Zygote.var"#75#76"{Zygote.Pullback{Tuple{var"#3#4", Float64}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:f, :ϕ, :θ)}}, Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, Tuple{Zygote.var"#2224#back#315"{Zygote.Jnew{NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, Nothing, true}}}}}}, Zygote.var"#1990#back#194"{Zygote.var"#190#193"{Zygote.Context{false}, GlobalRef, BaseDataSet}}, Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.Pullback{Tuple{Type{NamedTuple{(:r,)}}, Tuple{Float64}}, Tuple{Zygote.Pullback{Tuple{Type{NamedTuple{(:r,), Tuple{Float64}}}, Tuple{Float64}}, Tuple{Zygote.var"#2224#back#315"{Zygote.Jnew{NamedTuple{(:r,), Tuple{Float64}}, Nothing, true}}}}}}, Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.Pullback{Tuple{typeof(Core.kwcall), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}, typeof(logpdf), BaseDataSet}, Tuple{Zygote.var"#2017#back#204"{typeof(identity)}, Zygote.var"#2173#back#293"{Zygote.var"#291#292"{Tuple{Tuple{Nothing, Nothing, Nothing}, Tuple{}}, Zygote.Pullback{Tuple{CMBLensing.var"##logpdf#815", Base.Pairs{Symbol, Any, Tuple{Symbol, Symbol, Symbol}, NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}, typeof(logpdf), BaseDataSet}, Any}}}, Zygote.var"#2370#back#419"{Zygote.var"#pairs_namedtuple_pullback#418"{(:f, :ϕ, :θ), NamedTuple{(:f, :ϕ, :θ), Tuple{BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}, NamedTuple{(:r,), Tuple{Float64}}}}}}}}, Zygote.var"#1990#back#194"{Zygote.var"#190#193"{Zygote.Context{false}, GlobalRef, BaseField{Fourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 2, CUDA.Mem.DeviceBuffer}}}}, Zygote.var"#1990#back#194"{Zygote.var"#190#193"{Zygote.Context{false}, GlobalRef, BaseField{IEBFourier, ProjLambert{Float32, CuArray{Float32, 1, CUDA.Mem.DeviceBuffer}, CuArray{Float32, 2, CUDA.Mem.DeviceBuffer}}, ComplexF32, CuArray{ComplexF32, 3, CUDA.Mem.DeviceBuffer}}}}}}})(Δ::Float32)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface.jl:45
 [43] gradient(f::Function, args::Float64)
    @ Zygote ~/.julia/packages/Zygote/XJ8pP/src/compiler/interface.jl:97
 [44] top-level scope
    @ In[14]:17

Before tagging 0.7

  • Scalar indexing error when printing Diagonal{<:CuArray}
  • Fields not printing type right sometimes?
  • Test serialization and upgrade JLD2 dep
  • Fix Images dep

TagBot trigger issue

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

Plots.jl recipes

Would be nice to add plot recipes for FlatField, FieldTuple, InterpolatedCℓs, etc. Currently I have these two recipes kicking around:

@recipe function f(m::FlatMap)
	    seriestype   :=  :heatmap
	    seriescolor  --> :vik
	    aspect_ratio --> :equal
	    axis --> false
	    grid --> false
	    size --> (500, 450)
	    clims --> (-maximum(abs.(m)), maximum(abs.(m)))
	    m[:Ix]
end

@recipe function f(Cℓ::InterpolatedCℓs, ℓrange::AbstractVector = 1:5000)
	    xguide --> L"\ell"
	    ℓrange, Cℓ.(ℓrange)
end

Happy to add this in myself, but wanted to discuss a little bit first. Do we want the plot recipes to exactly replicate the PyPlot functionality in plotting.jl? Because of Plots.jl's frontend/backend approach, this might be pretty hard / impossible. I get the sense that PyPlot.jl is more customizable and verbose, so maybe it makes sense for the Plots.jl recipes to provide "quick and dirty" plotting functionality, while the current PyPlot.jl functions you've written could be more "production quality"?

support non-zero EB/TB covariance

CMBLensing currently doesn't support non-zero EB/TB covariance in its signal/noise covariance construction. See

CMBLensing.jl/src/flat_s0s2.jl

Lines 73 to 84 in 292bcea

# A Flat TEB covariance of the form:
#
# [ΣTT ΣTE ⋅
# ΣTE ΣEE ⋅
# ⋅ ⋅ ΣBB]
#
# We store the 2x2 block as a 2x2 SMatrix, ΣTE, so that we can easily call sqrt/inv on
# it, and the ΣBB block separately as ΣB.
struct FlatIEBCov{T,F} <: ImplicitOp{IEBFourier,S02,Pix}
ΣTE :: SMatrix{2,2,Diagonal{T,F},4}
ΣB :: Diagonal{T,F}
end

Would be good to add that feature to allow modeling of correlated EB/TB noise/signal. I haven't thought through all the details of how to implement this yet. So this is a reminder.

Bug loading CAMB Cls

Hi,

I was playing around with CMBLensing.jl and I have found a bug in the 'load_camb_Cls()' function.

If you do try to read some CAMB file and you enter in the 'else' clause of the 'custom_tensor_params != nothing' condition (starting at line 221 on CMBLensing.jl/cls.jl), you would find that neither the 'tensor_filename' or 'r' variables have been previously defined, raising you an error that kills the code.

Maybe you meant to use 'unlensed_tensor_filename' (defined at line 197) instead of 'tensor_filename'?

Support for nightly

I'm willing to work on https://discourse.julialang.org/t/help-building-mwe-for-1-8-latency-regression/84796, but the package currently struggles on nightly (which is where all fixes to Julia occur). Would someone be willing to get it working, and then I can take it from there?

Current error:

  ✗ CMBLensing
  124 dependencies successfully precompiled in 79 seconds. 62 already precompiled.

ERROR: The following 1 direct dependency failed to precompile:

CMBLensing [b60c06c0-7e54-11e8-3788-4bd722d65317]

Failed to precompile CMBLensing [b60c06c0-7e54-11e8-3788-4bd722d65317] to /home/tim/.julia/compiled/v1.9/CMBLensing/jl_4JRAiB.
ERROR: LoadError: MethodError: no method matching _truncate_at_width_or_chars(::String, ::Int64)

Closest candidates are:
  _truncate_at_width_or_chars(::Bool, ::Any, ::Any)
   @ Base show.jl:79
  _truncate_at_width_or_chars(::Bool, ::Any, ::Any, ::Any)
   @ Base show.jl:79
  _truncate_at_width_or_chars(::Bool, ::Any, ::Any, ::Any, ::Any)
   @ Base show.jl:79

Stacktrace:
  [1] var"@⌛"(__source__::LineNumberNode, __module__::Module, args::Vararg{Any})
    @ CMBLensing ~/.julia/dev/CMBLensing/src/util.jl:416
  [2] #macroexpand#61
    @ ./expr.jl:119 [inlined]
  [3] macroexpand
    @ ./expr.jl:117 [inlined]
  [4] docm(source::LineNumberNode, mod::Module, meta::Any, ex::Any, define::Bool) (repeats 2 times)
    @ Base.Docs ./docs/Docs.jl:538
  [5] (::DocStringExtensions.var"#35#36"{typeof(DocStringExtensions.template_hook)})(::LineNumberNode, ::Vararg{Any})
    @ DocStringExtensions ~/.julia/packages/DocStringExtensions/fF54E/src/templates.jl:11
  [6] var"@doc"(__source__::LineNumberNode, __module__::Module, x::Vararg{Any})
    @ Core ./boot.jl:534
  [7] include(mod::Module, _path::String)
    @ Base ./Base.jl:434
  [8] include(x::String)
    @ CMBLensing ~/.julia/dev/CMBLensing/src/CMBLensing.jl:2
  [9] top-level scope
    @ ~/.julia/dev/CMBLensing/src/CMBLensing.jl:110
 [10] include
    @ ./Base.jl:434 [inlined]
 [11] include_package_for_output(pkg::Base.PkgId, input::String, depot_path::Vector{String}, dl_load_path::Vector{String}, load_path::Vector{String}, concrete_deps::Vector{Pair{Base.PkgId, UInt64}}, source::Nothing)
    @ Base ./loading.jl:1617
 [12] top-level scope
    @ stdin:1
in expression starting at /home/tim/.julia/dev/CMBLensing/src/numerical_algorithms.jl:51
in expression starting at /home/tim/.julia/dev/CMBLensing/src/numerical_algorithms.jl:51
in expression starting at /home/tim/.julia/dev/CMBLensing/src/CMBLensing.jl:2
in expression starting at stdin:1

julia> methods(Base._truncate_at_width_or_chars)
# 3 methods for generic function "_truncate_at_width_or_chars" from Base:
 [1] _truncate_at_width_or_chars(ignore_ansi::Bool, str, width)
     @ show.jl:79
 [2] _truncate_at_width_or_chars(ignore_ansi::Bool, str, width, chars)
     @ show.jl:79
 [3] _truncate_at_width_or_chars(ignore_ansi::Bool, str, width, chars, truncmark)
     @ show.jl:79

xref JuliaLang/julia#37568 for the change that might have broken your package. (Which is a fine change since it's an internal method.)

Make Nside a tuple by default

Currently Nside=4 and Nside=(4,4) don't broadcast together; a possible solution would be to always convert Nside to a tuple. @marius311 suggested

Flat(;Nside, θpix=θpix₀, ∂mode=fourier∂, D=1) = Flat{Nside .* (1,1), θpix, ∂mode, D}

in flat_fftgrid.jl

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo D3

    Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

  • javascript

    JavaScript (JS) is a lightweight interpreted programming language with first-class functions.

  • web

    Some thing interesting about web. New door for the world.

  • server

    A server is a program made to process requests and deliver data to clients.

  • Machine learning

    Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google ❤️ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.