ChiantiPy Documentation¶

Welcome to the ChiantiPy documentation. ChiantiPy is a pure Python package for performing calculations of astrophysical spectra using the CHIANTI atomic database.

The latest version of ChiantiPy is 0.12.0 and is compatible with CHIANTI database version 10.0. It is not compatible with previous versions

ChiantiPy v0.12.0 is released under the OSI approved ISC license. From Wikipedia: The ISC license is a permissive free software license written by the Internet Software Consortium (ISC). It is functionally equivalent to the simplified BSD and MIT/Expat licenses, …

CHIANTI consists of a database of atomic data that can be used to interpret spectral lines and continua emitted from high-temperature, optically-thin astrophysical sources.

CHIANTI is developed and maintained by scientists at George Mason University (USA), the University of Michigan (USA), and the University of Cambridge (UK). The first version of CHIANTI was released in 1997 and version 10.0 in 2021.

Getting started with ChiantiPy¶

Prerequisites¶

CHIANTI, the atomic database for astrophysical spectroscopy (Version 10 or later)

Python3 (3.8 is the current development version)

Numpy (currently developed with 1.20)

Scipy (currently developed with 1.6)

Matplotlib (currently developed with 3.3.4)

Matplotlib requires a GUI library

PyQt5

Once one of these is installed, it must be set as the backend in your matplotlibrc file, e.g., backend: Qt5Agg

ipyparallel (required for multiprocessing with ipymspectrum)
(not really a prerequisite but extremely useful) IPython version 7.21 and Jupyter

Install the CHIANTI database¶

The gzipped data tar ball can be downloaded from the CHIANTI website

put the file in a convenient directory, cd to the directory and untar the file
ChiantiPy uses the environment variable XUVTOP to find the database. Set XUVTOP to the name of the directory where the CHIANTI data tarball was placed. For example

setenv XUVTOP /data1/xuv/directory.where.the.tarball.was.placed

or on Windows: To set the environment variable, go to Control Panel -> System -> Advanced System Properties -> Environment Variables.

Some sites have the CHIANTI database maintained as part of a SolarSoft distribution. In that case, simply set XUVTOP to the directory were it resides, usually something like $SSW/packages/chianti/dbase

Install the Prerequisites¶

On Linux systems this can usually be done with your package manager.

On Windows, Linux and Mac systems, it is possible to use

the Anaconda distribution from from Continuum, or,

the Canopy distribution from Enthought.

On Windows, it is also possible to use:

WinPython

All of these packages are free, at least for noncommercial use (I believe) and have a considerable amount of documentation. You shoud check the version of IPython that is provided.

Install the ChiantiPy package¶

In order to be compatible with the latest version (10) of the CHIANTI atomic database, it is necessary to install the latest version (0.10.0) of ChiantiPy

pip install ChiantiPy

or

pip3 install ChiantiPy

I have not tried this with ChiantiPy, myself.

The ChiantiPy package can be downloaded from the ChiantiPy project page at Sourceforge, untar it, cd to the directory where it was unpacked, and then, as root

python setup.py install

If you do not have root privileges, simply put the ChiantiPy directory in your PYTHONPATH

python setup.py install --prefix=somewhere_in_my_PYTHONPATH

or on a Mac, with the Anaconda package

python setup.py install --prefix=/Users/your_user_name/anaconda/

Thanks to Peter Young (GMU) for providing the instructions for installation on Mac and Windows

Note - ChiantiPy interactions with various GUI backends¶

First, Matplotlib requires a GUI backend and can be specified by the user in the matplotlibrc file. Matplotlib expects to find this file in $HOME/.config/matplotlib, although it might require that you copy it to that directory.

ChiantiPy also uses a GUI dialog widget set. Selections can also be made via the command line. The user choice is specified in the chiantirc file. One is included with the distribution. On Linux, if it is copied into either the $HOME/.config or $HOME/.chianti directory, it will automatically be picked up. It is a text file and can be edited. On Windows, it should be copied to $PROFILEHOME/.config or $PROFILEHOME/.chianti where it will also be picked up. Otherwise, the default GUI is to use the command line. A default chiantirc file is included with the distribution.

In order for the ChiantiPy dialog widget to be used, a backend for them must be initiated. If you choose the same backend for matplotlib (PyQt5 is best) as for the ChiantiPy widgets, then running %matplotlib in an IPython or Jupyter session will do the trick. In an interactive Python session, invoking a matplotlib or matplotlib qt command first should also do the trick.

matplotlib inline

or

matplotlib qt

if you are using Qt5

If you choose to use a GUI backend other than that used for matplotlib, then in an IPython or a Jupyter command the following magic commands are also available to start the backend:

%gui qt

ChiantiPy has mostly been tested with the Qt5 backend for Matplotlib and using the ChiantiPy Qt5 widgets.

Quick Start¶

This short tutorial will demonstrate some of the capabilities of ChiantiPy and the CHIANTI database. It assumes that you know what the CHIANTI database provides and why you want to use it. It is useful to begin by exploring the properties of the ion class, as much of ChiantiPy is based on it. An ion such as Fe XIV is specified by the string ‘fe_14’, in the usual CHIANTI notation.

Perhaps the easiest way is to use a jupyter-notebook or a jupyter3-notebook to load the quick start notebook file QuickStart.ipynb in the directory jupyter_notebooks. Then, just run each cell step by step. If you are not familiar with notebooks, then you can cut and paste the following code into a Python/IPython session.

N.B.: in the time some of the plots and data were produced, there have been some changes to ChiantiPy and CHIANTI. It is possible that you might find difference (hopefully small).

Bring up a Python session (using > Python -i ), or better yet, an IPython session

import ChiantiPy.core as ch
import numpy as np
import matplotlib.pyplot as plt

What we will really be interested in are various properties of the Fe XIV emissivities as a function of temperature and density. So, let’s define a numpy array of temperatures

t = 10.**(5.8 + 0.05*np.arange(21.))

In ChiantiPy, temperatures are currently given in degrees Kelvin and densities as the number electron density per cubic cm. Then, construct fe14 as would be typically done

fe14 = ch.ion('fe_14', temperature=t, eDensity=1.e+9, em=1.e+27)

note that eDensity is the new keyword for electron density

Level populations¶

fe14.popPlot()

produces a matplotlib plot window were the population of the top 10 (the default) levels are plotted as a function of temperature.

If the level populations had not already been calculated, popPlot() would have invoked the populate() method which calculates the level populations and stores them in the Population dictionary, with keys = [‘protonDensity’, ‘population’, ‘temperature’, ‘density’].

A ChiantiPy Convention¶

Classes and function of ChiantiPy start with lower case letters. Data/attributes that are attached to the instantiation of a class will start with a capital letter. For example,

fe14.populate() creates fe14.Population containing the level population information

fe14.intensity() created fe14.Intensity contain the line intensities information

fe14.spectrum() creates fe14.Spectrum contain the line and continuum spectrum information

Spectral Line Intensities¶

fe14.intensityPlot(wvlRange=[210.,220.],linLog='log')

will plot the intensities for the top (default = 10) lines in the specified wavelength range. If the Intensity attribute has not yet been calculated, it will calculate it. Since there are 21 temperature involved, a single temperature is selected (21/2 = 10). Otherwise,

fe14.intensityPlot(index=2, wvlRange=[210., 220.], linLog = 'log')

plots the intensities for a temperature = t[2] = 7.9e+5, in this case. And, by specifying relative = 1, the emissivities will be plotted relative to the strongest line.

_images/fe14_intensity_plot_log_index2.png

fe14.intensityList(wvlRange=[200,220], index=10)

gives the following terminal output:

 using index =    10 specifying temperature =   2.00e+06, eDensity =    1.00e+09 em =   1.00e+27

 ------------------------------------------

 Ion  lvl1  lvl2                     lower - upper                           Wvl(A)    Intensity      A value Obs
 fe_14     1    11              3s2.3p 2P0.5 - 3s2.3d 2D1.5                  211.3172    2.336e+02     3.81e+10 Y
 fe_14     4    27              3s.3p2 4P1.5 - 3s.3p(3P).3d 4P1.5            212.1255    5.355e-01     2.21e+10 Y
 fe_14     4    28              3s.3p2 4P1.5 - 3s.3p(3P).3d 4D2.5            212.1682    4.039e-01     1.15e+10 Y
 fe_14     3    24              3s.3p2 4P0.5 - 3s.3p(3P).3d 4D0.5            213.1955    8.073e-01     4.26e+10 Y
 fe_14     3    23              3s.3p2 4P0.5 - 3s.3p(3P).3d 4D1.5            213.8822    1.393e+00     2.97e+10 Y
 fe_14     5    28              3s.3p2 4P2.5 - 3s.3p(3P).3d 4D2.5            216.5786    9.736e-01     2.83e+10 Y
 fe_14     5    25              3s.3p2 4P2.5 - 3s.3p(3P).3d 4D3.5            216.9173    1.730e+00     4.29e+10 Y
 fe_14     7    32              3s.3p2 2D2.5 - 3s.3p(3P).3d 2F3.5            218.1767    3.734e+00     1.70e+10 Y
 fe_14     4    22              3s.3p2 4P1.5 - 3s.3p(3P).3d 4P2.5            218.5725    2.391e+00     2.65e+10 Y
 fe_14     2    12              3s2.3p 2P1.5 - 3s2.3d 2D2.5                  219.1305    5.077e+01     4.27e+10 Y

------------------------------------------

optionally, an output file could also be created by setting the keyword outFile to the name of the desired name

fe14.intensityList(wvlRange=[210.,220.], relative=1, index=11)

