Super Friends-of-Friends (SFoF): Galaxy Cluster Detection Algorithm

Author: Samuel Farrens
Email: samuel.farrens@cea.fr
Version: 4.0

Introduction
Notice
Contributors
Scientific Background and Method
Installation and Execution
Examples
Doxygen Documentation

Introduction

SFoF is a friends-of-friends galaxy cluster detection algorithm that operates in either spectroscopic or photometric redshift space. The linking parameters, both transverse and along the line-of-sight, change as a function of redshift to account for selection effects.

The code is written in C++ and implements OMP to loop through the photometric redshift bins.

Larger catalogues can be split into overlapping pieces using the cat_split.cpp code. These pieces can than be run through the FoF independently and the subsequent results merged using the cat_merge.cpp code.

Notice

This software is fully open source and all are welcome to use or modify it for any purpose.

I would kindly request that any scientific publications making use of this software cite Farrens et. al (2011).

Contributors

The vast majority of this code has been written from scratch by Samuel Farrens. Additional contributions have been made by:

Filipe Abdalla - (debugging, concepts and ideas)
Eduardo Cypriano - (proto-code, concepts and ideas )
Stefano Sartor - (optimisation)
Luca Tornatore - (optimisation)

Scientific Background and Method

This section provides a brief summary of how SFoF works. In particular, how the percolation is handled both across the sky and along the line-of-sight. More comprehensive details can be found in Farrens et. al (2011).

Angular Percolation

Unlike a standard FoF this algorithm percolates in angular space.

The angular distance in radians between two galaxies (D) is calculated as shown in the figure on the right. Where $\alpha$ and $\delta$ correspond to right ascension and declination, respectively.

For two galaxies in a given redshift bin to be considered friends (i.e. linked) they must satisfy the following condition:

$D \leq D_{friend}(z)$

where $D_{friend}(z)$ is the transverse linking length in radians for a given redshift bin.

Redshift Binning

This section is only relevant for fof_mode=dynamic.

The first task the code performs is to bin all of the input galaxies by redshift. This is used to calculate $dn\/dz$ where $dn$ is the number of galaxies in a given bin and $dz$ is the bin width. Each galaxy is only counted once for this calculation, thus for photometric data the peak photometric redshift value of the galaxy is used.

NOTE: If a predefined $N(z)$ is provided, then these values are used for the $dn\/dz$ calculation.

The differential comoving volume as a function of redshift, $dV\/dz$ , and the angular diameter distance, $d_A$ , are then calculated for each bin using the values of $H_0$ , $\Omega_M$ and $\Omega_\Lambda$ provided.

Finally the angular linking length, $R_{friend}(z)$ , for each bin is defined as:

$R_{friend}(z) = ((\frac{dn(z)}{dz}\frac{dz}{dV(z)})^{0.5}r_{ref})\/d_A$

where $r_{ref}$ is:

$r_{ref} = (\frac{dn(z_{ref})}{dz}\frac{dz}{dV(z_{ref})})^{0.5} R_0$

$z_{ref}$ is the specified reference redshift and $R_0$ is the input transverse linking parameter. This calculation ensures that:

$R_{friend}(z_{ref}) = R_0\/d_A(z_{ref})$

and that for bins with less galaxies (e.g. at higher redshifts when selection effects have a stronger impact) the value of $R_{friend}(z_{ref})$ will increase, while for bins with more galaxies the value of $R_{friend}(z_{ref})$ will decrease. This produces $N_{gal}$ values that are more redshift independent.

Line-of-Sight Linking

• Spectroscopic Data

In the spectroscopic mode the line-of-sight linking length is calculated as follows:

$z_{friend} = z_0\/(1 + z)$

For two galaxies to be friends they must satisfy:

$|z_1 - z_2| \leq z_{friend}$

In this sense the percolation is performed in 3 dimensions.

• Photometric Data

In the photometric mode a galaxy is allocated to a redshift bin if it satisfies the following:

$|z_{gal} - z_{bin}| \leq \delta z_{gal} \times z_0$

In this case $z_0$ is a factor that determines how much the galaxies smear along the line-of-sight.

In this mode percolation is performed in 2 dimensions for each redshift bin independently. As galaxies can exist in multiple bins it is possible to form "proto-clusters" in different bins with similar members.

When the percolation has finished for all of the bins proto-clusters with common members are merged to form the final detections.

Cluster properties

• Centre

The cluster centre (RA, Dec, z) is calculated as the median of the galaxy members. The errors are calculated as the standard error on the median (i.e. $\sigma \/n^{0.5}$ ).

• Richness

The cluster richness is calculated a the number of member galaxies.

• Singal-to-Noise

The cluster singal-to-noise ratio is calculated as follows:

$SNR = (N_{gal} - A \times Bg)/(A \times Bg)^{0.5}$

where $A$ is the cluster area and $Bg$ is the background level at the cluster redshift. Unless an $N(z)$ is provided, the code simply takes the number of objects at the cluster redshift divided by the catalogue area as $Bg$ .

• Radius

The cluster radius, $r_{cls}$ , is calculated as the distance from the cluster center to the position of the farthest member in the units specified.

• Area

The cluster area is calculated as:

$\pi r_{cls}^2$

in the units specified.

Optimisation

• k-d Tree

The code make us of an angular k-d Tree (implemented by Luca Tornatore) to reduce the number of calculations required.

• Union-Find

The code also makes use of a union-find data structure (implemented by Stefano Sartor) to speed up the processes of merging proto-clusters.

• OpenMP

OpenMP is used to perform the redshift bin percolations in parallel.

• Splitting

The cat_split.cpp code can be used to divide large data sets into overlapping pieces that can be processed individually. The cat_merge.cpp code can then reassemble the full catalogue using the results with little to no loss of information.

sfarrens/sfof