- NAME
- DESCRIPTION
- WARNING
- SYNOPSIS
- UNITS
- NOTES
- THEORY
- CONSTANTS
- SYNTAX
- SUMMARY
- ROUTINES
- new
- version
- stringify
- setvars
- omega_matter or matter
- omega_lambda or lambda
- h0 or hO
- lum_dist or luminosity_distance
- adiam_dist or angular_diameter_distance
- pmot_dist or proper_motion_distance
- comov_dist or comoving_distance
- comov_vol or comoving_volume
- dcomov_vol or differential_comoving_volume
- lookback_time
- abs_mag or absolute_magnitude
- app_mag or apparent_magnitude
- luminosity
- flux

- TODO
- ACKNOWLEDGEMENTS
- SEE ALSO
- AUTHOR

# NAME

Astro::Cosmology - calculate cosmological distances, volumes, and times

# DESCRIPTION

This module provides a set of routines to calculate a number of cosmological quantities based on distance and time. Some are a bit complex - e.g. the volume element at a given redshift - while some, such as the conversion between flux and luminosity, are more mundane.

To calculate results for a given cosmology you create an `Astro::Cosmology`

object with the desired cosmological parameters, and then call the object's methods to perform the actual calculations. If you aren't used to objects, it may sound confusing; hopefully the SYNOPSIS section below will help (after all, a bit of code is worth a thousand words). The advantage of using an object-orientated interface is that the object can carry around the cosmological parameters, so you don't need to keep on specifying them whenever you want to calculate anything; it also means you can write routines which can just accept an `Astro::Cosmology`

object rather than all the cosmological parameters.

This module *requires* that the PDL distribution is installed on your machine; PDL is available from CPAN or http://pdl.perl.org/

# WARNING

Whilst I believe the results are accurate, I do not guarantee this. Caveat emptor, as the Romans used to say...

# SYNOPSIS

```
use Astro::Cosmology qw( :constants );
# what is the luminosity distance, in metres, for
# a couple of cosmologies
#
my $z = sequence(10) / 10;
my $eds = Astro::Cosmology->new;
my $sn = Astro::Cosmology->new( matter => 0.3, lambda => 0.7 );
my $de = 1.0e6 * PARSEC * $eds->lum_dist($z);
my $ds = 1.0e6 * PARSEC * $sn->lum_dist($z);
# let's change the parameters of the $sn cosmology
$sn->setvars( lambda=>0.6, matter=>0.2 );
```

# UNITS

If H0 is set to 0, then the units used are the Hubble distance, volume per steradian, or time. If greater than zero, distances are measured in Mpc, volumes in Mpc^3/steradian, and time in years.

# NOTES

The comoving volume routine gives a slightly smaller answer than Figure 6 of Carroll, Press & Turner for z ~ 100. It could be due to differences in the numerical methods, but I've not yet investigated it thoroughly.

A year is defined to be YEAR_TROPICAL seconds. Let me know if this is wrong.

# THEORY

The following calculations were cobbled together from a number of sources, including the following (note that errors in the documentation or code are mine, and are not due to these authors):

```
Distance measures in cosmology, Hogg, D.W., astro-ph/9905116
Perlmutter et al. 1997, ApJ, 483, 565
Carroll, Press & Turner 1992, ARAA, 30, 499
Weinberg, S., sections 14.6.8, 15.3.25
Sandage, A. 1961, ApJ, 133, 355-392
```

In the following all values are in "natural" units: Hubble distance, volume, or time.

Symbols used in the following:

```
om is omega_matter
ol is omega_lambda
ok is 1 - om - ol
kappa is sqrt( abs(ok) )
```

## Distances

For cosmologies with no lambda term, the luminosity distances (`dl`

) are calculated by the standard formulae:

```
empty: dl = 0.5 * z * (2+z)
flat: dl = 2 * ( 1+z - sqrt(1+z) )
otherwise: dl = (2 / (om*om)) *
( om*z + (om-2) * (sqrt(1+om*z)-1) )
```

For non-zero lambda cosmologies, the luminosity distance is calculated using:

```
closed: dl = (1+z) * sin( kappa * dc ) / kappa
open: dl = (1+z) * sinh( kappa * dc ) / kappa
flat: dl = (1+z) * dc
```

where `dc`

is the comoving distance, calculated by numerical integration of the following from 0 to `z`

:

` 1.0 / sqrt( (1+z)^2 * (1+om*z) - z*(2+z)*ol )`

The comoving distance is always calculated by numerical integration of the above formula. The angular diameter and proper motion distances are defined as `dl/(1+z)^2`

and `dl/(1+z)`

respectively.

## Volumes

If `dm`

is the proper motion distance, then the comoving volume `vc`

is given by

```
flat: vc = dm^3 / 3
open: vc = dm * sqrt(1+ok*dm^2) - asinh(dm*kappa) /
( 2 * kappa * ok )
closed: vc = dm * sqrt(1+ok*dm^2) - asin(dm*kappa) /
( 2 * kappa * ok )
```

The differential comoving volume, `dvc`

