Code

acs version 2.1.0 now available

Posted by Ezra Glenn on July 11, 2017
Code / Comments Off on acs version 2.1.0 now available

We are pleased to announce the release of version 2.1.0 of the “acs” package, now available on CRAN http://cran.r-project.org/web/packages/acs/index.html.

The package allows users to download, manipulate, analyze, and present demographic data from the U.S. Census, with special tools and methods to simplify the tasks of working with estimates and standard errors contained in data from the American Community Survey (ACS).

Important: version 2.1.0 of the package is a “minor update” in terms of features, but it includes a number of low-level tweaks necessary to accommodate upcoming changes in the Census API, including a shift to https transfer. Current users are strongly encouraged to update as soon as possible to avoid problems at the end of the summer.

Other minor changes include (a) removing plyr from a “dependency” and simply importing the required “rbind.fill” function, and (b) updating cbind/rbind options to be consistent with S3 methods.

For more information on the package and the update, please see the “Working with acs.R” user guide at http://dusp.mit.edu/sites/dusp.mit.edu/files/attachments/publications/working_with_acs_R_v_2.0.pdf.

For current acs-package users who are upgrading to 2.1.0:

  • When updating, try the “clean=T” option, which may be able to migrate your census api key:
> update.packages("acs", clean=T)

If this fails to migrate the key, you can always try:

> api.key.migrate()

And, if all else fails, just re-install a key with api.key.install().

  • After installing (and loading) the package, we highly recommend installing acs variable lookup tables on your system – these are not migrated, and installing them greatly speeds up the package:
> acs.tables.install()”

(And since you are installing the table, you only need to do this once — or just once, until new acs tables come out.)

Tags: , , , ,

acs version 2.0: now on CRAN

Posted by Ezra Glenn on March 14, 2016
Code / Comments Off on acs version 2.0: now on CRAN

After far too long, we are pleased to release version 2.0 of the acs package.

The biggest improvement is full support for all ACS, SF1, and SF3 data currently available via the Census API, including ACS data from 2005-2014 and Decennial data from 1990, 2000, and 2010. (See below for more info.)

1 Downloading and installing

To install the updated version, simply fire up an R session and type:

> install.packages("acs", clean=T)

2 Learn more

To learn more about the package, see the following:

And be sure to join the acs.R User Group Mailing List.

3 Notes and updates

A few notes about this new package:

  • API Keys: by default, when R updates a package, it overwrites the old package files. Unfortunately, that is where archived api.keys get saved by api.key.install(). As part of the version 2.0 package installation, “configure” and “cleanup” scripts can be run which try to migrate the key to a new location. If this fails, the install script will suggest that users run api.key.migrate() after installation, which might resolve the issue. At worst, if both methods fail, a user can simply re-run api.key.install() with the original key and be good to go.
  • endyear now required: under the old package, acs.fetch and acs.lookup would default to endyear=2011 when no endyear was provided. This seemed smart at the time – 2011 was the most recent data available – but it is becoming increasingly absurd. One solution would have been to change the default to be whatever data is most recent, but that would have the unintended result of making the same script run differently from one year to the next: bad mojo. So the new preferred “version 2.0 solution” is to require users to explicitly indicate the endyear that they want to fetch each time. Note that this may require some changes to existing scripts.
  • ACS Data Updates: the package now provides on-board support for all endyears and spans currently available through the API, including:
    • American Community Survey 5-Year Data (2005-2009 through 2010-2014)
    • American Community Survey 3 Year Data (2013, 2012)
    • American Community Survey 1 Year Data (2014, 2013, 2012, 2011)

    See http://www.census.gov/data/developers/data-sets.html for more info, including guidance about which geographies are provided for each dataset.

  • Decennial Census Data: for the first time ever, the package now also includes the ability to download Decennial Data from the SF1 and SF3, using the same acs.fetch() function used for ACS data.
    • SF1/Short-Form (1990, 2000, 2010)
    • SF3/Long-Form (1990, 2000)1

    When fetched via acs.fetch(), this data is downloaded and converted to acs-class objects. (Note: standard errors for Decennial data will always be zero, which is technically not correct for SF3 survey data, but no margins of error are reported by the API.) See http://www.census.gov/data/developers/data-sets/decennial-census-data.html for more info.

    Also note that census support for the 1990 data is a bit inconsistent – the variable lookup tables were not in the same format as others, and far less descriptive information has been provided about table and variable names. This can make it tricky to find and fetch data, but if you know what you want, you can probably find it; looking in the files in package’s extdata directory might help give you a sense of what the variable codes and table numbers look like.

  • Other improvements/updates/changes:
    • CPI tables: the CPI tables used for currency.year() and currency.convert() have been updated to include data up through 2015.
    • acs.fetching with saved acs.lookup results: the results of acs.lookup can still be saved and passed to acs.fetch via the “variable=” option,2 with a slight change: under v. 1.2, the passed acs.lookup results would overrule any explicit endyear or span; with v 2.0, the opposite is true (the endyear and span in the acs.lookup results are ignored by acs.fetch). This may seem insignificant, but it will eventually be important, when users want to fetch data from years that are more recent than the version of the package, and need to use old lookup results to do so.
    • divide.acs fixes: the package includes a more robust divide.acs() function, which handles zero denominators better and takes full advantage of the potential for reduced standard errors when dividing proportions.
    • acs.tables.install: to obtain variable codes and other metadata needed to access the Census API, both acs.fetch and acs.lookup must consult various XML lookup files, which are provided by the Census with each data release. To keep the size of the acs package within CRAN guidelines and to ensure tables will always be up-to-date, as of version 2.0 these files are accessed online at run-time for each query, rather than being bundled with each package release. As an alternative to these queries, users may use acs.tables.install to download and archive all current tables (approximately 10MB, as of version 2.0 release), which are saved by the package and consulted locally when present.

      Use of this function is completely optional and the package should work fine without it (assuming the computer is online and is able to access the lookup tables), but running it once may result in faster searches and quicker downloads for all subsequent sessions. (The results are saved and archived, so once a user has run the function, it is unnecessary to run again, unless the acs package is re-installed or updated.)

