Skip to main content
`Ctrl`+`K`

# 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 |Cosmology.to_format| and |Cosmology.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 |Cosmology.to_format| and |Cosmology.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 |Planck18| cosmology from which it was generated.

    >>> cosmo = Cosmology.from_format(cm, format="mapping")
    >>> cosmo
    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)

How did |Cosmology.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.

1. If the cosmology class is passed as the `cosmology` keyword argument to |Cosmology.from_format|,

2. 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 |Cosmology.from_format|.

    >>> del cm["cosmology"]  # remove cosmology class

    >>> Cosmology.from_format(cm, cosmology="FlatLambdaCDM")
    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)

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

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=<Quantity 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
    {'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=<Quantity 67.66 km / (Mpc s)>, Om0=0.30966, Tcmb0=<Quantity 0. K>, Neff=3.046, m_nu=None, Ob0=0.04897)

Let’s take a closer look at |Cosmology.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 |Cosmology.to_format| and |Cosmology.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
    {..., '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=<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)
    >>> 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 |Cosmology.from_format|.

    >>> del ct.meta["cosmology"]  # remove cosmology from metadata
    >>> Cosmology.from_format(ct, cosmology="FlatLambdaCDM")
    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)

Alternatively, specific cosmology classes can be used to parse the data.

    >>> from astropy.cosmology import FlatLambdaCDM
    >>> FlatLambdaCDM.from_format(ct)
     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)

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=<Quantity 67.66 km / (Mpc s)>, Om0=0.30966, Tcmb0=<Quantity 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 |Cosmology.to_format| and |Cosmology.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 |Planck18| cosmology can be recovered with |Cosmology.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 |Cosmology.to_format| and |Cosmology.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 |Cosmology.to_format| and |Cosmology.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
    {'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=<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)

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 |Cosmology.read| and |Cosmology.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}
    # - {name: H0, unit: km / (Mpc s), datatype: float64, description: Hubble ...}
    ...
    # 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 |Cosmology.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
    Planck18 67.66 0.30966 2.7255 3.046 [0.0,0.0,0.06] 0.04897

    >>> 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 |Cosmology.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 |Cosmology.read| and |Cosmology.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 |Cosmology.read| and |Cosmology.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 type="text/javascript" id="MathJax-script" async
        src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-chtml.js">
    </script>