# Global surface emission¶

Let’s explore simulation of signals generated by surface radiation fields that globally span the star.

We will also perform weak internal cross-checking of integrators that are algorithmically distinct in their discretisation of the computational domain. For instance, regular discretisation can be performed: (i) on a spacelike 2-surface embedded in an ambient Schwarzschild spacetime, yielding a *moving* mesh (between temporal hyperslices of the spacetime foliation) that tracks modes of radiative asymmetry; (ii) on a spacelike 2-surface embedded in an ambient Schwarzschild spacetime, yielding a
static mesh that does *not* move (between temporal hyperslices of the spacetime foliation) but plasma and modes of radiative asymmetry to flow through it; and (iii) on a distant image-plane through which radiation flows normally en route to some effectively asymptotic receiver.

The unexecuted notebook for this tutorial may be found in a GitHub repository:

```
git clone https://github.com/ThomasEdwardRiley/xpsi_workshop.git </path/to/clone>
cd </path/to/clone>/tutorials/v0.6/
```

You can use the default atmosphere extension module `xpsi/surface_radiation_field/archive/hot/blackbody.pyx`

as described below. To run this tutorial, you should therefore be able to simply use the default `xpsi/surface_radiation_field/hot.pyx`

extension that is automatically compiled when X-PSI is installed. However, you’ll have to switch the contents of the `xpsi/surface_radiation_field/local_variables.pyx`

extension, as instructed below, in order to change the mapping from global
variables to local variables.

```
[1]:
```

```
%matplotlib inline
from __future__ import print_function, division
import os
import numpy as np
import math
from matplotlib import pyplot as plt
from matplotlib import rcParams
from matplotlib.ticker import MultipleLocator, AutoLocator, AutoMinorLocator
from matplotlib import gridspec
from matplotlib import cm
from IPython.display import Image
import xpsi
from xpsi import Parameter
from xpsi.global_imports import _c, _G, _dpr, gravradius, _csq, _km, _2pi
```

```
/=============================================\
| X-PSI: X-ray Pulse Simulation and Inference |
|---------------------------------------------|
| Version: 0.7.0 |
|---------------------------------------------|
| https://thomasedwardriley.github.io/xpsi/ |
\=============================================/
Imported GetDist version: 0.3.1
Imported nestcheck version: 0.2.0
```

First we need to do some setup of the ambient spacetime and the surface embedded in it that the photosphere exists on.

```
[2]:
```

```
bounds = dict(distance = (0.1, 1.0), # (Earth) distance
mass = (1.0, 3.0), # mass
radius = (3.0 * gravradius(1.0), 16.0), # equatorial radius
cos_inclination = (0.0, 1.0)) # (Earth) inclination to rotation axis
spacetime = xpsi.Spacetime(bounds=bounds, values=dict(frequency=600.0))
```

```
Creating parameter:
> Named "frequency" with fixed value 6.000e+02.
> Spin frequency [Hz].
Creating parameter:
> Named "mass" with bounds [1.000e+00, 3.000e+00].
> Gravitational mass [solar masses].
Creating parameter:
> Named "radius" with bounds [4.430e+00, 1.600e+01].
> Coordinate equatorial radius [km].
Creating parameter:
> Named "distance" with bounds [1.000e-01, 1.000e+00].
> Earth distance [kpc].
Creating parameter:
> Named "cos_inclination" with bounds [0.000e+00, 1.000e+00].
> Cosine of Earth inclination to rotation axis.
```

## Default (phase-invariant)¶

First we invoke a globally uniform temperature field. There is no azimuthal dependence, meaning that the signal generated by the star is time-invariant. We are in need of an object that embeds a *globally* discretised surface into the ambient spacetime and exposes methods for integration over solid angle on our sky.

```
[3]:
```

```
bounds = dict(temperature = (None, None))
everywhere = xpsi.Everywhere(time_invariant=True,
bounds=bounds,
values={}, # no fixed/derived variables
sqrt_num_cells=512,
num_rays=512,
num_leaves=512,
num_phases=100) # specify leaves if time-dependent
```

```
Creating parameter:
> Named "temperature" with bounds [3.000e+00, 7.000e+00].
> log10(effective temperature [K] everywhere).
```

We are free to subclass Everywhere and implement custom functionality beyond the simple default above. The argument specifying the number of rays has the familiar meaning. The argument for the number of cells is now used to discretise the surface in azimuth and colatitude with respect to the stellar rotation axis, as was the case for the Elsewhere module. The new argument `time_invariant`

declares
whether or not the surface radiation field is dependent on azimuth; if it is independent of azimuth, a faster integrator is called.

Now we need an instance of Photosphere that we can feed our `everywhere`

object to. If we are not imaging the photosphere or we are satisfied with the default behaviour we do *not* need to subclass Photosphere.

