Built-in Cosmology To/From Formats#
To see the a list of the available conversion formats:
>>> from astropy.cosmology import Cosmology
>>> Cosmology.to_format.list_formats()
Format Read Write Auto-identify
----------------- ---- ----- -------------
astropy.cosmology Yes Yes Yes
astropy.model Yes Yes Yes
astropy.row Yes Yes Yes
astropy.table Yes Yes Yes
mapping Yes Yes Yes
yaml Yes Yes No
Cosmology#
Cosmology I/O, using to_format() and from_format().
This module provides functions to transform a Cosmology object to and from another
Cosmology object. The functions are registered with convert_registry under the
format name “astropy.cosmology”. You probably won’t need to use these functions as they
are present mainly for completeness and testing.
>>> from astropy.cosmology import Cosmology, Planck18
>>> Planck18.to_format("astropy.cosmology") is Planck18
True
>>> Cosmology.from_format(Planck18) is Planck18
True
Mapping#
Cosmology <-> Mapping I/O, using to_format() and from_format().
This module provides functions to transform a Cosmology instance to a mapping
(dict-like) object and vice versa, from a mapping object back to a Cosmology
instance. The functions are registered with convert_registry under the format name
“mapping”. The mapping object is a dict-like object, with the cosmology’s parameters
and metadata as items. dict is a fundamental data structure in Python, and this
representation of a Cosmology is useful for translating between many serialization and
storage formats, or even passing arguments to functions.
We start with the simple case of outputting a Cosmology as a mapping.
>>> from astropy.cosmology import Cosmology, Planck18
>>> cm = Planck18.to_format('mapping')
>>> cm
{'cosmology': <class 'astropy.cosmology...FlatLambdaCDM'>,
'name': 'Planck18', 'H0': <Quantity 67.66 km / (Mpc s)>, 'Om0': 0.30966,
'Tcmb0': <Quantity 2.7255 K>, 'Neff': 3.046,
'm_nu': <Quantity [0. , 0. , 0.06] eV>, 'Ob0': 0.04897,
'meta': ...
cm is a dict, with the cosmology’s parameters and metadata as items.
How might we use this dict? One use is to unpack the dict into a function:
>>> def function(H0, Tcmb0, **kwargs): ...
>>> function(**cm)
Another use is to merge the dict with another dict:
>>> cm2 = {'H0': 70, 'Tcmb0': 2.7}
>>> cm | cm2
{'cosmology': <class 'astropy.cosmology...FlatLambdaCDM'>, ..., 'H0': 70, ...}
Most saliently, the dict can also be used to construct a new cosmological instance
identical to the Planck 2018 cosmology from which it was generated.
>>> cosmo = Cosmology.from_format(cm, format="mapping")
>>> cosmo
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
How did from_format() know to return an instance of the FlatLambdaCDM class?
The mapping object has a field cosmology which can be either the string name of the
cosmology class (e.g. “FlatLambdaCDM”) or the class itself.
This field can be omitted under two conditions.
If the cosmology class is passed as the
cosmologykeyword argument tofrom_format(),If a specific cosmology class, e.g.
FlatLambdaCDM, is used to parse the data.
To the first point, we can pass the cosmology class as the cosmology keyword
argument to from_format().
>>> del cm["cosmology"] # remove cosmology class
>>> Cosmology.from_format(cm, cosmology="FlatLambdaCDM")
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
To the second point, we can use specific cosmology class to parse the data.
>>> from astropy.cosmology import FlatLambdaCDM
>>> FlatLambdaCDM.from_format(cm)
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
Also, the class’ default parameter values are used to fill in any information missing in
the data. For example, if Tcmb0 is missing, the default value of 0.0 K is used.
>>> del cm["Tcmb0"] # show FlatLambdaCDM provides default
>>> FlatLambdaCDM.from_format(cm)
FlatLambdaCDM(name="Planck18", H0=..., Tcmb0=0.0 K, ...)
If instead of missing information, there is extra information, there are a few
options. The first is to use the move_to_meta keyword argument to move fields that
are not in the Cosmology constructor to the Cosmology’s metadata.
>>> cm2 = cm | {"extra": 42, "cosmology": "FlatLambdaCDM"}
>>> cosmo = Cosmology.from_format(cm2, move_to_meta=True)
>>> cosmo.meta
OrderedDict([('extra', 42), ...])
Alternatively, the rename keyword argument can be used to rename keys in the mapping
to fields of the Cosmology. This is crucial when the mapping has keys that are not
valid arguments to the Cosmology constructor.
>>> cm3 = dict(cm) # copy
>>> cm3["cosmo_cls"] = "FlatLambdaCDM"
>>> cm3["cosmo_name"] = cm3.pop("name")
>>> rename = {'cosmo_cls': 'cosmology', 'cosmo_name': 'name'}
>>> Cosmology.from_format(cm3, rename=rename)
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=0.0 K, Neff=3.046, m_nu=None, Ob0=0.04897)
Let’s take a closer look at to_format(), because there a lot of options, to
tailor the output to specific needs.
The dictionary type may be changed with the cls keyword argument:
>>> from collections import OrderedDict
>>> Planck18.to_format('mapping', cls=OrderedDict)
OrderedDict([('cosmology', <class 'astropy.cosmology...FlatLambdaCDM'>),
('name', 'Planck18'), ('H0', <Quantity 67.66 km / (Mpc s)>),
('Om0', 0.30966), ('Tcmb0', <Quantity 2.7255 K>), ('Neff', 3.046),
('m_nu', <Quantity [0. , 0. , 0.06] eV>), ('Ob0', 0.04897),
('meta', ...
Sometimes it is more useful to have the name of the cosmology class, not the type
itself. The keyword argument cosmology_as_str may be used:
>>> Planck18.to_format('mapping', cosmology_as_str=True)
{'cosmology': 'FlatLambdaCDM', ...
The metadata is normally included as a nested mapping. To move the metadata into the
main mapping, use the keyword argument move_from_meta. This kwarg inverts
move_to_meta in Cosmology.to_format("mapping", move_to_meta=...) where extra
items are moved to the metadata (if the cosmology constructor does not have a variable
keyword-only argument – **kwargs).
>>> from astropy.cosmology import Planck18
>>> Planck18.to_format('mapping', move_from_meta=True)
{'cosmology': <class 'astropy.cosmology...FlatLambdaCDM'>,
'name': 'Planck18', 'Oc0': 0.2607, 'n': 0.9665, 'sigma8': 0.8102, ...
Lastly, the keys in the mapping may be renamed with the rename keyword.
>>> rename = {'cosmology': 'cosmo_cls', 'name': 'cosmo_name'}
>>> Planck18.to_format('mapping', rename=rename)
{'cosmo_cls': <class 'astropy.cosmology...FlatLambdaCDM'>,
'cosmo_name': 'Planck18', ...
Table#
Cosmology <-> Table I/O, using to_format() and from_format().
This module provides functions to transform a Cosmology object to and from a Table
object. The functions are registered with convert_registry under the format name
“astropy.table”. Table itself has an abundance of I/O methods, making this conversion
useful for further interoperability with other formats.
A Cosmology as a QTable will have the cosmology’s name and parameters
as columns.
>>> from astropy.cosmology import Planck18
>>> ct = Planck18.to_format("astropy.table")
>>> ct
<QTable length=1>
name H0 Om0 Tcmb0 Neff m_nu Ob0
km / (Mpc s) K eV
str8 float64 float64 float64 float64 float64[3] float64
-------- ------------ ------- ------- ------- ----------- -------
Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897
The cosmological class and other metadata, e.g. a paper reference, are in the Table’s metadata.
>>> ct.meta
OrderedDict([..., ('cosmology', 'FlatLambdaCDM')])
Cosmology supports the astropy Table-like protocol (see Table-like Objects) to the same effect:
>>> from astropy.table import QTable
>>> QTable(Planck18)
<QTable length=1>
name H0 Om0 Tcmb0 Neff m_nu Ob0
km / (Mpc s) K eV
str8 float64 float64 float64 float64 float64[3] float64
-------- ------------ ------- ------- ------- ----------- -------
Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897
To move the cosmology class from the metadata to a Table row, set the
cosmology_in_meta argument to False:
>>> Planck18.to_format("astropy.table", cosmology_in_meta=False)
<QTable length=1>
cosmology name H0 Om0 Tcmb0 Neff m_nu Ob0
km / (Mpc s) K eV
str13 str8 float64 float64 float64 float64 float64[3] float64
------------- -------- ------------ ------- ------- ------- ----------- -------
FlatLambdaCDM Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897
Astropy recommends QTable for tables with Quantity
columns. However the returned type may be overridden using the cls argument:
>>> from astropy.table import Table
>>> Planck18.to_format("astropy.table", cls=Table)
<Table length=1>
...
Fields of the cosmology may be renamed using the rename argument.
>>> Planck18.to_format("astropy.table", rename={"H0": "Hubble"})
<QTable length=1>
name Hubble Om0 Tcmb0 Neff m_nu Ob0
km / (Mpc s) K eV
str8 float64 float64 float64 float64 float64[3] float64
-------- ------------ ------- ------- ------- ----------- -------
Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897
Appropriately formatted tables can be converted to Cosmology instances. Since the
Table can hold arbitrary metadata, we can faithfully round-trip a Cosmology through
Table, e.g. to construct a Planck18 cosmology identical to the instance from which
it was generated.
>>> ct = Planck18.to_format("astropy.table")
>>> cosmo = Cosmology.from_format(ct, format="astropy.table")
>>> cosmo
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
>>> cosmo == Planck18
True
The cosmology information (row or metadata) may be omitted if the cosmology class
(or its string name) is passed as the cosmology keyword argument to
from_format().
>>> del ct.meta["cosmology"] # remove cosmology from metadata
>>> Cosmology.from_format(ct, cosmology="FlatLambdaCDM")
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
Alternatively, specific cosmology classes can be used to parse the data.
>>> from astropy.cosmology import FlatLambdaCDM
>>> FlatLambdaCDM.from_format(ct)
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
When using a specific cosmology class, the class’ default parameter values are used to fill in any missing information.
>>> del ct["Tcmb0"] # show FlatLambdaCDM provides default
>>> FlatLambdaCDM.from_format(ct)
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=0.0 K, Neff=3.046, m_nu=None, Ob0=0.04897)
For tables with multiple rows of cosmological parameters, the index argument is
needed to select the correct row. The index can be an integer for the row number or, if
the table is indexed by a column, the value of that column. If the table is not indexed
and index is a string, the “name” column is used as the indexing column.
Here is an example where index is needed and can be either an integer (for the row
number) or the name of one of the cosmologies, e.g. ‘Planck15’.
>>> from astropy.cosmology import Planck13, Planck15, Planck18
>>> from astropy.table import vstack
>>> cts = vstack([c.to_format("astropy.table")
... for c in (Planck13, Planck15, Planck18)],
... metadata_conflicts='silent')
>>> cts
<QTable length=3>
name H0 Om0 Tcmb0 Neff m_nu Ob0
km / (Mpc s) K eV
str8 float64 float64 float64 float64 float64[3] float64
-------- ------------ ------- ------- ------- ----------- --------
Planck13 67.77 0.30712 2.7255 3.046 0.0 .. 0.06 0.048252
Planck15 67.74 0.3075 2.7255 3.046 0.0 .. 0.06 0.0486
Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897
>>> cosmo = Cosmology.from_format(cts, index=1, format="astropy.table")
>>> cosmo == Planck15
True
Fields in the table can be renamed to match the Cosmology class’
signature using the rename argument. This is useful when the table’s column names do
not match the class’ parameter names.
>>> renamed_table = Planck18.to_format("astropy.table", rename={"H0": "Hubble"})
>>> renamed_table
<QTable length=1>
name Hubble Om0 Tcmb0 Neff m_nu Ob0
km / (Mpc s) K eV
str8 float64 float64 float64 float64 float64[3] float64
-------- ------------ ------- ------- ------- ----------- -------
Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897
>>> cosmo = Cosmology.from_format(renamed_table, format="astropy.table",
... rename={"Hubble": "H0"})
>>> cosmo == Planck18
True
Model#
Cosmology <-> Model I/O, using to_format() and from_format().
This module provides functions to transform a Cosmology object to and from a
Model. The functions are registered with convert_registry
under the format name “astropy.model”.
Using format="astropy.model" any redshift(s) method of a cosmology may be turned
into a astropy.modeling.Model. Each Cosmology
Parameter is converted to a astropy.modeling.Model
Parameter and the redshift-method to the model’s __call__ /
evaluate. Now you can fit cosmologies with data!
>>> from astropy.cosmology import Cosmology, Planck18
>>> model = Planck18.to_format("astropy.model", method="lookback_time")
>>> model
<FlatLambdaCDMCosmologyLookbackTimeModel(H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. , 0. , 0.06] eV, Ob0=0.04897,
name='Planck18')>
The Planck 2018 cosmology can be recovered with from_format().
>>> print(Cosmology.from_format(model))
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
YAML#
Cosmology <-> YAML I/O, using to_format() and from_format().
This module provides functions to transform a Cosmology object to and from a yaml representation. The functions are registered with
convert_registry under the format name “yaml”. This format is primarily intended for
use by other I/O functions, e.g. Table’s metadata serialization, which themselves
require YAML serialization.
>>> from astropy.cosmology import Planck18
>>> yml = Planck18.to_format("yaml")
>>> yml
"!astropy.cosmology...FlatLambdaCDM\nH0: !astropy.units.Quantity...
>>> print(Cosmology.from_format(yml, format="yaml"))
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
Row#
Cosmology <-> Row I/O, using to_format() and from_format().
A Cosmology as a Row will have
the cosmology’s name and parameters as columns.
>>> from astropy.cosmology import Planck18
>>> cr = Planck18.to_format("astropy.row")
>>> cr
<Row index=0>
cosmology name H0 Om0 Tcmb0 Neff m_nu Ob0
km / (Mpc s) K eV
str13 str8 float64 float64 float64 float64 float64[3] float64
------------- -------- ------------ ------- ------- ------- ----------- -------
FlatLambdaCDM Planck18 67.66 0.30966 2.7255 3.046 0.0 .. 0.06 0.04897
The cosmological class and other metadata, e.g. a paper reference, are in the Table’s metadata.
>>> cr.meta
OrderedDict([('Oc0', 0.2607), ('n', 0.9665), ...])
Now this row can be used to load a new cosmological instance identical
to the Planck18 cosmology from which it was generated.
>>> cosmo = Cosmology.from_format(cr, format="astropy.row")
>>> cosmo
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
For more information on the argument options, see Table.
Built-in Cosmology Read/Write Formats#
To see a list of the available read/write file formats:
>>> from astropy.cosmology import Cosmology
>>> Cosmology.write.list_formats()
Format Read Write Auto-identify
----------- ---- ----- -------------
ascii.ecsv Yes Yes Yes
ascii.html Yes Yes Yes
ascii.latex No Yes Yes
ECSV#
Cosmology <-> ECSV I/O, using read() and write().
This module provides functions to write/read a Cosmology object to/from an ECSV file.
The functions are registered with readwrite_registry under the format name
“ascii.ecsv”.
We assume the following setup:
>>> from pathlib import Path
>>> from tempfile import TemporaryDirectory
>>> temp_dir = TemporaryDirectory()
To see reading a Cosmology from an ECSV file, we first write a Cosmology to an ECSV file:
>>> from astropy.cosmology import Cosmology, Planck18
>>> file = Path(temp_dir.name) / "file.ecsv"
>>> Planck18.write(file)
>>> with open(file) as f: print(f.read())
# %ECSV 1.0
# ---
# datatype:
# - {name: name, datatype: string}
...
# meta: !!omap
# - {Oc0: 0.2607}
...
# schema: astropy-2.0
name H0 Om0 Tcmb0 Neff m_nu Ob0
Planck18 67.66 0.30966 2.7255 3.046 [0.0,0.0,0.06] 0.04897
Now we can read the Cosmology from the ECSV file, constructing a new cosmological
instance identical to the Planck18 cosmology from which it was generated.
>>> cosmo = Cosmology.read(file)
>>> print(cosmo)
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
>>> cosmo == Planck18
True
If a file already exists, attempting to write will raise an error unless
overwrite=True.
>>> Planck18.write(file, overwrite=True)
By default the cosmology class is written to the Table metadata. This can be changed to
a column of the table using the cosmology_in_meta keyword argument.
>>> file = Path(temp_dir.name) / "file2.ecsv"
>>> Planck18.write(file, cosmology_in_meta=False)
>>> with open(file) as f: print(f.read())
# %ECSV 1.0
# ---
# datatype:
# - {name: cosmology, datatype: string}
# - {name: name, datatype: string}
...
# meta: !!omap
# - {Oc0: 0.2607}
...
# schema: astropy-2.0
cosmology name H0 Om0 Tcmb0 Neff m_nu Ob0
FlatLambdaCDM Planck18 67.66 0.30966 2.7255 3.046 [0.0,0.0,0.06] 0.04897
The cosmology information (column or metadata) may be omitted if the cosmology class
(or its string name) is passed as the cosmology keyword argument to
read(). Alternatively, specific cosmology classes can be used to parse the
data.
>>> from astropy.cosmology import FlatLambdaCDM
>>> print(FlatLambdaCDM.read(file))
FlatLambdaCDM(name="Planck18", H0=67.66 km / (Mpc s), Om0=0.30966,
Tcmb0=2.7255 K, Neff=3.046, m_nu=[0. 0. 0.06] eV, Ob0=0.04897)
When using a specific cosmology class, the class’ default parameter values are used to fill in any missing information.
For files with multiple rows of cosmological parameters, the index argument is
needed to select the correct row. The index can be an integer for the row number or, if
the table is indexed by a column, the value of that column. If the table is not indexed
and index is a string, the “name” column is used as the indexing column.
Here is an example where index is needed and can be either an integer (for the row
number) or the name of one of the cosmologies, e.g. ‘Planck15’.
>>> from astropy.cosmology import Planck13, Planck15, Planck18
>>> from astropy.table import vstack
>>> cts = vstack([c.to_format("astropy.table")
... for c in (Planck13, Planck15, Planck18)],
... metadata_conflicts='silent')
>>> file = Path(temp_dir.name) / "file3.ecsv"
>>> cts.write(file)
>>> with open(file) as f: print(f.read())
# %ECSV 1.0
# ---
# datatype:
# - {name: name, datatype: string}
...
# meta: !!omap
# - {Oc0: 0.2607}
...
# schema: astropy-2.0
name H0 Om0 Tcmb0 Neff m_nu Ob0
Planck13 67.77 0.30712 2.7255 3.046 [0.0,0.0,0.06] 0.048252
Planck15 67.74 0.3075 2.7255 3.046 [0.0,0.0,0.06] 0.0486
Planck18 67.66 0.30966 2.7255 3.046 [0.0,0.0,0.06] 0.04897
>>> cosmo = Cosmology.read(file, index="Planck15", format="ascii.ecsv")
>>> cosmo == Planck15
True
Fields of the table in the file can be renamed to match the
Cosmology class’ signature using the rename argument. This is
useful when the files’s column names do not match the class’ parameter names.
>>> file = Path(temp_dir.name) / "file4.ecsv"
>>> Planck18.write(file, rename={"H0": "Hubble"})
>>> with open(file) as f: print(f.read())
# %ECSV 1.0
# ---
# datatype:
# - {name: name, datatype: string}
...
# meta: !!omap
# - {Oc0: 0.2607}
...
# schema: astropy-2.0
name Hubble Om0 Tcmb0 Neff m_nu Ob0
...
>>> cosmo = Cosmology.read(file, rename={"Hubble": "H0"})
>>> cosmo == Planck18
True
By default Cosmology instances are written using
QTable as an intermediate representation (for details see
to_format(), with format="astropy.table"). The Table type
can be changed using the cls keyword argument.
>>> from astropy.table import Table
>>> file = Path(temp_dir.name) / "file5.ecsv"
>>> Planck18.write(file, cls=Table)
For most use cases, the default cls of QTable is recommended
and will be largely indistinguishable from other table types, as the ECSV format is
agnostic to the table type. An example of a difference that might necessitate using a
different table type is if a different ECSV schema is desired.
Additional keyword arguments are passed to QTable.read and QTable.write.
LaTeX#
Cosmology <-> LaTeX I/O, using read() and write().
We assume the following setup:
>>> from pathlib import Path
>>> from tempfile import TemporaryDirectory
>>> temp_dir = TemporaryDirectory()
Writing a cosmology to a LaTeX file will produce a table with the cosmology’s type, name, and parameters as columns.
>>> from astropy.cosmology import Cosmology, Planck18
>>> file = Path(temp_dir.name) / "file.tex"
>>> Planck18.write(file, format="ascii.latex")
>>> with open(file) as f: print(f.read())
\begin{table}
\begin{tabular}{cccccccc}
cosmology & name & $H_0$ & $\Omega_{m,0}$ & $T_{0}$ & $N_{eff}$ & $m_{nu}$ & $\Omega_{b,0}$ \\
& & $\mathrm{km\,Mpc^{-1}\,s^{-1}}$ & & $\mathrm{K}$ & & $\mathrm{eV}$ & \\
FlatLambdaCDM & Planck18 & 67.66 & 0.30966 & 2.7255 & 3.046 & 0.0 .. 0.06 & 0.04897 \\
\end{tabular}
\end{table}
The cosmology’s metadata is not included in the table.
To save the cosmology in an existing file, use overwrite=True; otherwise, an
error will be raised.
>>> Planck18.write(file, format="ascii.latex", overwrite=True)
To use a different table class as the underlying writer, use the cls kwarg. For
more information on the available table classes, see the documentation on Astropy’s
table classes and on Cosmology.to_format("astropy.table").
By default the parameter names are converted to LaTeX format. To disable this, set
latex_names=False.
>>> file = Path(temp_dir.name) / "file2.tex"
>>> Planck18.write(file, format="ascii.latex", latex_names=False)
>>> with open(file) as f: print(f.read())
\begin{table}
\begin{tabular}{cccccccc}
cosmology & name & H0 & Om0 & Tcmb0 & Neff & m_nu & Ob0 \\
& & $\mathrm{km\,Mpc^{-1}\,s^{-1}}$ & & $\mathrm{K}$ & & $\mathrm{eV}$ & \\
FlatLambdaCDM & Planck18 & 67.66 & 0.30966 & 2.7255 & 3.046 & 0.0 .. 0.06 & 0.04897 \\
\end{tabular}
\end{table}
HTML#
Cosmology <-> html I/O, using read() and write().
We assume the following setup:
>>> from pathlib import Path
>>> from tempfile import TemporaryDirectory
>>> temp_dir = TemporaryDirectory()
Writing a cosmology to a html file will produce a table with the cosmology’s type, name, and parameters as columns.
>>> from astropy.cosmology import Planck18
>>> file = Path(temp_dir.name) / "file.html"
>>> Planck18.write(file)
>>> with open(file) as f: print(f.read())
<html>
<head>
<meta charset="utf-8"/>
<meta content="text/html;charset=UTF-8" http-equiv="Content-type"/>
</head>
<body>
<table>
<thead>
<tr>
<th>cosmology</th> <th>name</th> <th>H0</th> <th>Om0</th> <th>Tcmb0</th>
<th>Neff</th> <th colspan="3">m_nu</th> <th>Ob0</th>
</tr>
</thead>
<tr>
<td>FlatLambdaCDM</td> <td>Planck18</td> <td>67.66</td> <td>0.30966</td>
<td>2.7255</td> <td>3.046</td> <td>0.0</td> <td>0.0</td> <td>0.06</td>
<td>0.04897</td>
</tr>
</table>
</body>
</html>
The cosmology’s metadata is not included in the file.
To save the cosmology in an existing file, use overwrite=True; otherwise, an
error will be raised.
>>> Planck18.write(file, overwrite=True)
To use a different table class as the underlying writer, use the cls kwarg. For
more information on the available table classes, see the documentation on Astropy’s
table classes and on Cosmology.to_format("astropy.table").
By default the parameter names are not converted to LaTeX / MathJax format. To
enable this, set latex_names=True.
>>> file = Path(temp_dir.name) / "file2.html"
>>> Planck18.write(file, latex_names=True)
>>> with open(file) as f: print(f.read())
<html>
...
<thead>
<tr>
<th>cosmology</th>
<th>name</th>
<th>$$H_{0}$$</th>
<th>$$\Omega_{m,0}$$</th>
<th>$$T_{0}$$</th>
<th>$$N_{eff}$$</th>
<th colspan="3">$$m_{nu}$$</th>
<th>$$\Omega_{b,0}$$</th>
</tr>
...
Note
A HTML file containing a Cosmology HTML table should have scripts enabling MathJax.
<script src="https://polyfill.io/v3/polyfill.min.js?features=es6"></script>
<script type="text/javascript" id="MathJax-script" async
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js">
</script>