-
Hubbles Law and Model Fitting
Computational Physics
Physics is a natural science which attempts to describe the
Universe in terms of a few basic concepts suchas time, space, mass,
and electric charge. These quantities can be assigned numerical
values that everyphysicist can agree upon. Nature is complex, so
physicists choose to study natural phenomena that appearto be as
simple as possible and can be reproduced reliably by other
physicists.
Most physicists specialize in one of three types of activity.
Experimental physicists observe thesephenomena, measure their
properties using instruments, and attempt to discover simple laws
describe theseobservations: experimental physics is based on
technology. Theoretical physicists invent mathematicalmodels that
relate measured properties and construct theories which organize
and unify these models:theoretical physics is based on mathematics.
Computational physicists use digital computers to
analyzeexperimental data and explore the properties of models and
theories: computational physics is based oncomputer science an
numerical analysis.
Experimentalists spend most of their time designing and building
instruments, and in collecting andanalyzing experimental data.
Theorists work primarily with mathematical theories and equations,
andmake predictions that can be verified or falsified by
experiment. Computationalists design algorithms tosolve equations
or analyze data, write and debug computer programs that implement
algorithms, and runsimulations to explore theories and compare with
experimental data.
The Expanding Universe
A galaxy is a collection of several billion stars. Galaxies have
characteristic shapes and are separted fromone another by empty
space. More than 10,000 galaxies have been identified and
cataloged, and Earthreceives light from more than a hundred billion
galaxies. The location and speed of a galaxy are examplesof natural
phenomena that astronomers have attempted to measure. Fig. 1 shows
a typical galaxy studiedby Edwin Hubble[1] and his collaborator
Milton Humason.
Cepheid Variables as Standard Candles
A Cepheid variable is a type of star whose luminosity varies
with a period of a few days. Its absoluteluminosity can be
predicted from its period. Its apparent luminosity observed on
Earth can therefore beused to infer its distance.
The speed of a galaxy can be inferred from the shift in
wavelength of spectral lines in the light it emits.Lines from
distant galaxies are generally redshifted, which indicates that
they are receding from us.
Hubble analyzed the data in Fig. 2 using the relation
rK +X cos cos + Y sin cos + Z sin = v , (1)
where r, v are the measured distance and speed of the galaxy
located at galactic longitude and latitude ,and K,X, Y, Z are
constants. Fig. 3 shows the results of his analysis. He concluded
thatK 500 km/s/Mpc, which is considerably larger that the current
best value of Hubbles constantH(t0) 72 km/s/Mpc.
1
-
Figure 1: Hubble lists Barnards Galaxy NGC 6822, see
http://antwrp.gsfc.nasa.gov/apod/ap020123.html, at a distance r =
0.214 Mpc (1 Mega-parsec = 3.0861019 km) moving towards us with
speed v = 130km/s.
General-Relativistic Theory of Cosmology
General Relativity is a mathematical theory that relates the
properties of time and space to the energydensity measured at each
point in space and instant of time. The mathematical equations of
GeneralRelativity can be written
R 12gR = 8GN
c4T g (2)
where GN is Newtons gravitational constant, c is the speed of
light, and is the cosmological constant.The other quantities in the
equation are functions of the time-space 4-vector x = {ct,~r}. The
metrictensor g(x) describes the geometry of spacetime, the Ricci
tensor R and curvature scalar R arefunctions of the metric tensor
and its spacetime derivatives, and the stress-energy tensor T,
representsthe energy and momentum density of matter and
radiation.
This complex set of nonlinear partial differential equations is
extremely challenging to solve. Analyticsolutions exist only for
very simple distributions of matter and radiation. The simplest
cosmological modelassumes that spacetime is homogeneous and
isotropic and described by the Robertson-Walker metric
ds2 3
=0
3=0
gdxdx = c2dt2 R2(t)
[dr2
1 kr2 + r2(d2 + sin2 d2)
], (3)
where R is the cosmological scale factor, r, , are
spherical-polar coordinates, and the curvature constantk = 0,1
signifies a flat, open, or closed universe.The simplest assumption
about matter and radiation is that it behaves like uniform perfect
fluid withdensity and pressure p. This leads to the
Friedmann-Lamatre equations
H2 (R
R
)2=
8GN
3 kc
2
R2+
c2
3,
R
R= 4GN
3(+ 3p) +
c2
3. (4)
H(t) is the Hubble parameter and its value at the present time
t0 is Hubbles constantH(t0) = 72 km/s/Mpc.
2
-
Figure 2: Table 1 from Hubbles paper [1].
3
-
Figure 3: A Figure from Hubbles paper [1].
4
-
We will study these differential equations later in the course.
For this lecture all we need to know is how torelate them galaxy
redshifts in an expanding universe. Suppose R1 is the scale factor
when light offrequency 1 was emitted from a distant galaxy, and R2
is the scale factor when this light is observed onEarth with
frequency 2, then the redshift z is given by
z + 1 =12
=R2R1
1 + v12c
, (5)
where v12 is the speed of the distant galaxy relative to the
observer.
Algorithm for fitting data to a straight line
Consider a data set with n data points labeled by an index i =
0, 1, . . . , n1. Each point consists of tworeal numbers xi, yi.
For example, n is the number of observed galaxies, and xi and yi
are their radialdistances and velocities.
We would like to summarize this data set using a model equation
that relates the two real variables x, y,for example a linear
model
y(x) = a+ bx , (6)
with intercept a and slope b.
Least-squares algorithm
The least-squares algorithm determines the model parameters a, b
by minimizing the function
f(a, b) n1i=0
(yi a bxi)2 . (7)
This procedure tends to make the deviation of yi from the point
y(xi) = a+ bxi on the straight line assmall as possible. The
derivatives of f vanish at its minimum
f
a= 2
n1i=0
(yi a bxi) = 0 , and fb
= 2n1i=0
xi(yi a bxi) = 0 . (8)
These two equations can be solved simultaneously for the two
unknowns a, b. Define the following sums:
sx n1i=0
xi , sy n1i=0
yi , sxx n1i=0
x2i , sxy n1i=0
xiyi . (9)
Then the least-squares values of the parameters are given by
a =sxxsy sxsxynsxx s2x
, b =nsxy sxsynsxx s2x
. (10)
Uncertainty estimates
The number of degrees of freedom of the fit is the number of
data points minus the number of parameters: = n 2. An estimate of
the variance of the data set from the model prediction is
2 f(a, b)
=1
n 2n1i=0
(yi y(xi))2 . (11)
5
-
The standard deviation is an estimate of the error bar in each
yi. These error estimates can bepropagated to the parameters a, b
considered as functions of yi:
2a =
n1i=0
(a
yi
)2=
2sxxnsxx s2x
, 2b =
n1i=0
(b
yi
)2=
2n
nsxx s2x. (12)
Programming in C++
The simplest C++ program consists of 12 characters:
int main(){}
Every C++ program must define a unique main function, which can
have either no arguments as definedhere by empty parentheses (), or
two arguments usually written (int argc, char *argc[]). The
returnvalue of the function is of type int, which usually
represents a 32-bit integer in the range [231..2311].Note the
required space between int and main. The body of the function in
braces {} is empty: thefunction does nothing except to return the
integer 0 (zero) by default.
The following program prints a message on the display.
#include /* standard C++ input output stream header */
int main() // main function returns 0 on successful
completion
{
std::cout
-
started by the two characters /* and ended by the two characters
*/ and can extend over more thanone line. C++-style comments are
started by the two characters // and extend to the end of the
line.
Computing with integers and real numbers
Physical quantities are represented real numbers, which include
integers, rational fractions, and realnumbers like
2 and that require an infinite number of decimal digits to
express exactly. Integers that
are not too large in magnitude can be represented in C++ by
quantities of type int and rationalfractions and real numbers that
are not too large or too small can represented by quantities of
typedouble with approximately 15 decimal digits of precision.
#include /* defines arc-tangent function atan */
#include /* defines cout, cin and endl */
#include /* defines numeric_limits */
using namespace std; // import included std objects into global
namespace
const double pi = 4 * atan(1.0); // pi in radians from
arc-tangent function
int main () {
cout
-
types like int or double as parameters. The type has static
member functions, such as min andmax, which return limiting
values.
The program uses the do { } while (condition); control
structure: the block of statements in braces{ } is executed
repeatedly while the logical expression condition evaluates to
true.
Computing the Hubble Constant
Hubble used Eq. 1 with 4 parameters to model his data. We will
use a simpler linear equation with twoparameters
v(r) = a+ br , (13)
to determine Hubbles constant as the slope b using the linear
least-squares algorithm.
#include
#include
using namespace std;
const int n = 24; // number of galaxies in Table 1
double r[n] = { // distances in Mpc
0.032, 0.034, 0.214, 0.263, 0.275, 0.275, 0.45, 0.5, 0.5, 0.63,
0.8, 0.9,
0.9, 0.9, 0.9, 1.0, 1.1, 1.1, 1.4, 1.7, 2.0, 2.0, 2.0, 2.0
};
double v[n] = { // velocities in km/s
+170, +290, -130, -70, -185, -220, +200, +290, +270, +200, +300,
-30,
+650, +150, +500, +920, +450, +500, +500, +960, +500, +850,
+800, +1090
};
int main() {
// declare and initialize various sums to be computed
double s_x = 0, s_y = 0, s_xx = 0, s_xy = 0;
// compute the sums
for (int i = 0; i < n; i++) {
s_x += r[i];
s_y += v[i];
s_xx += r[i] * r[i];
s_xy += r[i] * v[i];
}
// evaluate least-squares fit forumlas
double denom = n * s_xx - s_x * s_x;
double a = (s_xx * s_y - s_x * s_xy) / denom;
double b = (n * s_xy - s_x * s_y) / denom;
8
-
// estimate the variance in the data set
double sum = 0;
for (int i = 0; i < n; i++) {
double v_of_r_i = a + b * r[i];
double error = v[i] - v_of_r_i;
sum += error * error;
}
double sigma = sqrt(sum / (n - 2)); // estimate of error bar in
v
// estimate errors in a and b
double sigma_a = sqrt(sigma * sigma * s_xx / denom);
double sigma_b = sqrt(sigma * sigma * n / denom);
// print results
cout.precision(4);
cout
-
Figure 4: Remnant of the Type Ia supernova SN 1604
http://en.wikipedia.org/wiki/SN_1604 observedby Johannes
Kepler.
Supernovae and Hubbles constant
A plot of light intensity emitted as a function of time is
called the light curve of the supernova explosion.Type Ia
supernovae have characteristic light curves from which the their
absolute luminosities can beinferred. Their distances from Earth
can then be calculated from the observed apparent luminosities.
Thus Type Ia supernovae can be used as standard candles, just
like Cepheid variable stars. Becausesupernova explosions are
billions of times brighter than typical stars they can be observed
at much greaterdistances from Earth. Their distances and redshifts
can be used to measure the Hubble parameter, seeFig. 5.
Astronomers measure the brightness of an object in the sky using
a unit called the magnitude. Theabsolute magnitude of the object is
denoted by M and the apparent magnitude by m. The absolutemagnitude
is defined to be the apparent magnitude observed at a distance of
10 parsecs from the object.The distance modulus is defined as the
difference between the apparent and absolute magnitudes
mM = 5 log10 r 5 , (14)
where r is the distance in parsecs of the object from Earth.
Davis et al.[4] study redshift and distance modulus data using a
set of 192 Type Ia supernovae with largeredshifts. This data set is
available as a file giving redshift z, distance modulus and the
error in foreach object, as shown by the following snippet:
; Columns
; SN= supernova identifier
; z = redshift
; mu= distance modulus
; mu_err = error in distance modulus
;
; SN z mu mu_err
b013 0.4260 41.98 0.23
d033 0.5310 42.96 0.17
10
-
Figure 5: From reference [2].
11
-
d083 0.3330 40.71 0.14
d084 0.5190 42.95 0.29
We will write a program to fit this data to a straight line and
estimate Hubbles constant. According toEq. 14, Supernova b013 is
248.9 Mpc from Earth, and the relativistic Doppler formula
1 + z =1 + v
c1 v2
c2
(15)
gives its speed to be v = 0.341 c. At these cosmological
distances and relativistic velocities the equations ofgeneral
relativity must be used to relate the general relativistic
redshift
z =R(t0)
R(t) 1 , (16)
to the distance modulus. For distant supernovae the relation can
be approximated as follows:
= 25 + 5 log10
(cz
H0
)+ 1.086(1 q0)z + . . . (17)
where c is measured in km/s and H0 in km/s/Mpc. This equation
follows from a Taylor expansion of thecosmic scale factor
R(t) = R(t0)
[1 + (t t0)H0 1
2(t t0)2q0H20 + . . .
], (18)
where t is the time of emission of light from the supernova
and
H0 R(t0)R(t0)
, and q0 R(t0)R(t0)R2(t0)
, (19)
are Hubbles constant and the deceleration parameter at the
present cosmological time t0. See Chapter 146 of Weinberg[3] for a
detailed derivation of these formulas.
Chi-square Fitting to a Straight Line
Hubbles 1929 paper did not quote error bars on the data values,
although we can fairly safely assume thathe quoted values with an
appropriate number of significant digits. To fit Hubbles data we
used a simpleleast-squares fit and estimated the error bar in the
data set from the deviations of the data points from thefitted
straight line. It is not possible to estimate the reliability of
the least-squares fit in the absence oferror bars on the data.
If the error bars i are available on the y values of the set,
then it is possible to take them into account byminimizing the
chi-square sum, which is defined as
2(a, b) n1i=0
(yi a bxi
i
)2. (20)
In this expression, data values with small error bars are given
more weight than data points with largeerror bars.
The parameters a, b are determined by minimizing this function.
The following formulas are discussed indetail in Numerical
Recipes[5]:
b =1
Stt
n1i=0
tiyii
, a =Sy Sxb
S, 2a =
1
S
(1 +
S2xSStt
), 2b =
1
Stt. (21)
12
-
Here
ti =1
i
(xi Sx
S
), Stt =
n1i=0
t2i , (22)
and
S =n1i=0
1
2i, Sx =
n1i=0
xi2i
, Sy =n1i=0
yi2i
. (23)
The goodness of fit can be computed as the probability Q that
the value of 2 should be greater than orequal to its computed
value. Because this involves computing an incomplete Gamma
function, we will usethe simpler criterion that the 2 per degree of
freedom is close to unity:
2/d.o.f 1n 2
n1i=0
(yi a bxi
i
)2 1 . (24)
Because the fit has two parameters a, b, the number of degrees
of freedom is = n 2. Two data pointscan be fit exactly with two
parameters. If 2 n 2, then the terms in the sum have average
magnitudeclose to one. This implies that the deviations from the
straight line are consistent with the error bars. If2/d.o.f 1 the
fit is too good to be true; and if it is much larger than unity,
data cannot beapproximated by a straight line.
C++ strings, files and Gnuplot
A good way of visualizing a data set is to plot it. If you do
not have a better plotting program availableyou should download and
install Gnuplot from http://gnuplot.info/ and learn how to use
it.
The following simple program shows how to simulate some data
points with error bars and plot them usingGnuplot from a C++
program.
#include /* defines abs() */
#include /* defines rand() and system() */
#include /* defines ofstream object for writing to a file */
#include
#include /* defines string objects */
using namespace std;
// path to gnuplot executable - change if located somewhere
else
#ifdef _MSC_VER /* this variable is defined by Visual C++ */
string gnuplot("C:\\gnuplot\\bin\\wgnuplot.exe");
#else /* Linux or Macintosh */
string gnuplot("/usr/bin/gnuplot");
#endif
int main() {
string plot_file_name("plot.data");
13
-
ofstream plot_file(plot_file_name.c_str());
for (int i = 0; i < 50; i++) {
double x = 0.2 * i;
double random_error = 0.2 * (-1 + 2.0 * rand() / (RAND_MAX +
1.0));
double y = sin(x) + random_error;
double error_bar = abs(random_error);
plot_file
-
#include
#include
#include
#include
#include
#include
using namespace std;
// ---------------- declare global variables
----------------
string url("http://dark.dark-cosmology.dk/~tamarad/SN/");
string data_file_name("Davis07_R07_WV07.dat");
vector // C++ std template vector type
z_data, // redshift - column 2 in data file
mu_data, // distance modulus - column 3
mu_err_data; // error in distance modulus - column 4
// ---------------- function declarations ----------------
void read_data(); // opens and reads the data file
void chi_square_fit( // makes a linear chi-square fit
const vector& x, // vector of x values - input
const vector& y, // vector of y values - input
const vector& err, // vector of y error values - input
double& a, // fitted intercept - output
double& b, // fitted slope - output
double& sigma_a, // estimated error in intercept -
output
double& sigma_b, // estimated error in slope - output
double& chi_square // minimized value of chi-square sum -
output
);
// ---------------- function definitions ----------------
int main() {
cout
-
intercept, slope, intercept_err, slope_err, chisqr);
cout.precision(4);
cout
-
double& sigma_b, // estimated error in slope - output
double& chi_square) // minimized value of chi-square sum -
output
{
int n = x.size();
double S = 0, S_x = 0, S_y = 0;
for (int i = 0; i < n; i++) {
S += 1 / err[i] / err[i];
S_x += x[i] / err[i] / err[i];
S_y += y[i] / err[i] / err[i];
}
vector t(n);
for (int i = 0; i < n; i++)
t[i] = (x[i] - S_x/S) / err[i];
double S_tt = 0;
for (int i = 0; i < n; i++)
S_tt += t[i] * t[i];
b = 0;
for (int i = 0; i < n; i++)
b += t[i] * y[i] / err[i];
b /= S_tt;
a = (S_y - S_x * b) / S;
sigma_a = sqrt((1 + S_x * S_x / S / S_tt) / S);
sigma_b = sqrt(1 / S_tt);
chi_square = 0;
for (int i = 0; i < n; i++) {
double diff = (y[i] - a - b * x[i]) / err[i];
chi_square += diff * diff;
}
}
The chi_square_fit function uses reference objects and variables
for its arguments. A reference variableis declared by appending an
ampersand & to its type. The function works on the original
object orvariable, so any changes it makes persist after it
returns. If instead ordinary variables are used, then thefunction
makes a copy. For a const input variable copying can waste time and
memory, especially theobject is very large. If the function
modifies a non-const variable, the changes are made to the copy
andare lost when the function returns.
References
[1] Edwin Hubble, A relation between distance and radial
velocity among extra-galactic nebulae, Proc.Natl. Acad. Sci. USA
15, 168 (1929), http://www.pnas.org/content/15/3/168.full.pdf.
17
-
[2] K.A. Olive and J.A. Peacock, Big-bang cosmology, in C.
Amsler et al., Phys. Lett. B667, 1
(2008),http://pdg.lbl.gov/2009/reviews/rpp2009-rev-bbang-cosmology.pdf.
[3] S. Weinberg, Gravitation and Cosmology (Wiley, 1972).
[4] T.M. Davis et al., Scrutinizing Exotic Cosmological Models
Using ESSENCE Supernova DataCombined with Other Cosmological
Probes, Ap. J. 666 716
(2007),http://arxiv.org/abs/astro-ph/0701510. Data can be
downloaded fromhttp://dark.dark-cosmology.dk/~tamarad/SN/.
[5] W.H. Press, S.A. Teukolsky, W.T. Vetterling and B.P.
Flannery, Numerical Recipes in C (CambridgeUniversity Press 1992),
15.2 Fitting Data to a Straight
Line,http://www.nrbook.com/a/bookcpdf/c15-2.pdf.
[6] Herbert Schildt, C++ Beginners
Guide,http://msdn.microsoft.com/en-us/beginner/cc305129.aspx,
Chapter 1: C++
Fundamentals,http://go.microsoft.com/?linkid=8310946.
18