```
[4]:
```

```
photosphere = xpsi.Photosphere(hot = None, elsewhere = None, everywhere = everywhere,
values=dict(mode_frequency = spacetime['frequency']))
```

```
Creating parameter:
> Named "mode_frequency" with fixed value 6.000e+02.
> Coordinate frequency of the mode of radiative asymmetry in the
photosphere that is assumed to generate the pulsed signal [Hz].
```

```
[5]:
```

```
star = xpsi.Star(spacetime = spacetime, photospheres = photosphere)
```

Let’s check the vector of parameter values in the `Star`

instance and the other objects it encapsulates references to.

```
[6]:
```

```
star
```

```
[6]:
```

```
Free parameters
---------------
mass: Gravitational mass [solar masses].
radius: Coordinate equatorial radius [km].
distance: Earth distance [kpc].
cos_inclination: Cosine of Earth inclination to rotation axis.
temperature: log10(effective temperature [K] everywhere).
```

```
[7]:
```

```
def set_defaults():
global star # for clarity
# (Earth) distance
star['distance'] = 0.33
# gravitational mass
star['mass'] = 2.0
# coordinate equatorial radius
star['radius'] = 12.0
# (Earth) inclination to rotation axis
star['cos_inclination'] = math.cos(1.0)
# isotropic blackbody temperature
star['temperature'] = 5.7
set_defaults()
```

We assign parameter values and update the star as follows:

```
[8]:
```

```
star['temperature'] = 6.0
star.update()
```

Let’s compute the incident specific flux signal, up to some constant coefficient.

```
[9]:
```

```
energies = np.logspace(-2.0, np.log10(3.0), 100, base=10.0)
```

```
[10]:
```

```
photosphere.integrate(energies=energies, threads=4)
```

The signal is time-invariant and therefore we need to copy the spectrum to a sequence of matrix columns to get the desired energy-phase signal matrix:

```
[11]:
```

```
temp = np.tile(photosphere.signal[0][0], (1,len(everywhere.phases_in_cycles)))
```

We need a helper function to plot the signal, normalised to the maximum specific flux:

```
[12]:
```

```
from xpsi.tools import phase_interpolator
def plot_2D_pulse(z, x, shift, y, ylabel,
num_rotations=5.0, res=5000, normalise=True,
error=False,
cm=cm.viridis, vmin=None, vmax=None, label=None):
""" Helper function to plot a phase-energy pulse.
:param array-like z:
Either one, or a pair, of *ndarray[m,n]* objects representing the signal at
*n* phases and *m* values of an energy variable. A pair is required if
the fractional difference is to be plotted.
:param ndarray[n] x: Phases the signal is resolved at.
:param float shift: Phase shift to apply.
:param ndarray[m] x: Energy values the signal is resolved at.
"""
fig = plt.figure(figsize = (12,6))
gs = gridspec.GridSpec(1, 2, width_ratios=[50,1], wspace=0.025)
ax = plt.subplot(gs[0])
ax_cb = plt.subplot(gs[1])
new_phases = np.linspace(0.0, num_rotations, res)
if error:
interpolated = phase_interpolator(new_phases,
x,
np.ascontiguousarray(z[0]), shift)
interpolated /= phase_interpolator(new_phases,
x,
np.ascontiguousarray(z[1]), shift)
interpolated -= 1.0
interpolated *= 100.0
vmax = np.max(np.abs(interpolated))
vmin = -vmax
else:
interpolated = phase_interpolator(new_phases,
x,
np.ascontiguousarray(z), shift)
if normalise:
interpolated /= np.max(interpolated)
if vmin is None:
vmin = np.min(interpolated)
if vmax is None:
vmax = np.max(interpolated)
profile = ax.pcolormesh(new_phases,
y,
interpolated,
cmap = cm,
vmin = vmin,
vmax = vmax,
linewidth = 0,
rasterized = True)
profile.set_edgecolor('face')
ax.set_xlim([0.0, num_rotations])
ax.set_yscale('log')
ax.set_ylabel(ylabel)
ax.set_xlabel(r'Phase')
veneer((0.1, 0.5), (None,None), ax)
cb = plt.colorbar(profile,
cax = ax_cb,
ticks = AutoLocator())
cb.set_label(label=label or r'Signal (normalised by maximum)', labelpad=25)
cb.solids.set_edgecolor('face')
cb.outline.set_linewidth(1.0)
rcParams['text.usetex'] = False
rcParams['font.size'] = 18.0
def veneer(x, y, axes, lw=1.0, length=8):
""" Make the plots a little more aesthetically pleasing. """
if x is not None:
if x[1] is not None:
axes.xaxis.set_major_locator(MultipleLocator(x[1]))
if x[0] is not None:
axes.xaxis.set_minor_locator(MultipleLocator(x[0]))
else:
axes.xaxis.set_major_locator(AutoLocator())
axes.xaxis.set_minor_locator(AutoMinorLocator())
if y is not None:
if y[1] is not None:
axes.yaxis.set_major_locator(MultipleLocator(y[1]))
if y[0] is not None:
axes.yaxis.set_minor_locator(MultipleLocator(y[0]))
else:
axes.yaxis.set_major_locator(AutoLocator())
axes.yaxis.set_minor_locator(AutoMinorLocator())
axes.tick_params(which='major', colors='black', length=length, width=lw)
axes.tick_params(which='minor', colors='black', length=int(length/2), width=lw)
plt.setp(axes.spines.values(), linewidth=lw, color='black')
```