give the following terminal/notebook output

 using index =    11 specifying temperature =   2.24e+06, eDensity =    1.00e+09 em =   1.00e+27

 ------------------------------------------

 Ion  lvl1  lvl2                     lower - upper                           Wvl(A)    Intensity      A value Obs
 fe_14     1    11              3s2.3p 2P0.5 - 3s2.3d 2D1.5                  211.3172    1.000e+00     3.81e+10 Y
 fe_14     4    27              3s.3p2 4P1.5 - 3s.3p(3P).3d 4P1.5            212.1255    2.267e-03     2.21e+10 Y
 fe_14     4    28              3s.3p2 4P1.5 - 3s.3p(3P).3d 4D2.5            212.1682    1.694e-03     1.15e+10 Y
 fe_14     3    24              3s.3p2 4P0.5 - 3s.3p(3P).3d 4D0.5            213.1955    3.390e-03     4.26e+10 Y
 fe_14     3    23              3s.3p2 4P0.5 - 3s.3p(3P).3d 4D1.5            213.8822    5.891e-03     2.97e+10 Y
 fe_14     5    28              3s.3p2 4P2.5 - 3s.3p(3P).3d 4D2.5            216.5786    4.083e-03     2.83e+10 Y
 fe_14     5    25              3s.3p2 4P2.5 - 3s.3p(3P).3d 4D3.5            216.9173    7.085e-03     4.29e+10 Y
 fe_14     7    32              3s.3p2 2D2.5 - 3s.3p(3P).3d 2F3.5            218.1767    1.557e-02     1.70e+10 Y
 fe_14     4    22              3s.3p2 4P1.5 - 3s.3p(3P).3d 4P2.5            218.5725    1.009e-02     2.65e+10 Y
 fe_14     2    12              3s2.3p 2P1.5 - 3s2.3d 2D2.5                  219.1305    2.096e-01     4.27e+10 Y

------------------------------------------

G(n,T) function¶

fe14.gofnt(wvlRange=[210., 220.],top=3)

brings up a matplotlib plot window which shows the emissivities of the top (strongest) 3 lines in the wavelength region from 210 to 220 Angstroms.

quickly followed by a dialog where the line(s) of interest can be specified

and finally a plot of the G(n,T) function for the specified lines(s).

The G(n,T) calculation is stored in the Gofnt dictionary, with keys = [‘gofnt’, ‘temperature’, ‘density’]

while the is a fairly straightforward way to get a G(T) function, it is not very practical to use for a more than a handful of lines. For if the fe_14 line at 211.3172 is in a list of lines to be analyzed, a more practical way is the following

fe14.intensity()
dist = np.abs(np.asarray(fe14.Intensity['wvl']) - 211.3172)
idx = np.argmin(dist)
print(' wvl = %10.3f '%(fe14.Intensity['wvl'][idx]))

prints

wvl = 211.317

plt.loglog(temp,fe14.Intensity['intensity'][:,idx])

once the axes are properly scaled, this produces the same values as fe14.Gofnt[‘gofnt’]

Ionization Equilibrium¶

For the Fe XIV example, the temperature was chosen to center around 2.e+6. It was not immediately apparent why this was done but in most of the following examples it is necessary to pick an appropriate temperature. This can be done with the ioneq class. To look at the ionization equilibrium for the iron ions (Z = 26, or ‘fe’)

fe = ch.ioneq(26)
fe.load()
fe.plot()
plt.tight_layout()

brings up a plot showing the ionization equilibrium for all of the stages of iron as a function of temperature

This is pretty crowded and we are only interested in Fe XIV (fe_14), so

plt.figure()
fe.plot(stages=[13,14,15],tRange=[1.e+6, 6.e+6], yr = [1.e-2, 0.4])
plt.tight_layout()

produces a plot of the ionization equilibria of Fe XIII, XIV and XV over a limited temperature range (tRange) and vertical range (yr)

from this it is clear that Fe XIV (fe_14) is formed at temperatures near $2 \times 10^6$ K

Intensity Ratios¶

fe14.intensityRatio(wvlRange=[210., 225.])

this brings up a plot showing the relative emissivities on the Fe XIV lines

following by a dialog where you can selector the numerator(s) and denominator(s) of the desired intensity ratio

so the specified ratio is then plotted

if previously, we had done

dens = 10.**(6. + 0.1*arange(61))
fe14 = ch.ion('fe_14', 2.e+6, dens)
fe14.intensityRatio(wvlRange=[210., 225.])

then the plot of relative intensities vs density would appear

the same numerator/denominator selector dialog would come up and when 2 or more lines are selected, the intensity ratio versus density appears.

to obtain ratios of lines widely separated in wavelength, the wvlRanges keyword can be used:

