A COMPUTATIONAL FRAMEWORK
A computational framework implemented in the raceland package allows for:
Constructing racial landscape based on race-specific raster grids.
Describing the racial pattern of a racial landscape at different scales or/and for the whole area of interests using metrics derived from Information Theory concept (entropy and mutual information).
Mapping the racial landscape.
Mapping racial diversity and segregation at different scales.
A computational framework consists of the four steps (see figure below, the blue font indicates the names of function from the raceland package).
Input data
Racial landscape method is based on high resolution race-specific raster grids. Each cell in race-specific grids contains race subpopulation density. SocScape project provides high-resolution raster grids for 1990, 2000, 2010 years for 365 metropolitan areas and for each county in the conterminous US. Data is available at http://sil.uc.edu
The calculation can be also performed using vector shapefile with attribute table containing race counts for aggregated data. In such case shapefile is first rasterized using zones_to_rasters() function from the raceland package (people of given race are redistributed to the cells by dividing the number of people by the number of cells belonging to the particular spatial units.).
Please notice that the rasterization time depends on the number of divisions and for large areas (i.e. metropolitan areas) can be timeconsuming. It is recommended to use the smallest available divisions.
Here we demonstrate a computational framework using example of the area of 60x60 cells. The input data is a high-resolution (30m) raster grids. Race-specific rasters are stored as GeoTiffs (The directory contains 5 files for 5 race-groups: Asians, Blacks, Hispanic, others and Whites).
The RasterStack with race-specific grids is created based on GeoTiff files (files will be sorted and read into RasterStack in alphabetical order; the categories in racial landscape will depend on order of layers in input data - see details in the next section).
Working with high resolution grids
race_raster = stack(list_raster)
race_raster
#> class : RasterStack
#> dimensions : 60, 60, 3600, 5 (nrow, ncol, ncell, nlayers)
#> resolution : 30, 30 (x, y)
#> extent : 685545, 687345, 2103255, 2105055 (xmin, xmax, ymin, ymax)
#> crs : +proj=aea +lat_1=29.5 +lat_2=45.5 +lat_0=23 +lon_0=-96 +x_0=0 +y_0=0 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs
#> names : asian, black, hispanic, other, white
#> min values : 0, 0, 0, 0, 0
#> max values : 1.3333334, 15.3125000, 9.6666670, 0.5714286, 3.7500000
Working with vector data
While using vector data, shapefile should be read to R using st_read() function from sf package. In the next step spatial object is rasterized using zones_to_rasters() from raceland package.
Function zones_to_rasters() requires 3 arguments:
- v - an sf object with aggregated attribute data
- resolution - a resolution of the output raster (below we use resolution=30, there is the same resolution as SocScape grids)
- variables - a character vector with columns names from v. The values from these columns will be (1) rasterized and (2) recalculated to densities. Each column will be represented as an layer in the output RasterStack.
vect_data = st_read(pf_to_data)
#> Reading layer `block_data' from data source `/home/jn/R/x86_64-redhat-linux-gnu-library/3.6/raceland/vect_data/block_data.gpkg' using driver `GPKG'
#> Simple feature collection with 264 features and 6 fields
#> geometry type: POLYGON
#> dimension: XY
#> bbox: xmin: 685545 ymin: 496468.7 xmax: 687345 ymax: 498268.7
#> epsg (SRID): NA
#> proj4string: +proj=aea +lat_1=29.5 +lat_2=45.5 +lat_0=37.5 +lon_0=-96 +x_0=0 +y_0=0 +ellps=GRS80 +units=m +no_defsOnce vector data is rasterized there is no difference, whether race_raster object or race_raster_from_vect will be used for futher analysis.
Constructing racial landscape
Racial landscape is a high-resolution grid in which each cell contains only inhabitants of a single race.
Racial landscape is constructed based on race-specific grids. Racial composition at each cell is translated to probabilities of drawing a person of a specific race from a cell. Thus, a race label of a cell is a random variable. To obtain a stochastic realization of racial landscape, we use cell’s race probabilities and a random number generator to randomly assign specific race label to each cell (Monte Carlo procedure).
Multiple draws yield to a series of realization with a slightly different pattern (see example below). The pattern uncertainty occurs only at sub-block scale and only if there is significant sub-block racial diversity.
A single realization-based visualization is sufficiently accurate. For increased accuracy, racial topography is quantified as an ensemble average from multiple realizations. It is recommended to calculate at least 30 realizations.
Realization is constructed using create_realizations() function with two arguments:
- x - RasterStack with race-specific population densities assign to each cell
- n - number of realizations to generate.
Function returns RasterStack object containing n realizations. Single race label in racial landscape is assigned based on an order of race-specific grids stored in RasterStack (For example race_raster object has five layers named: asian, black, hispanic, other, white. The race labels in racial landscape raster will be 1 - asian, 2- black, 3 - hispanic, 4 - other, 5 - white).
#generate 100 realizations based on race_raster object
real_raster = create_realizations(x = race_raster, n = 100)#plot 5 first realizations
plot(real_raster[[1:5]], col = c("#F16667", "#6EBE44", "#7E69AF", "#C77213","#F8DF1D"))
Racial landscape provides a skewed visualization of the racial pattern because it does not take into consideration spatial variability of the population densities. To obtain an accurate depiction of racial distribution the values of RL must be modified to reflect race and subpopulation densities.
Function plot_realization() display realization taking into account also subpopulation density. Function takes 3 arguments:
- x - raster object (RasterLayer, RasterStack, RasterBrick) with one selected realization representing a racial landscape,
- y - RasterStack with race-specific population densities
- hex - a character vector with colors specified in hexadecimal format. Colors should correspond to categories in realization (racial landscape).
#In race_colors first color corresponds to asian, second to black, third to hispanics, fourth to other and fifth to white)
race_colors = c("#F16667", "#6EBE44", "#7E69AF", "#C77213","#F8DF1D")
plot_realization(x = real_raster[[1]], y = race_raster, hex = race_colors)
Describing racial patterns of racial landscape.
A racial pattern is described by exposure matrix. In the domain of landscape ecology, landscape pattern can be described by a co-occurrence matrix. The co-occurrence matrix is a tabulation of cells’ adjacencies. Adjacencies between pairs of cells is defined by 4-connectivity rule (There are max. 4 adjacencies: north, east, south and west cell as is shown in figure below).
The co-occurrence matrix has the size KxK (K - number of categories), is symmetrical and can be calculated for any region regardless of its size or shape.
Exposure matrix is a modification of co-occurrence matrix. The exposure matrix is calculated in the same way as the co-occurrence matrix but each adjacency contributes as a location-specific value to the matrix instead of the constant value 1. The contributed value is calculated as average of local population densities in the two adjacent cells.
Let consider an example of racial landscape presented below. Co-occurrence matrix is constructed using only adjacencies from racial landscape. To obtain exposure matrix each cell in racial landscape has assign 2 types of information: single race class and local population density. Considering 2 green adjacent cells - this pair will contribute 1 to co-occurrence matrix (one adjacent pair) and the average from 2 and 1 [(2+1)/2)=1.5] to exposure matrix.
Calculating local subpopulation densities
Local densities of subpopulations (race-specific local densities) along with racial landscapes are used to construct exposure matrix. Local densities are calculated using create_densities() function, which requires 3 arguments:
- x - RasterStack with realizations
- y - RasterStack with shares of subpopulations (input data RasterStack)
- window_size - the size, expressed in the number of cells, of a square-shaped window for which local densities will be calculated; it is recommended to use the small window_size, i.e 10 (window_size=10 means that the local densities will be calculated from the area of 10x10cells).
The output is a RasterStack with local densities calculated separately for each realization.
Exposure matrix.
Here we show an example, how exposure matrix is calculated. Please notice, that the calculation of the exposure matrix is build-in into calculate_metrics() function and there is no need to calculate exposure matrix separately.
Exposure matrix can be calculated separately using get_wecoma() function from comat package. Calculation of exposure matrix require 2 arguments:
- x - RasterLayer with one selected realization
- y - RasterLayer with local densities corresponding to selected realizations.
As default the exposure matrix with 4-directions adjaciencies (neighboorhood=4) is calculated using the average values from 2 adjacent cells (fun=‘mean’).
exposure_mat = comat::get_wecoma(x = real_raster[[1]], w = dens_raster[[1]])
colnames(exposure_mat) = c("ASIAN", "BLACK", "HISPANIC", "OTHER", "WHITE")
rownames(exposure_mat) = c("ASIAN", "BLACK", "HISPANIC", "OTHER", "WHITE")
round(exposure_mat, 2)
#> ASIAN BLACK HISPANIC OTHER WHITE
#> ASIAN 6.38 14.33 34.74 0.00 41.26
#> BLACK 14.33 7437.67 3304.19 138.26 1730.58
#> HISPANIC 34.74 3304.19 9235.52 92.86 3953.01
#> OTHER 0.00 138.26 92.86 7.72 76.17
#> WHITE 41.26 1730.58 3953.01 76.17 3257.62Information theory metrics (IT metrics)
To lucid quantification of racial topography, further compression of exposure matrix is required. A racial pattern can be described (in the same way like landscape pattern in the domain of landscape ecology) by using Information Theory metrics - entropy and mutual information. Entropy is associated with measuring racial diversity and mutual information is associated with measuring racial segregation.
Information theory metrics are calculated using function calculate_metrics(). This function calculates exposure matrix and summarizes it by calculating four IT-derived matrics: entropy (ent), joint entropy (joinent), conditional entropy (condent) and mutual information (mutinf). Function requires the following arguments:
- x - RasterStack with realizations
- w - RasterStack with local densities.
- neighboorhood - adjacencies between cells can be defined in 4 directions (neighboorhood=4) or 8 directions (neighboorhood=8).
- fun - function to calculate values from adjacent cells to contribute to exposure matrix, fun=‘mean’ calculate average values of population density from two adjacent cells. Other available options are geometric mean (‘geometry_mean’) or value from focal cell (‘focal’)
- size = NULL - calculation will be performed for the whole area (see explanation later)
- threshold - the share of NA cells to allow metrics calculation. threshold=1 - calculation will be performed, even if there are 100% cells with NA values (recommended with size=NULL)
head(metr_df)
#> realization row col ent joinent condent mutinf
#> 1 1 1 1 1.619287 3.117388 1.498101 0.1211861
#> 2 2 1 1 1.632915 3.145918 1.513003 0.1199124
#> 3 3 1 1 1.635939 3.155173 1.519234 0.1167045
#> 4 4 1 1 1.647369 3.168565 1.521196 0.1261725
#> 5 5 1 1 1.623655 3.134438 1.510783 0.1128714
#> 6 6 1 1 1.652653 3.179137 1.526485 0.1261682IT matrics are calculated for each realization separately and in the next step an average value from all realization is calculated.
Describing local racial patterns of racial landscape (calculation at different spatial scales).
Unlike the previous methods, racial landscape method does not depend on the division into specific zones (census tract, census block, etc.). Calculation of racial diversity (entropy) and racial segregation (mutual information) can be performed for the whole area of interests without introducing any arbitrary divisions.
Racial landscape method allows also for performing calculation at different spatial scales.
Defining local patterns
Let consider an example presented below. Racial landscape covers the area 16 by 16 cells. Such area can be divided into a square-shaped block of cells. Each square of cells will represent a local pattern (a local landscape) and for each local pattern are calculated IT metrics (entropy and mutual information). The extent of a local pattern is defined by 2 parameters: size and shift.
Size parameter, expressed in the numbers of cells, is a length of the side of a square-shaped block of cells. It defines the extent of a local pattern.
Shift parameter defines the shift between adjacent squares of cells along the n-s and w-e directions. It describes the density (resolution) of the output grid. The resolution of the resultant map will be reduced to the new resolution = orginal resolution x shift.
shift=size - the input map will be simple divided into a grid of non overlaping square windows. Each square window defines an extent of a local pattern.
shift < size - results in the grid of overlapping square windows. A local pattern is calculated from the square window defined by size parameter, next square window is shifted (in n-s and w-e directions) by the number of cells defined by shift parameter.
The example presented below consists of racial landscape 16 by 16 cells. Setting size = 4 (and shift= 4) results in dividing racial landscape into 4 squared windows, each 4x4 cells. Each window represents a local pattern. For each local pattern IT metrics can be calculated, and the results will be assigned to the resultant grid of square windows. In fact the original racial landscape with 16x16 cells is reduced to the 2x2 ‘large cells’.
Setting size=4 and shitf = 2 results in overlapping square windows. First the window of the size 4x4 defines the local pattern (see dark blue square). In the next step this window is shifted by 2 cells to the right and the new local pattern is selected (see light blue square). It will create a resultant grid of the cell size defined by shift parameter.
Calculate IT metrics from local patterns (1)
Function create_grid() create spatial object with a grid (each ‘cell’ is defined by size and shift). Function require the RasterStack object with realizations (racial landscapes) and size parameter. If shift parameter is not set it is assumed that size=shift.
Below such grid is imposed into racial landscape to show local patterns.
grid_sf = create_grid(real_raster, size=20)
plot_realization(real_raster[[1]], race_raster, hex = race_colors)
plot(grid_sf, col = NA, border = 'black', add=TRUE, bty="n", box=FALSE, lwd=2)
#> Warning in plot.sf(grid_sf, col = NA, border = "black", add = TRUE, bty =
#> "n", : ignoring all but the first attribute
Function calculate_metrics() is used to calculate IT metrics. Parameter size=20 means that the area of interests will be divided into a grid of local patterns of the size 20x20 cells (which in this case corresponds to the square of 0.6 km x 0.6km). The neighboorhood=4 defines that adjacencies between cells are defined in four directions, fun=‘mean’ calculate average values of population density from adjacent cells, threshold = 0.5 - calculation will be performed if there is at least 50% of non-NA cells.
IT metrics are calculated for each local pattern for each realization. The output table will have 900 rows (there are 9 local patterns of size 20x20 cells and 100 realizations).
metr_df_20 = calculate_metrics(x = real_raster, w= dens_raster, neighbourhood = 4, fun = "mean", size = 20, threshold = 0.5)
metr_df_20[metr_df_20$realization%in%c(1),]
#> realization row col ent joinent condent mutinf
#> 1 1 1 1 1.281924 2.544877 1.262953 0.01897095
#> 2 1 1 2 1.581338 3.053299 1.471962 0.10937600
#> 3 1 1 3 1.407264 2.739290 1.332025 0.07523925
#> 4 1 2 1 1.576214 3.006004 1.429790 0.14642448
#> 5 1 2 2 1.500900 2.986992 1.486092 0.01480764
#> 6 1 2 3 1.497882 2.810140 1.312258 0.18562471
#> 7 1 3 1 1.361779 2.649672 1.287892 0.07388689
#> 8 1 3 2 1.503632 2.984446 1.480813 0.02281893
#> 9 1 3 3 1.403683 2.762787 1.359104 0.04457966Racial topography at the analysed scale is quantified as an ensemble average from multiple realizations. First, for each square window is calculated the average value of entropy and mutual information based on 100 realizations. Table below shows the mean (ent_mean, mutinf_mean) and standard deviation (ent_sd, mutinf_sd) values for each square window.
by_motif = group_by(metr_df_20, row, col)
smr = summarize(by_motif,
ent_mean = mean(ent, na.rm=TRUE),
ent_sd = sd(ent, na.rm=TRUE),
mutinf_mean = mean(mutinf, na.rm=TRUE),
mutinf_sd = sd(mutinf, na.rm=TRUE))
smr
#> # A tibble: 9 x 6
#> # Groups: row [3]
#> row col ent_mean ent_sd mutinf_mean mutinf_sd
#> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#> 1 1 1 1.26 0.0432 0.0199 0.00869
#> 2 1 2 1.59 0.0133 0.164 0.0265
#> 3 1 3 1.42 0.0290 0.0481 0.0153
#> 4 2 1 1.61 0.0256 0.152 0.0383
#> 5 2 2 1.52 0.0210 0.0364 0.0137
#> 6 2 3 1.51 0.0266 0.157 0.0290
#> 7 3 1 1.38 0.0457 0.137 0.0461
#> 8 3 2 1.54 0.0239 0.0163 0.00717
#> 9 3 3 1.42 0.0289 0.0491 0.0153Then the average from the mean values of entropy and mutual information is calculated.
Racial diversity-segregation classification
Bivariate classification shows at the same times changes in racial diversity and segregation. The values of entropy (the measure of racial diversity) and mutual information (the measure of racial segregation) are reclassified into 9 classes coded by nine colors.
#n is a number of categories in racial landscape
bivariate_classification <- function(entropy, mutual_information, n) {
#calculate bivariate classification
nent = log2(n)
ent_cat = cut(entropy, breaks=c(0,0.66,1.33, nent),labels = c(1,2,3),include.lowest = TRUE, right=TRUE)
ent_cat = as.integer(as.character(ent_cat))
mut_cat = cut(mutual_information, breaks=c(0,0.33,0.66,1),labels = c(10,20,30),include.lowest = TRUE, right=TRUE)
mut_cat = as.integer(as.character(mut_cat))
bivar_cls = mut_cat+ent_cat
bivar_cls = as.factor(bivar_cls)
return(bivar_cls)
}Mapping local racial diversity and racial segregation
The average value of entropy and mutual information calculated for each square-shaped window from all realizations can be joined to spatial grid object. Such operation allows for mapping metrices and show how segregation and racial diversity change over the area.
biv_colors = c('11' = "#e8e8e8", '12' = "#e4acac", '13' = "#c85a5a", '21' = "#b0d5df", '22' = "#ad9ea5", '23' = "#985356", '31' = "#64acbe",'32'= "#627f8c",'33'="#574249")
bcat = biv_colors[names(biv_colors)%in%unique(attr_grid$bivar_cls)]
plot(attr_grid['bivar_cls'], pal=bcat, main = "Racial diversity and residential segregation")
Calculate IT metrics from local patterns (2)
The next example shows how to calculate a local pattern using overlapping windows. This option is recommended to use, especially for bigger size value. Using overlapping windows does not introduce arbitrary boundaries.
To obtain overlapping windows function calculate_metrics() requires additional argument - shift.
metr_df_10 = calculate_metrics(x = real_raster, w= dens_raster, neighbourhood = 4, fun = "mean", size = 20, shift=10, threshold = 0.5)
by_motif = group_by(metr_df_10, row, col)
smr10 = summarize(by_motif,
ent_mean = mean(ent, na.rm=TRUE),
ent_sd = sd(ent, na.rm=TRUE),
mutinf_mean = mean(mutinf, na.rm=TRUE),
mutinf_sd = sd(mutinf, na.rm=TRUE))
complete_smr = apply(smr10[,c('ent_mean', 'ent_sd', 'mutinf_mean', 'mutinf_sd')], 2, mean, na.rm=TRUE)
round(complete_smr, 4)
#> ent_mean ent_sd mutinf_mean mutinf_sd
#> 1.4764 0.0322 0.0828 0.0233
#calculate bivariate classification
smr10$bivar_cls = bivariate_classification(entropy = smr$ent_mean, mutual_information = smr$mutinf_mean, n = nlayers(race_raster))
#create spatial grid object
grid_sf10 = create_grid(real_raster, size=20, shift = 10)
attr_grid10 = dplyr::left_join(grid_sf10, smr10, by = c("row", "col"))Mapping local racial diversity and racial segregation
#plot(attr_grid['ent_mean'], key.pos = 1, bty="n", box=FALSE, main = "Racial diversity (Entropy)")
plot(attr_grid10['ent_mean'], breaks = ent_breaks, key.pos = 1, pal = rev(brewer.pal(length(ent_breaks)-1, name = "RdBu")), bty="n", box=FALSE, main = "Racial diversity (Entropy)")
#plot(attr_grid['mutinf_mean'], key.pos = 1, main = "Racial segregation (Mutual Information)")
plot(attr_grid10['mutinf_mean'], breaks = mut_breaks, key.pos = 1, pal = rev(brewer.pal(length(mut_breaks)-1, name = "RdBu")), bty="n", box=FALSE, main = "Racial diversity (Entropy)")
biv_colors = c('11' = "#e8e8e8", '12' = "#e4acac", '13' = "#c85a5a", '21' = "#b0d5df", '22' = "#ad9ea5", '23' = "#985356", '31' = "#64acbe",'32'= "#627f8c",'33'="#574249")
bcat = biv_colors[names(biv_colors)%in%unique(attr_grid10$bivar_cls)]
plot(attr_grid10['bivar_cls'], pal=bcat, main = "Racial diversity and residential segregation")