```
[13]:
```

```
plot_2D_pulse(temp,
x=everywhere.phases_in_cycles,
shift=np.array([0.0]),
y=energies,
num_rotations=2.0,
ylabel=r'Energy (keV)')
```

If we declare the signal as time-dependent, a different integrator is called:

```
[14]:
```

```
everywhere.time_invariant = False
```

```
[15]:
```

```
photosphere.integrate(energies=energies, threads=4)
```

```
[16]:
```

```
plot_2D_pulse((photosphere.signal[0][0], temp),
x=everywhere.phases_in_cycles,
shift=0.0,
y=energies,
ylabel=r'Energy (keV)',
cm=cm.RdBu,
label=r"Pct. frac. diff.",
num_rotations=1.0,
error=True)
```

We can also call a third integrator. This integrator is more general purpose, and thus inexorably more expensive to call. First we need to force the spacetime to be static (otherwise univeral relations are invoked based on the stellar spin frequency as set above):

```
[17]:
```

```
spacetime.a = 0.0 # spacetime spin parameter (~angular momentum)
spacetime.q = 0.0 # spacetime mass quadrupole moment
```

Now we call the integrator. The integrator discretises a distant image plane instead of the stellar surface. The *image* of the star is spatially resolved on the image plane. The integrator yields four-dimensional information about the signal. We trace a set of rays from the image plane to the star; the set is roughly equal in cardinality to the number of cells that discretise the surface above. Note that when this extension module is called, some output for diagnostics is directed to the
terminal in which you launched this Jupyter notebook.

**If you are uninterested in generating images, you can deactivate caching of the photon specific intensity fields on the sky, which dominates memory consumption. Actually, this is the default behaviour. If you activate caching of intensities and declare that you have enough memory for X-PSI to use (see the method docstring), note that this call below could consume up to ~15 GB of RAM, and you would be forced to reduce the number of energies, phases, and/or rays to proceed if this is
problematic. Alternatively, if you want to examine convergence of integrators, and want images, you will need to tune up resolution settings, and then you do the calculations on a so-called fat node of a high-performance system that offers increased OpenMP parallelism and crucially, a higher memory bank.**

```
[18]:
```

```
photosphere.image(reimage = True,
energies = energies,
phases = everywhere.phases_in_cycles * _2pi,
sqrt_num_rays = 512,
threads = 4, # OpenMP
max_steps = 100000, # max number of steps per ray
epsrel_ray = 1.0e-12) # ray relative tolerance
```

```
Imaging the star...
Warning: a ray map has not been cached... tracing new ray set...
Commencing ray tracing and imaging...
Ray tracing complete.
Ray set cached.
Phase-resolved specific flux integration complete.
Star imaged.
```

We now compare the signal to those computed above. The phase-energy resolved specific flux signal (integrated over sky solid angle) can be accessed through the `images`

property of the `photosphere`

object. The elements of this property also contain image plane coordinates, stellar surface coordinates, and quantities such as the specific *photon* intensity as a function of phase, energy, and sky direction (image plane coordinates). Note that the units of the specific flux signal are
photons/cm\(^{2}\)/s/keV because it has already been scaled by the square of the distance. The signals generated by the integrators above have not been scaled by the square of the distance (an implementation specific detail that is susceptible to change in the future).

```
[20]:
```

```
plot_2D_pulse((photosphere.images[0]*spacetime.d_sq, temp),
x=everywhere.phases_in_cycles,
shift=0.0,
y=energies,
ylabel=r'Energy (keV)',
cm=cm.RdBu,
label=r"Pct. frac. diff.",
num_rotations=1.0,
error=True)
```

```
[20]:
```

