forked from NeotomaDB/EPD_binder
-
Notifications
You must be signed in to change notification settings - Fork 2
Expand file tree
/
Copy pathsimple_workflow.Rmd
More file actions
491 lines (346 loc) · 27.6 KB
/
simple_workflow.Rmd
File metadata and controls
491 lines (346 loc) · 27.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
---
title: "A Simple Workflow"
author:
- name: "Simon Goring"
institute: [uwiscgeog,uwiscdsi]
correspondence: true
email: goring@wisc.edu
orcid_id: 0000-0002-2700-4605
- name: "Socorro Dominguez Vidaña"
institute: [rhtdata]
correspondence: false
email: s.dominguez@wisc.edu
orcid_id: 0000-0002-7926-4935
institute:
- uwiscgeog:
name: "University of Wisconsin -- Madison: Department of Geography"
- uwiscdsi:
name: "University of Wisconsin -- Data Science Institute"
date: "`r Sys.Date()`"
always_allow_html: true
output:
html_document:
code_folding: show
fig_caption: yes
keep_md: yes
self_contained: yes
theme: readable
toc: yes
toc_float: yes
css: "text.css"
pdf_document:
pandoc_args: "-V geometry:vmargin=1in -V geometry:hmargin=1in"
word_document:
fig_caption: yes
self_contained: yes
toc: yes
always_allow_html: true
csl: 'https://bit.ly/3khj0ZL'
---
```{r setup, echo=FALSE}
options(warn = -1)
pacman::p_load(neotoma2, dplyr, ggplot2, sf, geojsonsf, leaflet, DT, readr, stringr, rioja, tidyr)
```
## Introducción
El objetivo de este documento es mostrar como usar el paquete de R para la base de datos Neotoma, `neotoma2`.
La [librería neotoma2](https://github.com/NeotomaDB/neotoma2) está disponible en GitHub y actualmente la documentación sólo está en inglés - trabajamos para tenerla en español próximamente.
## ¿Qué aprenderemos?
Los objetivos de aprendizaje de este taller son:
- Aprender cómo se organiza la información dentro de Neotoma (Sitios, Unidades de colección y Conjuntos de datos)
- Cómo se traduce esta estructura en el paquete neotoma2 para R:
## En R:
* Busqueda de sitios: Buscar sitios a partir de nombres o parámetros geográficos.
* Filtrar resultados: Filtración de resultados utilizando parametros temporales o espaciales.
* Exploración de datos: Obtener información de muestras para los grupos de datos seleccionados.
* Visualizar datos: Realizar gráficos estratigráficos básicos.
1. [Búsqueda de Sitios](#3-site-searches): Buscar sitios a partir de nombres o parámetros geográficos.
2. [Filtrar Resultados](#33-filter-records-tabset): Filtración de resultados utilizando parametros temporales o espaciales.
3. [Exploración de Datos](#34-pulling-in-sample-data): Obtener información de muestras para los grupos de datos seleccionados.
4. [Visualizar Datos](#4-simple-analytics): Realizar gráficos estratigráficos básicos.
## Antecedentes
### Obtener ayuda coh Neotoma
Si estás planeando trabajar con Neotoma, te invitamos a unirte a nuestro canal de [Slack](https://join.slack.com/t/neotomadb/shared_invite/zt-cvsv53ep-wjGeCTkq7IhP6eUNA9NxYQ), donde tenemos un espacio específico para preguntas sobre el paquete en R: el canal #it_r (también hay #it_r_es si prefieres ayuda en español).
También puedes unirte a la comunidad de Neotoma a través de nuestras listas de correo en Google Groups. Para hacerlo, revisa la información en nuestro sitio web o [contáctanos](mailto:neotoma-contact@googlegroups.com) para ser agregado.
### La estrucura de Neotoma
Los datos en la base de datos de Neotoma están organizados como un conjunto de relaciones conectadas que permiten representar los distintos elementos de un análisis paleoecológico:
- Espacio y tiempo:
- ¿Dónde está ubicada una muestra (latitud y longitud)?
- ¿A qué profundidad fue tomada dentro de un perfil estratigráfico?
- ¿Qué edad estimada tiene esa muestra?
- ¿Qué edad tienen los elementos encontrados dentro o cerca de esa muestra?
- Observaciones:
- ¿Qué se está contando o midiendo?
- ¿Qué unidades se están usando?
- ¿Quién lo observó?
- Métodos científicos
- ¿Qué modelo estadístico se usó para calcular la edad?
- ¿Qué tipo de incertidumbre se consideró para describir esa observación?
- Modelos conceptuales de datos
- ¿Cómo se relacionan las observaciones dentro de una muestra con otras muestras de la misma colección?
- ¿Cómo se vincula una observación fósil con especies actuales o extintas relacionadas?
La paleoecología es un campo amplio y en constante evolución por lo que estas relaciones pueden ser bastante complejas. Por eso, la base de datos está altamente estructurada y normalizada, lo que permite agregar nuevos conocimientos sin afectar el modelo de datos central.
Si quieres profundizar en cómo está organizada la base de datos, puedes leer el Manual de la base de datos de Neotoma o revisar directamente el esquema del modelo relacional.
#### Estructura de Datos en Neotoma
{width=75%}
En Neotoma, los datos se asocian a **sitios** -- ubicaciones específicas con coordenadas de latitud y longitud.
Dentro de un **sitio**, puede haber una o más [**unidades de colecta**](https://open.neotomadb.org/manual/dataset-collection-related-tables-1.html#CollectionUnits) -- que son los puntos específicos donde se recolectan físicamente las uestras dentro del sitio. Por ejemplo:
* Una **cueva** es un sitio que puede tener más de una **colección**, con entidades específicas (espeleotemas)
* Un **sitio arqueológico** puede tener una o más **colecciones**, como pozos dentro de una excavación.
* Un **sitio** de muestreo de polen puede tener varias **colecciones** -- es decir, diferentes núcleos dentro de la cuenca del lago.
* Una ciénaga es un **sitio** que puede tener diversas **colecciones** -- una transecta con varias muestras de superficie.
Las unidades de colección pueden tener coordenadas GPS de mayor resolución que el sitio general, pero siguen considerándose parte del mismo sitio.
Los datos dentro de una **colección** son recopilados a partir de diferentes [**unidades de análisis**](https://open.neotomadb.org/manual/sample-related-tables-1.html#AnalysisUnits), por ejemplo:
* Todo el sedimento a 10cm de profundidad en un perfil de corte (la colección) a lo largo de un lago meándrico (el sitio) es una unidad de análisis;
* Todo el material en una muestra de superficie (colección) tomada de una ciénaga (el sitio) es una unidad de análisis;
* Todos los restos fósiles en una capa enterrada de huesos (colección) en una cueva (el sitio) también forman una unidad de análisis.
Los datos recolectados en una unidad de análisis se agrupan según su tipo de conjunto de datos (carbón, diatomeas, dinoflagelados, etc.) y se organizan como una [**muestra**](https://open.neotomadb.org/manual/sample-related-tables-1.html#Samples). El conjunto de muestras de una colección para un tipo de datos determinado se asigna a un [**conjunto de datos**](https://open.neotomadb.org/manual/dataset-collection-related-tables-1.html#Datasets).
* Una muestra puede ser todas las diatomeas (conjunto de datos) extraídas del sedimento a 12 cm de profundidad (unidad de análisis) en un núcleo (colección) de un lago (el sitio).
* Otra muestra puede ser el registro de un solo hueso de mamut (muestra y unidad de análisis, tipo de datos: vertebrados) encontrado en la ribera de un río (sitio y unidad de colección).
#### Estructura de Datos en `neotoma2` {#222-data-structures-in-neotoma2}

Si observamos el [diagrama UML](https://es.wikipedia.org/wiki/Lenguaje_unificado_de_modelado) podemos observar que la estructura de datos en el paquete `neotoma2` refleja la estructura original de la base de datos.
Como veremos en la sección [Búsqueda de Sitios](#3-site-searches), podemos buscar estos objetos y empezar a trabajar con ellos (en la sección [Análisis Simple](#4-simple-analytics)).
Un punto que debemos tener en cuenta, *en el paquete `neotoma2`, la mayoría de los objetos son de la clase `sites` , que contienen mayor o menor información*. Hay diferentes funciones que operan sobre `sites`. Cuando queremos obtener mayor información sobre los sitios `sites`, utilizamos las funciones `get_datasets()` o `get_downloads()` que pueblan con mayor información los sitios.
## Búsqueda de sitios
### `get_sites()`
Hay diferentes maneras de encontrar sitios en `neotoma2`. Debémos pensar en los `sitios` como objetos espaciales. Tienen nombre, ubicación y pueden ser encontrados bajo en contexto de unidades geopolíticas. Sin embargo, bajo el contexto de la API y del paquete de R, los sitios en sí mismos no contienen datos sobre la taxonomía, el grupo de datos o las edades. Simplemente es un contenedor al que le podemos agregar más información. Es así que cuando buscamos por sitio, lo hacemos usando los siguientes atributos (en inglés):
| Parámetro | Descripción |
| ------------- | --------------------------------------------------------------------------- |
| sitename | Un nombre válido, usando `%` como comodín. |
| siteid | Un identificador numérico único del sitio en la base de datos de Neotoma. |
| loc | Un vector de caja delimitadora, GeoJSON o cadena WKT. |
| altmin | Límite inferior de altitud para los sitios. |
| altmax | Límite superior de altitud para los sitios. |
| database | La base de datos específica de donde se extraen los registros. |
| datasettype | El tipo de conjunto de datos (ver `get_tables(datasettypes)`). |
| datasetid | Identificador numérico único del conjunto de datos en Neotoma. |
| doi | Un DOI válido para un conjunto de datos en Neotoma. |
| gpid | Un ID numérico único o cadena de texto que identifica una unidad geopolítica. |
| keywords | Palabras clave únicas para muestras registradas en Neotoma. |
| contacts | Un nombre o ID numérico de personas asociadas con los sitios. |
| taxa | IDs numéricos únicos o nombres de taxones asociados con los sitios. |
#### Nombre del sitio: `sitename="%Lago%"` {.tabset}
Hay ocasiones en las que sabremos exactamente el nombre del sitio que estamos buscando ("Lago Titicaca"), y habrà ocasiones en las que tendremos una idea aproximada sobre el nombre (por ejemplo, sabemos que el nombre es parecido a "Lago Titicaca", o "Lake Titicaca", pero no estamos seguros de como fue ingresado a la base de datos).
De forma general, utilizamos el formato: `get_sites(sitename="XXXXX")` para buscar un sitio por nombre.
PostgreSQL (y la API) utilizan el signo de porcentaje como comodín. De esta forma, `"%Titicaca%"` seleccionará ["Lake Titicaca"](https://data.neotomadb.org/21984) y en caso de existir, también seleccionaría "Lago Titicaca" y "Pantano **Titicaca**". La búsqueda tampoco distingue entre mayúsculas y minúsculas, por lo que simplemente podría escribir `"%titicaca%"`.
##### Code
```{r sitename, eval=FALSE}
lago_titicaca <- neotoma2::get_sites(sitename = "%titicaca%")
lago_titicaca
```
##### Result
```{r sitenamePlot, echo=FALSE}
lago_titicaca <- neotoma2::get_sites(sitename = "%titicaca%")
lago_titicaca
```
#### Ubicación: `loc=c()` {.tabset}
El paquete `neotoma` utilizaba un cuadro delimitador para buscar por ubicación. El cuadro estaba estructurado como un vector con valores de latitud y longitud: `c(xmin, ymin, xmax, ymax)`. En `neotoma2` se puede utilizar esta misma caja delimitadora o podemos definir objetos espaciales más complejos con el [paquete `sf`](https://r-spatial.github.io/sf/). El paquete `sf` nos permite trabajar con datos ráster y polígonos en R, para seleccionar sitios existentes en objetos espaciales más complejos. El parametro `loc` trabaja con vectores simples, objetos [WKT](https://arthur-e.github.io/Wicket/sandbox-gmaps3.html), objetos [geoJSON](http://geojson.io/#map=2/20.0/0.0) y objectos `sf` en R. **Notar que** el paquete `neotoma2` es un función contenedora API que utiliza un URL ([api.neotomadb.org](https://api.neotomadb.org)).
Buscar sitios utilizando una ubicación. En el siguiente código hay tres representaciones de Sudamérica: geoJSON, WKT y con un cuadro delimitador. También hemos transformado el elemento `sa$geoJSON` a un objeto del paquete `sf`. Podemos utilizar cualquiera de estas cuatro representaciones para trabajar con el paquete `neotoma2`.
```{r boundingBox}
sa <- list(geoJSON = '{"type": "Polygon",
"coordinates": [[
[-79.66, -5.97],
[-70.06, -19.07],
[-74.38, -55.59],
[-34.67, -6.52],
[-76.41, 8.37],
[-79.66, -5.97]
]]}',
WKT = 'POLYGON ((-79.66, -5.97,
-70.06, -19.07,
-74.38, -55.59,
-34.67, -6.52,
-76.41, 8.37,
-79.66, -5.97))',
bbox = c(-79.66, -55.59, -34.67, 8.37))
sa$sf <- geojsonsf::geojson_sf(sa$geoJSON)
sa_sites <- neotoma2::get_sites(loc = sa$sf, all_data = TRUE)
```
Puedes siempre hacer un gráfico de los `sites` obtenidos con `plot()`, pero los datos perderan el contexto geográfico. La función `plotLeaflet()` regresa un mapa de la librería `leaflet()` y permite mayor personalización o agregar datos espaciales adicionales (como nuestro cuadro delimitador, `sa$sf`, que funciona directamente con el paquete `leaflet`):
##### Code
Note the use of the `%>%` pipe here. If you are not familiar with this symbol, check our ["Piping in R" section](#piping-in-r) of the Appendix.
```{r plotL, eval=FALSE}
neotoma2::plotLeaflet(sa_sites) %>%
leaflet::addPolygons(map = .,
data = sa$sf,
color = "green")
```
##### Result
```{r plotLeaf, echo=FALSE}
neotoma2::plotLeaflet(sa_sites) %>%
leaflet::addPolygons(map = .,
data = sa$sf,
color = "green")
```
#### Auxiliares para objetos de tipo Sitios {.tabset}

Si observamos al [diagrama UML](https://es.wikipedia.org/wiki/Lenguaje_unificado_de_modelado) para los objetos de `neotoma2` podemos ver que hay un conjunto de funciones qeu operan a nivel de `sites` (sitios). Conforme vamos agregando información a los objetos `sites` mediante las funciones `get_datasets()` o `get_downloads()`, podemos utilizar un mayor número de funciones auxiliares. Podemos así, tomar ventaja de funciones como `summary()` para tener un mejor entendimiento de los diferentes tipos de datos que tenemos en este conjunto de sitios. El código a continuación regresa la tabla de resumen. Hacemos después un poco de magia con R para cambiar el formato en que los datos están siendo representados (convirtiéndolo a un objeto `datatable()`), pero la pieza principal es la llamada a la función `summary()`.
##### Code
```{r summary_sites, eval=FALSE}
# Give information about the sites themselves, site names &cetera.
neotoma2::summary(sa_sites)
# Give the unique identifiers for sites, collection units and datasets found at those sites.
neotoma2::getids(sa_sites)
```
##### Result
```{r summarySitesTable, eval=TRUE, echo=FALSE}
neotoma2::summary(sa_sites) %>%
DT::datatable(data = ., rownames = FALSE,
options = list(scrollX = "100%", dom = 't'))
```
Podemos ver que no hay cronologías asociadas con el objeto `sites`. Esto es porque, por el momento, no hemos extraído la información necesaria de los `dataset`. Todo lo que sabemos, tras la llamada `get_sites()` son los tipos de conjuntos de datos con los que contamos.
### Búsqueda de conjuntos de datos (`get_datasets()`): {.tabset}
Sabemos que las `colecciones` y los `conjuntos de datos` están contenidos en los `sitios`. Similarmente, un objeto de tipo `sites` contienen `collectionunits` que contienen `datasets`. En la tabla anterior podemos ver que algunos de los sitios contienen registros de diatomeas. Dicho esto, solo tenemos la información de `sites`, pero por conveniencia, la API devuelve información adicional sobre los conjuntos de datos lo que nos permite navegar de manera más fácil los registros.
Con un objeto `sites` podemos llamar directamente a la función `get_datasets()`, que nos permitirá extraer metadatos sobre los conjuntos de datos. Podemos utilizar la función `datasets()` en cualqueir momento para obtener más información de los conjuntos de datos que un objeto `sites` pueda contener. Comparemos la información impresa `datasets(sa_sites)` contra una llamada similar utilizando el siguiente código.
#### Code
```{r datasetsFromSites, eval=FALSE}
# This may be slow, because there's a lot of sites!
sa_datasets <- neotoma2::get_datasets(sa_sites, all_data = TRUE)
datasets(sa_datasets)
```
#### Result
```{r datasetsFromSitesResult, echo=FALSE, message=FALSE}
sa_datasets <- neotoma2::get_datasets(sa_sites, all_data = TRUE)
datasets(sa_datasets) %>%
as.data.frame() %>%
DT::datatable(data = .,
options = list(scrollX = "100%", dom = 't'))
```
### Filtrar Registros con `filter()` {.tabset}
Si decidimos únicamente obtener registros de un sólo tipo de datos, o si requerimos de mayor filtración, debemos considerar filtrar antes de descargar todos los datos y muestras. Para ello, utilizaremos la función `filter()`. Por ejemplo, si requerimos únicamente los registros de polen, podemos filtrar de la siguiente forma:
#### Code
```{r downloads, eval=FALSE}
sa_pollen <- sa_sites %>%
neotoma2::filter(datasettype == "pollen")
neotoma2::summary(sa_pollen)
```
#### Result
```{r downloadsCode, echo = FALSE}
sa_pollen <- sa_sites %>%
neotoma2::filter(datasettype == "pollen")
neotoma2::summary(sa_pollen) %>% DT::datatable(data = .,
options = list(scrollX = "100%", dom = 't'))
```
Podemos ver que aún faltan las cronologías para estos registros. Para obtener esta información, debemos hacer otras funciones que recolecten esta informacion desde la API.
### Obteniendo las muestras con `sample()`.
Debido a que los datos de las muestras agregan mucha sobrecarga (para Sudamérica, los datos de polen sobrecargara nuestro `sites` object más que 20 veces), por eso llamamos la función `get_downloads()` después de haber hecho un filtrado preliminar. Después de `get_datasets()`, tenemos información sufciente para filtar basados en ubicación, límites de tiempo y tipo conjunto de datos. Cuando ejecutamos`get_downloads()` podemos hacer un filtrado más fino a nivel de unidad de análisis o nivel de taxón.
El siguiente comando puede tomar algo de tiempo. Por eso, hemos guardado el resultado en un archivo RDS. Puedes intentar correr este comando por tu cuenta o puedes cargar el archivo RDS.
```{r taxa}
## This line is commented out because we've already run it for you.
sa_dl <- sa_pollen %>% get_downloads(all_data = TRUE)
saveRDS(sa_dl, "data/saDownload.RDS")
sa_dl <- readRDS("data/saDownload.RDS")
```
Una vez que hemos hecho la descarga, ahora tenemos información de cada sitio asociado a las unidades de colecta, los tipos de conjunto de datos, y a todas las muestras asociadas a estos conjuntos. Para extraer toda las muestras, utilizamos la función `samples`:
```{r allSamples}
allSamp <- samples(sa_dl)
```
Una vez hecho esto, obtenemos un `data.frame` esto es una tabla con **nrow(allSamp)** renglones y **ncol(allSamp)** columnas. La razón de que esta tabla sea muy larga es porque estamos obteniendo los datos en un formato **largo**. Cada rengón contiene toda la información que se necesita para interpretarse correctamente:
```{r colNamesAllSamp, echo = FALSE}
colnames(allSamp)
```
Para algunos tipos de conjunto de datos o análisis específicos, algunas columnas podrán no ser necesarias. Sin embargo, para otros conjuntos de datos pueden ser críticamente importantes. Para permitir que el paquete `neotoma2` sea lo más útil posible para todos los usuarios, hemos incluido todas las columnas posibles.
#### Extracción de taxones {.tabset}
Si quieres saber que taxones existen en los registros, puedes utilizar la función `taxa()` en el objeto `sites`. La función `taxa()` regresa los taxones únicos junto con dos columnas adicionales `sites` y `samples` que indican en cuantos sitios y en cuantas muestras el taxón aparece, esto nos ayuda a comprender mejor que tan común es cada taxón individual.
##### Code
```{r taxa2, eval=FALSE}
neotomatx <- neotoma2::taxa(sa_dl)
```
##### Results
```{r taxaprint, echo=FALSE, message=FALSE}
neotomatx <- sa_dl %>% neotoma2::filter(datasettype == 'pollen') %>% taxa()
neotomatx %>%
DT::datatable(data = head(neotomatx, n = 20), rownames = FALSE,
options = list(scrollX = "100%", dom = 't'))
```
#### Entendiendo las Taxonomías en Neotoma {-}
Las taxonomías en Neotoma no siempre son tan directas como podríamos pensar. La identificación taxonómica en paleoecología puede ser compleja y verse influenciada por la morfología del organismo, el estado de conservación del palinomorfo, la experiencia del/la analista, entre otros factores. Puedes leer más sobre este tema en la sección sobre [Conceptos Taxonómicos del Manual de Neotoma](https://open.neotomadb.org/manual/database-design-concepts.html#taxonomy-and-synonymy).
En la base de datos utilizamos identificadores únicos (por ejemplo, `taxonid`, `siteid`, `analysisunitid`) porque nos permiten conectar los distintos registros entre sí. Los valores de `taxonid` que devuelve la función `taxa()` se pueden vincular con la columna `taxonid` en la tabla que devuelve `samples()`. Esto nos permite, por ejemplo, crear tablas de armonización taxonómica si lo necesitamos.
También notarás que el nombre del taxón (`taxonname`) aparece en el campo `variablename`. En Neotoma, los conteos individuales de muestras se reportan como [`variables`](https://open.neotomadb.org/manual/taxonomy-related-tables-1.html#Variables). Una "variable" puede representar una especie, una medición de laboratorio o incluso un proxy no orgánico, como carbón (charcoal) o mediciones de fluorescencia de rayos X (XRF). Estas variables incluyen tanto la unidad de medida como el valor correspondiente.
## Análisis Simples
### Trazado Estratigráfico
Podemos utilizar paquetes como `rioja` para hacer trazados estratigráficos para un único registro. Pero primero tenemos que hacer un manejo de datos diferente. A pesar de que podríamos hacer armonización nuevamente, vamos a tomar los 10 taxones más comúnes en un sitio dado los trazaremos en un diagrama estratigráfico.
Utilizaremos la función `arrange()` para ordenar confrome al número de veces que un taxón aparece en un núcleo. De esta forma, podemos tomar las muestras y seleccionar los taxones que aparecen en las diez primeras filas del marco de datos `plottingTaxa`.
#### Organizar datos
```{r stratiplotraw, message = FALSE}
# Get a particular site, in this case we are simply subsetting the
# `sa_dl` object to get Lake Solsø:
plottingSite <- sa_dl[[1]]
counts <- plottingSite %>%
samples() %>%
toWide(ecologicalgroup = c("TRSH"),
unit = c("NISP"),
elementtypes = c("pollen"),
groupby = "age",
operation = "prop")
counts <- counts[, colSums(counts > 0.01, na.rm = TRUE) > 5]
counts
```
### {.tabset}
Aparentemente, esto es una llamada compleja de comandos. Sin embargo, la función `toWide()` proporciona control sobre los taxones, unidades y otros elementos para que puedan ser ingresados en una matriz (`depth` x `taxon`) que muchas herramientas estadísticas como los paquetes `vegan` o `rioja` usan.
Para crear gráficas, podemos usar `strat.plot()` del paquete `rioja`, ordenar los taxones usando puntajes promedio ponderados (`wa.order`). También se ha agregado un gráfico CONISS al borde del gráfico, para mostrar cómo funciona el nuevo marco de datos amplio con funciones métricas de distancia.
#### Mostrar el gráfico
```{r plotStrigraphraw, message=FALSE, warning=FALSE, out.width='90%'}
clust <- rioja::chclust(dist(sqrt(counts)),
method = "coniss")
# Plot the stratigraphic plot, converting proportions to percentages:
plot <- rioja::strat.plot(counts[,-1] * 100, yvar = counts$age,
title = sa_dl[[1]]$sitename,
ylabel = "Calibrated Years BP",
xlabel = "Pollen (% of Trees and Shrubs)",
y.rev = TRUE,
clust = clust,
wa.order = "topleft",
scale.percent = TRUE)
rioja::addClustZone(plot, clust, 4, col = "red")
```
## Conclusion
Hemos hecho muchas cosas en este ejemplo.
- Buscamos sitios utilizando nombres y parámetros geográficos.
- Filtramos resultados utilizando parámetros espaciales y temporales.
- Obtuvimos información de las muestras de los conjuntos de datos seleccionados.
- Hicimos un análisis estratográfico básico.
¡Esperamos que utilizen estos ejemplos como un bloque para usar en el futuro en su trabajo o para algo nuevo y divertido!
## Apéndice
### Instalación {#localinstall}
## CRAN
```r
install.packages('neotoma2')
library(neotoma2)
```
## Github (recomendado)
Sin embargo, para instalar la versión más actualizada, es recomendable hacer (versión 1.0.6):
```r
install.packages('devtools')
devtools::install_github("NeotomaDB/neotoma2@dev")
library(neotoma2)
```
Para las liberías adicionales, puedes usar pacman. Si no tienes `pacman` instalado, puedes instalarlo usando el siguiente comando:
```{r setupFake, eval=FALSE}
options(warn = -1)
install.packages("pacman")
pacman::p_load(neotoma2, dplyr, ggplot2, sf, geojsonsf, leaflet, terra, DT, readr, stringr, rioja)
```
## Virtual
Aunque se puede trabajar de forma local, este tutorial se puede hacer utilizando la instancia de Binder. Binder ejecutará una sesión de RStudio en tu navegador, con todas las liberías necesarias.
### Github Pages (Estás aquí)
O bien, para una versión más amena, se puede utilizar la instancia de Github-pages.
### Rmd en Binder
Estas aquí.
### Pipas en `R` {.tabset}
Las pipas o pipes en R son una forma de encadenar funciones. Generalmente, se puede utilizar los operadores: `|>` or `%>%`. `|>` es nativo en R y `%>%` viene del ecosistema `tidyverse` en R. En `neotoma2` usamos `%>%`.
Este operador es muy útil pues funciona como una tubería que lleva agua de un lugar a otro. En programación, es como una línea de montaje donde los datos entran por una función, se modifican y el resultado es ingresado a la siguiente función. Esto hace que el código sea legible y más facil de escribir. También reduce el número de variables que se necesitan, ahorrando espacio en memoria.
Por ejemplo, sin los pipes en `neotoma2` para extraer un sitio y luego crear la gráfica haríamos:
```r
# Retrieve the site
plot_site <- neotoma2::get_sites(sitename = "%ø%")
# Plot the site
neotoma2::plotLeaflet(object = plot_site)
```
Es decir, primero creamos la variable `plot_site` que sólo utilizaríamos una vez pero que fue necesaria para poder ejecutar la función `plotLeaflet`.
Con la pipa (`%>%`) no necesitamos crear la variable, simplemente escribimos nuestro código. Así `plotLeaflet()` no requiere un argumento `object` porque utiliza la respuesta generada por `get_sites(sitename = "%ø%")`.
```r
# Retrieve the site
neotoma2::get_sites(sitename = "%ø%") %>%
plotLeaflet()
```