marius311 / cmblensing.jl Goto Github PK

View Code? Open in Web Editor NEW

52.0 12.0 10.0 315.16 MB

The automatically differentiable and GPU-compatible toolkit for CMB analysis.

Home Page: https://cosmicmar.com/CMBLensing.jl

License: Other

Julia 98.77% Dockerfile 1.23%

julia cmb bayesian physics cosmology automatic-differentiation gpu

cmblensing.jl's Issues

Fix EB constructor

FlatEBFourier(arr, arr, θpix=θpix)

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

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 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.

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

passing operators to `load_sim_dataset` is delicate on v0.2.1

passing M̂=1 or B=1 to load_sim_dataset causes dataset creation to fail, and passing L=Identity causes resimulate! to fail.

Figure out a way to get MyBinder working again

This used to work but the double whammy of recent Julia versions getting a little more memory-hungry when loading packages and MyBinder lowering their memory cap makes it so the kernel gets killed every time trying to using CMBLensing.

This yielded no help: https://discourse.julialang.org/t/is-there-a-way-cap-memory-usage-to-keep-mybinder-from-crashing/32325

So try and think of something else...

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.

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"?

Give argmaxf_lnP a more reasonable default tolerance

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

Recent AD woes

Figure out what about ChainRules 1.0 broke AD https://github.com/marius311/CMBLensing.jl/runs/3303656637#step:6:750
Figure out why this takes forever @time gradient(f -> norm(unmix(f,ϕ,(;),ds)[1]), f) (or merge PPL which seems unaffected)

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

Recommend Projects

React

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

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

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

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
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.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

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

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.

marius311 / cmblensing.jl Goto Github PK

cmblensing.jl's Issues

Fix EB constructor

Before tagging 0.7

Bug loading CAMB Cls

support non-zero EB/TB covariance

Make Nside a tuple by default

passing operators to `load_sim_dataset` is delicate on v0.2.1

Figure out a way to get MyBinder working again

Support non-square flat-sky maps

Plots.jl recipes

Give argmaxf_lnP a more reasonable default tolerance

Gradient with respect to r gives error

Recent AD woes

TagBot trigger issue

Document that MKL should be used

Support for nightly

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	# 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