```
fig = plt.figure(figsize=(10,10))
ax = fig.add_subplot(211)
ax.plot(energies,
temp[:,0]/np.max(temp[:,0]),
'k-')
ax.plot(energies,
photosphere.signal[0][0][:,0]/np.max(temp[:,0]),
'k--')
ax.plot(energies,
photosphere.images[0][:,0]*spacetime.d_sq/np.max(temp[:,0]),
'k-.')
ax.set_xscale('log')
ax.set_ylabel(r'Normalised photons/cm$^{2}$/s/keV')
ax.set_yscale('log')
ax.xaxis.set_ticklabels([])
veneer((None, None), (None, None), ax)
ax = fig.add_subplot(212)
ax.plot(energies,
100.0*np.abs(photosphere.signal[0][0][:,0]/temp[:,0] - 1.0),
'k--')
ax.plot(energies,
100.0*np.abs(photosphere.images[0][:,0]*spacetime.d_sq/temp[:,0] - 1.0),
'k-.')
ax.set_xscale('log')
ax.set_xlabel('Energy [keV]')
ax.set_yscale('log')
ax.set_ylabel('Abs. % frac. diff.')
veneer((None, None), (None, None), ax)
plt.subplots_adjust(hspace=0.1)
```

The differences can be reduced, within the scope of a given algorthm, by defining higher resolution integration settings. The integration algorithms are so distinct that this consistency validates the tools internally; verification against external packages would nevertheless permit stronger guarantees of robustness. The simple package rayXpanda offered a weak validation of the Schwarzschild ray integration routines called by the surface-discretisation signal integrators.

Let’s visualise the distribution of rays, and thus the discretisation pattern on the image plane.

```
[21]:
```

```
# shape into (elliptical) rings and (quasi-linear) spokes
x = photosphere.images[1][1:].reshape(512,512)
y = photosphere.images[2][1:].reshape(512,512)
x_origin = photosphere.images[1][0]
y_origin = photosphere.images[2][0]
```

```
[22]:
```

```
fig = plt.figure(figsize=(10,10))
plt.scatter(x_origin, y_origin, color='k', marker='+')
# stride through rings and spokes
plt.scatter(x[::8,::8], y[::8,::8], s=0.1, color='k', marker='.')
plt.plot(x[-1,:], y[-1,:], color='k', linewidth=0.5)
ax = plt.gca()
ax.set_xlim([-1.025,1.025])
ax.set_ylim([-1.025,1.025])
veneer((0.05,0.25), (0.05,0.25), ax)
```

Notice that the rays are squeezed towards the stellar limb. The origin of the ray pattern, and the outer boundary are such that the image of the star is efficiently and accurately bounded with minimal ray wastage.

Let’s plot a photon specific intensity sky map, with the surface coordinates and ray pattern overplotted. We thus need to cache intensities when we integrate, so let’s choose a few energies and fewer rays to reduce memory requirements by a factor of \(\sim\!25\):

```
[23]:
```

```
photosphere.image(reimage = True,
cache_intensities = 1.0, # cache size limit in GBs
energies = np.array([0.01,0.1,0.5,1.0,2.0,5.0]),
phases = everywhere.phases_in_cycles * _2pi,
sqrt_num_rays = 400,
threads = 4,
max_steps = 100000,
epsrel_ray = 1.0e-12)
```

```
Imaging the star...
Cached ray set to be reused... commencing imaging...
Intensity caching complete.
Star imaged.
```

```
[24]:
```

```
fig = plt.figure(figsize=(10,10))
plt.tricontour(photosphere.images[1],
photosphere.images[2],
photosphere.images[3],
levels=np.linspace(0.1, math.pi-0.1, 50),
colors='k',
linestyles='solid',
linewidths=0.25)
phi = np.copy(photosphere.images[4][...])
for i in range(len(phi)):
# rays that scatter have negative constant values <-100
# for quantities such as the azimuth
if phi[i] > -100.0:
if phi[i] > math.pi:
while phi[i] > math.pi:
phi[i] -= 2.0 * math.pi
elif phi[i] < -math.pi:
while phi[i] < -math.pi:
phi[i] += 2.0 * math.pi
phi_lvls = np.linspace(np.min(phi[phi > -100.0]),
np.max(phi[phi > -100.0]), 100)
plt.tricontour(photosphere.images[1], # x
photosphere.images[2], # y
phi,
levels = phi_lvls,
linestyles = 'solid',
linewidths = 0.25,
extend = 'neither',
colors='k')
intensity = photosphere.images[-1][0,0,:]
lvls = np.linspace(np.min(intensity[intensity > 0.0]),
np.max(intensity), 200)
plt.tricontourf(photosphere.images[1],
photosphere.images[2],
intensity,
levels=lvls)
# overplot the ray pattern
plt.scatter(x_origin, y_origin, color='k', marker='+')
plt.scatter(x[::4,::4], y[::4,::4],
s=0.1, color='k', marker='.')
ax = plt.gca()
ax.set_xlim([-1.025,1.025])
ax.set_ylim([-1.025,1.025])
veneer((0.05,0.25), (0.05,0.25), ax)
```

The contour artefact is seemingly unavoidable due to the wrapping of the azimuthal coordinate; one can put the boundary (beyond which \(\phi\mapsto\phi-2\pi\)) at different azimuths, but in *matplotlib* the thick dark contour mass remains (here visible at the northern and southern rotation poles).

