Calling Julia and CMBLensing.jl directly from Python is very transparent. This is made possible by the PyJulia package. You can install it into your Python environment with, e.g.:
$ pip install --user julia
Important: If your Python executable is statically-linked (this is quite often the case, e.g. its the default on Ubuntu and Conda) you need one extra step. Basically, instead of running
ipython at the command line to launch your interpreter, run
python-jl -m IPython, respectively. If you use Jupyter, you'll need to edit your
kernel.json file (you can find its location via
jupyter kernelspec list) and change it to use
The wrapper script
python-jl does some special initializion but otherwise drops you into the Python/IPython interpreter that you are familiar with.
The PyJulia docs also give instructions on how to install a dynamically-linked Python executable which is the most ideal solution, and only slightly more work than above.
Once PyJulia is installed, you can access any Julia package
Foo from the Python package
julia.Foo, and everything pretty much works the same.
julia.Base.cos(1) # <--- this is Julia's cosine function
You can also run arbitrary Julia code with the
%julia cell magic (this is helpful if you want to use Julia language features or syntax which don't exist in Python):
Initializing Julia interpreter. This may take some time...
1:10 is not valid Python syntax, but we can do:
The cell magic lets you interpolate values from Python into the Julia expression, which can be a convenient way to pass values back and forth:
x = %julia 1 + 2
%julia 2 * $x
The most robust way to call CMBLensing.jl from Python is just to wrap everything in Julia magic and interpolate things back and forth as-needed. Lets try and follow the Lensing a flat-sky map example from Python. First, we load the package:
%%julia using CMBLensing
Next, we simulate some data:
%%julia @unpack f,ϕ = load_sim( θpix = 2, Nside = 256, T = Float32, pol = :I );
Similarly, the rest of the commands from that example will work in Python if just called via Julia magic.
At any point, you can do whatever you'd like with any of the results stored in Julia variables, e.g. transferring the simulated maps back as Python arrays,
f = %julia f[:Ix] f
array([[ 83.1514 , 23.623978 , -42.170746 , ..., 115.40506 , 129.26775 , 122.00488 ], [ 50.508858 , -9.879875 , -67.244064 , ..., 88.794785 , 101.036896 , 91.63074 ], [ 14.685867 , -42.260757 , -91.37895 , ..., 58.16095 , 67.700645 , 56.849426 ], ..., [ 97.74786 , 55.47443 , 16.993637 , ..., 181.1901 , 167.52165 , 137.82213 ], [ 99.95541 , 50.42902 , -1.9884338, ..., 163.58401 , 160.40869 , 140.06123 ], [ 98.6102 , 42.169704 , -20.451847 , ..., 140.11429 , 149.05315 , 137.11221 ]], dtype=float32)
You can also pass variables back to Julia, e.g.
%julia g = FlatMap($f);
You can also call Julia directly without magic, which sometimes offers more flexibility, although has some limitations.
To do so, first import CMBLensing. into Python. In Julia,
using CMBLensing imports all of the CMBLensing symbols into the current namespace. In Python this is:
from julia.CMBLensing import *
If we want to call
load_sim as before, we must take into account a few things:
- You won't be able to use the
@unpackmacro since macros on arbitrary code don't exist in Python.
Float32isn't imported into Python by default, so you'll need to specify the module.
:Pis invalid syntax in Python, you should use a string
Given all of that, the call will look like:
sim = load_sim( θpix = 2, Nside = 256, T = julia.Base.Float32, pol = "P" )
If we wish to grab the lensing potential from the result, there's an additional consideration. Python does not differentiate between the characters
ϕ (\phi) and
φ (\varphi), and maps both of them back to
φ (\varphi) in Julia, which unfortunately is the wrong one for CMBLensing (which instead makes extensive use of the variable name
ϕ (\phi)). Thus, calling
sim.ϕ from Python does not work. Instead, we have to do that part in Julia:
ϕ = %julia $sim.ϕ
To plot, we need to use the plot function from Julia's PyPlot, since this will know about plotting CMBLensing objects.
from julia.PyPlot import plot
For non-CMBLensing objects, this plot function will just pass-through to matplotlib, so will not affect affect your session otherwise.