, is calculated using the proper motion distance, `dm`

, and the differential proper motion distance, `ddm`

, by

` dvc = dm^2 * ddm / sqrt( 1 + ok*dm^2 )`

where

` ddm = dc * sqrt( 1 + abs(ok) * dm^2 )`

## Times

The lookback time is calculated by integration of the following formula from 0 to `z`

:

` 1.0 / ( (1+z) * sqrt( (1+z)^2 * (1+om*z) - z*(2+z)*ol ) )`

## Flux and Magnitudes

The conversion between absolute and apparent magnitudes is calculated using:

` $app_mag = $abs_mag + 25 + 5 * $cosmo->lum_dist($z)->log10();`

The conversion between flux and luminosity is calculated using

` $lumin = FOURPI * $dl * $dl * $flux`

where

` $dl = $cosmo->lum_dist($z) * 1.0e8 * PARSEC`

Note that these equations do not include any pass-band or evolutionary corrections.

## Integration Technique

All integrations are performed using Romberg's method, which is an iterative scheme using progressively higher-degree polynomial approximations. The method stops when the answer converges (ie the absolute difference in the values from the last two iterations is smaller than the `ABSTOL`

parameter, which is described in the new method).

Typically, the romberg integration scheme produces greater accuracy for smooth functions when compared to simpler methods (e.g. Simpson's method) while having little extra overhead for badly-behaved functions.

# CONSTANTS

Currently the following constants are available via `use Astro::Cosmology qw( :constants )`

:

LIGHT - the speed of light in m/s.

PARSEC - one parsec in metres.

STERADIAN - one steradian in degrees^2.

YEAR_TROPICAL - one tropical year in seconds.

PI - defined as 4.0 * atan(1.0,1.0) [this is in uppercase, whatever this document may say]

FOURPI - 4.0 * PI [again PI should be in upper case here]

Please do *not* use this feature, as it will be removed when an 'Astronomy constants' is created - e.g. see the astroconst package at http://clavelina.as.arizona.edu/astroconst/ .

# SYNTAX

This document uses the `$object->func(...)`

syntax throughout. If you prefer the `func($object,...)`

style, then you need to import the functions:

` use Astro::Cosmology qw( :Func );`

Most functions have two names; a short one and a (hopefully) more descriptive one, such as `pmot_dist()`

and `proper_motion_distance()`

.

Most of the routines below include a `sig:`

line in their documentation. This is an attempt to say how they `thread' (in the PDL sense of the word). So, for routines like `lum_dist`

- which have a sig line of `dl() = $cosmo->lum_dist( z() )`

- the return value has the same format as the input `$z`

value; supply a scalar, get a scalar back, send in a piddle and get a piddle of the same dimensions back. For routines like `abs_mag`

- with a sig line of `absmag() = $cosmo->abs_mag( appmag(), z() )`

- you can thread over either of the two input values, in this case the apparent magnitude and redshift.

# SUMMARY

## Utility routines

new

version

stringify

setvars

matter/omega_matter, lambda/omega_lambda, h0/hO

## Distance measures

lum_dist/luminosity_distance

adiam_dist/angular_diameter_distance

pmot_dist/proper_motion_distance

comov_dist/comoving_distance

## Volume measures

comov_vol/comoving_volume

dcomov_vol/differential_comoving_volume

## Time measures

lookback_time

# ROUTINES

## new

```
my $cosmo = Astro::Cosmology->new(
matter => 0.3, lambda => 0.7 );
my $cosmo = Astro::Cosmology->new(
{ matter => 0.3, lambda => 0.7 } );
```

Create the object with the required cosmological parameters. Case does not matter and you can use the minimum number of letters which remain unique (the parsing is done by the PDL::Options module).

The options can be specified directly as a list - as shown in the first example above - or in a hash reference - as shown in the second example. You can not mix the two forms within a single call. The options are:

```
OMEGA_MATTER or MATTER - default 1.0
OMEGA_LAMBDA or LAMBDA - default 0.0
H0 or HO - default 50.0
ABSTOL - default 1.0e-5
```

If H0 is set to 0, then answers are returned in units of the Hubble distance, volume, or time, otherwise in Mpc, Mpc^3/steradian, or years.

`ABSTOL`

(absolute tolerance) is used as a convergence criteria when integrating functions as well as whether values are close enough to 0. You should not have to worry about it.

## version

```
print "Version is " . Astro::Cosmology->version . "\n";
if ( $cosmo->version > 0.9 ) {
do_something_interesting();
}
```

Returns the version number of the Astro::Cosmolgy module as a string. This method is *not* exported, so it has to be called using either of the two methods shown above.

## stringify

` print $cosmo;`

Returns a string representation of the object. The operator "" is overloaded by this function, so that `print $cosmo`

gives a readable answer.

## setvars

` $cosmo->setvars( matter => 0.3, lambda => 0.7 );`

Change the cosmological parameters of the current object. The options are the same as for new.

## omega_matter or matter

```
$cosmo->omega_matter( 1.0 );
my $omega = $cosmo->omega_matter;
```

If supplied with an argument, sets the value of `Omega_matter`

. Returns the current value of the parameter.

## omega_lambda or lambda

```
$cosmo->omega_lambda( 0.8 );
my $lambda = $cosmo->omega_lambda;
```

If supplied with an argument, sets the value of `Omega_lambda`

. Returns the current value of the parameter.

## h0 or hO

```
$cosmo->h0( 75 );
my $cosmo->$h0 = h0;
```

If supplied with an argument, sets the value of `H0`

. Returns the current value of the parameter.

## lum_dist or luminosity_distance

```
sig: dl() = $cosmo->lum_dist( z() )
my $dl = $cosmo->lum_dist( $z );
```

returns the luminosity distance, for a given redshift, `$z`

, for the current cosmology.

## adiam_dist or angular_diameter_distance

```
sig: da() = $cosmo->adiam_dist( z() )
my $da = $cosmo->adiam_dist( $z );
```

returns the angular diameter distance, for a given redshift, `$z`

, for the current cosmology.

## pmot_dist or proper_motion_distance

```
sig: dm() = $cosmo->pmot_dist( z() )
my $dm = $cosmo->pmot_dist( $z );
```

returns the proper motion distance, for a given redshift, `$z`

, for the current cosmology.

## comov_dist or comoving_distance

```
sig: dc() = $cosmo->comov_dist( z() )
my $dc = $cosmo->comov_dist( $z );
```

returns the line-of-sight comoving distance, for a given redshift, `$z`

, for the current cosmology.

## comov_vol or comoving_volume

```
sig: dv() = $cosmo->comov_vol( z() )
my $dv = $cosmo->comov_vol( $z );
```

returns the comoving volume out to a given redshift, `$z`

, for the current cosmology. Does not work if `omega_matter`

and `omega_lambda`

are both 0.0.

## dcomov_vol or differential_comoving_volume

```
sig: ddv() = $cosmo->dcomov_vol( z() )
my $ddv = $cosmo->dcomov_vol( $z );
```

returns the differential comoving volume at a given redshift, `$z`

, for the current cosmology. Does not work if `omega_matter`

and `omega_lambda`

are both 0.0.

## lookback_time

```
sig: t() = $cosmo->lookback_time( zmax() )
sig: t() = $cosmo->lookback_time( zmin(), zmax() )
my $delta_t = $cosmo->lookback_time( [$zmin,] $zmax );
```

Returns the lookback time between `$zmin`

and `$zmax`

. If `$zmin`

is not supplied it defaults to 0.0.

## abs_mag or absolute_magnitude

```
sig: absmag() = $cosmo->abs_mag( appmag(), z() )
my $absolute_mag = $cosmo->abs_mag( $apparent_mag, $z );
```

Returns the absolute magnitude - excluding K and evolutionary corrections - for the given apparent magnitude.

## app_mag or apparent_magnitude

```
sig: appmag() = $cosmo->app_mag( absmag(), z() )
my $apparent_mag = $cosmo->app_mag( $absolute_mag, $z );
```

Returns the apparent magnitude for a given absolute magnitude. As with abs_mag, the K- and evolutionary-corrections are left up to the user.

## luminosity

```
sig: lumin() = $cosmo->luminosity( flux(), z() )
my $lumin = $cosmo->luminosity( $flux, $z );
```

Returns the luminosity of a source of a given flux. As with abs_mag, the K- and evolutionary-corrections are left up to the user.

The spatial units of the flux must be `cm^-2`

, so a flux in `erg/cm^2/s`

will be converted into a luminosity in `erg/s`

.

## flux

```
sig: flux() = $cosmo->flux( lumin(), z() )
my $flux = $cosmo->flux( $lumin, $z );
```

Returns the flux of a source of a given luminosity. As with `abs_mag`

, the K- and evolutionary-corrections are left up to the user.

The spatial units of the flux is `cm^-2`

, so a luminosity in `erg/s`

will be converted into a flux in `erg/cm^2/s`

.

# TODO

Add ability to request a particular unit; for example have `$cosmo->lum_dist()`

return *cm* rather than *Mpc*.

Add the ability to use Pen's approximations ("Analytical Fit to the Luminosity Distance for Flat Cosmologies with a Cosmological Constant", 1999, ApJS, 120, 49).

There is currently no method to calculate the age of the universe at a given redshift.

# ACKNOWLEDGEMENTS

Thanks to Brad Holden for trying out early versions of this module and for providing some of the test code.

The cosmology routines make use of code based on routines from

```
NUMERICAL METHODS: FORTRAN Programs, (c) John H. Mathews 1994
NUMERICAL METHODS for Mathematics, Science and Engineering, 2nd Ed, 1992
Prentice Hall, Englewood Cliffs, New Jersey, 07632, U.S.A.
```

The "Integration Technique" section of the documentation is based on that from from the Math::Integral::Romberg module by Eric Boesch (available on CPAN).

# SEE ALSO

# AUTHOR

Copyright (C) Douglas Burke <djburke@cpan.org> 1999, 2000, 2001.

All rights reserved. There is no warranty. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.