Let’s generate the photon specific intensity sky maps at a set of energies, and optionally an animated compilation of those images.

```
[25]:
```

```
sky_map_kwargs = {'panel_indices': (0,1,2,3,4,5), # select energy indexes
'num_levels': 500,
'colormap': cm.Purples_r,
'phase_average': True,
'annotate_energies': True,
'energy_annotation_format': '[%.2f keV]',
'annotate_location': (0.025,0.025)} # do not phase average if you want to animate a sequence
```

NB: a colormap like `cm.Purples_r`

this will make the lowest finite intensity distinct from the black zero-intensity background from the surface and behind the star.

```
[26]:
```

```
photosphere.image(reimage = False,
energies = np.array([0.01,0.1,0.5,1.0,2.0,5.0]),
phases = everywhere.phases_in_cycles * _2pi,
plot_sky_maps = True,
sky_map_kwargs = sky_map_kwargs,
animate_sky_maps = False,
animate_kwargs = {})
```

```
Imaging the star...
Plotting intensity sky maps...
Averaging (specific) intensity over rotational phase...
Averaged (specific) intensity over rotational phase.
Normalising each sky map panel separately...
Normalised sky map panels separately.
Rendering phase-averaged images...
Intensity sky maps plotted.
Star imaged.
```

Let’s display a set of sky phase-averaged maps (which are indentical to the phase-resolved maps for this axisymmetric surface radiation field specification):

```
[27]:
```

```
Image("./images/skymap_0.png")
```

```
[27]:
```

```
[28]:
```

```
!mkdir images/uniform
!mv images/skymap_0.png images/uniform/skymap_default.png
```

With that out of the way, let’s explore a surface radiation field whose spatial structure exhibits higher-complexity.

## Custom (phase-dependent)¶

Let us, inspired by Lockhart et al. (2019), set up a surface radiation field constituted by: (i) a hot spot whose temperature decreases away from a point \(P\) as a function of angular separation; and (ii) a hot ring whose angular centre is the antipode \(Q\) of \(P\) and whose temperature decreases away (as a function of angular separation from \(Q\)) from a locus of points with constant angular separation to point \(Q\). The temperature is everywhere that of the local comoving photosphere, which radiates isotropically as a blackbody.

You now need to reinstall the package after replacing the contents of `xpsi/surface_radiation_field/local_variables.pyx`

with the exact contents of `xpsi/surface_radiation_field/archive/local_variables/tutorial_spot_and_ring.pyx`

. The `local_variables.pyx`

extension module must transform some set of *global* variables into *local* variables at the spacetime event defined by the intersection of a ray with the stellar surface. A vector of local variables is then passed to the
`xpsi/surface_radiation_field/hot.pyx`

module for evaluation of the specific intensity of radiation, w.r.t a local comoving surface frame, that after Lorentz transformation is transported along the ray to the image plane.

**Once you can reinstalled the package, you need to restart the IPython kernel and then execute code cells [1], [2], and [12] above.**

First we will subclass Everywhere to provide a custom implementation of the surface radiation field for a surface-discretisation integrator.

```
[4]:
```

```
class CustomEverywhere(xpsi.Everywhere):
""" Custom radiation field globally spanning the surface. """
@classmethod
def create_parameters(cls, bounds, values={}, *args, **kwargs):
""" Create custom parameter objects. """
T = Parameter('spot_temperature',
strict_bounds = (3.0, 7.0), # very cold --> very hot
bounds = bounds.get('spot_temperature', None),
doc = 'log10(spot temperature [K])',
symbol = r'$\log_{10}(T\;[\rm{K}])$',
value = values.get('spot_temperature', None))
colatitude = Parameter('colatitude',
strict_bounds = (0.0, math.pi),
bounds = bounds.get('colatitude', None),
doc = 'spot centre colatitude [radians]',
symbol = r'$\Theta$',
value = values.get('colatitude', None))
spot_scale = Parameter('spot_scale',
strict_bounds = (0.0, math.pi/2.0),
bounds = bounds.get('spot_scale', None),
doc = 'scale of temperature variation [radians]',
symbol = r'$\sigma$',
value = values.get('spot_scale', None))
rotation = Parameter('rotation',
strict_bounds = (0.0, 2.0*math.pi),
bounds = bounds.get('rotation', None),
doc = 'stellar rotation [radians]',
symbol = r'$\phi$',
value = values.get('rotation', None))
return cls(*args,
custom=[T,
colatitude,
spot_scale,
rotation],
**kwargs)
@staticmethod
def angular_separation(theta, phi, colatitude):
""" Colatitude in rotated basis (anti-clockwise about y-axis). """
return xpsi.HotRegion.psi(theta, phi, colatitude)
def _compute_cellParamVecs(self):
""" Custom temperature field variation to imitate hot spot + ring. """
# all radiate, but can be changed with overwrite
self._cellRadiates = np.ones(self._theta.shape, dtype=np.int32)
separation = self.angular_separation(self._theta, self._phi, self['colatitude'])
self._cellParamVecs = np.ones((self._theta.shape[0],
self._theta.shape[1],
2), dtype=np.double)
self._cellParamVecs[...,0] = self['spot_temperature'] * np.exp(-(separation-self['spot_scale'])**2.0/(2.0*0.25*self['spot_scale']))
self._cellParamVecs[...,0] += self['spot_temperature'] * np.exp(-(separation-math.pi)**2.0/(2.0*self['spot_scale']))
for i in range(self._cellParamVecs.shape[1]):
self._cellParamVecs[:,i,-1] *= self._effGrav # unused here
self._phi += self['rotation']
```