Other than these points, everything should run the same as the acs package you’ve come to know and love, and all your old scripts and data objects should still be fine. (Again, with the one big exception that you’ll need to add “endyear=XXXX” to any calls to acs.fetch and acs.lookup.)

Special thanks to package beta testers (Ari, Arin, Bethany, Emma,John, and Michael) and the entire acs-r community, as well as to Uwe and Kurt at CRAN for their infinite patience and continuing care and stewardship of the system.

Footnotes:

1

SF3 was discontinued after 2000 and replaced with the ACS.

2

did you even know this was possible…???

Tags: , , , ,

Presenting acs.R at the ACS Data User Conference

Posted by Ezra Glenn on April 06, 2015
Census, Code / Comments Off on Presenting acs.R at the ACS Data User Conference

On May 12, 2015, I’ll be presenting the acs.R package in a session of the American Community Survey Data User Group Conference in Hyattsville, MD. The paper, titled “Estimates with errors and errors with estimates: Using the R ‘acs’ package for analysis of American Community Survey data,” is available through the SSRN or my faculty publications webpage.

Better yet, the session will also include a presentation by Michael Laviolette, Dennis Holt, and Kristin K. Snow of the State of New Hampshire Department of Health and Human Services on “Using the R Language and ‘acs’ Package to Compile and Update a Social Vulnerability Index for New Hampshire.” It’s great to see how planners are using and extending this package in all sorts of exciting new settings and applications.

Click these links to see the complete program or to register for the conference.

acs.R useRs: Share your success stories

Posted by Ezra Glenn on October 20, 2014
Census, Code, Free Software, Open-Source / Comments Off on acs.R useRs: Share your success stories

Have you been using the acs.R package to download and analyze Census data in your work? Do you have a story you’d be willing to share, to help us promote the package and show off all the cool ways people are using open source tools to make sense of data and help inform communities, policy-makers, and researchers? If so, please let us know: email your news or project descriptions to eglenn@mit.edu and we’ll post them here to inform and inspire our readers. Be sure to include good images, news coverage, quotations, or other materials to help tell the story — and feel free to include links, scripts, or examples as well.

Thanks!

PS: Don’t forget to subscribe to the acs.R mailing list to remain in touch with the growing acs.R user community.

acs.R version 1.2: Now, with 2012 data

Posted by Ezra Glenn on January 22, 2014
Census, Code, Self-promotion / No Comments