fe12 = ch.ion('fe_12', temperature=t, eDensity=1.e+9
fe12.intensityRatio(wvlRanges=[[190.,200.],[1240.,1250.]])

Spectra of a single ion¶

fe14 = ch.ion('fe_14', temperature = 2.e+6, density = 1.e+9)
wvl = wvl=200. + 0.125*arange(801)
fe14.spectrum(wvl, em=1.e+27)
plot(wvl, fe14.Spectrum['intensity'])

this will calculate the spectrum of fe_14 over the specified wavelength range and filter it with the default filter which is a gaussian (filters.gaussianR) with a ‘resolving power’ of 1000 which gives a gaussian width of wvl/1000.

other filters available in chianti.tools.filters include a boxcar filter and a gaussian filter where the width can be specified directly

if hasattr(fe14,'Em'):
    print(' Emission Measure = %12.2e'%(fe14.Em))
else:
    print(' the value for the emission measure is unspecified')

Emission Measure = 1.00e+27

import chianti.tools.filters as chfilters
fe14.spectrum(wvl,filter=(chfilters.gaussian,.04))

calculates the spectrum of fe_14 for a gaussian filter with a width of 0.04 Angstroms. The current value of the spectrum is kept in fe14.Spectrum with the following keys:

for akey in sorted(fe14.Spectrum.keys()):
    print(' %10s'%(akey))

allLines em filter filterWidth intensity wvl xlabel ylabel

plot(wvl,fe14.Spectrum['intensity'])
plt.xlabel(fe14.Spectrum['xlabel'])
plt.ylabel(fe14.Spectrum['ylabel'])

New in ChiantiPy 0.6, the label keyword has been added to the ion.spectrum method, and also to the other various spectral classes. This allows several spectral calculations for different filters to be saved and compared

temp = 10.**(5.8 + 0.1*np.arange(11.))
dens = 1.e+9
fe14 = ch.ion('fe_14', temp, dens)
emeas = np.ones(11,'float64')*1.e+27
wvl = 200. + 0.125*np.arange(801)
fe14.spectrum(wvl,filter=(chfilters.gaussian,.4),label='.4',em=emeas, label='0.4')
fe14.spectrum(wvl,filter=(chfilters.gaussian,1.),label='1.', label-'1.0')
plt.plot(wvl,fe14.Spectrum['.4']['intensity'][5])
plt.plot(wvl,fe14.Spectrum['1.']['intensity'][5],'-r')
plt.xlabel(fe14.Spectrum['.4']['xlabel'])
plt.ylabel(fe14.Spectrum['.4']['ylabel'])
plt.legen(loc='upper right')

Free-free and free-bound continuum¶

The module continuum provides the ability to calculate the free-free and free-bound spectrum for a large number of individual ions. The two-photon continuum is produced only by the hydrogen-like and helium-like ions

temperature = 2.e+7
em = 1.e+27
c = ch.continuum('fe_25', temperature = temperature, em = em)
wvl = 1. + 0.002*arange(4501)
c.freeFree(wvl)
plot(wvl, c.FreeFree['intensity'])
c.freeBound(wvl)
plot(wvl, c.FreeBound['intensity'])
fe25=ch.ion('fe_25',2.e+7,1.e+9,em=1.e+27)
fe25.twoPhoton(wvl)
plt.plot(wvl,fe25.TwoPhoton['intensity'],label='2 photon')
plt.legend(loc='upper right')

produces

In the continuum calculations, the specified ion, Fe XXV in this case, is the target ion for the free-free calculation. For the free-bound calculation, specified ion is also the target ion. In this case, the radiative recombination spectrum of Fe XXV recombining to form Fe XXIV is returned.

The multi-ion class Bunch¶

The multi-ion class bunch [new in v0.6] inherits a number of the same methods inherited by the ion class, for example intensityList, intensityRatio, and intensityRatioSave. As a short demonstration of its usefulness, Widing and Feldman (1989, ApJ, 344, 1046) used line ratios of Mg VI and Ne VI as diagnostics of elemental abundance variations in the solar atmosphere. For that to be accurate, it is necessary that the lines of the two ions have the same temperature response.

t = 10.**(5.0+0.1*np.arange(11))
bnch=ch.bunch(t,1.e+9,wvlRange=[300.,500.],ionList=['ne_6','mg_6'],abundance='unity')
bnch.intensityRatio(wvlRange=[395.,405.],top=7)

produces and initial plot of the selected lines, a selection widget and finally a plot of the ratio

there seems to be a significant temperature dependence to the ratio, even though both are formed near 4.e+5 K.

A new keyword argument keepIons has been added in v0.6 to the bunch and the 3 spectrum classes. It should be used with some care as it can lead to very large instances in the case of a large number of ions, temperature, or densities.

dwvl = 0.01
nwvl = (406.-394.)/dwvl
wvl = 394. + dwvl*np.arange(nwvl+1)
bnch2=ch.bunch(t, 1.e+9, wvlRange=[wvl.min(),wvl.max()], elementList=['ne','mg'], keepIons=1,em=1.e+27)
bnch2.convolve(wvl,filter=(chfilters.gaussian,5.*dwvl))
plt.plot(wvl, bnch2.Spectrum['intensity'][6],label='Total')
plt.title('Temperature = %10.2e for t[6]'%(t[6]))

elapsed seconds = 11.000 elapsed seconds = 0.000e+00

for one in sorted(bnch2.IonInstances.keys()):
  print('%s'%(one))

yields:

mg_10 mg_10d mg_3 mg_4 mg_5 mg_6 mg_8 mg_9 ne_10 ne_2 ne_3 ne_5 ne_6 ne_8

these IonInstances have all the properties of the Ion class for each of these ions

plt.plot(wvl,bnch2.IonInstances['mg_6'].Spectrum['intensity'][6],'r',label='mg_6')
plt.legend(loc='upper left')

produces

There is demo notebooks for the bunch class, bunch_demo.ipynb, in the jupyter_notebooks directory

Spectra of multiple ions and continuum¶

the spectrum for all ions in the CHIANTI database can also be calculated

The spectrum for a selection of all of the ions in the CHIANTI database can also be calculated. There are 3 spectral classes.

spectrum - the single processor implementation that can be used anywhere
mspectrum - uses the Python multiprocessing class and cannot be used in a IPython qtconsole or notebook
ipymspectrum [new in v0.6] - uses the IPython parallel class and can be used in a IPython qtconsole or notebook

The single processor spectrum class¶

temperature = [1.e+6, 2.e+6]
density = 1.e+9
wvl = 200. + 0.05*arange(2001)
emeasure = [1.e+27 ,1.e+27]
s = ch.spectrum(temperature, density, wvl, filter = (chfilters.gaussian,.2), em = emeasure, doContinuum=0, minAbund=1.e-5)
subplot(311)
plot(wvl, s.Spectrum['integrated'])
subplot(312)
plot(wvl, s.Spectrum['intensity'][0])
subplot(313)
plot(wvl, s.Spectrum['intensity'][1])

produces

The integrated spectrum is formed by summing the spectra for all temperatures.

For minAbund=1.e-6, the calculatation takes 209 s on a 3.5 GHz processor.

For minAbund=1.e-5, the calculatation takes 122 s on a 3.5 GHz processor.

The filter is not applied to the continuum.

Calculations with the Spectrum module can be time consuming. One way to control the length of time the calculations take is to limit the number of ions with the ionList keyword and to avoid the continuum calculations by setting the doContinuum keyword to 0 or False. Another way to control the length of time the calculations take is with the minAbund keyword. It sets the minimum elemental abundance that an element can have for its spectra to be calculated. The default value is set include all elements. Some usefull values of minAbund are:

minAbund = 1.e-4, will include H, He, C, O, Ne

minAbund = 2.e-5 adds N, Mg, Si, S, Fe

minAbund = 1.e-6 adds Na, Al, Ar, Ca, Ni

The multiple processor mspectrum class¶

Another way to speed up calculations is to use the mspectrum class which uses multiple cores on your local computer. It requires the Python multiprocessing module which is available with Python versions 2.6 and later. mspectrum is called in the same way as spectrum but you can specify the number of cores with the proc keyword. The default is 3 but it will not use more cores than are available on your machine. For example,

s = ch.mspectrum(temperature, density ,wvl, em=emeasure, filter = (chfilters.gaussian,.005), proc=4)

The multiple processor ipymspectrum class¶

next, we will use the ipymspectrum class. First, it is necessary to start up the cluster. In some shell

> ipcluster start –n=4

or, if you are using Python3

> ipcluster3 start –n=4

this will start 4 engines if you have 4 cores but it won’t start more than you have

then in an IPython notebook or qtconsole

temp = [1.e+6, 2.e+6]
dens = 1.e+9
wvl = 200. + 0.05*np.arange(2001)
emeasure = [1.e+27 ,1.e+27]
s = ch.ipymspectrum(temp, dens, wvl, filter = (chfilters.gaussian,.2), em = emeasure, doContinuum=1, minAbund=1.e-5, verbose=0)
plt.figure
plt.plot(wvl, s.Spectrum['integrated'])

produces

spectrum, mspectrum and ipymspectrum can all be instantiated with the same arguments and keyword arguments. Most of the examples below use the ipymspectrum class for speed.

temperature = 1.e+7
wvl = 10. + 0.005*arange(2001)
s = ch.ipymspectrum(temperature, density, wvl, filter = (chfilters.gaussian,.015))
plot(wvl, s.Spectrum['intensity'])

produces

It is also possible to specify a selection of ions by means of the ionList keyword, for example, ionList=[‘fe_11’,’fe_12’,’fe_13’]

s2 = ch.ipymspectrum(temp, dens, wvl, filter = (chfilters.gaussian,.2), em = emeasure, doContinuum=0, keepIons=1, elementList=['si'], minAbund=1.e-4)
plt.subplot(211)
plt.plot(wvl,s2.Spectrum['intensity'][0])
plt.ylabel(r'erg cm$^{-2}$ s$^{-1}$ sr$^{-1} \AA^{-1}$')
plt.subplot(212)
plt.plot(wvl,s2.IonInstances['si_9'].Spectrum['intensity'][0])
plt.ylabel(r'erg cm$^{-2}$ s$^{-1}$ sr$^{-1} \AA^{-1}$')
plt.xlabel(r'Wavelength ($\AA$)')
plt.title('Si IX')

Because keepIons has been set, the ion instances of all of the ions are maintained in the s2.IonInstances dictionary. It has been possible to compare the spectrum of all of the ions with the spectrum of a single ion. It should be used with some care as it can lead to very large instances in the case of a large number of ions, temperature, or densities.

temp=2.e+7
dens=1.e+9
wvl = 1. + 0.002*np.arange(4501)
s3 = ch.ipymspectrum(temp, dens, wvl, filter = (chfilters.gaussian,.015),doContinuum=1, em=1.e+27,minAbund=1.e-5,verbose=0)
plt.plot(wvl, s3.Spectrum['intensity'])

with doContinuum=1, the continuum can be plotted separately

plot(wvl, s3.Spectrum['intensity'])  plot(wvl,s.FreeFree['intensity'])
plot(wvl,s.FreeBound['intensity'])
plot(wvl,s.FreeBound['intensity']+s.FreeFree['intensity'])

produces

temperature = 2.e+7
density = 1.e+9
em-1.e+27
wvl = 1.84 + 0.0001*arange(601)
s4 = ch.ipymspectrum(temperature, density ,wvl, filter = (chfilters.gaussian,.0003), doContinuum=1, minAbund=1.e-5, em=em, verbose=0)

produces

There are two demo notebooks, spectrum_demo.ipynb and spectrum_demo_2.ipynb in the jupyter_notebooks directory.

Radiative loss rate¶

the radiative loss rate can be calculated as a function of temperature and density:

temp = 10.**(4.+0.05*arange(81))
rl = ch.radLoss(temp, 1.e+4, minAbund=2.e-5)
rl.radLossPlot()

produces, in 446 s:

the radiative losses are kept in the rl.RadLoss dictionary

the abundance keyword argument can be set to the name of an available abundance file in XUVTOP/abund

if abundance=’abc’, or some name that does not match an abundance name, a dialog will come up so that a abundance file can be selected

Jupyter Notebooks¶

There are 9 jupyter notebooks in the jupyter_notebooks directory that demonstrate the capabilities of ChiantyPy together with the CHIANTI database. There is also a README.txt file that provides a short explanation of the notebooks.

A summary of the notebooks¶

This directory contains 9 Jupyter IPython notebooks that demonstrate some of the ways to use ChiantiPy and the CHIANTI database

QuickStart.ipynb - a notebook that generally follows the Quick-Start guide in the docs

A demo of the bunch class is found in: bunch_demo.ipynb

Two demos of the spectrum class are found in: spectrum_demo.ipynb and spectrum_demo_2.ipynb

The directory also contains 5 other notebooks and a json file. These are demo files for reproducing some of the analyses in the paper “Electron densities and their uncertainties derived from spectral emission line intensities” by Kenneth Dere. This paper has been published in the Monthly Notices of the Royal Astronomical Society, 2020, 496, 2334.

The notebook file ‘1_fe_13_demo_make_model.ipynb’ constructs the model that is used by 2_fe_13_demo_check_model.ipynb and 3_fe_13_demo_chi2_search.ipynb by reading the ‘tab2_1993_qs_fe_13.json’ file. It is easiest if all files are placed in the same directory. This files contains the Fe XIII line intensities from Brosius et al., 1996, Astrophysical Journal Supplement Series, 106, 143. This notebook file needs to be run first.

The next notebook to run is: 2_fe_13_demo_check_model.ipynb – This notebook load the previously created pickle containing the match attribute. In this notebook a density and emission measure are guessed from an ‘em loci’ plot and the predictions compard with the observations.

The next notebook to run is: 3_fe_13_demo_chi2_search.ipynb – This performs a brute force chi-squared search over the density range and finds the best fit density and emission measure. These best values are then inserted into the model, a prediction made and compared with the observations.

The next notebook to run is: 4_fe_13_demo_mcmc.ipynb – This performs a MCMC analysis of the spectra to determine the most likely density and emission measure from an analysis of the trace. The trace is also save for futher analysis.

The next notebook to run is: 5_fe_13_demo_mcmc_trace_analyze.ipynb – the load the trace so that it can be re-analyzed

QuickStart.ipynb¶

bunch_demo.ipynb¶

spectrum_demo.ipynb¶

spectrum_demo_2.ipynb¶

1_fe_13_demo_make_match.ipynb¶

2_fe_13_demo_check_model.ipynb¶

3_fe_13_demo_chi2_search.ipynb¶

4_fe_13_demo_mcmc.ipynb¶

5_fe_13_demo_mcmc_trace_analyze.ipynb¶

Tutorial¶

The ChiantiPy Approach¶

Python is a modern, object-oriented programming language. It provides a number of features that are useful to the programmer and the end user, such as, classes with methods (function-like) and attributes (data), and functions, among other things. ChiantiPy has been constructed so that the primary means to calculate the spectral properties of ions and groups of ions is by way of Python classes.

More detailed information can be found in the API Reference.

ChiantiPy Classes¶

There are 7 basic classes that are provided by ChiantiPy.

ion

this class is very useful in itself and is the basic unit employed by all of the other classes

continuum

for calculating the free-free (bremstrahlung), free-bound (radiative recombination) continuum as well as the radiative loss rates due to these processes.

bunch

allows the user to specify a bunch of ions and to calculate the radiative properties of the selected ions in a group. The ions can be specified by list of individual ions, list of elements, as well as by the minimum elemental abundance. The properties of each ion are available, as with members of the ion class. Among other things, the ratios of lines of different ions and elements can be calculated and then displayed.

spectrum

the spectrum class calculates the intensities of the line and continuum and them convolves the complete spectrum with a filter such as a Gaussian of specified width

there are actually 3 spectrum classes. Two of these all the use of multiple cpu cores to speed the calculation. The basic spectrum class does not do multi-processes and is therefore compatible with most Python environments

mspectrum

mspectrum duplicates the calculations of the spectrum class but it employes the Python multiprocessing package in order to use multiple cpu cores to calculate the spectrum. This class can be used in a basic Python shell, in a Python script, or in an IPython terminal. It can not be used in either the Jupyter qtconsole or the Jupyter notebook.

ipymspectrum

this class employes the IPython ipyparallel module to provide access to multiple cpu cores. It can only be used in the Jupyter qtconsole and the Jupyter notebook.

ioneq

this class allows the user to load and plot the ionization equilibria of a specfic element. It can read the ionization equililbrium files in the CHIANTI $XUVTOP/ioneq directory. Different ionization equilibria can be plotted against each other

it is also possible to calculate the ionization equilibria of an individual element using the ionization and recombination rates in the CHIANTI database. The results of this calculation can also be plotted agains existing calculations in the CHIANTI $XUVTOP/ioneq directory.

ChiantiPy Classes, Methods and Attributes¶

Each of the ChiantiPy classes listed above has a number of methods for calculating various properties. The results of these calculations are stored as attributes of the class that has been instantiatied (created). In Python, all objects, which includes everything in Python, have introspection so that all methods and attributes can be discovered and used. The IPython terminal and the Jupyter qtconsole both provide their own methods of easily displaying the methods and attributes.

Some methods in each class are more useful to the user than others. For example, below the populate() method is demonstrated below. However, it is generally not necessary for the user to use the populate() method. Methods that need the ion population will make use that the Population attribute is available and, if not, use the populate() method to create it.

Below, the methods that are most likely of interest to users are listed below. All of the available methods are presented and documented in the API section, a part of the ChiantiPy documentation.

ion

popPlot() method

plots the level populations of the top (most highly populated) levels as a function of temperature and/or density.

gofnt() method

an interactive method that plots the most intense lines of an ion in a give wavelength range (wvlRange) and allows the user to select a line or several lines, that will be summed, and then plots the GofT function for the selected lines and saves these values in the Gofnt dictionary as an attribute of the ion object.

emiss() method

calculates the spectral line emissivities of the ion and saves these in the Emiss dictionary as an attribute of the ion object.

intensity() method

calculates the intensity of the specified ion as a function of temperature and density. These properties are saved in the Intensity dictionary, available as an attribute of the ion.

intensityList() method

lists the spectral line intensities in a given wavelength range (wvlRange) in an interactive terminal or notebook

intensityPlot() method

plots the spectral line intensites in a given wavelength range (wvlRange) for the top most intensity lines.

intensityRatio() method

an interactive method that plots the most intense lines of an ion in a give wavelength range (wvlRange) and allows the user to select a pair of lines or a pair of lines to be summed and then plots the intensity ratio as a function of temperature and/or density. The ratio is saved in the IntensityRatio dictionary as an attribute of the ion.

spectrum() method

calculates the spectrum of the ion as a function of wavelength. The spectral line intensities are pass through a selectable filter to simulate the spectrometer line profile. The spectrum is save in the Spectrum dictionary as an attribute of the ion.

ionizRate() method

calculates the ionization rate coefficient as a function of temperature. The rate coefficient is save in the IonizRate dictionary as an attribute. Uses the methods diRate() and eaRate() to first calculate the direct and excitation-ionization (ea) rate coefficients and sums them.

recombRate() method

calculates the recombination rate coefficient as a function of temperature. The rate coefficient is save in the RecombRate dictionary as an attribute. Uses the methods rrRate() and drRate() to first calculate the radiative recombination and dielectronic recombination rate coefficients and sums them.

ioneq

load() method

reads a selected, existing ionization equilibrium calculation for a given element and saves it as a numpy array Ioneq as an attribute of the object.

calculate() method

calculates the ionization equilibrium of a selected element from the CHIANTI ionization and recombination rates for a specified temperature(s) and saves it as a numpy array Ioneq as an attribute of the object.

plot() method

plots the loaded or calculated ionization equilibrium. Various parameters can be specified to plot only those aspects that are desired. Can also plot an additional existing ionization equilibrium for comparison

bunch

the init method calculates the spectral line intensities for the selection of ions save the information in the Intensity dictionary as an attribute . It does not calculate the continuum.

beyond the init method, the bunch class inherits all of the following methods that are described under the ion class above

intensityList()

intensityPlot()

intensityRatio()

in addition, it inherits the following methods that are described under the spectrum class below

convolve()

lineSpectrumPlot()

spectrumPlot()

spectrum

the init method calculates the spectral line intensities and the continuum due to the free-free (bremstrahlung), free-bound (radiative recombination), and two-photon processes. The line intensities are convolved using the convolve() method (below). The sum is saved in the Spectrum dictionary as an attribute.

beyond the init method, the spectrum class also inherits the same methods as the bunch class including intensityList(), intensityPlot, and intensityRatio.

convolve()

convolves the line spectrum with specified filter from ChiantiPy.tools.filters using a specified width.

lineSpectrumPlot()

plots the convolved line spectrum as a function wavelength

spectrumPlot()

plots the spectrum calculated by the init method. The summed (integrated) spectrum can be plotted or the spectrum for a specific temperature can be plotted.

mspectrum

the mspectrum behaves in the same way as the spectrum class except that it invokes the Python multiprocessing module so that the calculations are made using a specified number of cpu cores. mspectrum can not be used in the Jupyter qtconsole or notebook.

ipymspectrum

the ipymspectrum behaves in the same way as the spectrum class except that it invokes the IPython ipyparallel module so that the calculations are made using a specified number of cpu cores. ipymspectrum can only be used in the IPython terminal or the Jupyter qtconsole or notebook.

The ion class, basic properties¶

Bring up a Python session, or better yet, an IPython session

import ChiantiPy.core as ch
fe14 = ch.ion('fe_14')

The fe14 object is instantiated with a number of methods and data. Methods start with lowercase letters and attributes start with uppercase letters. It is best not to simply import ion as there is a method with the same name in matplotlib. A few examples:

fe14.IonStr
  >> 'fe_14'
fe14.Spectroscopic
  >> 'Fe XIV'

CHIANTI and spectroscopic notation for the ion

fe14.Z
  >> 26
fe14.Ion
  >> 14

nuclear charge Z and the ionization stage (in spectroscopic notation) for the ion

fe14.Ip
  >> 392.16196

this is the ionization potential in electron volts.

fe14.FIP
  >> 7.9023801573028294

this is the first ionization potential (FIP) in electron volts - the ionization potential of the neutral (Fe I).

fe14.Abundance
  >> 0.00012589265
fe14.AbundanceName
  >> 'sun_photospheric_1998_grevesse'

this is the abundance of iron relative to hydrogen for the specified elemental abundance set. For the ion class, the abundance can be specified by the abuncance keyword argument or the abundanceName keyword argument. In the case the abundance is taken from default abundcance set. The specified defaults can be examined by

fe14.Defaults
  >>  {'abundfile': 'sun_photospheric_1998_grevesse', 'flux': 'energy', 'ioneqfile': 'chianti', 'wavelength': 'angstrom'}

the defaults can be specified by the user in the chiantrc file. One is included in the distribution but needs to be place in the proper directory to be picked up. On Linux, it should be placed either in $HOME/.config or $HOME/.chianti. On Windows, it should be copied to $PROFILEHOME/.config or $PROFILEHOME/.chianti. If it is not found, a set of coded default values are used.

fe14.Elvlc.keys()
>>  ['ecmth', 'term', 'ref', 'pretty', 'spd', 'ecm', 'j', 'l', 'erydth', 'conf', 'lvl', 'spin', 'eryd', 'mult']

fe14.Elvlc is a dictionary that describes the energy levels of the Fe XIV ion. The key ‘ecm’ provides the energies, relative to the ground level, in inverse cm. The ‘ref’ key provides the references in the scientific literature where the data were provided.

fe14.Elvlc['ref']
>> ['%filename: fe_14.elvlc',
      %observed energy levels: Churilov S.S., Levashov V.E., 1993, Physica Scripta 48, 425,
      %observed energy levels: Redfors A., Litzen U., 1989, J.Opt.Soc.Am.B 6, #8, 1447,
      %theoretical energy levels: Storey P.J., Mason H.E., Young P.R., 2000, A&ASS 141, 28,
      %comment,
      Only level 16 does not have an observed energy. I have placed in,
      the third energy column a recommended value for the energy value of,
      this level, based on the theoretical and observed splittings of the,
      4F levels. It is this energy value which is used to compute the,
      wavelengths of transitions involving level 16 given in the .wgfa,
      file.,
      %produced as part of the Arcetri/Cambridge/GMU/NRL 'CHIANTI' atomic data base collaboration,
      %,
      %   P.R.Young Feb 99']

If the fe14 ion object had be instantiated (created) with a temperature and an electron density, then many more attributes can be calculated. For example, if the populate() method is used, it creates a dictionary attribute Population. One thing to remember with Python is that capitalization matters.

import numpy as np
t = 10.**(5.8+0.1*np.arange(11))
dens = 1.e+9
fe14 = ch.ion('fe_14')
fe14.populate()
fe14.Population.keys()
>>['ci', 'protonDensity', 'popmat', 'eDensity', 'rec', 'population', 'temperature']

fe14.Population['population'].shape
>>(21, 739)

'%10.2e'%(fe14.Temperature[10])
>> '  2.00e+06'

fe14.Population['population'][10,:5]
>>array([ 8.71775703e-01, 1.27867444e-01, 4.91230626e-09, 4.29120495e-08, 1.35517895e-08])

gives the population of the first 5 of 739 levels of Fe XIV at a temperature of 2.00e+6

to be continued

ChiantiPy’s API documentation¶

ChiantiPy package¶

Subpackages¶

ChiantiPy.Gui package¶

Subpackages¶

ChiantiPy.Gui.gui_cl package¶

Submodules¶

ChiantiPy.Gui.gui_cl.gui module¶

Command line selection dialogs.

class ChiantiPy.Gui.gui_cl.gui.choice2Dialog(items, label=None, parent=None)¶

Bases: object

Make a single or multiplee selection from a list of items and another single or multiple selection from the same list.

Useful for picking numerators and denominators.

expects the input of an array of items, will select one or more from both widgets the keywords label and parent are there for consistency with real gui dialogs

ChiantiPy.Gui.gui_cl.gui.chpicker(path, filter='*.*', label=None)¶

Select a filename from using a command line dialog.

the label keyword is included for consistency but does nothing

class ChiantiPy.Gui.gui_cl.gui.selectorDialog(items, label=None, parent=None)¶

Bases: object

Make a single or multiple selection from a list of items.

expects the input of an array of items, will select one or more the label and parent keywords are for consistency with other modules but do nothing

Module contents¶

command-line selection dialogs

ChiantiPy.Gui.gui_qt5 package¶

Submodules¶

ChiantiPy.Gui.gui_qt5.gui module¶

PyQt5 widget selection dialogs

class ChiantiPy.Gui.gui_qt5.gui.choice2Dialog(items, label=None, parent=None, multi=True)¶

Bases: PyQt5.QtWidgets.QDialog

Make a single or multiple selection from a list of items and another single or multiple selection from the same list.

Useful for picking numerators and denominators.

expects the input of an array of items, will select one or more from both widgets.

accept(self)¶

reject(self)¶

class ChiantiPy.Gui.gui_qt5.gui.chpicker(dir, label)¶

Bases: PyQt5.QtWidgets.QWidget

dialog to select a single file name under the directory code largely taken from pythonspot.com

initUI()¶

openFileNameDialog()¶

class ChiantiPy.Gui.gui_qt5.gui.selectorDialog(items, label=None, parent=None, multiChoice=True)¶

Bases: PyQt5.QtWidgets.QDialog

Make a single or multiple selection from a list of items.

expects the input of an array of items, will select one or more

accept(self)¶

reject(self)¶

ChiantiPy.Gui.gui_qt5.ui module¶

class ChiantiPy.Gui.gui_qt5.ui.Ui_choice2DialogForm¶

Bases: object

retranslateUi(choice2DialogForm)¶

setupUi(choice2DialogForm)¶

class ChiantiPy.Gui.gui_qt5.ui.Ui_selectorDialogForm¶

Bases: object

retranslateUi(selectorDialogForm)¶

setupUi(selectorDialogForm)¶

Module contents¶

PyQt5 selection dialog widgets

Module contents¶

Select GUI package

ChiantiPy.base package¶

Submodules¶

ChiantiPy.base._IonTrails module¶

Base classes used in the ChiantiPy.core.ion and ChiantiPy.core.spectrum classes. Mostly printing, plotting and saving routines.

class ChiantiPy.base._IonTrails.ionTrails¶

Bases: object

Base class for ChiantiPy.core.ion and ChiantiPy.core.spectrum

argCheck(temperature=None, eDensity=None, pDensity='default', em=None, verbose=0)¶: to check the compatibility of the three arguments and put them into numpy arrays of atleast_1d and create attributes to the object

intensityList(index=- 1, wvlRange=None, wvlRanges=None, top=10, relative=0, outFile=0, rightDigits=4)¶

List the line intensities. Checks to see if there is an existing Intensity attribute. If it exists, then those values are used. Otherwise, the intensity method is called.

This method prints an ASCII table with the following columns:

Ion: the CHIANTI style notation for the ion, e.g. ‘c_4’ for C IV
lvl1: the lower level of the transition in the CHIANTI .elvlc file
lvl2: the upper level of the transition in the CHIANTI .elvlc file
lower: the notation, usually in LS coupling, of the lower fine structure level
upper: the notation, usually in LS coupling, of the upper fine structure level
Wvl(A): the wavelength of the transition in units as specified in the chiantirc file.
Intensity
A value: the Einstein coefficient for spontaneous emission from level ‘j’ to level ‘i’
Obs: indicates whether the CHIANTI database considers this an observed line or one obtained from theoretical energy levels

Regarding the intensity column, if ‘flux’ in the chiantirc file is set to ‘energy’, the intensity is given by,

\[I = \Delta E_{ij}n_jA_{ij}\mathrm{Ab}\frac{1}{N_e} \frac{N(X^{+m})}{N(X)}\mathrm{EM},\]

in units of ergs cm^-2 s^-1 sr^-1. If ‘flux’ is set to ‘photon’,

\[I = n_jA_{ij}\mathrm{Ab}\frac{1}{N_e}\frac{N(X^{+m})}{N(X)} \mathrm{EM},\]

where,

$\Delta E_{ij}$ is the transition energy (ergs)
$n_j$ is the fractions of ions in level $j$
$A_{ij}$ is the Einstein coefficient for spontaneous emission from level $j$ to level $i$ (in s^-1)
$\mathrm{Ab}$ is the abundance of the specified element relative to hydrogen
$N_e$ is the electron density (in cm^-3)
$N(X^{+m})/N(X)$ is the fractional ionization of ion as a function of temperature
$\mathrm{EM}$ is the emission measure integrated along the line-of-sight, $\int\mathrm{d}l\,N_eN_H$ (cm^-5) where $N_H$ is the density of hydrogen (neutral + ionized) (cm^-3)

Note that if relative is set, the line intensity is relative to the strongest line and so the output will be unitless.

Parameters

index (int,optional) – Index the temperature or eDensity array to use. -1 (default) sets the specified value to the middle of the array
wvlRange (tuple) – Wavelength range
wvlRanges (a tuple, list or array that contains at least 2) – 2 element tuples, lists or arrays so that multiple wavelength ranges can be specified
top (int) – Number of lines to plot, sorted by descending magnitude.
relative (int) – specifies whether to normalize to strongest line default (relative = 0) specified that the intensities should be their calculated values
outFile (str) – specifies the file that the intensities should be output to default(outFile = 0) intensities are output to the terminal
rightDigits (int) – specifies the format for the wavelengths for the number of digits to right of the decimal place

intensityPlot(index=- 1, wvlRange=None, top=10, linLog='lin', relative=False, verbose=False, plotFile=0, em=0)¶

Plot the line intensities. Uses Intensity if it already exists. If not, calls the intensity method.

Parameters

index (integer) – specified which value of the temperature array or eDensity array to use. default (index=-1) sets the specified value to the middle of the array
wvlRange (2 element tuple, list or array determines the wavelength range)
top (integer) – specifies to plot only the top strongest lines, default = 10
linLog (str) – default(‘lin’) produces a plot where the intensity scale is linear if set to ‘log’, produces a plot where the intensity scale is logarithmic
normalize (= 1 specifies whether to normalize to strongest line) – default (relative = 0) specified that the intensities should be their calculated values
plotFile – default=0, the plot is not saved to a file othewise, the plot is saved to the ‘plotFile’
em (emission measure) – if an Intensity attribute needs be created, then the emission measure is applied

intensityRatio(wvlRange=None, wvlRanges=None, top=10, title=True)¶

Plot the intensity ratio of 2 lines or sums of lines. Shown as a function of density and/or temperature. For a single wavelength range, set wvlRange = [wMin, wMax] For multiple wavelength ranges, set wvlRanges = [[wMin1,wMax1],[wMin2,wMax2], …] A plot of relative emissivities is shown and then a dialog appears for the user to choose a set of lines.

Parameters

wvlRange (array-like) – Wavelength range, i.e. min and max
wvlRanges (a tuple, list or array that contains at least 2) – 2 element tuples, lists or arrays so that multiple wavelength ranges can be specified
top (int) – specifies to plot only the top strongest lines, default = 10

intensityRatioSave(outFile=0)¶

Save the intensity ratio to a file.

The intensity ratio as a function to temperature and eDensity is saved to an asciii file. Descriptive information is included at the top of the file.

Parameters: outFile – default(0): the plot of the intensity ratio is not saved str/unicode: the plot is saved to the file names ‘outFile’

ChiantiPy.base._SpecTrails module¶

Base class used in several ChiantiPy objects

class ChiantiPy.base._SpecTrails.specTrails(temperature, density)¶

Bases: object

a collection of methods for use in spectrum calculations

convolve(wavelength=0, filter=(<function gaussianR>, 1000.0), label=0, verbose=False)¶

the first application of spectrum calculates the line intensities within the specified wavelength range and for set of ions specified

wavelength will not be used if applied to ‘spectrum’ objects

wavelength IS need for ‘bunch’ objects - in this case, the wavelength should not extend beyond the limits of the wvlRange used for the ‘bunch’ calculation

Keyword Arguments

wavelength (‘int’, list) – if an int, the attribute ‘Wavelength’ is looked for otherwise, wavelength is used
filter (tuple) – first elements if one of the ChiantiPy.tools.filters object second element is the width appropriate to the filter
label (str) – if set, creates a Spectrum[label] attribute
verbose (bool) – if True, prints info to the terminal

ionGate(elementList=None, ionList=None, minAbund=None, doLines=1, doContinuum=1, doWvlTest=1, doIoneqTest=1, includeDiel=False, verbose=0)¶: creates a list of ions for free-free, free-bound, and line intensity calculations if doing the radiative losses, accept all wavelength -> doWvlTest=0 the list is a dictionary self.Todo

lineSpectrumPlot(index=0, integrated=False, saveFile=False, linLog='lin')¶

to plot the line spectrum as a function of wavelength

Keyword Arguments

index (int) – selects the temperature of the calculated line spectrum
integrated (bool) – if True, plots the integrated/summed line spectrum
saveFile (bool, str) – if set, saves the plot to ‘saveFile’
linLog (str) – should be either ‘lin’ for linear, or ‘log’ for logarithmic base10

saveData(filename)¶

Parameters: filename (str) – filename where the pickle file of the saved data will be stored

following running a ch.spectrum calculation, save the calculation as a dictionary to a pickle file

spectrumPlot(index=- 1, integrated=False, saveFile=False, linLog='lin')¶

to plot the spectrum as a function of wavelength

Keyword Arguments

index (int) – selects the temperature of the calculated spectrum
integrated (bool) – if True, plots the integrated/summed spectrum
saveFile (bool, str) – if set, saves the plot to ‘saveFile’
linLog (str) – should be either ‘lin’ for linear, or ‘log’ for logarithmic base10

Module contents¶

Base classes for ion- and spectrum-related objects.

ChiantiPy.core package¶

Subpackages¶

ChiantiPy.core.tests package¶

Submodules¶

ChiantiPy.core.tests.test_Continuum module¶

ChiantiPy.core.tests.test_Ion module¶

ChiantiPy.core.tests.test_Ioneq module¶

Tests for ioneq class

ChiantiPy.core.tests.test_Ioneq.test_calculate_ioneq()¶

ChiantiPy.core.tests.test_Ioneq.test_el_input()¶

ChiantiPy.core.tests.test_Ioneq.test_el_z_inputs_same()¶

ChiantiPy.core.tests.test_Ioneq.test_load_ioneq()¶

ChiantiPy.core.tests.test_Ioneq.test_load_ioneq_alternate_file()¶

ChiantiPy.core.tests.test_Ioneq.test_z_input()¶

ChiantiPy.core.tests.test_Spectrum module¶

Tests for the spectrum and bunch classes

ChiantiPy.core.tests.test_Spectrum.test_bunch()¶

ChiantiPy.core.tests.test_Spectrum.test_spectrum_array()¶

ChiantiPy.core.tests.test_Spectrum.test_spectrum_scalar()¶

Module contents¶

Submodules¶

ChiantiPy.core.Continuum module¶

Continuum module

class ChiantiPy.core.Continuum.continuum(ionStr, temperature, abundance=None, em=None, verbose=0)¶

Bases: ChiantiPy.base._IonTrails.ionTrails

The top level class for continuum calculations. Includes methods for the calculation of the free-free and free-bound continua.

Parameters

ionStr (str) – CHIANTI notation for the given ion, e.g. ‘fe_12’ that corresponds to the Fe XII ion.
temperature (array-like) – In units of Kelvin
abundance (float or str, optional) – Elemental abundance relative to Hydrogen or name of CHIANTI abundance file, without the ‘.abund’ suffix, e.g. ‘sun_photospheric_1998_grevesse’.
em (array-like, optional) – Line-of-sight emission measure ($\int\mathrm{d}l\,n_en_H$), in units of $\mathrm{cm}^{-5}$, or the volumetric emission measure ($\int\mathrm{d}V\,n_en_H$) in units of $\mathrm{cm}^{-3}$.

Examples

>>> import ChiantiPy.core as ch
>>> import numpy as np
>>> temperature = np.logspace(4,9,20)
>>> cont = ch.continuum('fe_15',temperature)
>>> wavelength = np.arange(1,1000,10)
>>> cont.freeFree(wavelength)
>>> cont.freeBound(wavelength, include_abundance=True, include_ioneq=False)
>>> cont.calculate_free_free_loss()
>>> cont.calculate_free_bound_loss()

Notes

The methods for calculating the free-free and free-bound emission and losses return their result to an attribute. See the respective docstrings for more information.

References

101(1,2,3): Sutherland, R. S., 1998, MNRAS, 300, 321
102(1,2): Verner & Yakovlev, 1995, A&AS, 109, 125
103(1,2,3,4,5,6): Karzas and Latter, 1961, ApJSS, 6, 167
104(1,2,3,4,5): Itoh, N. et al., 2000, ApJS, 128, 125
106(1,2,3,4,5,6,7,8,9,10): Mewe, R. et al., 1986, A&AS, 65, 511
107(1,2,3,4): Rybicki and Lightman, 1979, Radiative Processes in Astrophysics, (Wiley-VCH)
108(1,2,3,4): Gronenschild, E.H.B.M. and Mewe, R., 1978, A&AS, 32, 283

calculate_free_bound_loss(**kwargs)¶

Calculate the free-bound energy loss rate of an ion. The result is returned to the free_bound_loss attribute.

The free-bound loss rate can be calculated by integrating the free-bound emission over the wavelength. This is difficult using the expression in calculate_free_bound_emission so we instead use the approach of 108 and 106. Eq. 1a of 106 can be integrated over wavelength to get the free-bound loss rate,

\[\frac{dW}{dtdV} = C_{ff}\frac{k}{hc}T^{1/2}G_{fb},\]

in units of erg $\mathrm{cm}^3\,\mathrm{s}^{-1}$ where $G_{fb}$ is the free-bound Gaunt factor as given by Eq. 15 of 106 (see mewe_gaunt_factor for more details) and $C_{ff}$ is the numerical constant as given in Eq. 4 of 108 and can be written in terms of the fine structure constant $\alpha$,

\[C_{ff}\frac{k}{hc} = \frac{8}{3}\left(\frac{\pi}{6}\right)^{1/2}\frac{h^2\alpha^3}{\pi^2}\frac{k_B}{m_e^{3/2}} \approx 1.43\times10^{-27}\]

freeBound(wvl, includeAbund=True, includeIoneq=True, verbose=False)¶

Calculates the free-bound (radiative recombination) continuum emissivity of an ion. Provides emissivity in units of ergs $\mathrm{cm}^{-2}$ $\mathrm{s}^{-1}$ $\mathrm{str}^{-1}$ $\mathrm{\AA}^{-1}$ for an individual ion. If includeAbund is set, the abundance is included. If includeIoneq is set, the ionization equililibrium for the given ion is included

Notes

Uses the Gaunt factors of 103 for recombination to the ground level
Uses the photoionization cross sections of 3 to develop the free-bound cross section
Does not include the elemental abundance or ionization fraction
The specified ion is the target ion
uses the corrected version of the K-L bf gaunt factors available in CHIANTI V10
revised to calculate the bf cross, fb cross section and the maxwell energy distribution
the Verner cross sections are not included for now

References

3: Verner & Yakovlev, 1995, A&AS, 109, 125

freeBoundLoss(includeAbund=True, includeIoneq=True, verbose=False)¶

to calculate the free-bound (radiative recombination) energy loss rate coefficient of an ion, the ion is taken to be the target ion, including the elemental abundance and the ionization equilibrium population uses the Gaunt factors of 103 Karzas, W.J, Latter, R, 1961, ApJS, 6, 167 provides rate = erg cm^-2 s^-1 .. rubric:: Notes

Uses the Gaunt factors of 103 for recombination to the ground level
Uses the photoionization cross sections of 2 to develop the free-bound cross section
Does not include the elemental abundance or ionization fraction
The specified ion is the target ion
uses the corrected version of the K-L bf gaunt factors available in CHIANTI V10
revised to calculate the bf cross, fb cross section and the maxwell energy distribution
the Verner cross sections are not included for now
using the RESTART formulation

References

2: Verner & Yakovlev, 1995, A&AS, 109, 125

freeBoundLossMao(includeAbund=False, includeIoneq=False)¶: to calculate the radiative loss rate from the parameters of Mao J., Kaastra J., Badnell N.R. <Astron. Astrophys. 599, A10 (2017)>=2017A&A…599A..10M

freeBoundLossMewe(**kwargs)¶

Calculate the free-bound energy loss rate of an ion. The result is returned to the free_bound_loss attribute.

The free-bound loss rate can be calculated by integrating the free-bound emission over the wavelength. This is difficult using the expression in calculate_free_bound_emission so we instead use the approach of 108 and 106. Eq. 1a of 106 can be integrated over wavelength to get the free-bound loss rate,

\[\frac{dW}{dtdV} = C_{ff}\frac{k}{hc}T^{1/2}G_{fb},\]

in units of erg $\mathrm{cm}^3\,\mathrm{s}^{-1}$ where $G_{fb}$ is the free-bound Gaunt factor as given by Eq. 15 of 106 (see mewe_gaunt_factor for more details) and $C_{ff}$ is the numerical constant as given in Eq. 4 of 108 and can be written in terms of the fine structure constant $\alpha$,

\[C_{ff}\frac{k}{hc} = \frac{8}{3}\left(\frac{\pi}{6}\right)^{1/2}\frac{h^2\alpha^3}{\pi^2}\frac{k_B}{m_e^{3/2}} \approx 1.43\times10^{-27}\]

freeFree(wavelength, includeAbund=True, includeIoneq=True, **kwargs)¶

Calculates the free-free emission for a single ion. The result is returned as a dict to the FreeFree attribute. The dict has the keywords intensity, wvl, temperature, em.

The free-free emission for the given ion is calculated according Eq. 5.14a of 107, substituting $\nu=c/\lambda$, dividing by the solid angle, and writing the numerical constant in terms of the fine structure constant $\alpha$,

\[\frac{dW}{dtdVd\lambda} = \frac{c}{3m_e}\left(\frac{\alpha h}{\pi}\right)^3\left(\frac{2\pi}{3m_ek_B}\right)^{1/2}\frac{Z^2}{\lambda^2T^{1/2}}\exp{\left(-\frac{hc}{\lambda k_BT}\right)}\bar{g}_{ff},\]

where $Z$ is the nuclear charge, $T$ is the electron temperature in K, and $\bar{g}_{ff}$ is the velocity-averaged Gaunt factor. The Gaunt factor is estimated using the methods of 104 and 101, depending on the temperature and energy regime. See itoh_gaunt_factor and sutherland_gaunt_factor for more details.

The free-free emission is in units of erg $\mathrm{cm}^3\mathrm{s}^{-1}\mathrm{\mathring{A}}^{-1}\mathrm{str}^{-1}$. If the emission measure has been set, the units will be multiplied by $\mathrm{cm}^{-5}$ or $\mathrm{cm}^{-3}$, depending on whether it is the line-of-sight or volumetric emission measure, respectively.

Parameters

wavelength (array-like) – In units of angstroms
includeAbund (bool, optional) – If True, include the ion abundance in the final output.
includeIoneq (bool, optional) – If True, include the ionization equilibrium in the final output

freeFreeLoss(includeAbund=True, includeIoneq=True, **kwargs)¶

Calculate the free-free energy loss rate of an ion. The result is returned to the FreeFreeLoss attribute.

The free-free radiative loss rate is given by Eq. 5.15a of 107. Writing the numerical constant in terms of the fine structure constant $\alpha$,

\[\frac{dW}{dtdV} = \frac{4\alpha^3h^2}{3\pi^2m_e}\left(\frac{2\pi k_B}{3m_e}\right)^{1/2}Z^2T^{1/2}\bar{g}_B\]

where where $Z$ is the nuclear charge, $T$ is the electron temperature, and $\bar{g}_{B}$ is the wavelength-averaged and velocity-averaged Gaunt factor. The Gaunt factor is calculated using the methods of 103. Note that this expression for the loss rate is just the integral over wavelength of Eq. 5.14a of 103, the free-free emission, and is expressed in units of erg $\mathrm{cm}^3\,\mathrm{s}^{-1}$.

free_free_loss(includeAbund=True, includeIoneq=True, **kwargs)¶

Calculate the free-free energy loss rate of an ion. The result is returned to the free_free_loss attribute.

The free-free radiative loss rate is given by Eq. 5.15a of 107. Writing the numerical constant in terms of the fine structure constant $\alpha$,

\[\frac{dW}{dtdV} = \frac{4\alpha^3h^2}{3\pi^2m_e}\left(\frac{2\pi k_B}{3m_e}\right)^{1/2}Z^2T^{1/2}\bar{g}_B\]

where where $Z$ is the nuclear charge, $T$ is the electron temperature, and $\bar{g}_{B}$ is the wavelength-averaged and velocity-averaged Gaunt factor. The Gaunt factor is calculated using the methods of 103. Note that this expression for the loss rate is just the integral over wavelength of Eq. 5.14a of 107, the free-free emission, and is expressed in units of erg $\mathrm{cm}^3\,\mathrm{s}^{-1}$.

ioneqOne()¶: Provide the ionization equilibrium for the selected ion as a function of temperature. Similar to but not identical to ion.ioneqOne() - the ion class needs to be able to handle the ‘dielectronic’ ions returned in self.IoneqOne

ioneq_one(stage, **kwargs)¶

Calculate the equilibrium fractional ionization of the ion as a function of temperature.

Uses the ChiantiPy.core.ioneq module and does a first-order spline interpolation to the data. An ionization equilibrium file can be passed as a keyword argument, ioneqfile. This can be passed through as a keyword argument to any of the functions that uses the ionization equilibrium.

Parameters: stage (int) – Ionization stage, e.g. 25 for Fe XXV

itoh_gaunt_factor(wavelength)¶

Calculates the free-free gaunt factors of 104.

An analytic fitting formulae for the relativistic Gaunt factor is given by Eq. 4 of 104,

\[g_{Z} = \sum^{10}_{i,j=0}a_{ij}t^iU^j\]

where,

\[t = \frac{1}{1.25}(\log_{10}{T} - 7.25),\ U = \frac{1}{2.5}(\log_{10}{u} + 1.5),\]

$u=hc/\lambda k_BT$, and $a_{ij}$ are the fitting coefficients and are read in using ChiantiPy.tools.io.itohRead and are given in Table 4 of 104. These values are valid for $6<\log_{10}(T)< 8.5$ and $-4<\log_{10}(u)<1$.

See also

ChiantiPy.tools.io.itohRead: Read in Gaunt factor coefficients from 104

mewe_gaunt_factor(**kwargs)¶

Calculate the Gaunt factor according to 106 for a single ion $Z_z$.

Using Eq. 9 of 106, the free-bound Gaunt factor for a single ion can be written as,

\[G_{fb}^{Z,z} = \frac{E_H}{k_BT}\mathrm{Ab}(Z)\frac{N(Z,z)}{N(Z)}f(Z,z,n)\]

where $E_H$ is the ground-state potential of H, $\mathrm{Ab}(Z)$ is the elemental abundance, $\frac{N(Z,z)}{N(Z)}$ is the fractional ionization, and $f(Z,z,n)$ is given by Eq. 10 and is approximated by Eq 16 as,

\[f(Z,z,n) \approx f_2(Z,z,n_0) = 0.9\frac{\zeta_0z_0^4}{n_0^5}\exp{\left(\frac{E_Hz_0^2}{n_0^2k_BT}\right)} + 0.42\frac{z^4}{n_0^{3/2}}\exp{\left(\frac{E_Hz^2}{(n_0 + 1)^2k_BT}\right)}\]

where $n_0$ is the principal quantum number, $z_0$ is the effective charge (see Eq. 7 of 106), and $\zeta_0$ is the number of vacancies in the 0th shell and is given in Table 1 of 106. Here it is calculated in the same manner as in fb_rad_loss.pro of the CHIANTI IDL library. Note that in the expression for $G_{fb}$, we have not included the $N_H/n_e$ factor.

Raises: ValueError – If no .fblvl file is available for this ion

rrRate()¶: Provide the radiative recombination rate coefficient as a function of temperature (K). a revised copy of the Ion method

sutherland_gaunt_factor(wavelength)¶

Calculates the free-free gaunt factor calculations of 101.

The Gaunt factors of 101 are read in using ChiantiPy.tools.io.gffRead as a function of $u$ and $\gamma^2$. The data are interpolated to the appropriate wavelength and temperature values using ~scipy.ndimage.map_coordinates.

vernerCross(wvl)¶

Calculates the photoionization cross-section using data from 102 for transitions to the ground state.

The photoionization cross-section can be expressed as $\sigma_i^{fb}=F(E/E_0)$ where $F$ is an analytic fitting formula given by Eq. 1 of 102,

\[F(y) = ((y-1)^2 + y_w^2)y^{-Q}(1 + \sqrt{y/y_a})^{-P},\]

where $E$ is the photon energy, $n$ is the principal quantum number, $l$ is the orbital quantum number, $Q = 5.5 + l - 0.5P$, and $\sigma_0,E_0,y_w,y_a,P$ are fitting paramters. These can be read in using ChiantiPy.tools.io.vernerRead.

ChiantiPy.core.Ion module¶

Ion class

class ChiantiPy.core.Ion.ion(ionStr, temperature=None, eDensity=None, pDensity='default', radTemperature=None, rStar=None, abundance=None, setup=True, em=None, verbose=0)¶

Bases: ChiantiPy.base._IoneqOne.ioneqOne, ChiantiPy.base._IonTrails.ionTrails, ChiantiPy.base._SpecTrails.specTrails

The top level class for performing spectral calculations for an ion in the CHIANTI database.

Parameters

ionStr (str) – CHIANTI notation for the given ion, e.g. ‘fe_12’ that corresponds to the Fe XII ion.
temperature (float , tuple, list, ~numpy.ndarray, optional) – Temperature array (Kelvin)
eDensity (float , tuple, list, or ~numpy.ndarray, optional) – Electron density array ($\mathrm{cm^{-3}}$ )
pDensity (float, tuple, list or ~numpy.ndarray, optional) – Proton density ($\mathrm{cm}^{-3}$ )
radTemperature (float or ~numpy.ndarray, optional) – Radiation black-body temperature (in Kelvin)
rStar (float or ~numpy.ndarray, optional) – Distance from the center of the star (in stellar radii)
abundance (float or str, optional) – Elemental abundance relative to Hydrogen or name of CHIANTI abundance file to use, without the ‘.abund’ suffix, e.g. ‘sun_photospheric_1998_grevesse’.
setup (bool or str, optional) – If True, run ion setup function. Otherwise, provide a limited number of attributes of the selected ion
em (float or ~numpy.ndarray, optional) – Emission Measure, for the line-of-sight emission measure ($\mathrm{\int \, n_e \, n_H \, dl}$) ($\mathrm{cm}^{-5}$.), for the volumetric emission measure $\mathrm{\int \, n_e \, n_H \, dV}$ ($\mathrm{cm^{-3}}$).

Variables

~ion.IonStr (str) – Name of element plus ion, e.g. fe_12 for Fe XII
~ion.Z (int) – the nuclear charge, 26 for fe_12.
~ion.Ion (int) – the ionization stage, 12 for fe_12.
~ion.Dielectronic (bool) – true if the ion is a ‘dielectronic’ ion where the levels are populated by dielectronic recombination.
~ion.Spectroscopic (str) – the spectroscopic notation for the ion, such as Fe XII for fe_12.
~ion.Filename (str) – the complete name of the file generic filename in the CHIANTI database, such as $XUVTOP/fe/fe_12/fe_12.
~ion.Ip (float) – the ionization potential of the ion
~ion.FIP (float) – the first ionization potential of the element
~ion.Defaults (dict) – these are specified by the software unless a chiantirc file is found in ‘$HOME/.chianti’:

Notes

The keyword arguments temperature, eDensity, radTemperature, rStar, em must all be either a float or have the same dimension as the rest if specified as lists, tuples or arrays.

The Defaults dict should have the following keys:

abundfile, the elemental abundance file, unless specified in chiantirc this defaults to sun_photospheric_1998_grevesse.
ioneqfile, the ionization equilibrium file name. Unless specified in ‘chiantirc’ this is defaults to chianti. Other choices are availble in $XUVTOP/ioneq
wavelength, the units of wavelength (Angstroms, nm, or kev), unless specified in the ‘chiantirc’ this is defaults to ‘angstrom’.
flux, specified whether the line intensities are give in energy or photon fluxes, unless specified in the ‘chiantirc’ this is defaults to energy.
gui, specifies whether to use gui selection widgets (True) or to make selections on the command line (False). Unless specified in the ‘chiantirc’ this is defaults to False.

boundBoundLoss(allLines=1)¶

Calculate the summed radiative loss rate for all spectral lines of the specified ion.

Parameters

allLines (bool) – If True, include losses from both observed and unobserved lines. If False, only include losses from observed lines.
includes elemental abundance and ionization fraction.

Returns

creates the attribute
BoundBoundLoss (dict with the keys below.) – rate : the radiative loss rate ($\mathrm{erg \, cm^{-3}} \, \mathrm{s}^{-1}$) per unit emission measure.

temperature : (K).

eDensity : electron density ($\mathrm{cm^{-3}}$)

diCross(energy=None, verbose=False)¶

Calculate the direct ionization cross section (cm$^2) as a function of the incident electron energy in eV, puts values into attribute DiCross

Parameters

energy (array-like) – incident electron energy in eV
verbose (bool, int) – with verbose set to True, printing is enabled

Variables

~ion.diCross.DiCross (dict) – keys: energy, cross

diRate()¶: Calculate the direct ionization rate coefficient as a function of temperature (K)

drPopulate(popCorrect=1, verbose=0)¶: Calculate level populations for specified ion. possible keyword arguments include temperature, eDensity, pDensity, radTemperature and rStar different from method populate() in that it includes the dielectronic recombination from all levels specified by the .auto file - consequently, it also calculates the populations of the higher ionization stage

drRate()¶: Provide the dielectronic recombination rate coefficient as a function of temperature (K).

drRateLvl(verbose=0)¶: to calculate the level resolved dielectronic rate from the higher ionization stage to the ion of interest rates are determined from autoionizing A-values the dictionary self.DrRateLvl contains rate = the dielectronic rate into an autoionizing level effRate = the dielectronic rate into an autoionizing level mutilplied by the branching ratio for a stabilizing transition totalRate = the sum of all the effRates

eaCross(energy=None, verbose=False)¶

Provide the excitation-autoionization cross section.

Energy is given in eV.

eaDescale()¶: Calculates the effective collision strengths (upsilon) for excitation-autoionization as a function of temperature.

eaRate()¶: Calculate the excitation-autoionization rate coefficient.

emiss(allLines=True)¶

Calculate the emissivities for lines of the specified ion.

units: ergs s^-1 str^-1

Does not include elemental abundance or ionization fraction

Wavelengths are sorted

set allLines = True to include unidentified lines

emissList(index=- 1, wvlRange=None, wvlRanges=None, top=10, relative=0, outFile=0)¶

List the emissivities.

wvlRange, a 2 element tuple, list or array determines the wavelength range

Top specifies to plot only the top strongest lines, default = 10

normalize = 1 specifies whether to normalize to strongest line, default = 0

emissPlot(index=- 1, wvlRange=None, top=10, linLog='lin', relative=0, verbose=0, plotFile=0, saveFile=0)¶

Plot the emissivities.

wvlRange, a 2 element tuple, list or array determines the wavelength range

Top specifies to plot only the top strongest lines, default = 10

linLog specifies a linear or log plot, want either lin or log, default = lin

normalize = 1 specifies whether to normalize to strongest line, default = 0

emissRatio(wvlRange=None, wvlRanges=None, top=10)¶: Plot the ratio of 2 lines or sums of lines. Shown as a function of density and/or temperature. For a single wavelength range, set wvlRange = [wMin, wMax] For multiple wavelength ranges, set wvlRanges = [[wMin1,wMax1],[wMin2,wMax2], …] A plot of relative emissivities is shown and then a dialog appears for the user to choose a set of lines.

gofnt(wvlRange=0, top=10, verbose=0, plot=True)¶

Calculate the ‘so-called’ G(T) function.

Given as a function of both temperature and eDensity.

Only the top( set by ‘top’) brightest lines are plotted. the G(T) function is returned in a dictionary self.Gofnt

intensity(allLines=1, verbose=0)¶

Calculate the intensities for lines of the specified ion.

units: ergs cm^-3 s^-1 str^-1

includes elemental abundance and ionization fraction.

the emission measure ‘em’ is included if specified

intensityRatioInterpolate(data, scale='lin', plot=0, verbose=0)¶: to take a set of date and interpolate against the IntensityRatio the scale can be one of ‘lin’/’linear’ [default], ‘loglog’, ‘logx’, ‘logy’,

ionizCross(energy=None)¶

Provides the total ionization cross section.

Notes

uses diCross and eaCross.

ionizRate()¶

Provides the total ionization rate.

Calls diRate and eaRate.

p2eRatio()¶

Calculates the proton density to electron density ratio using Eq. 7 of 1.

Notes

Uses the abundance and ionization equilibrium.

References

1: Young, P. R. et al., 2003, ApJS, 144, 135

popPlot(top=10, levels=[], scale=0, plotFile=0, outFile=0, pub=0, addTitle=None)¶

Plots populations vs temperature or eDensity.

top specifies the number of the most highly populated levels to plot (the default)

or can set levels to an array such as a list to set the desired levels to plot

if scale is set, then the population, if plotted vs. density, is divided by density - only useful if plotting level populations vs density

if pub is set, the want publication plots (bw, lw=2).

populate(popCorrect=1, verbose=0)¶: Calculate level populations for specified ion. possible keyword arguments include temperature, eDensity, pDensity, radTemperature and rStar populate assumes that all of the population in the higher ionization stages exists only in the ground level use drPopulate() for cases where the population of various levels in the higher ionization stage figure into the calculation

recombRate()¶

Provides the total recombination rate coefficient.

Calls drRate and rrRate

rrRate()¶: Provide the radiative recombination rate coefficient as a function of temperature (K).

rrlvlDescale(verbose=1)¶: Interpolate and extrapolate rrlvl rates. Used in level population calculations.

setup(alternate_dir=None, verbose=False)¶

Setup various CHIANTI files for the ion including .wgfa, .elvlc, .scups, .psplups, .reclvl, .cilvl, and others.

Parameters

alternate_dir (str) – directory cotaining the necessary files for a ChiantiPy ion; use to setup an ion with files not in the current CHIANTI directory
verbose (bool)

Notes

If ion is initiated with setup=False, call this method to do the setup at a later point.

setupIonrec(alternate_dir=None, verbose=False)¶

Setup method for ion recombination and ionization rates.

Notes

Allows a bare-bones ion object to be setup up with just the ionization and recombination rates. For ions without a complete set of files - one that is not in the MasterList.

spectrum(wavelength, filter=(<function gaussianR>, 1000.0), label=0, allLines=1)¶

Calculates the line emission spectrum for the specified ion.

Convolves the results of intensity to make them look like an observed spectrum the default filter is the gaussianR filter with a resolving power of 1000. Other choices include chianti.filters.box and chianti.filters.gaussian. When using the box filter, the width should equal the wavelength interval to keep the units of the continuum and line spectrum the same.

includes ionization equilibrium and elemental abundances

can be called multiple times to use different filters and widths uses label to keep the separate applications of spectrum sorted by the label for example, do .spectrum( …. label = ‘test1’) and do .spectrum( …. label = ‘test2’) then will get self.Spectrum.keys() = test1, test2 and self.Spectrum[‘test1’] = {‘intensity’:aspectrum, ‘wvl’:wavelength, ‘filter’:useFilter.__name__, ‘filterWidth’:useFactor}

Notes

scipy.ndimage.filters also includes a range of filters.

twoPhoton(wvl, verbose=False)¶

to calculate the two-photon continuum - only for hydrogen- and helium-like ions includes the elemental abundance and the ionization equilibrium includes the emission measure if specified discussed in 105

References

105: Young et al., 2003, ApJSS, 144, 135

twoPhotonEmiss(wvl)¶: To calculate the two-photon continuum rate coefficient - only for hydrogen- and helium-like ions

twoPhotonLoss()¶: to calculate the two-photon energy loss rate - only for hydrogen- and helium-like ions includes the elemental abundance and the ionization equilibrium does not include the emission measure

upsilonDescale(prot=0)¶: Provides the temperatures and effective collision strengths (upsilons) set prot for proton rates otherwise, ce will be set for electron collision rates uses the new format “scups” files

ChiantiPy.core.Ioneq module¶

Ionization equilibrium class

class ChiantiPy.core.Ioneq.ioneq(el_or_z)¶

Bases: object

Calculation ion fractions as a function of temperature assuming ionization equilibrium.

Parameters: el_or_z (int or str) – Atomic number or symbol

Note

When either loading or calculating a set of ion fractions, the temperature and ion fractions are returned to the Temperature and Ioneq attributes, respectively.

calculate(temperature)¶: Calculate ion fractions for given temperature array using the total ionization and recombination rates.

load(ioneqName=None)¶: Read temperature and ion fractions from a CHIANTI “.ioneq” file.

plot(stages=0, tRange=0, yr=0, oplot=False, label=1, title=1, bw=False, semilogx=0, verbose=0)¶

Plots the ionization equilibria.

self.plot(tRange=None, yr=None, oplot=False) stages = sequence of ions to be plotted, neutral == 1, fully stripped == Z+1 tRange = temperature range, yr = ion fraction range

for overplotting: oplot=”ioneqfilename” such as ‘mazzotta’ or if oplot=True or oplot=1 and a widget will come up so that a file can be selected. bw, if True, the plot is made in black and white

plotRatio(stageN, stageD, tRange=0, yr=0, label=1, title=1, bw=0, semilogx=1, verbose=0)¶

Plots the ratio of the ionization equilibria of two stages of a given element

self.plotRatio(stageN, stageD) stages = sequence of ions to be plotted, neutral == 1, fully stripped == Z+1 stageN = numerator stageD = denominator tRange = temperature range, yr = ion fraction range

ChiantiPy.core.IpyMspectrum module¶

ChiantiPy.core.IpyMspectrum.doAll(inpt)¶: to process ff, fb and line inputs

class ChiantiPy.core.IpyMspectrum.ipymspectrum(temperature, eDensity, wavelength, filter=(<function gaussianR>, 1000.0), label=None, elementList=None, ionList=None, minAbund=None, keepIons=0, doLines=1, doContinuum=1, allLines=1, em=None, abundance=None, verbose=0, timeout=0.1)¶

Bases: ChiantiPy.base._IonTrails.ionTrails, ChiantiPy.base._SpecTrails.specTrails

this is the multiprocessing version of spectrum for using inside an IPython Qtconsole or notebook.

be for creating an instance, it is necessary to type something like the following into a console

> ipcluster start –n=3

this is the way to invoke things under the IPython 6 notation

Calculate the emission spectrum as a function of temperature and density.

temperature and density can be arrays but, unless the size of either is one (1), the two must have the same size

the returned spectrum will be convolved with a filter of the specified width on the specified wavelength array

the default filter is gaussianR with a resolving power of 100. Other filters, such as gaussian, box and lorentz, are available in ChiantiPy.filters. When using the box filter, the width should equal the wavelength interval to keep the units of the continuum and line spectrum the same.

A selection of elements can be make with elementList a list containing the names of elements that are desired to be included, e.g., [‘fe’,’ni’]

A selection of ions can be make with ionList containing the names of the desired lines in Chianti notation, i.e. C VI = c_6

Both elementList and ionList can not be specified at the same time

a minimum abundance can be specified so that the calculation can be speeded up by excluding elements with a low abundance. With solar photospheric abundances -

setting minAbund = 1.e-4 will include H, He, C, O, Ne setting minAbund = 2.e-5 adds N, Mg, Si, S, Fe setting minAbund = 1.e-6 adds Na, Al, Ar, Ca, Ni

Setting em will multiply the spectrum at each temperature by the value of em.

em [for emission measure], can be a float or an array of the same length as the temperature/density. allLines = 1 will include lines with either theoretical or observed wavelengths. allLines=0 will include only those lines with observed wavelengths

proc = the number of processors to use timeout - a small but non-zero value seems to be necessary

ChiantiPy.core.Mspectrum module¶

class ChiantiPy.core.Mspectrum.mspectrum(temperature, eDensity, wavelength, filter=(<function gaussianR>, 1000.0), label=0, elementList=None, ionList=None, minAbund=None, keepIons=0, abundance=None, doLines=1, doContinuum=1, allLines=1, em=None, proc=3, verbose=0, timeout=0.1)¶

Bases: ChiantiPy.base._IonTrails.ionTrails, ChiantiPy.base._SpecTrails.specTrails

this is the multiprocessing version of spectrum set proc to the desired number of processors, default=3

Calculate the emission spectrum as a function of temperature and density.

temperature and density can be arrays but, unless the size of either is one (1), the two must have the same size

the returned spectrum will be convolved with a filter of the specified width on the specified wavelength array

the default filter is gaussianR with a resolving power of 100. Other filters, such as gaussian, box and lorentz, are available in chianti.filters. When using the box filter, the width should equal the wavelength interval to keep the units of the continuum and line spectrum the same.