```
[5]:
```

```
bounds = dict(spot_temperature = (5.5, 6.5),
colatitude = (None, None),
spot_scale = (None, None),
rotation = (None, None))
everywhere = CustomEverywhere.create_parameters(bounds=bounds,
values={}, # no fixed/derived variables
time_invariant=False, # choose appropriate integrator
sqrt_num_cells=512,
num_rays=1000,
num_leaves=512,
num_phases=100)
```

```
Creating parameter:
> Named "spot_temperature" with bounds [5.500e+00, 6.500e+00].
> log10(spot temperature [K]).
Creating parameter:
> Named "colatitude" with bounds [0.000e+00, 3.142e+00].
> spot centre colatitude [radians].
Creating parameter:
> Named "spot_scale" with bounds [0.000e+00, 1.571e+00].
> scale of temperature variation [radians].
Creating parameter:
> Named "rotation" with bounds [0.000e+00, 6.283e+00].
> stellar rotation [radians].
```

We want to image the photosphere and the default behaviour of Photosphere is insufficient. We therefore subclass Photosphere to provide a custom implementation of a higher-complexity radiation field. The customisation is actually very simple: we must make a property return a vector of global variable values that are relayed to a compiled extension module
`xpsi.surface_radiation_field.local_variables`

by the image-plane discretisation integrator. Thus, the bulk of the customisation must be written in `xpsi/surface_radiation_field/local_variables.pyx`

for compilation; this has already been handled for this tutorial (see instructions above).

```
[6]:
```

```
class CustomPhotosphere(xpsi.Photosphere):
""" Implement custom global variables property. """
@property
def global_variables(self):
return np.array([self['spot_temperature'],
self['colatitude'],
self['spot_scale'],
self['rotation']])
```

```
[7]:
```

```
photosphere = CustomPhotosphere(hot = None,
elsewhere = None,
everywhere = everywhere,
values=dict(mode_frequency = spacetime['frequency']))
```

```
Creating parameter:
> Named "mode_frequency" with fixed value 6.000e+02.
> Coordinate frequency of the mode of radiative asymmetry in the
photosphere that is assumed to generate the pulsed signal [Hz].
```

```
[8]:
```

```
star = xpsi.Star(spacetime = spacetime, photospheres = photosphere)
```

```
[9]:
```

```
def set_defaults():
global star # for clarity
star['distance'] = 0.3
star['mass'] = 2.0
star['radius'] = 12.0
star['cos_inclination'] = math.cos(1.0)
star['spot_temperature'] = 6.2
star['colatitude'] = 3.0 * math.pi/4.0
star['spot_scale'] = 0.5
star['rotation'] = math.pi/2.0
set_defaults()
```

```
[10]:
```

```
star.update()
```

```
[11]:
```

```
energies = np.logspace(-2.0, np.log10(3.0), 100, base=10.0)
```

```
[12]:
```

```
photosphere.integrate(energies=energies, threads=4)
```

```
[13]:
```

```
plot_2D_pulse(photosphere.signal[0][0],
x=everywhere.phases_in_cycles,
shift=0.0,
y=energies,
ylabel=r'Energy (keV)')
```

Let’s render the surface temperature field represented by our regular mesh in colatitude and azimuth:

```
[14]:
```

```
fig = plt.figure(figsize = (10,10))
ax = fig.add_subplot(111)
veneer((20, 100), (20, 100), ax)
z = everywhere._cellParamVecs[...,0]
patches = plt.imshow(z, rasterized = True)
```

Colatitude increases downwards, whilst azimuth increases rightwards. The mesh is constructed such that the \(\phi\mapsto\phi-2\pi\) boundary is the meridian on which the angular centre of the ring lies. We can make a crude plot of the surface temperature field in a more natural way:

```
[15]:
```