As some of you have noticed, the new five-year Census ACS data has just come out, and is now available via the Census API. To make sure you are able to fetch the freshest possible data to play with in R, I’ve updated the acs.R package to version 1.2, which now includes full support for the 2008–2012 ACS data.

The latest version is now available on the CRAN repository. If you’ve already installed the package in the past, you can easily update with the update.packages() command; if you’ve never installed it, you can just as easily install it for the first time, by simply typing install.packages(“acs”). In either case, be sure to load the library after installing by typing library(acs), and install (or re-install) an API key with api.key.install() — see the documentation and the latest version of the acs user guide for more info.

To get the latest data, just continue to use the acs.fetch() function as usual, but specify endyear=2012. (By default, endyear is set to 2011 if no year is explicitly passed to acs.fetch, and I didn’t want to change this for fear of breaking existing user scripts. In the future, we might to rethink this, so that it selects the most recent endyear by default. Thoughts?)

(Note: If you’re not sure which version you are using, you can always type packageVersion(“acs”) to find out.)

New choropleth package in R

Posted by Ezra Glenn on January 22, 2014
Census, Code, Free Software, Open-Source / No Comments

A while back I posted a recipe (based on some great examples on the Revolution Analytics blog) showing how to use the acs package in R to create choropleth maps. Now, through the magic of open-source software development — and the hard work of developer Ari Lamstein and the generosity of his employers — this process has gotten even easier: I call your attention to Ari’s new chorolethr package for R.

Ari is a Senior Software Engineer at Trulia, where he works on data science and visualization, primarily related to real estate and housing markets. As part of the company’s “Innovation Week” he developed the choropleth package, moving well beyond the sample scripts to create a powerful suite of mapping functions. With a single command, a user can now generate maps at the state, county, or zip code level, from any of the data available via the ACS.

http://tech.truliablog.com/files/2014/01/county-income.png

The package is not yet up on CRAN, but Ari promises that’s in the works; for now, you can learn more about it — including installation instructions using install_github() — on the Trulia Tech + Design blog. (I’m of course proud to note that the acs.R package lies at the foundation of these tools, doing the heavy-lifting of fetching and processing up-to-date data from the American Community Survey — but Ari’s work is already moving beyond these humble roots, allowing users to create choropleth maps of any data they can get their hands on….)

To learn more about the types of projects undertaken by Trulia staffers during Innovation week, see this short video. Congratulations — and thanks — to both Ari and Trulia for helping to drive innovation forward in R and other open source projects.

Census API Down Due to Breakdown of Federal Government

Posted by Ezra Glenn on October 02, 2013
Census, Code / No Comments