```
plt.figure(figsize=(10,10))
plt.subplot(111, projection="lambert")
plt.grid(True)
Lat = -everywhere._theta + math.pi/2.0
z = everywhere._cellParamVecs[...,0]
plt.contour(everywhere._phi, Lat, z,
levels=np.linspace(np.min(z), np.max(z), 50))
_ = plt.gca().set_xticklabels([])
```

Note that although the star looks lensed, it is merely a projection (mimicking Scwarzschild light bending for an equatorial observer) that allows us to render all \(4\pi\) steradians of the surface. The real lensing is yet to come! First we need to force our exterior spacetime to be that of Schwarzschild:

```
[16]:
```

```
spacetime.a = 0.0 # spacetime spin parameter (~angular momentum)
spacetime.q = 0.0 # spacetime mass quadrupole moment
```

Now call the imaging routine in the same manner as above:

```
[17]:
```

```
photosphere.image(reimage = True,
energies = energies,
phases = everywhere.phases_in_cycles * _2pi,
sqrt_num_rays = 1000, # because why not?
threads = 4,
max_steps = 100000,
epsrel_ray = 1.0e-12)
```

```
Imaging the star...
Warning: a ray map has not been cached... tracing new ray set...
Commencing ray tracing and imaging...
Ray tracing complete.
Ray set cached.
Phase-resolved specific flux integration complete.
Star imaged.
```

Let’s examine the phase-energy resolved photon specific flux signal and compare it to the signal computed by via surface discretisation:

```
[18]:
```

```
plot_2D_pulse(np.ascontiguousarray(photosphere.images[0]),
x=everywhere.phases_in_cycles,
shift=0.0,
y=energies,
ylabel=r'Energy (keV)')
```

```
[19]:
```

```
plot_2D_pulse((photosphere.images[0]*spacetime.d_sq, photosphere.signal[0][0]),
x=everywhere.phases_in_cycles,
shift=0.0,
y=energies,
ylabel=r'Energy (keV)',
cm=cm.RdBu,
label=r"Pct. frac. diff.",
num_rotations=1.0,
error=True)
```

Now the really fun part: photon specific intensity sky maps. Now that we are not pursuing a high-resolution signal to compare to an integrator that discretises the stellar surface, we reduce the number of energies and rays to avoid memory issues when caching the sky photon specific intensity field in four dimensions. Nevertheless, if you run these cells as is, you might want to grab a beverage of choice while you wait up to ~30 minutes. **In previous X-PSI versions, the animator required massive
memory due to matplotlib imshow() usage issues, but this was fixed in X-PSI v0.6; nevertheless, you could start with a smaller number of phases, just to check that it works without eating more memory than you want to spare.**

```
[20]:
```

```
sky_map_kwargs = {'panel_indices': (0,1,2,3,4,5),
'num_levels': 100, # in intensity field rendering
'colormap': cm.Greys_r,
'phase_average': False,
'annotate_energies': True, # background from the surface and behind the star
'energy_annotation_format': '[%.2f keV]',
'annotate_location': (0.025,0.025)}
# you can install ffmpeg with conda in order to animate
animate_kwargs = {'cycles': 4, 'fps': 32}
```

```
[21]:
```

```
!rm images/*.png
```

```
[22]:
```

```
photosphere.image(reimage = True,
reuse_ray_map = False,
cache_intensities = 1.0, # cache size limit in GBs
energies = np.array([0.01,0.1,0.5,1.0,2.0,5.0]),
phases = everywhere.phases_in_cycles * _2pi,
sqrt_num_rays = 400,
threads = 4,
max_steps = 100000,
epsrel_ray = 1.0e-12,
plot_sky_maps = True, # activate if you want to plot frames
sky_map_kwargs = sky_map_kwargs,
animate_sky_maps = False, # activate if you want to animate
free_memory = False, # activate if memory is a concern, then ray-map/intensity caches deleted
animate_kwargs = animate_kwargs)
```

```
Imaging the star...
Commencing ray tracing and imaging...
Ray tracing complete.
Ray set cached.
Intensity caching complete.
Plotting intensity sky maps...
Normalising each sky map panel separately...
Normalised sky map panels separately.
Rendering images for phase numbers [1, 10]...
Rendering images for phase numbers (10, 20]...
Rendering images for phase numbers (20, 30]...
Rendering images for phase numbers (30, 40]...
Rendering images for phase numbers (40, 50]...
Rendering images for phase numbers (50, 60]...
Rendering images for phase numbers (60, 70]...
Rendering images for phase numbers (70, 80]...
Rendering images for phase numbers (80, 90]...
Rendering images for phase numbers (90, 100]...
Intensity sky maps plotted.
Animating intensity sky maps...
Writing to disk: ./images/skymap_animated.mp4...
Intensity sky maps animated.
Star imaged.
```

If you are executing this notebook, you can view the video file:

```
[23]:
```

```
%%HTML
<div align="middle">
<video width="100%" controls loop>
<source src="images/skymap_animated.mp4" type="video/mp4">
</video></div>
```

```
[24]:
```

```
!mkdir images/frames_ring_and_spot
!mv images/*.png images/frames_ring_and_spot/.
```

Here is a frame for the purpose of the documentation notebook. Each panel displays the photon specific intensity field, on the sky, at a given energy; energy increases from top-left to bottom-right. The intensity field in each panel is normalised over sky direction and phase, for each energy in the sequence.

```
[26]:
```

```
Image("./images/frames_ring_and_spot/skymap_50.png")
```

```
[26]:
```

Finally, let’s phase-average the intensity sky maps:

```
[27]:
```

```
sky_map_kwargs['phase_average'] = True
# only one set of panels so why not choose higher res.?
sky_map_kwargs['num_levels'] = 500
photosphere.image(reimage = False, # because we decided not to free_memory earlier
energies = np.array([0.01,0.1,0.5,1.0,2.0,5.0]),
phases = everywhere.phases_in_cycles * _2pi,
plot_sky_maps = True,
sky_map_kwargs = sky_map_kwargs)
```

```
Imaging the star...
Plotting intensity sky maps...
Averaging (specific) intensity over rotational phase...
Averaged (specific) intensity over rotational phase.
Normalising each sky map panel separately...
Normalised sky map panels separately.
Rendering phase-averaged images...
Intensity sky maps plotted.
Star imaged.
```

```
[28]:
```

```
!mv images/skymap_0.png images/frames_ring_and_spot/skymap_phase_averaged_spot_and_ring.png
```

```
[29]:
```

```
Image("images/frames_ring_and_spot/skymap_phase_averaged_spot_and_ring.png")
```

```
[29]:
```

To understand the phase-averaged intensity field associated with the ring, consider a fix sky direction through which the upper and lower extremities (in colatitude) of the ring pass as the star rotates. The bright surface regions pass over such sky directions for a greater fraction of the one revolution than for sky directions closer in surface colatitude to the centre of the ring.

## Rotating spacetime¶

The integrator that discretises an image plane, being more general purpose (but not as general purpose as a number of other open-source codes), can also handle a rotating spacetime via a CPU-based implementation of the quasi-Kerr formalism Psaltis & Johannsen (2012) and Bauböck et al. (2012), in which the exterior spacetime solution has a finite angular momentum and mass quadrupole moment. If we delete the custom values of these spacetime variables, universal relations from AlGendy & Morsink (2014) will be invoked.

```
[30]:
```

```
del spacetime.a
del spacetime.q
```

```
[31]:
```

```
spacetime.a # dimensions of length
```

```
[31]:
```

```
765.8499186550695
```

```
[32]:
```

```
spacetime.q # dimensionless
```

```
[32]:
```

```
0.1146198823594334
```

```
[33]:
```

```
sky_map_kwargs = {'panel_indices': (0,1,2,3,4,5),
'num_levels': 500, # in intensity field rendering
'colormap': cm.Greys_r,
'phase_average': True}
photosphere.image(reimage = True,
reuse_ray_map = False, # have to do manually because free parameters have not changed
cache_intensities = 1.0, # cache size limit in GBs
energies = np.array([0.01,0.1,0.5,1.0,2.0,5.0]),
phases = everywhere.phases_in_cycles * _2pi,
sqrt_num_rays = 400,
threads = 4,
max_steps = 100000,
epsrel_ray = 1.0e-12,
plot_sky_maps = True,
sky_map_kwargs = sky_map_kwargs)
```

```
Imaging the star...
Commencing ray tracing and imaging...
Ray tracing complete.
Ray set cached.
Intensity caching complete.
Plotting intensity sky maps...
Averaging (specific) intensity over rotational phase...
Averaged (specific) intensity over rotational phase.
Normalising each sky map panel separately...
Normalised sky map panels separately.
Rendering phase-averaged images...
Intensity sky maps plotted.
Star imaged.
```

```
[34]:
```

```
!mv images/skymap_0.png images/frames_ring_and_spot/skymap_phase_averaged_spot_and_ring__rotating_spacetime.png
```

```
[35]:
```

```
Image("images/frames_ring_and_spot/skymap_phase_averaged_spot_and_ring__rotating_spacetime.png")
```

```
[35]:
```

You should be able to detect the extra lateral asymmetry introduced at lower energies that was not present for a static ambient spacetime.

Note that the temporal and azimuthal coordinates are no longer those used above for the Schwarzschild exterior spacetime solution, and thus the surface radiation field is inherently different when the same functions of azimuthal and temporal coordinates are used to construct it.

The integrator can also handle some forms of time evolution of the surface radiation field beyond pure bulk rotation, but such a usage pattern is more advanced and thus left for a future tutorial.