Due to the shutdown of the federal government, it appears that many federal websites are down as well, including the Census API (see http://outage.census.gov/closed.txt). As a result, the acs.R package is currently unable to download data – sorry! If you to use acs.fetch or anything related that requires the API, you will probably get the following error:

> acs.fetch(geo=geo.make(state=25), table.number="B01003")
Error in file(file, "rt") : cannot open the connection

I assume that once this all gets sorted out, the site will come right back as before.

Using acs.R to create choropleth maps

Posted by Ezra Glenn on July 15, 2013
Census, Code, Maps / No Comments

Some time ago, FlowingData issued a challenge to create choropleth maps with open source tools, resulting in some nice little scripts using R’s ggplot2 and maps packages — all nicely covered on the Revolution Analytics blog. Some users have recently asked whether the acs package can be used to create similar maps, and the answer (of course) is yes. Here’s how.

For starters, to manage expectations, keep in mind that the map_data() function, which actually generates the geographic data you need to plot maps, does not currently provide boundary data for very many Census geographies — so sadly a lot of the new expanded support for various Census summary levels built into the acs package can’t be used. What you can do, however, is very easily plot state and county maps, which is what we’ll showcase below.

Secondly, the statistician in me feels compelled to point out one problem with using the acs package for these sorts of maps: choropleth maps are really fun to use to quickly show off the geographic distribution of some key statistic, but there is a price: in order to plot the data, we are really limited to a single number for each polygon. As a result, we can plot estimates from the ACS, but only if we are willing to ignore the margins of errors, and pretend that the data is less “fuzzy” than it really is. Given that the whole point of the acs package was to call attention to standard errors, and provide tools to work with them, it seems sort of counter-intuitive to use the package in this way — but given the ease of downloading ACS through the acs.fetch() function, it may still be a good (although slightly irresponsible) use of the package.

Given all that, I’ll step back down off my high horse, and show you how to make some maps, drawing heavily on the scripts provided by Hadley Wickham for using the ggplot2 package. For this example, let’s look at the percentage of people who take public transportation to work in the U.S., by county.

For starters, we’ll need to install and load the required packages:

> install.packages("acs")
> install.packages("ggplot2")
> install.packages("maps")
> library(acs)
> library(ggplot2)
> library(maps)

If you haven’t already obtained and installed an API key from the Census, you’ll need to do that as well — see ?api.key.install or check section 3.3 in the user guide.

Next, we use the map_data function to create some map boundary files to use later.

# load the boundary data for all counties
> county.df=map_data("county")
# rename fields for later merge
> names(county.df)[5:6]=c("state","county")
> state.df=map_data("state")

Turning to the acs package, we create a new geo.set consisting of all the tracts for all the state, and in a single call to acs.fetch download Census table B08301, which contains data on Mean of Transportation to Work. (If we didn’t know the table number we needed, we could use acs.lookup() to search for likely candidates, or even pass search strings directly to the acs.fetch() function.)

# wow! a single geo.set to hold all the counties...?
> us.county=geo.make(state="*", county="*")
# .. and a single command to fetch the data...!
> us.transport=acs.fetch(geography=us.county, 
     table.number="B08301", col.names="pretty")

The data we’ve fetched includes estimates of raw numbers of workers, not percentages, so we’ll need to do some division. Since we are interested in a proportion (and not a ratio), we to use the divide.acs function, not just “/”.1 For our dataset, the 10th column is the number of workers taking public transportation to work, and the 1st column is the total number of workers in the county. (See acs.colnames(us.transport) to verify this.) After we complete the division, we extract the estimates into a new data.frame, along with state and county names for each. (We need to do a little string manipulation to make these fields match with those from the map_data function above.)

> us.pub.trans=divide.acs(numerator=us.transport[,10], 
     denominator=us.transport[,1], method="proportion")
> pub.trans.est=data.frame(county=geography(us.pub.trans)[[1]], 
     percent.pub.trans=as.numeric(estimate(us.pub.trans)))
# this next step is all for Louisiana!
> pub.trans.est$county=gsub("Parish", "County", pub.trans.est$county)
# clean up county names and find the states
> pub.trans.est$state=tolower(gsub("^.*County, ", "", pub.trans.est$county))
> pub.trans.est$county=tolower(gsub(" County,.*", "", pub.trans.est$county))

Next, following Wickham’s script, we merge the boundaries with the data into a new data.frame (called choropleth) and reorder and recode it for out map levels.

> choropleth=merge(county.df, pub.trans.est, by=c("state","county"))
> choropleth=choropleth[order(choropleth$order), ]
> choropleth$pub.trans.rate.d=cut(choropleth$percent.pub.trans, 
     breaks=c(0,.01,.02,.03,.04,.05,.1,1), include.lowest=T)

And voila – a single call to ggplot and we have our map!

> ggplot(choropleth, aes(long, lat, group = group)) +
     geom_polygon(aes(fill = pub.trans.rate.d), colour = "white", size = 0.2) + 
     geom_polygon(data = state.df, colour = "white", fill = NA) +
     scale_fill_brewer(palette = "Purples")

./acs_scripts/choropleth_county_pub_trans.jpg

(For those who would like to see the entire script in all its efficient 14-line glory, I’ve pasted it below for easy cutting and pasting.)

install.packages("acs")
install.packages("ggplot2")
install.packages("maps")
library(acs)
library(ggplot2)
library(maps)
county.df=map_data("county")
names(county.df)[5:6]=c("state","county")
state.df=map_data("state")
us.county=geo.make(state="*", county="*")
us.transport=acs.fetch(geography=us.county, 
     table.number="B08301", col.names="pretty")
us.pub.trans=divide.acs(numerator=us.transport[,10], 
     denominator=us.transport[,1], method="proportion")
pub.trans.est=data.frame(county=geography(us.pub.trans)[[1]], 
     percent.pub.trans=as.numeric(estimate(us.pub.trans)))
pub.trans.est$county=gsub("Parish", "County", pub.trans.est$county)
pub.trans.est$state=tolower(gsub("^.*County, ", "", pub.trans.est$county))
pub.trans.est$county=tolower(gsub(" County,.*", "", pub.trans.est$county))
choropleth=merge(county.df, pub.trans.est, by=c("state","county"))
choropleth=choropleth[order(choropleth$order), ]
choropleth$pub.trans.rate.d=cut(choropleth$percent.pub.trans, 
     breaks=c(0,.01,.02,.03,.04,.05,.1,1), include.lowest=T)
ggplot(choropleth, aes(long, lat, group = group)) +
     geom_polygon(aes(fill = pub.trans.rate.d), colour = "white", size = 0.2) + 
     geom_polygon(data = state.df, colour = "white", fill = NA) +
     scale_fill_brewer(palette = "Purples")

wpid-choropleth\_county\_pub\_trans1.jpg

Footnotes:

1 Technically, since we are going to ignore the standard errors in our map, this could just be a standard division using “/”, but we might later want to look at the margins of error, etc. (For more on this issue, see ?divide.acs.)

Tags: , , , , ,

acs.R version 1.1: PUMAs and Zip Codes and MSAs, Oh My!

Posted by Ezra Glenn on July 14, 2013
Census, Code, Self-promotion / No Comments

Development continues on the acs package for R, with the latest update (version 1.1) now officially available on the CRAN repository. If you’ve already installed the package in the past, you can easily update with the update.packages() command; if you’ve never installed it, you can just as easily install it for the first time, by simply typing install.packages(“acs”). In either case, be sure to load the library after installing by typing library(acs), and install (or re-install) an API key with api.key.install() — see the documentation and the latest version of the acs user guide (which still references version 1.0).

Beyond improvements described in a previous post about version 1.0, the most significant change in the latest version is support for many more different combinations of census geography via the geo.make function. As described in the manual and on-line help, users can now specify options to create user-defined geographies composed of combinations of states, counties, county subdivisions, tracts, places, blockgroups (all available in the previous version), plus many more: public use microdata areas (PUMAs), metropolitan statistical areas (MSAs), combined statistical areas (CSAs), zip code tabulation areas, census regions and divisions, congressional district and state legislative districts (both upper and lower chambers), American Indian Areas, state school districts (of various types), New England County and Town Areas (NECTAs), and census urban areas. These geographies can be combined to create 25 different census summary levels, which can then even be bundled together to make even more complex geo.sets.

Once created and saved, these new user-defined geo.sets can be fed into the existing acs.fetch function to immediately download data from the ACS for these areas, combining them as desired in the process (and handling all those pesky estimates and margins of error in statistically-appropriate ways.)

We encourage you to update to the latest version and begin to explore the full power of the census data now available through the Census American Community Survey API. (And be sure to subscribe to the acs.R user group mailing list to be informed of future improvements.

Tags: , , , , ,

acs.R example: downloading all the tracts in a county or state

Posted by Ezra Glenn on July 03, 2013
Census, Code / No Comments

An acs.R user asks:

 
> How do I use acs to download all the census tracts? is there
> some handy command to do that?

Here’s some help:

All the tracts in a single county

You can’t automatically download all the tracts for the whole country (or even for an entire state) in a single step (but see below for ways to do this). If you just need all the tracts in a single county, it’s really simple — just use the “*” wildcard for the tract number when creating your geo.set.

The example below creates a geo.set for all the tracts in Middlesex County, Massachusetts, and then downloads data from ACS table B01003 on Total Population for them.

> my.tracts=geo.make(state="MA", county="Middlesex", tract="*") 
> acs.fetch(geography=my.tracts, table.number="B01003")

All the tracts in a state

If you happen to have a vector list of the names (or FIPS codes) of all the counties in a given state (or the ones you want), you could do something like this to get all the tracts in each of them:

> all.tracts=geo.make(state="MA", county=list.of.counties, 
  tract="*")
> acs.fetch(geography=all.tracts, table.number="B01003")

As an added bonus, if you don’t happen to have a list of counties, but want to use the package to get one, you could do something like this:

> mass=acs.fetch(geography=geo.make(state=25, county="*"), 
  table.number="B01003")

#  mass is now a new acs object with data for each county in
#  Massachusetts.  The "geography" function returns a dataframe of the
#  geographic metadata, which includes FIPS codes as the third
#  column.  So you can use it like this:

> all.tracts=geo.make(state="MA", 
  county=as.numeric(geography(mass)[[3]]), 
  tract="*", check=T)
> acs.fetch(geography=all.tracts, table.number="B01003")

All the tracts in the entire country

In theory, you could even use this to get all the tracts from all the 3,225 counties in the country:

> all.counties=acs.fetch(geography=geo.make(state="*", county="*"),
  table.number="B01003")
> all.tracts=geo.make(state=as.numeric(geography(all.counties)[[2]]),,
  county=as.numeric(geography(all.counties)[[3]]), tract="*", check=T)

Unfortunately (or perhaps fortunately), this is just too much for R to download without changing some of the internal variables that limit this sort of thing — if you try, R will complain with “Error: evaluation nested too deeply: infinite recursion…” To prove to yourself that it works, you could limit the number of counties to just the first 250, and try that — it will get you from Autauga County, Alabama to Bent County, Colorado.

> some.counties=all.counties[1:250]
> some.tracts=geo.make(state=as.numeric(geography(some.counties)[[2]]), 
  county=as.numeric(geography(some.counties)[[3]]), tract="*", check=T)
> lots.of.data=acs.fetch(geography=some.tracts, table.number="B01003")

This is really a lot of data — on my machine, this took about 18 seconds, resulting in a new acs object containing population data on 11,872 different tracts. I haven’t checked to see what the upper limits are, but I imagine it wouldn’t take much to figure out a way to get tract-level data from all 3,225 counties. (But remember: with great power comes great responsibility — don’t be too rough on downloading stuff from the Census, even if it is free and easy.)

Using the built-in FIPS data

An alternative approach to these last two examples would be to use the FIPS datasets that we’ve built-in to the acs.R package. For example, the “fips.county” dataset includes the names of each county, by state. Feed this (or part of this) to your geo.make command and you can do all sorts of neat things.

> head(fips.county)
  State State.ANSI County.ANSI    County.Name ANSI.Cl
1    AL          1           1 Autauga County      H1
2    AL          1           3 Baldwin County      H1
3    AL          1           5 Barbour County      H1
4    AL          1           7    Bibb County      H1
5    AL          1           9  Blount County      H1
6    AL          1          11 Bullock County      H1
> 

So instead of the last block above, you could do something like this:

> random.counties=sample(x=3225,size=20, replace=F)
> some.tracts=geo.make(state=fips.county[random.counties,1], 
  county=fips.county[random.counties,3], tract="*", check=T)
Testing geography item 1: Tract *, Ponce Municipio, Puerto Rico .... OK.
Testing geography item 2: Tract *, Alleghany County, North Carolina .... OK.
Testing geography item 3: Tract *, Wayne County, Pennsylvania .... OK.
Testing geography item 4: Tract *, Comerio Municipio, Puerto Rico .... OK.
Testing geography item 5: Tract *, Lafayette County, Wisconsin .... OK.
Testing geography item 6: Tract *, Hartford County, Connecticut .... OK.
Testing geography item 7: Tract *, Real County, Texas .... OK.
Testing geography item 8: Tract *, Costilla County, Colorado .... OK.
Testing geography item 9: Tract *, Sarpy County, Nebraska .... OK.
Testing geography item 10: Tract *, McLennan County, Texas .... OK.
Testing geography item 11: Tract *, Donley County, Texas .... OK.
Testing geography item 12: Tract *, McIntosh County, Georgia .... OK.
Testing geography item 13: Tract *, Chilton County, Alabama .... OK.
Testing geography item 14: Tract *, Richland County, Montana .... OK.
Testing geography item 15: Tract *, Mitchell County, Kansas .... OK.
Testing geography item 16: Tract *, Muscogee County, Georgia .... OK.
Testing geography item 17: Tract *, Martin County, Indiana .... OK.
Testing geography item 18: Tract *, Naguabo Municipio, Puerto Rico .... OK.
Testing geography item 19: Tract *, Aguas Buenas Municipio, Puerto Rico .... OK.
Testing geography item 20: Tract *, Washington County, Arkansas .... OK.

> # you may get different counties in your random set
>
> acs.fetch(geography=some.tracts, table.number="B01003")

Which will return population data from all the tracts in a random set of 20 counties.

Tags: , , , ,