├── .Rbuildignore ├── .github ├── .gitignore └── workflows │ ├── R-CMD-check.yaml │ └── pkgdown.yaml ├── .gitignore ├── DESCRIPTION ├── LICENSE.md ├── NAMESPACE ├── R ├── aspe-package.R ├── data_dictionnaire.R ├── data_liste_rouge.R ├── data_passerelle_taxo.R ├── data_protection_especes.R ├── data_taille_poids.R ├── data_traits_bio.R ├── def_attribut_id.R ├── donnees_test.R ├── expl_commentaires_champs.R ├── expl_lister_champs.R ├── expl_trouver_table.R ├── expl_trouver_variable.R ├── export_tables_csv.R ├── export_tables_rdata.R ├── geo_aggr_richesse.R ├── geo_ajouter_crs.R ├── geo_attribuer.R ├── geo_convertir_coords_df.R ├── gg_ajouter_arriere_plan_int.R ├── gg_colo_ext_pops.R ├── gg_density_env_esp.R ├── gg_dyn_esp.R ├── gg_gerer_seuils_classes_ipr_int.R ├── gg_histo_longueur.R ├── gg_temp_abondance.R ├── gg_temp_env.R ├── gg_temp_indic_div.R ├── gg_temp_ipr.R ├── gg_temp_ipr_pc_bon.R ├── gg_temp_metriq.R ├── gg_temp_metriq_grille.R ├── gg_temp_peuplement.R ├── globals.R ├── imp_corres_aspe_taxref.R ├── imp_extraire_date_fichier.R ├── imp_extraire_noms_tables.R ├── imp_extraire_noms_tables2.R ├── imp_importer_dump_sql.R ├── imp_lire_lignes_dump.R ├── imp_scinder_dump.R ├── imp_tables_a_partir_des_lignes.R ├── imp_trouver_index_fin.R ├── ip_completer_classes_couleur.R ├── ipr_formater_pour_macro.R ├── ipr_pivoter_1colonne_par_an.R ├── ipr_renommer_pour_macro.R ├── mef_ajouter_abs.R ├── mef_ajouter_ambiance.R ├── mef_ajouter_dept.R ├── mef_ajouter_esp.R ├── mef_ajouter_groupe_points.R ├── mef_ajouter_intervenants.R ├── mef_ajouter_ipr.R ├── mef_ajouter_libelle.R ├── mef_ajouter_libelle_site.R ├── mef_ajouter_lots.R ├── mef_ajouter_mei.R ├── mef_ajouter_metriques.R ├── mef_ajouter_moyen_prospection.R ├── mef_ajouter_objectif.R ├── mef_ajouter_ope_date.R ├── mef_ajouter_ope_desc_peche.R ├── mef_ajouter_ope_env.R ├── mef_ajouter_passage.R ├── mef_ajouter_proba_presence_ipr.R ├── mef_ajouter_qualification.R ├── mef_ajouter_stats_taille.R ├── mef_ajouter_surf_calc.R ├── mef_ajouter_type_longueur.R ├── mef_ajouter_type_lot.R ├── mef_ajouter_type_materiel.R ├── mef_ajouter_type_prelevement.R ├── mef_ajouter_type_protocole.R ├── mef_ajouter_utilisateurs.R ├── mef_ajouter_validation.R ├── mef_colo_ext_pops.R ├── mef_compter_pres_abs_env.R ├── mef_creer_passerelle.R ├── mef_filtrer_id.R ├── mef_filtrer_nb_mini_annees.R ├── mef_filtrer_ope_id.R ├── mef_ipr_radar.R ├── mef_pivoter_var_env.R ├── mef_recoder_esp_code_alt.R ├── mef_ssech_abs.R ├── mef_ssech_esp_env.R ├── misc_charger_donnees_test.R ├── misc_derniere_date.R ├── misc_nom_dernier_fichier.R └── utils.R ├── README.md ├── _pkgdown.yml ├── aspe.Rproj ├── data-raw ├── data_dictionnaire.R ├── data_liste_rouge.R ├── data_passerelle_taxo.R ├── data_protection_especes.R ├── data_taille_poids.R ├── data_traits_bio.R └── prepare_test_data.R ├── data ├── classe_ipr.rda ├── data_dictionnaire.rda ├── data_liste_rouge.rda ├── data_passerelle_taxo.rda ├── data_protection_especes.rda ├── data_taille_poids.rda ├── data_traits_bio.rda ├── lot_poissons.rda ├── mesure_individuelle.rda ├── operation.rda ├── operation_description_peche.rda ├── operation_donnees_environnementales.rda ├── operation_ipr.rda ├── operation_objectif.rda ├── point_prelevement.rda ├── prelevement_elementaire.rda ├── ref_espece.rda ├── ref_logique_3.rda ├── ref_logique_4.rda ├── ref_moyen_prospection.rda ├── ref_objectif.rda ├── ref_protocole.rda ├── ref_type_longueur.rda ├── ref_type_lot.rda ├── ref_type_prelevement_elementaire.rda ├── ref_type_projection.rda └── station.rda ├── inst ├── CITATION └── extdata │ ├── 2012_crustacea_RL_mainland_FR_202245.csv │ ├── 2019_fish_RL_mainland_FR__202173.csv │ ├── APT_20230718_SANDRE.csv │ ├── freshwaterecology.info_species_traits.xlsx │ ├── species_protection_status.xlsx │ └── species_traits.xlsx.old ├── man ├── aspe-package.Rd ├── data_dictionnaire.Rd ├── data_liste_rouge.Rd ├── data_passerelle_taxo.Rd ├── data_protection_especes.Rd ├── data_taille_poids.Rd ├── data_traits_bio.Rd ├── def_attribut_id.Rd ├── donneesTest.Rd ├── expl_commentaires_champs.Rd ├── expl_lister_champs.Rd ├── expl_trouver_table.Rd ├── expl_trouver_variable.Rd ├── export_tables_csv.Rd ├── export_tables_rdata.Rd ├── figures │ ├── hex_logo_aspe.png │ ├── lifecycle-archived.svg │ ├── lifecycle-defunct.svg │ ├── lifecycle-deprecated.svg │ ├── lifecycle-experimental.svg │ ├── lifecycle-maturing.svg │ ├── lifecycle-questioning.svg │ ├── lifecycle-stable.svg │ └── lifecycle-superseded.svg ├── geo_aggr_richesse.Rd ├── geo_ajouter_crs.Rd ├── geo_attribuer.Rd ├── geo_convertir_coords_df.Rd ├── gg_ajouter_arriere_plan_int.Rd ├── gg_colo_ext_pops.Rd ├── gg_density_env_esp.Rd ├── gg_dyn_esp.Rd ├── gg_gerer_seuils_classes_ipr_int.Rd ├── gg_histo_longueur.Rd ├── gg_temp_abondance.Rd ├── gg_temp_env.Rd ├── gg_temp_indic_div.Rd ├── gg_temp_ipr.Rd ├── gg_temp_ipr_pc_bon.Rd ├── gg_temp_metriq.Rd ├── gg_temp_metriq_grille.Rd ├── gg_temp_peuplement.Rd ├── imp_corres_aspe_taxref.Rd ├── imp_extraire_date_fichier.Rd ├── imp_extraire_noms_tables.Rd ├── imp_extraire_noms_tables2.Rd ├── imp_importer_dump_sql.Rd ├── imp_scinder_dump.Rd ├── imp_tables_a_partir_des_lignes.Rd ├── imp_trouver_index_fin.Rd ├── ip_completer_classes_couleur.Rd ├── ipr_formater_pour_macro.Rd ├── ipr_pivoter_1colonne_par_an.Rd ├── ipr_renommer_pour_macro.Rd ├── mef_ajouter_abs.Rd ├── mef_ajouter_ambiance.Rd ├── mef_ajouter_dept.Rd ├── mef_ajouter_esp.Rd ├── mef_ajouter_groupe_points.Rd ├── mef_ajouter_intervenants.Rd ├── mef_ajouter_ipr.Rd ├── mef_ajouter_libelle.Rd ├── mef_ajouter_libelle_site.Rd ├── mef_ajouter_lots.Rd ├── mef_ajouter_mei.Rd ├── mef_ajouter_metriques.Rd ├── mef_ajouter_moyen_prospection.Rd ├── mef_ajouter_objectif.Rd ├── mef_ajouter_ope_date.Rd ├── mef_ajouter_ope_desc_peche.Rd ├── mef_ajouter_ope_env.Rd ├── mef_ajouter_passage.Rd ├── mef_ajouter_proba_presence_ipr.Rd ├── mef_ajouter_qualification.Rd ├── mef_ajouter_stats_taille.Rd ├── mef_ajouter_surf_calc.Rd ├── mef_ajouter_type_longueur.Rd ├── mef_ajouter_type_lot.Rd ├── mef_ajouter_type_materiel.Rd ├── mef_ajouter_type_prelevement.Rd ├── mef_ajouter_type_protocole.Rd ├── mef_ajouter_utilisateurs.Rd ├── mef_ajouter_validation.Rd ├── mef_colo_ext_pops.Rd ├── mef_compter_pres_abs_env.Rd ├── mef_creer_passerelle.Rd ├── mef_filtrer_id.Rd ├── mef_filtrer_nb_mini_annees.Rd ├── mef_filtrer_ope_id.Rd ├── mef_ipr_radar.Rd ├── mef_pivoter_var_env.Rd ├── mef_recoder_esp_code_alt.Rd ├── mef_ssech_abs.Rd ├── mef_ssech_esp_env.Rd ├── misc_charger_donnees_test.Rd ├── misc_derniere_date.Rd └── misc_nom_dernier_fichier.Rd ├── tests ├── testthat.R └── testthat │ ├── test-mef_ajouter_lots.R │ └── test-mef_creer_passerelle.R └── vignettes ├── .gitignore ├── aspe_01_importation_tables.Rmd ├── aspe_02_construire_un_jeu_de_donnees.Rmd ├── aspe_03_fiche_station.Rmd └── img └── message_erreur_import.png /.Rbuildignore: -------------------------------------------------------------------------------- 1 | ^.*\.Rproj$ 2 | ^\.Rproj\.user$ 3 | ^\.github$ 4 | ^LICENSE\.md$ 5 | #^CITATION\.cff$ 6 | ^_pkgdown\.yml$ 7 | ^docs$ 8 | ^pkgdown$ 9 | ^data-raw$ 10 | -------------------------------------------------------------------------------- /.github/.gitignore: -------------------------------------------------------------------------------- 1 | *.html 2 | -------------------------------------------------------------------------------- /.github/workflows/R-CMD-check.yaml: -------------------------------------------------------------------------------- 1 | # Workflow derived from https://github.com/r-lib/actions/tree/v2/examples 2 | # Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help 3 | on: 4 | push: 5 | branches: [main, master] 6 | pull_request: 7 | branches: [main, master] 8 | 9 | name: R-CMD-check 10 | 11 | jobs: 12 | R-CMD-check: 13 | runs-on: ${{ matrix.config.os }} 14 | 15 | name: ${{ matrix.config.os }} (${{ matrix.config.r }}) 16 | 17 | strategy: 18 | fail-fast: false 19 | matrix: 20 | config: 21 | - {os: macos-latest, r: 'release'} 22 | - {os: windows-latest, r: 'release'} 23 | - {os: ubuntu-latest, r: 'devel', http-user-agent: 'release'} 24 | - {os: ubuntu-latest, r: 'release'} 25 | - {os: ubuntu-latest, r: 'oldrel-1'} 26 | 27 | env: 28 | GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }} 29 | R_KEEP_PKG_SOURCE: yes 30 | 31 | steps: 32 | - uses: actions/checkout@v4 33 | 34 | - uses: r-lib/actions/setup-pandoc@v2 35 | 36 | - uses: r-lib/actions/setup-r@v2 37 | with: 38 | r-version: ${{ matrix.config.r }} 39 | http-user-agent: ${{ matrix.config.http-user-agent }} 40 | use-public-rspm: true 41 | 42 | - uses: r-lib/actions/setup-r-dependencies@v2 43 | with: 44 | extra-packages: any::rcmdcheck 45 | needs: check 46 | 47 | - uses: r-lib/actions/check-r-package@v2 48 | with: 49 | upload-snapshots: true 50 | -------------------------------------------------------------------------------- /.github/workflows/pkgdown.yaml: -------------------------------------------------------------------------------- 1 | # Workflow derived from https://github.com/r-lib/actions/tree/v2/examples 2 | # Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help 3 | on: 4 | push: 5 | branches: [main, master] 6 | pull_request: 7 | branches: [main, master] 8 | release: 9 | types: [published] 10 | workflow_dispatch: 11 | 12 | name: pkgdown 13 | 14 | jobs: 15 | pkgdown: 16 | runs-on: ubuntu-latest 17 | # Only restrict concurrency for non-PR jobs 18 | concurrency: 19 | group: pkgdown-${{ github.event_name != 'pull_request' || github.run_id }} 20 | env: 21 | GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }} 22 | permissions: 23 | contents: write 24 | steps: 25 | - uses: actions/checkout@v4 26 | 27 | - uses: r-lib/actions/setup-pandoc@v2 28 | 29 | - uses: r-lib/actions/setup-r@v2 30 | with: 31 | use-public-rspm: true 32 | 33 | - uses: r-lib/actions/setup-r-dependencies@v2 34 | with: 35 | extra-packages: any::pkgdown, local::. 36 | needs: website 37 | 38 | - name: Build site 39 | run: pkgdown::build_site_github_pages(new_process = FALSE, install = FALSE) 40 | shell: Rscript {0} 41 | 42 | - name: Deploy to GitHub pages 🚀 43 | if: github.event_name != 'pull_request' 44 | uses: JamesIves/github-pages-deploy-action@v4.4.1 45 | with: 46 | clean: false 47 | branch: gh-pages 48 | folder: docs 49 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .Rproj.user 2 | .Rhistory 3 | .RData 4 | .Ruserdata 5 | .Rproj 6 | inst/doc 7 | -------------------------------------------------------------------------------- /DESCRIPTION: -------------------------------------------------------------------------------- 1 | Package: aspe 2 | Type: Package 3 | Title: An R Package to Analyse and Visualise River Fish Data in France 4 | Version: 0.4.2 5 | Date: 2024-10-09 6 | Authors@R: c( 7 | person(given = "Pascal", 8 | family = "Irz", 9 | email = "pascal.irz@ofb.gouv.fr", 10 | role = c("aut", "cre"), 11 | comment = c(ORCID = "0000-0002-2066-8935")), 12 | person(given = "Cédric", 13 | family = "Mondy", 14 | email = "cedric.mondy@ofb.gouv.fr", 15 | role = "ctb", 16 | comment = c(ORCID = "0000-0003-2788-0936")), 17 | person(given = "Benoît", 18 | family = "Richard", 19 | email = "benoit.richard@ofb.gouv.fr", 20 | role = "ctb", 21 | comment = c(ORCID = "0000-0003-4522-027X")), 22 | person(given = "Emmanuelle", 23 | family = "Dortel", 24 | email = "emmanuelle.dortel@cefe.cnrs.fr", 25 | role = "ctb"), 26 | person(given = "Lilian", 27 | family = "Bonnafoux", 28 | email = "l.bonnafoux@peche63.com", 29 | role = "ctb") 30 | ) 31 | Maintainer: Pascal Irz 32 | Description: The aspe package provides a suite of tools for most of the common 33 | processing of the ASPE database , including 34 | importation of the tables from a dump of the PostGreSQL database, 35 | calculation of abundances, densities, size distributions, 36 | along with graphical output and spatial processing. 37 | URL: https://github.com/PascalIrz/aspe/, 38 | https://doi.org/10.5281/zenodo.7458005, 39 | https://pascalirz.github.io/aspe/ 40 | BugReports: https://github.com/PascalIrz/aspe/issues 41 | License: GPL (>= 3) 42 | Encoding: UTF-8 43 | LazyData: true 44 | RoxygenNote: 7.3.2 45 | Imports: 46 | dplyr, 47 | forcats, 48 | ggiraph, 49 | ggplot2, 50 | ggpubr, 51 | ggtext, 52 | lifecycle, 53 | lubridate, 54 | magrittr, 55 | patchwork, 56 | purrr, 57 | readr, 58 | readxl, 59 | rlang, 60 | scales, 61 | sf, 62 | shiny, 63 | stringi, 64 | stringr, 65 | tibble, 66 | tidyr 67 | Suggests: 68 | flextable, 69 | gdata, 70 | knitr, 71 | mapview, 72 | rmarkdown, 73 | testthat (>= 3.0.0) 74 | VignetteBuilder: knitr 75 | Roxygen: list(markdown = TRUE) 76 | Depends: 77 | R (>= 2.10) 78 | Config/testthat/edition: 3 79 | -------------------------------------------------------------------------------- /R/aspe-package.R: -------------------------------------------------------------------------------- 1 | #' @keywords internal 2 | "_PACKAGE" 3 | 4 | ## usethis namespace: start 5 | #' @importFrom lifecycle deprecated 6 | ## usethis namespace: end 7 | NULL 8 | -------------------------------------------------------------------------------- /R/data_dictionnaire.R: -------------------------------------------------------------------------------- 1 | #' Signification des champs de la base Aspe 2 | #' 3 | #' @docType data 4 | #' 5 | #' @usage data(data_dictionnaire) 6 | #' 7 | #' @keywords datasets 8 | #' 9 | #' @examples 10 | #' \donttest{ 11 | #' data(data_dictionnaire) 12 | #' data_dictionnaire} 13 | "data_dictionnaire" 14 | -------------------------------------------------------------------------------- /R/data_liste_rouge.R: -------------------------------------------------------------------------------- 1 | #' Données sur le statut liste rouge des espèces de poissons 2 | #' 3 | #' Tableau avec en lignes desespèces de poissons et en colonnes les données sur le 4 | #' statut liste rouge de ces espèces. 5 | #' 6 | #' @docType data 7 | #' 8 | #' @usage data(data_liste_rouge) 9 | #' 10 | #' @keywords datasets 11 | #' 12 | #' @examples 13 | #' \donttest{ 14 | #' data(data_liste_rouge) 15 | #' data_liste_rouge} 16 | "data_liste_rouge" 17 | -------------------------------------------------------------------------------- /R/data_passerelle_taxo.R: -------------------------------------------------------------------------------- 1 | #' Table de passage entre les identifiants des espèces 2 | #' 3 | #' Tableau indiquant les correspondances entre les identifiants esp_id de la base Aspe, 4 | #' asp_code_alternatif à trois lettres, taxref, sandre et le nom latin. 5 | #' 6 | #' @docType data 7 | #' 8 | #' @usage data(data_passerelle_taxo) 9 | #' 10 | #' @keywords datasets 11 | #' 12 | #' @examples 13 | #' \donttest{ 14 | #' data(data_passerelle_taxo) 15 | #' data_passerelle_taxo} 16 | "data_passerelle_taxo" 17 | -------------------------------------------------------------------------------- /R/data_protection_especes.R: -------------------------------------------------------------------------------- 1 | #' Données sur la protection réglementaire des espèces (poissons et écrevisses) 2 | #' 3 | #' Tableau avec une ligne par espèce protégée et une colonne indiquant le texte de référence. 4 | #' 5 | #' @docType data 6 | #' 7 | #' @usage data(data_protection_especes) 8 | #' 9 | #' @keywords datasets 10 | #' 11 | #' @examples 12 | #' \donttest{ 13 | #' data("data_protection_especes") 14 | #' data_protection_especes} 15 | "data_protection_especes" 16 | -------------------------------------------------------------------------------- /R/data_taille_poids.R: -------------------------------------------------------------------------------- 1 | #' Relations taille - poids 2 | #' 3 | #' Tableau des relations taille calculées depuis la base ASPE ainsi que celles 4 | #' issues de Fishbase. Pour ces dernières, les paramètres a et b ont été moyennés par espèce 5 | #' en distinguant longueur fourche et longueur totale. 6 | #' NB : Les unités sont les mêmes que dans la base de référence Fishbase, 7 | #' à savoir pour la taille (en fait la longueur), le cm, et pour le poids (en fait 8 | #' la masse), le gramme. Si l'on utilise les données de la base ASPE, il faut donc 9 | #' opérer une conversion de longueur car celles-ci sont en mm. 10 | #' 11 | #' @docType data 12 | #' 13 | #' @usage data(data_taille_poids) 14 | #' 15 | #' @keywords datasets 16 | #' 17 | #' @examples 18 | #' \donttest{ 19 | #' data(data_taille_poids) 20 | #' data_taille_poids} 21 | "data_taille_poids" 22 | -------------------------------------------------------------------------------- /R/data_traits_bio.R: -------------------------------------------------------------------------------- 1 | #' Données sommaires sur les espèces de poissons 2 | #' 3 | #' Tableau d'une centaine de lignes correspondant aux espèces de poissons 4 | #' référencées par leur code à trois lettres et de colonnes précisant le 5 | #' statut de ces espèces ainsi que leur principaux habitats. 6 | #' 7 | #' @docType data 8 | #' 9 | #' @usage data(data_traits_bio) 10 | #' 11 | #' @keywords datasets 12 | #' 13 | #' @examples 14 | #' \donttest{ 15 | #' data(data_traits_bio) 16 | #' data_traits_bio} 17 | "data_traits_bio" 18 | -------------------------------------------------------------------------------- /R/donnees_test.R: -------------------------------------------------------------------------------- 1 | #' Extrait de la base Aspe utilisé pour les tests des fonctions et pour les vignettes 2 | #' 3 | #' 4 | #' Il s'agit d'extraits des tables principales de la base qui ont été expurgés des taxons sensibles. 5 | #' 6 | #' Ces tables sont décrites en détail dans https://doi.org/10.1051/kmae/2022021 7 | #' @name donneesTest 8 | #' @keywords datasets 9 | "classe_ipr" 10 | 11 | #' @rdname donneesTest 12 | "lot_poissons" 13 | 14 | #' @rdname donneesTest 15 | "mesure_individuelle" 16 | 17 | #' @rdname donneesTest 18 | "operation" 19 | 20 | #' @rdname donneesTest 21 | "operation_description_peche" 22 | 23 | #' @rdname donneesTest 24 | "operation_donnees_environnementales" 25 | 26 | #' @rdname donneesTest 27 | "operation_ipr" 28 | 29 | #' @rdname donneesTest 30 | "operation_objectif" 31 | 32 | #' @rdname donneesTest 33 | "point_prelevement" 34 | 35 | #' @rdname donneesTest 36 | "prelevement_elementaire" 37 | 38 | #' @rdname donneesTest 39 | "ref_espece" 40 | 41 | #' @rdname donneesTest 42 | "ref_logique_3" 43 | 44 | #' @rdname donneesTest 45 | "ref_logique_4" 46 | 47 | #' @rdname donneesTest 48 | "ref_moyen_prospection" 49 | 50 | #' @rdname donneesTest 51 | "ref_objectif" 52 | 53 | #' @rdname donneesTest 54 | "ref_protocole" 55 | 56 | #' @rdname donneesTest 57 | "ref_type_longueur" 58 | 59 | #' @rdname donneesTest 60 | "ref_type_lot" 61 | 62 | #' @rdname donneesTest 63 | "ref_type_prelevement_elementaire" 64 | 65 | #' @rdname donneesTest 66 | "ref_type_projection" 67 | 68 | #' @rdname donneesTest 69 | "station" 70 | 71 | -------------------------------------------------------------------------------- /R/expl_commentaires_champs.R: -------------------------------------------------------------------------------- 1 | #' Obtenir les commentaires qui donnent la signification des champs des tables 2 | #' 3 | #' @param fichier_dump Le chemin vers le fichier d'extension .sql (décompressé) ou 4 | #' .sql.gz (archive). 5 | #' 6 | #' @return Un dataframe avec pour chacun des champs sa table d'appartenance et sa signification. 7 | #' @export 8 | #' 9 | #' @importFrom stringr str_replace str_subset str_sub str_extract 10 | #' 11 | #' @examples 12 | #' \dontrun{ 13 | #' expl_commentaires_champs(fichier_dump = "../raw_data/dump.sql") 14 | #' } 15 | #' 16 | #' 17 | expl_commentaires_champs <- function(fichier_dump) { 18 | 19 | lignes_dump <- imp_lire_lignes_dump(fichier_dump) 20 | 21 | # sélection des lignes contenant les commentaires des champs 22 | mes_lignes <- lignes_dump %>% 23 | stringr::str_subset(pattern = 'COMMENT ON COLUMN') %>% 24 | str_replace("COMMENT ON COLUMN ", "") 25 | 26 | # noms de la table = préfixe du nom complet du champ 27 | nom_table <- mes_lignes %>% 28 | str_extract("[^\\.]*") 29 | 30 | # nom du champ 31 | nom_var <- mes_lignes %>% 32 | str_replace("[^\\.]*", "") %>% 33 | str_replace("\\.", "") %>% 34 | str_extract("[^ IS ]*") 35 | 36 | # commentaire sur le champ 37 | comm_var <- mes_lignes %>% 38 | str_replace("[^ IS ]*", "") %>% 39 | str_replace(" IS ", "") %>% 40 | str_sub(start = 2, end = -3) %>% 41 | str_replace("''", "'") 42 | 43 | # assemblage du résultat ; suppression des champs des tables temporaires 44 | data.frame(nom_table, 45 | nom_var, 46 | comm_var) %>% 47 | filter(!str_detect(nom_table, "^temp_")) 48 | } 49 | -------------------------------------------------------------------------------- /R/expl_lister_champs.R: -------------------------------------------------------------------------------- 1 | #' Lister les champs contenus dans les différents dataframes d'un fichier .RData 2 | #' 3 | #' @param rdata Caractère. Chemin vers le fichier .RData 4 | #' 5 | #' @return Un dataframe avec pour chacun des champs (colonnes) son nom et celui de la table 6 | #' qui le contient 7 | #' @export 8 | #' 9 | #' @importFrom purrr map reduce 10 | #' @importFrom stringr str_replace 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' synthese <- expl_lister_champs('processed_data/toutes_tables_aspe_sauf_mei.RData') 15 | #' } 16 | expl_lister_champs <- function(rdata) 17 | 18 | { 19 | 20 | load(rdata) 21 | 22 | map(.x = ls(), 23 | .f = function(x) 24 | 25 | { 26 | 27 | champs <- get(x) %>% colnames() 28 | table <- rep(x, length(champs)) 29 | data.frame(champs, table) 30 | 31 | } 32 | 33 | ) %>% 34 | 35 | reduce(rbind) %>% 36 | mutate(champs = str_replace(string = champs, 37 | pattern = '"', 38 | replacement = '')) 39 | 40 | } 41 | -------------------------------------------------------------------------------- /R/expl_trouver_table.R: -------------------------------------------------------------------------------- 1 | #' Rechercher les dataframes dont le nom contient un pattern 2 | #' 3 | #' Cette fonction est utile pour explorer la base quand on a une idée de ce que son nom 4 | #' peut contenir. Par exemple pour les tables liées au point on peut chercher, parmi les noms 5 | #' des dataframes chargés, ceux contenant la chaîne de caractères "point". 6 | #' 7 | #' @param nom_contient Chaine de caractères recherchés parmi les noms des tables. 8 | #' 9 | #' @return Un vecteur caractères contenant les noms des tables. 10 | #' @export 11 | #' 12 | #' @importFrom stringr str_subset 13 | #' @importFrom purrr map 14 | #' 15 | #' @examples 16 | #' \dontrun{ 17 | #' expl_trouver_table(nom_contient = "point") 18 | #' } 19 | expl_trouver_table <- function(nom_contient) { 20 | 21 | ###################################### 22 | # lister_dfs <- function() 23 | # 24 | # { 25 | # objets <- ls(envir = globalenv()) 26 | # 27 | # test_1obj <- function(obj) { 28 | # is.data.frame(get(obj)) 29 | # } 30 | # 31 | # test <- map(.x = objets, 32 | # .f = test_1obj) 33 | # 34 | # test %>% 35 | # unlist() 36 | # 37 | # } 38 | 39 | ################################# 40 | # Liste des dataframes 41 | mes_dfs <- ls(envir = globalenv())[lister_dfs()] 42 | 43 | # parmi les dfs, ceux dont le nom correspondent au pattern recherché 44 | mes_dfs %>% 45 | str_subset(pattern = nom_contient) 46 | 47 | } 48 | -------------------------------------------------------------------------------- /R/expl_trouver_variable.R: -------------------------------------------------------------------------------- 1 | #' Rechercher les variables dont le nom contient un pattern 2 | #' 3 | #' @param nom_contient Chaine de caractères recherchés parmi les noms des variables 4 | #' des différentes tables. 5 | #' 6 | #' @return Un dataframe indiquant les noms de variables contenant la chaine recherchée 7 | #' ainsi que leur table d'appartenance. 8 | #' @export 9 | #' 10 | #' @importFrom purrr map 11 | #' @importFrom stringr str_subset str_replace_all 12 | #' @importFrom dplyr mutate 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' expl_trouver_variable(nom_contient = "ope") 17 | #' } 18 | expl_trouver_variable <- 19 | function(nom_contient) { 20 | 21 | # collecte de tous les objets de l'environnement 22 | fun <- function(envir = parent.frame()) ls(envir = envir) 23 | 24 | all_names <- fun(.GlobalEnv) 25 | 26 | all_obj <- map(.x = all_names, 27 | .f = get) 28 | # test pour trouver ceux qui sont des dataframes 29 | test_df <- map(.x = all_obj, 30 | .f = is.data.frame) %>% 31 | as.data.frame %>% 32 | t() 33 | # sélection et nommage des dataframes 34 | dfs <- all_obj[test_df] 35 | dfs_names <- all_names[test_df] 36 | 37 | # collecte des noms des colonnes 38 | dfs_col_names <- map(.x = dfs, 39 | .f = colnames) 40 | 41 | names(dfs_col_names) <- dfs_names 42 | 43 | # noms des variables contenant la chaine recherchée 44 | variables <- dfs_col_names %>% 45 | unlist() 46 | 47 | selection <- variables %>% 48 | str_detect(nom_contient) 49 | 50 | selected_variables <- variables[selection] 51 | 52 | # mise en forme et nettoyage 53 | df <- names(selected_variables) # les noms sont ceux des dataframes 54 | 55 | final <- data.frame(table = df, 56 | variable = selected_variables) %>% 57 | mutate(table = str_replace_all(table, 58 | pattern = "[:digit:]", 59 | replacement = "")) 60 | 61 | rownames(final) <- NULL 62 | 63 | final 64 | 65 | } 66 | -------------------------------------------------------------------------------- /R/export_tables_csv.R: -------------------------------------------------------------------------------- 1 | #' Exporter tous les dataframes de l'environnement en csv 2 | #' 3 | #' @param repertoire Texte. Chemin vers le répertoire où les fichiers csv seront stockés. 4 | #' 5 | #' @return Les fichiers csv 6 | #' @export 7 | #' 8 | #' @importFrom purrr map 9 | #' @importFrom utils write.csv2 10 | #' 11 | #' @examples 12 | #' \dontrun{ 13 | #' export_tables_csv(repertoire = "../output") 14 | #' } 15 | export_tables_csv <- function(repertoire = NA) 16 | 17 | { 18 | 19 | # création du nom et répertoire de sortie s'ils ne sont pas indiqués 20 | 21 | if(is.na(repertoire)) 22 | { 23 | repertoire <- "processed_data/" 24 | } 25 | 26 | if(!dir.exists(repertoire)) 27 | { 28 | dir.create(repertoire) 29 | } 30 | 31 | ###################################### 32 | # lister_dfs <- function() 33 | # 34 | # { 35 | # objets <- ls(envir = globalenv()) 36 | # 37 | # test_1obj <- function(obj) { 38 | # is.data.frame(get(obj)) 39 | # } 40 | # 41 | # test <- map(.x = objets, 42 | # .f = test_1obj) 43 | # 44 | # test %>% 45 | # unlist() 46 | # 47 | # } 48 | ####################################### 49 | 50 | exporter_df <- function(df_nom, repertoire) 51 | 52 | { 53 | df <- get(df_nom, envir = globalenv()) 54 | 55 | write.csv2(df, 56 | file = paste0(repertoire, "/", df_nom, ".csv")) 57 | 58 | } 59 | ################################# 60 | mes_dfs <- ls(globalenv())[lister_dfs()] 61 | 62 | map(.x = mes_dfs, 63 | .f = exporter_df, 64 | repertoire = repertoire) 65 | 66 | } 67 | 68 | -------------------------------------------------------------------------------- /R/geo_aggr_richesse.R: -------------------------------------------------------------------------------- 1 | #' Aggréger les richesses par entité hydrographique 2 | #' 3 | #' Calculer à partir des données Aspe le nombre d'espèces différentes recensées par 4 | #' Zone HYdro, Sous-secteur Hydro, Secteur Hydro ou Région hydro. 5 | #' 6 | #' Comme la fonction effectue une jointure entre les inventaires et les entités hydrographiques, 7 | #' il faut que les deux objets géographiques aient au moins un nom de champ en commun. 8 | #' 9 | #' @param ope_geo_data Objet de classe sf contenant les captures par opération. 10 | #' @param echelle Caractère. Au choix entre "ZoneHydro", "SousSecteurHydro", "SecteurHydro" 11 | #' et "RegionHydro". 12 | #' @param bassin_geo_poly Objet de classe sf contenant les polygones délimitant les 13 | #' entités hydrographiques. 14 | #' 15 | #' @return Un dataframe avec les richesses par entité hydrographique. 16 | #' @export 17 | #' 18 | #' @importFrom dplyr group_by syms summarise n_distinct ungroup filter right_join 19 | #' @importFrom sf st_drop_geometry st_as_sf 20 | #' 21 | #' @examples 22 | #' \dontrun{ 23 | #' richesse_par_unite_spatiale <- geo_aggr_richesse(ope_geo_data = data_geo, 24 | #' echelle = "Secteur_Hydro", 25 | #' bassin_geo_poly = bv_simp) 26 | #' } 27 | geo_aggr_richesse <- function(ope_geo_data, 28 | echelle = c("Zone_Hydro", "Sous_Secteur_Hydro", 29 | "Secteur_Hydro", "Region_Hydro"), 30 | bassin_geo_poly) 31 | 32 | { 33 | 34 | if(echelle == "Zone_Hydro") 35 | { 36 | code <- "CdZoneHydr" 37 | libelle <- "LbZoneHydr" 38 | } 39 | 40 | if(echelle == "Sous_Secteur_Hydro") 41 | { 42 | code <- "CdSousSect" 43 | libelle <- "LbSousSect" 44 | } 45 | 46 | if(echelle == "Secteur_Hydro") 47 | { 48 | code <- "CdSecteurH" 49 | libelle <- "LbSecteurH" 50 | } 51 | 52 | if(echelle == "Region_Hydro") 53 | { 54 | code <- "CdRegionHy" 55 | libelle <- "LbRegionHy" 56 | } 57 | 58 | richesse_par_unite_spatiale <- ope_geo_data %>% 59 | group_by(!!!syms(code), !!!syms(libelle)) %>% 60 | summarise(richesse = n_distinct(esp_code_alternatif), 61 | nb_ope = n_distinct(ope_id)) %>% 62 | ungroup() %>% 63 | sf::st_drop_geometry() %>% 64 | right_join(y = bassin_geo_poly) %>% 65 | sf::st_as_sf() %>% 66 | filter(!is.na(richesse)) 67 | 68 | richesse_par_unite_spatiale 69 | 70 | } 71 | -------------------------------------------------------------------------------- /R/geo_ajouter_crs.R: -------------------------------------------------------------------------------- 1 | #' Ajouter le code EPSG du CRS à un dataframe 2 | #' 3 | #' @param df Le dataframe de données. 4 | #' @param var_id_crs Caractère. Le nom de la variable qui contient l'identifiant du CRS 5 | #' au sens de la variable "typ_id" du dataframe "ref_type_projection" de la base Aspe. 6 | #' selon la 7 | #' 8 | #' @return Le dataframe complété. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr rename left_join enquo 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' pop <- point_prelevement %>% 16 | #' geo_ajouter_crs(var_id_crs = pop_typ_id) 17 | #' } 18 | geo_ajouter_crs <- function(df, var_id_crs) 19 | 20 | { 21 | 22 | var_id_crs <- enquo(var_id_crs) 23 | 24 | df %>% 25 | rename(typ_id = !!var_id_crs) %>% 26 | left_join(y = ref_type_projection %>% 27 | select(typ_id, 28 | typ_code_epsg)) 29 | 30 | } 31 | -------------------------------------------------------------------------------- /R/geo_attribuer.R: -------------------------------------------------------------------------------- 1 | #' Rajouter à l'objet sf des points de prélèvement les départements et (ou) les bassins auxquels 2 | #' ils appartiennent. 3 | #' @param points_geo Objet sf des points qui se verront attribuer des poilygones. 4 | #' points_geo doit avoir un CRS. 5 | #' @param poly_sf Objet sf des polygones à attribuer (ex: départements, secteurs hydro). 6 | #' @param crs_sortie Numérique. Identifiant EPSG du CRS de sortie. Par défaut, c'est celui de 7 | #' points_geo. 8 | #' 9 | #' @return L'bjet sf des points de prélèvement complété des informations sur les départements 10 | #' et les bassins. 11 | #' @export 12 | #' 13 | #' @importFrom dplyr left_join select 14 | #' @importFrom sf st_crs st_transform st_join 15 | #' 16 | #' @examples 17 | #' \dontrun{ 18 | #' points_geo <- points_geo %>% 19 | #' geo_attribuer(poly_sf = secteurs_hydro_carthage) 20 | #' } 21 | geo_attribuer <- 22 | function(points_geo, 23 | poly_sf, 24 | crs_sortie = NA) 25 | 26 | { 27 | if (is.na(crs_sortie)) { 28 | crs_sortie <- st_crs(points_geo) 29 | 30 | } else { 31 | points_geo <- points_geo %>% 32 | st_transform(crs = crs_sortie) 33 | 34 | } 35 | 36 | # if (!is.na(depts_geo)) { 37 | # if (sf::st_crs(depts_geo) != crs_sortie) { 38 | # depts_geo <- depts_geo %>% st_transform(crs = crs_sortie) 39 | # } 40 | # 41 | # points_geo <- points_geo %>% 42 | # st_join(depts_geo) 43 | # 44 | # } 45 | 46 | 47 | if (sf::st_crs(poly_sf) != crs_sortie) 48 | 49 | { 50 | 51 | poly_sf <- poly_sf %>% st_transform(crs = crs_sortie) 52 | 53 | } 54 | 55 | points_geo <- points_geo %>% 56 | st_join(poly_sf) 57 | 58 | 59 | 60 | points_geo 61 | 62 | } 63 | -------------------------------------------------------------------------------- /R/gg_ajouter_arriere_plan_int.R: -------------------------------------------------------------------------------- 1 | #' Ajouter un arrière plan de classes à un ggplot 2 | #' 3 | #' @param graphique Graphique ggplot. 4 | #' @param df_classes Dataframe contenant les limites de classes comme classe_ipr. 5 | #' 6 | #' @return Le graphique complété par son arrière-plan coloré. 7 | #' 8 | #' @examples 9 | #' \dontrun{ 10 | #' ggplot(data = data) %>% 11 | #' gg_ajouter_arriere_plan_int() 12 | #' } 13 | gg_ajouter_arriere_plan_int <- function(graphique, df_classes) 14 | 15 | { 16 | 17 | graphique <- graphique + 18 | geom_rect(data = df_classes, 19 | aes(ymin = classe_borne_inf, 20 | ymax = classe_borne_sup, 21 | fill = classe_libelle), 22 | xmin = -Inf, 23 | xmax = Inf, 24 | alpha = 0.3) + 25 | scale_fill_manual(values = df_classes$classe_couleur) + 26 | scale_y_continuous(trans = "reverse", 27 | expand = expansion(mult = c(0.05, 0.01))) 28 | 29 | graphique 30 | } 31 | 32 | -------------------------------------------------------------------------------- /R/gg_gerer_seuils_classes_ipr_int.R: -------------------------------------------------------------------------------- 1 | #' Gérer les limites de classes d'indices sur classe_ipr 2 | #' 3 | #' @param df_classes Dataframe d'entrée, en général classe_ipr 4 | #' @param metriques Booléen. Si TRUE, on considère qu'il s'agit des métriques et non de 5 | #' l'indice agrégé. Les seuils sont donc divisés par 7 (le nombre des métriques dans l'IPR). 6 | #' @param sup_500m Booléen. TRUE si les stations sont au-dessus de 500m d'altitude, ce qui change 7 | #' un seuil de classe IPR. 8 | #' 9 | #' @return Le dataframe filtré selon l'altitude 10 | #' 11 | #' @export 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' classe_classes_ipr <- classe_ipr %>% 16 | #' gg_gerer_seuils_classes_ipr_int() 17 | #' } 18 | gg_gerer_seuils_classes_ipr_int <- function(df_classes, 19 | metriques = FALSE, 20 | sup_500m) 21 | 22 | { 23 | 24 | # ne pas déplacer sinon le bloc suivant ne fonctionne pas 25 | df_classes <- df_classes %>% 26 | replace(is.na(.), 0) 27 | 28 | # suppression des lignes selon le seuil d'altitude 29 | if(sup_500m) { 30 | df_classes <- df_classes %>% 31 | filter(cli_altitude_max != 500) 32 | } else { 33 | df_classes <- df_classes %>% 34 | filter(cli_altitude_min != 500) 35 | } 36 | 37 | # si métriques, on divise les seuils par 7 38 | if(metriques) 39 | { 40 | df_classes <- df_classes %>% 41 | mutate(classe_borne_inf = cli_borne_inf / 7, 42 | classe_borne_sup = cli_borne_sup / 7, 43 | # pour éviter une bande grise après l'arrière-plan rouge 44 | classe_borne_sup = ifelse(cli_classe == 5, 45 | yes = Inf, 46 | no = classe_borne_sup), 47 | classe_libelle = cli_libelle) 48 | } else{ 49 | df_classes <- df_classes %>% 50 | mutate(classe_borne_inf = cli_borne_inf, 51 | classe_borne_sup = cli_borne_sup, 52 | # pour éviter une bande grise après l'arrière-plan rouge 53 | classe_borne_sup = ifelse(cli_classe == 5, 54 | yes = Inf, 55 | no = classe_borne_sup), 56 | classe_libelle = cli_libelle) 57 | 58 | } 59 | 60 | df_classes 61 | 62 | } 63 | -------------------------------------------------------------------------------- /R/gg_histo_longueur.R: -------------------------------------------------------------------------------- 1 | #' Produire l'histogramme de distribution des longueurs individuelles pour une opération 2 | #' de pêche 3 | #' 4 | #' @param indiv_df Le dataframe contanant les données nécessaires. 5 | #' @param operation Entier. Identifiant de l'opération de pêche au sens du champ ope_id. 6 | #' @param especes Vecteur caractères. Identifiants des codes espèces en trois lettres. 7 | #' Classiquement une seule espèce est désignée mais on peut préférer regrouper des 8 | #' sous-espèces avec des identifiants différents ou conserver les identifications 9 | #' au genre. 10 | #' @param type_longueur Vecteur caractères. Intitulé(s) du ou des type(s) de longueur 11 | #' à prendre en compte pour construire l'histogramme. Trois modalités sont proposées, 12 | #' qui correspondent aux modélités du champ tlo_libelle de la table ref_type_longueur. 13 | #' @param n_intervalles Nombre entier. Nombre d'intervalles de longueur sur l'axe des 14 | #' abscisses. La valeur par défaut est 30. 15 | #' 16 | #' @return L'histogramme. C'est un objet de classe ggplot qui peut donc être repris par la 17 | #' suite pour en modifier la mise en forme. 18 | #' @export 19 | #' 20 | #' @aliases mei_grapher_histo_longueur 21 | #' 22 | #' @importFrom ggplot2 aes geom_histogram labs 23 | #' @importFrom dplyr filter pull 24 | #' 25 | #' @examples 26 | #' \dontrun{ 27 | #' gg_histo_longueur (indiv_df = data_ind_56, 28 | #' operation = 6313, 29 | #' especes = "GOU", 30 | #' type_longueur = c("Fourche", "Estimée d'après le poids"), 31 | #' n_intervalles = 25) 32 | #' } 33 | gg_histo_longueur <- function(indiv_df, operation, especes, 34 | type_longueur = c("Totale", "Fourche", 35 | "Estim\\u00e9e d\\'apr\\u00e8s le poids"), 36 | n_intervalles = 30) 37 | 38 | { 39 | 40 | data_graph <- indiv_df %>% 41 | filter(ope_id == operation & 42 | esp_code_alternatif %in% especes & 43 | tlo_libelle %in% type_longueur) 44 | 45 | station <- data_graph %>% 46 | pull(pop_libelle) %>% 47 | as.character() %>% 48 | .[1] 49 | 50 | date <- data_graph %>% 51 | pull(ope_date) %>% 52 | format(format = '%d/%m/%Y') %>% 53 | .[1] 54 | 55 | titre <- paste(station, ' le ', date) 56 | 57 | legende <- paste(type_longueur, collapse = ", ") 58 | legende <- paste0('Type(s) de longueur(s) : ', legende) 59 | 60 | soustitre <- paste(especes, collapse = ", ") 61 | 62 | 63 | 64 | data_graph %>% 65 | ggplot(aes(x = mei_taille)) + 66 | geom_histogram(bins = n_intervalles) + 67 | labs(title = titre, subtitle = soustitre, caption = legende, x = 'Longueur (mm)', y = 'Effectif') 68 | 69 | 70 | } 71 | -------------------------------------------------------------------------------- /R/gg_temp_abondance.R: -------------------------------------------------------------------------------- 1 | #' Graphique de la série chronologique des abondances ou densités par espèce 2 | #' 3 | #' 4 | #' @param df Dataframe contenant les données. Il doit contenir au moins lz variable "annee" ainsi 5 | #' que deux autres, l'une pour l'espèce et l'autre pour l'abondance ou la densité. 6 | #' @param var_espece Nom de la variable contenant les identifiants des espèces. 7 | #' @param var_abondance Nom de la variable contenant les valeurs d'abondance ou de densité 8 | #' @param nb_colonnes Entier. Nombre (maxi) de colonnes de graphiques s'il y a plusieurs stations. 9 | #' Par défaut nb_colonnes = 4. 10 | #' 11 | #' @return Un graphique ggplot2. 12 | #' @export 13 | #' 14 | #' @importFrom ggplot2 ggplot aes geom_line labs facet_wrap vars 15 | #' @importFrom dplyr enquo filter group_by summarise pull mutate 16 | #' @importFrom forcats fct_reorder 17 | #' 18 | #' @examples 19 | #' \dontrun{ 20 | #' dept_densites_an %>% 21 | #' filter(dept == mon_dept) %>% 22 | #' gg_temp_abondance(var_espece = esp_nom_commun, 23 | #' var_abondance = densite_qd_pres_moy) 24 | #' } 25 | gg_temp_abondance <- function(df, 26 | var_espece, 27 | var_abondance, 28 | nb_colonnes = 6) 29 | 30 | { 31 | var_espece <- enquo(var_espece) 32 | var_abondance <- enquo(var_abondance) 33 | 34 | # vecteur des espèces avec au moins une densité non nulle 35 | mes_especes <- df %>% 36 | group_by(!!var_espece) %>% 37 | summarise(somme = sum(!!var_abondance)) %>% 38 | filter(somme > 0) %>% 39 | pull(!!var_espece) 40 | 41 | # filtrage des données et ordonnancement des espèces par abondance 42 | densites <- df %>% 43 | filter(!!var_espece %in% mes_especes) %>% 44 | mutate(!!var_espece := as.factor(!!var_espece)) %>% 45 | mutate(!!var_espece := fct_reorder(.f = !!var_espece, 46 | .x = !!var_abondance, 47 | .fun = sum, 48 | .desc = T)) 49 | 50 | # graphique 51 | densites %>% 52 | ggplot(aes(x = annee, 53 | y = !!var_abondance)) + 54 | geom_line(size = 0.5) + 55 | labs(x = "", 56 | y = "") + 57 | facet_wrap(vars(!!var_espece), 58 | scales = "free_y", 59 | ncol = nb_colonnes) 60 | 61 | } 62 | -------------------------------------------------------------------------------- /R/gg_temp_ipr_pc_bon.R: -------------------------------------------------------------------------------- 1 | #' Produire un graphique du pourcentage de stations en bon état au plan IPR sur un jeu de 2 | #' stations, en fonction de l'année 3 | #' 4 | #' @param ipr_df Dataframe contenant les données, issu de la fonction extraire_ipr(). 5 | #' @param titre Caractère. Titre du graphique. 6 | #' 7 | #' @return Le graphique issu de ggplot2. 8 | #' @export 9 | #' 10 | #' @importFrom scales number_format 11 | #' @importFrom ggplot2 aes geom_bar ggplot labs scale_x_continuous scale_y_continuous theme 12 | #' @importFrom forcats fct_recode 13 | #' 14 | #' @aliases ipr_grapher_pc_bon 15 | #' 16 | #' @examples 17 | #' \dontrun{ 18 | #' gg_temp_ipr_pc_bon(ipr_df = data_56, 19 | #' titre = "Morbihan") 20 | #' } 21 | gg_temp_ipr_pc_bon <- function(ipr_df, titre = NA) 22 | 23 | { 24 | 25 | premiere_annee <- min(ipr_df$annee) 26 | derniere_annee <- max(ipr_df$annee) 27 | 28 | pc_bon <- ipr_df %>% 29 | mutate(cli_libelle = fct_recode(cli_libelle, 30 | bon = "Excellent", 31 | bon = "Bon", 32 | pas_bon = "M\u00e9diocre", 33 | pas_bon = "Mauvais", 34 | pas_bon = "Tr\u00e8s mauvais")) %>% 35 | group_by(annee, cli_libelle) %>% 36 | summarise(n_pop = n_distinct(pop_id)) %>% 37 | ungroup() %>% 38 | pivot_wider(id_cols = annee, 39 | names_from = cli_libelle, 40 | values_from = n_pop) %>% 41 | mutate(pc_bon = 100 * bon / (bon + pas_bon)) 42 | 43 | # ----------------------------------------------------------- 44 | # Production du graphique 45 | # ----------------------------------------------------------- 46 | 47 | ggplot(data = pc_bon, aes(x = annee, y = pc_bon)) + 48 | geom_bar(stat = "identity") + 49 | scale_y_continuous(limits = c(0, NA)) + 50 | geom_bar(stat = "identity") + 51 | labs(y = "Pourcentage de stations en bon \u00e9tat d\'apr\u00e8s l\'IPR", 52 | title = titre) + 53 | scale_x_continuous(labels = scales::number_format(accuracy = 1, big.mark = ''), 54 | breaks = seq(premiere_annee, derniere_annee, 2), 55 | limits = c(premiere_annee - 0.5, derniere_annee + 0.5)) 56 | 57 | } 58 | 59 | 60 | -------------------------------------------------------------------------------- /R/imp_corres_aspe_taxref.R: -------------------------------------------------------------------------------- 1 | #' Importer une table de correspondance entre les codes espèces 3 lettres Aspe et leurs codes Taxref 2 | #' 3 | #' La donnée ne provient pas de la base ASPE, mais de l'API SANDRE. Les données importées ont été 4 | #' filtrées afin de ne pas récupérer l'intégralité du référentiel "Appellation de taxons". Seuls 5 | # les taxons ayant un code alternatif "ASPE" sont nécessaires. 6 | #' 7 | #' @param url Caractère. URL du jeu de données à télécharger. 8 | #' Par défaut "https://api.sandre.eaufrance.fr/referentiels/v1/apt.csv?compress=true& 9 | #' filter=CodeAlternatifAp/OrgCdAlternatifASPE" 10 | #' 11 | #' @return Dataframe. Table de correspondence. 12 | #' @export 13 | #' 14 | #' @importFrom readr read_csv2 locale 15 | #' @importFrom dplyr filter select starts_with pull rename 16 | #' @importFrom tidyr pivot_longer pivot_wider 17 | #' @importFrom utils download.file 18 | #' 19 | #' @examples 20 | #' \dontrun{ 21 | #' taxref <- imp_corres_aspe_taxref() 22 | #' } 23 | imp_corres_aspe_taxref <- function( 24 | url = "https://api.sandre.eaufrance.fr/referentiels/v1/apt.csv?compress=true&filter=CodeAlternatifAp/OrgCdAlternatifASPE" 25 | ) 26 | 27 | { 28 | 29 | file <- paste0(tempdir(), 30 | "\\ref_sandre.csv.gz") 31 | 32 | download.file(url = url, 33 | destfile = file , 34 | mode = "wb") 35 | 36 | df <- read_csv2(file = file, 37 | locale = locale(encoding = 'UTF-8')) %>% 38 | select(CdAppelTaxon, 39 | starts_with("OrgCdAlternatif"), 40 | starts_with("CdAlternatif")) 41 | 42 | df1 <- df %>% 43 | select(CdAppelTaxon, 44 | starts_with("OrgCdAlternatif")) %>% 45 | pivot_longer(cols = OrgCdAlternatif1:OrgCdAlternatif11, 46 | names_to = "variable_org", 47 | values_to = "organisme") 48 | 49 | df2 <- df %>% 50 | select(CdAppelTaxon, 51 | starts_with("CdAlternatif")) %>% 52 | pivot_longer(cols = CdAlternatif1:CdAlternatif11, 53 | names_to = "variable_code", 54 | values_to = "code") 55 | 56 | df3 <- df1 %>% 57 | cbind(df2 %>% select(-CdAppelTaxon)) %>% 58 | filter(organisme %in% c("ASPE", "TAXREF")) 59 | 60 | mes_codes_sandre <- df3 %>% 61 | filter(organisme == "ASPE") %>% 62 | pull(CdAppelTaxon) %>% 63 | unique() 64 | 65 | df3 <- df3 %>% 66 | filter(CdAppelTaxon %in% mes_codes_sandre) %>% 67 | select(CdAppelTaxon, organisme, code) %>% 68 | pivot_wider(names_from = organisme, 69 | values_from = code) %>% 70 | rename(esp_code_sandre = CdAppelTaxon, 71 | esp_code_alternatif = ASPE, 72 | esp_code_taxref = TAXREF) 73 | 74 | df3 75 | 76 | } 77 | 78 | 79 | -------------------------------------------------------------------------------- /R/imp_extraire_date_fichier.R: -------------------------------------------------------------------------------- 1 | #' Obtenir la date du dump SQL de la base Aspe 2 | #' 3 | #' @param fichier Le chemin vers le fichier. 4 | #' @param date Date souhaitée, soit "creation", soit "modification" (par défaut). 5 | #' 6 | #' @return La date de création ou de modification. 7 | #' 8 | #' 9 | #' @examples 10 | #' \dontrun{ 11 | #' date-dump <- imp_extraire_date_fichier(fichier = "../raw_data/dump.sql", 12 | #' date = "creation") 13 | #' } 14 | #' 15 | #' 16 | imp_extraire_date_fichier <- function(fichier, date = "modification") { 17 | 18 | x <- fichier %>% 19 | file.info() 20 | 21 | if (date == "modification") 22 | { 23 | x <- x$mtime 24 | }else{ 25 | x <- x$ctime 26 | } 27 | 28 | x %>% 29 | format("%d/%m/%Y") 30 | 31 | } 32 | -------------------------------------------------------------------------------- /R/imp_extraire_noms_tables.R: -------------------------------------------------------------------------------- 1 | #' Extraire les noms des tables à partir des lignes du dump 2 | #' 3 | #' @param lignes_dump Nom de la liste qui contient les lignes du dump. 4 | #' 5 | #' @return Un vecteur caractères contenant les noms des tables. 6 | #' @export 7 | #' 8 | #' @import dplyr 9 | #' @importFrom stringi stri_detect_fixed 10 | #' @importFrom stringr str_replace_all str_subset 11 | #' 12 | #' @examples 13 | #' 14 | #' \dontrun{ 15 | #' imp_extraire_noms_tables (lignes_dump = mes_lignes_du_dump) 16 | #' } 17 | #' 18 | #' 19 | imp_extraire_noms_tables <- function(lignes_dump) { 20 | 21 | options(stringsAsFactors = F) 22 | # ------------------------------------------------------------ 23 | # NOMS DES TABLES 24 | # ------------------------------------------------------------ 25 | # Les noms des tables sont repérés car ils suivent "CREATE TABLE" 26 | # on ne récupère pas les tables temporaires préfixées par temp_ et batch_ 27 | noms_tables <- lignes_dump[which(stringi::stri_detect_fixed(lignes_dump, "CREATE TABLE"))] %>% 28 | stringr::str_replace_all(pattern = "CREATE TABLE ", replacement = "") %>% 29 | stringr::str_replace_all(pattern = " \\(", replacement = "") %>% 30 | stringr::str_subset("^temp_", negate = TRUE) %>% 31 | stringr::str_subset("^batch_", negate = TRUE) 32 | 33 | 34 | } 35 | -------------------------------------------------------------------------------- /R/imp_extraire_noms_tables2.R: -------------------------------------------------------------------------------- 1 | #' Extraire les noms des tables à partir des lignes du dump 2 | #' 3 | #' @param lignes_dump Nom de la liste qui contient les lignes du dump. 4 | #' 5 | #' @return Un vecteur caractères contenant les noms des tables. 6 | #' @export 7 | #' 8 | #' @import dplyr 9 | #' @importFrom stringi stri_detect_fixed 10 | #' @importFrom stringr str_replace_all str_subset 11 | #' 12 | #' @examples 13 | #' 14 | #' \dontrun{ 15 | #' imp_extraire_noms_tables (lignes_dump = mes_lignes_du_dump) 16 | #' } 17 | #' 18 | #' 19 | imp_extraire_noms_tables2 <- function(lignes_dump) { 20 | 21 | options(stringsAsFactors = F) 22 | # ------------------------------------------------------------ 23 | # NOMS DES TABLES 24 | # ------------------------------------------------------------ 25 | # Les noms des tables sont repérés car ils suivent "CREATE TABLE" 26 | # on ne récupère pas les tables temporaires préfixées par temp_ et batch_ 27 | noms_tables <- lignes_dump[which(stringi::stri_detect_fixed(lignes_dump, "CREATE TABLE aspe."))] %>% 28 | stringr::str_replace_all(pattern = "CREATE TABLE aspe.", replacement = "") %>% 29 | stringr::str_replace_all(pattern = " \\(", replacement = "") %>% 30 | stringr::str_subset("^temp_", negate = TRUE) %>% 31 | stringr::str_subset("^batch_", negate = TRUE) 32 | 33 | 34 | } 35 | -------------------------------------------------------------------------------- /R/imp_importer_dump_sql.R: -------------------------------------------------------------------------------- 1 | #' Importer le dump SQL de la base Aspe 2 | #' 3 | #' @param fichier_dump Le chemin vers le fichier d'extension .sql (décompressé) ou 4 | #' .sql.gz (archive). 5 | #' 6 | #' @return Les dataframes correspondant à chacune des tables de la base. 7 | #' @export 8 | #' 9 | #' @importFrom utils type.convert 10 | #' @importFrom stringi stri_detect_fixed 11 | #' @importFrom stringr str_replace_all str_subset str_sub str_split 12 | #' @importFrom purrr set_names map reduce 13 | #' 14 | #' @examples 15 | #' 16 | #' \dontrun{ 17 | #' imp_importer_dump_sql(fichier_dump = "../raw_data/dump.sql") 18 | #' } 19 | #' 20 | #' 21 | imp_importer_dump_sql <- function(fichier_dump) { 22 | 23 | # déclaration de noms de variables pour éviter des warnings en compilant le package 24 | tables_a_extraire <- index_ligne_debut <- index_ligne_fin <- nom_table <- NULL 25 | 26 | # lecture brute du fichier texte 27 | 28 | lignes_dump <- imp_lire_lignes_dump(fichier_dump) 29 | 30 | options(stringsAsFactors = F) 31 | 32 | noms_tables <- imp_extraire_noms_tables(lignes_dump = lignes_dump) 33 | 34 | imp_tables_a_partir_des_lignes(lignes_dump = lignes_dump, 35 | tables_a_extraire = noms_tables) 36 | } 37 | 38 | 39 | 40 | 41 | -------------------------------------------------------------------------------- /R/imp_lire_lignes_dump.R: -------------------------------------------------------------------------------- 1 | #' Lire les lignes du dump SQL de la base Aspe 2 | #' 3 | #' @param fichier_dump Le chemin vers le fichier d'extension .sql (décompressé) ou 4 | #' .sql.gz (archive). 5 | #' 6 | #' @return Une liste de chaînes de caractères avec autant d'éléments que de lignes sur le dump. 7 | #' @noRd 8 | #' 9 | #' 10 | #' @examples 11 | #' 12 | #' \dontrun{ 13 | #' lignes_dump <- imp_lire_lignes_dump (fichier_dump = "../raw_data/dump.sql") 14 | #' } 15 | #' 16 | #' 17 | imp_lire_lignes_dump <- function(fichier_dump) { 18 | 19 | # lecture brute du fichier texte 20 | 21 | readLines(fichier_dump, encoding = "UTF-8") 22 | 23 | } 24 | -------------------------------------------------------------------------------- /R/imp_trouver_index_fin.R: -------------------------------------------------------------------------------- 1 | #' Trouver la ligne de fin qui correspond à une table désignée par sa ligne de début 2 | #' 3 | #' Par exemple pour trouver le numéro de la ligne de fin d'une table qui débuterait à la ligne 6517552 4 | #' 5 | #' @param vecteur_index_lignes_fin Vecteur contenant les numéros de toutes les lignes contenant la séquence caractéristique 6 | #' de la fin d'une table. 7 | #' @param ligne_debut Numéro de la ligne de début de la table. 8 | #' 9 | #' @return Le numéro de la ligne de fin de la table. 10 | #' @export 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' imp_trouver_index_fin(vecteur_index_lignes_fin = mon_vecteur, ligne_debut = 6517552) 15 | #' } 16 | imp_trouver_index_fin <- function(vecteur_index_lignes_fin, ligne_debut) 17 | 18 | { 19 | 20 | which(vecteur_index_lignes_fin > ligne_debut) %>% 21 | min() %>% 22 | vecteur_index_lignes_fin[.] 23 | 24 | } 25 | -------------------------------------------------------------------------------- /R/ip_completer_classes_couleur.R: -------------------------------------------------------------------------------- 1 | #' Ajouter les codes couleurs aux classes IPR 2 | #' 3 | #' @param df_classes_ip Dataframe contenant les intitulés des classes, typiquement 4 | #' le dataframe classe_ipr de la base Aspe. 5 | #' @param var_numero_classe Variable contenant les numéros de classes de 1 (meilleur état) 6 | #' à 5 (le pire). 7 | #' @param var_libelle_classe Variable contenant les libellés de classes. 8 | #' @return Le dataframe complété. La colonne ajoutée est "classe_couleur". 9 | #' @export 10 | #' 11 | #' @importFrom dplyr case_when mutate rename 12 | #' @importFrom forcats fct_reorder 13 | #' @importFrom rlang := 14 | #' 15 | #' @examples 16 | #' \dontrun{ 17 | #' classe_ipr_plus <- classe_ipr_plus %>% 18 | #' ip_completer_classes_couleur(var_numero_classe = cip_classe, 19 | #' var_libelle_classe = cip_libelle) 20 | #' } 21 | ip_completer_classes_couleur <- function(df_classes_ip, 22 | var_numero_classe = cli_classe, 23 | var_libelle_classe = cli_libelle) 24 | 25 | { 26 | var_numero_classe <- enquo(var_numero_classe) 27 | var_libelle_classe <- enquo(var_libelle_classe) 28 | 29 | df_classes_ip <- df_classes_ip %>% 30 | mutate( 31 | classe_couleur = case_when( 32 | !!var_numero_classe == 1 ~ "#1f78b4", 33 | !!var_numero_classe == 2 ~ "#b2df8a", 34 | !!var_numero_classe == 3 ~ "#ffff33", 35 | !!var_numero_classe == 4 ~ "#ff7f00", 36 | !!var_numero_classe == 5 ~ "#e41a1c" 37 | ), 38 | !!var_libelle_classe := as.factor(!!var_libelle_classe), 39 | !!var_libelle_classe := fct_reorder(!!var_libelle_classe, 40 | !!var_numero_classe) 41 | ) 42 | 43 | df_classes_ip 44 | 45 | } 46 | -------------------------------------------------------------------------------- /R/ipr_pivoter_1colonne_par_an.R: -------------------------------------------------------------------------------- 1 | #' Convertir une table des IPR du format long au format large 2 | #' 3 | #' On appelle format large la présentation des données avec une colonne par année. 4 | #' S'il y a plusieurs valeurs de l'IPR pour un même point une année donnée, 5 | #' la valeur retournée sera la moyenne. 6 | #' 7 | #' @param ipr_df Le dataframe au format long contenant les IPR, issi de la fonction extraire-ipr() 8 | #' 9 | #' @return Un dataframe contenant les mêmes données, mais agencé avec une colonne par année. 10 | #' @export 11 | #' 12 | #' @importFrom tidyr pivot_wider 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' ipr_large_df <- ipr_pivoter_1colonne_par_an(ipr_df = mon_df_ipr) 17 | #' } 18 | ipr_pivoter_1colonne_par_an <- function(ipr_df) 19 | 20 | { 21 | 22 | ipr_df %>% 23 | select(annee, ipr, pop_id) %>% 24 | distinct() %>% 25 | pivot_wider(names_from = annee, 26 | values_from = ipr, 27 | names_sort = TRUE, 28 | values_fn = mean) 29 | 30 | } 31 | -------------------------------------------------------------------------------- /R/ipr_renommer_pour_macro.R: -------------------------------------------------------------------------------- 1 | #' Sélectionner et nommer les colonnes au format requis en entrée de la macro 2 | #' Excel de calcul de l'indice 3 | #' 4 | #' @param data Le dataframe contenant les données, issu de la fonction formater_pour_macro(). 5 | #' @param fichier_macro Caractère. Chemin vers le fichier Excel de la macro. 6 | #' 7 | #' @return Le dataframe 8 | #' @export 9 | #' 10 | #' @importFrom readxl read_xlsx 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' data_macro <- ipr_renommer_pour_macro(data = data_macro, 15 | #' fichier_macro = "raw_data/CalculIPRv1.3.xls") 16 | #' } 17 | ipr_renommer_pour_macro <- function(data, fichier_macro) { 18 | 19 | noms_colonnes <- readxl::read_xlsx(fichier_macro, skip = 1) 20 | 21 | noms_especes <- noms_colonnes %>% 22 | select(ABLab:VANab) %>% 23 | names() %>% 24 | str_sub(start = 1, end = 3) 25 | 26 | # il manque les espèces suivantes 27 | noms_especes_manquantes <- base::setdiff(noms_especes, names(data)) 28 | 29 | # il faut les rajouter 30 | data <- data %>% 31 | `is.na<-`(noms_especes_manquantes) 32 | 33 | # 34 | ref_operation <- data %>% 35 | select(ope_id:ope_date) %>% 36 | mutate(ope_date = format(ope_date, format = "%d/%m/%Y")) 37 | 38 | names(ref_operation) <- noms_colonnes %>% 39 | select(1:4) %>% 40 | names() 41 | 42 | var_env <- data %>% 43 | select(opi_param_surf:opi_param_bassin) 44 | 45 | names(var_env) <- noms_colonnes %>% 46 | select(6:15) %>% 47 | names() 48 | 49 | captures <- data %>% 50 | select(all_of(noms_especes)) 51 | 52 | names(captures) <- paste0(names(captures), 'ab') 53 | 54 | bind_cols(ref_operation, v1 = NA, var_env, v2 = NA, captures) 55 | 56 | } 57 | -------------------------------------------------------------------------------- /R/mef_ajouter_abs.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à un dataframe de présences les lignes des absences (avec effectif et densité nuls) 2 | #' 3 | #' La fonction fait appel au dataframe "operation" de la base Aspe qui doit impérativement avoir 4 | #' été chargé auparavant. 5 | #' 6 | #' @param df Dataframe avec les variables ope_id, esp_code_alternatif, effectif, dens_ind_1000m2 et annee. 7 | #' @param var_id Nom de la variable contenant les identifiants des observations (ex : ope_id), sans guillements. 8 | #' @param var_taxon Nom de la variable contenant les identifiants des taxons (ex : esp_code_alternatif), 9 | #' sans guillements. 10 | #' @param var_effectif Nom de la variable contenant les effectifs (ex : lop_effectif), sans guillements. 11 | #' 12 | #' @return Le dataframe avec des lignes supplémentaires pour chacune des espèces absentes à chacune 13 | #' des opérations. 14 | #' @export 15 | #' 16 | #' @importFrom dplyr select left_join enquo 17 | #' @importFrom tidyr complete 18 | #' 19 | #' @examples 20 | #' \dontrun{ 21 | #' df_complet <- mef_ajouter_abs(df = df_presences, 22 | #' var_id = ope_id, 23 | #' var_taxon = esp_code_alternatif, 24 | #' var_effectif = effectif) 25 | #' } 26 | mef_ajouter_abs <- function(df, var_id, var_taxon, var_effectif) 27 | 28 | { 29 | var_id <- enquo(var_id) 30 | var_taxon <- enquo(var_taxon) 31 | var_effectif <- enquo(var_effectif) 32 | 33 | df %>% 34 | droplevels() %>% # à retirer à terme 35 | select(!!var_id, !!var_taxon, !!var_effectif) %>% 36 | complete(!!var_id,!!var_taxon) %>% 37 | left_join(y = df %>% 38 | select(!!var_id, 39 | annee) %>% 40 | distinct()) %>% 41 | left_join(y = operation %>% 42 | select(ope_id, 43 | pop_id = ope_pop_id)) 44 | 45 | } 46 | -------------------------------------------------------------------------------- /R/mef_ajouter_ambiance.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle, quand le prélèvement élémentaire est une ambiance, ses données 2 | #' 3 | #' Le type de prélèvement doit donc être indiqué dans le data frame (Groupe de points, 4 | #' Passage ou Ambiance). On applique mef_ajouter_ambiance() après mef_ajouter_type_prelevement(). 5 | #' 6 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 7 | #' df doit contenir le champ "pre_id" (identifiant du prélèvement individuel). 8 | #' 9 | #' @return La passerelle complétée. 10 | #' @export 11 | #' 12 | #' @importFrom dplyr left_join select 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' passerelle <- passerelle %>% 17 | #' mef_ajouter_type_prelevement() %>% 18 | #' mef_ajouter_ambiance() 19 | #' } 20 | mef_ajouter_ambiance <- function(df) 21 | 22 | { 23 | df %>% 24 | left_join(y = ambiance %>% 25 | rename(pre_id = amb_id)) 26 | } 27 | -------------------------------------------------------------------------------- /R/mef_ajouter_dept.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle les numéros de départements. 2 | #' 3 | #' Si le code commune de la station est renseigné dans la table station, ses deux premiers caractères 4 | #' indiquent le département. S'il est manquant mais renseigné dans la table point_prelevement, 5 | #' c'est cette information qui est utilisée. Malgré tout l'information est manquantes dans 6 | #' certains cas 7 | #' 8 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 9 | #' La passerelle doit comprendre des colonnes "sta_id" et "pop_id". 10 | #' 11 | #' @return La passerelle complétée par le département. 12 | #' @export 13 | #' 14 | #' @importFrom dplyr left_join select filter 15 | #' @importFrom stringr str_sub 16 | #' 17 | #' @examples 18 | #' \dontrun{ 19 | #' passerelle <- passerelle %>% 20 | #' mef_ajouter_dept() 21 | #' } 22 | mef_ajouter_dept <- function(df) 23 | 24 | { 25 | 26 | df %>% 27 | left_join(y = station %>% 28 | select(sta_id, 29 | com_code_insee = sta_com_code_insee)) %>% 30 | mutate(dept_sta = as.character(com_code_insee), 31 | dept_sta = str_sub(dept_sta, 1, 2)) %>% 32 | left_join(point_prelevement %>% 33 | select(pop_id, 34 | pop_com_code_insee = pop_com_code_insee_wama)) %>% 35 | mutate(dept_pop = as.character(pop_com_code_insee), 36 | dept_pop = str_sub(dept_pop, 1, 2), 37 | dept = ifelse(is.na(dept_sta), 38 | yes = dept_pop, 39 | no = dept_sta)) %>% 40 | select(c(names(df), "dept")) 41 | 42 | } 43 | -------------------------------------------------------------------------------- /R/mef_ajouter_esp.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à un dataframe le code espèce à 3 lettres, son nom commun et scientifique 2 | #' 3 | #' Les codes sont "historiques", hérités du Conseil Supérieur de la Pêche. 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' La passerelle doit comprendre un champ avec le code taxon esp_id (typiquement, on utilise donc 7 | #' mef_ajouter_esp() après mef_ajouter_lots()) 8 | #' 9 | #' @return La passerelle complétée. 10 | #' @export 11 | #' 12 | #' @importFrom dplyr left_join select 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' passerelle <- mef_creer_passerelle() %>% 17 | #' mef_ajouter_lots() %>% 18 | #' mef_ajouter_esp() 19 | #' } 20 | mef_ajouter_esp <- function(df) 21 | 22 | { 23 | df %>% 24 | left_join(y = ref_espece %>% 25 | select(esp_id, 26 | esp_code_alternatif, 27 | esp_nom_commun, 28 | esp_nom_latin)) 29 | 30 | } 31 | -------------------------------------------------------------------------------- /R/mef_ajouter_groupe_points.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle, quand le prélèvement élémentaire est un groupe de points, ses données 2 | #' 3 | #' Le type de prélèvement doit donc être indiqué dans le data frame (Groupe de points, 4 | #' Passage ou Ambiance). On applique mef_ajouter_groupe_points() après mef_ajouter_type_prelevement(). 5 | #' 6 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 7 | #' df doit contenir le champ "pre_id" (identifiant du prélèvement individuel). 8 | #' 9 | #' @return La passerelle complétée. 10 | #' @export 11 | #' 12 | #' @importFrom dplyr left_join select 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' passerelle <- passerelle %>% 17 | #' mef_ajouter_type_prelevement() %>% 18 | #' mef_ajouter_groupe_points() 19 | #' } 20 | mef_ajouter_groupe_points <- function(df) 21 | 22 | { 23 | df %>% 24 | left_join(y = groupe_points %>% 25 | rename(pre_id = grp_id)) 26 | 27 | } 28 | -------------------------------------------------------------------------------- /R/mef_ajouter_intervenants.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle les intervenants sur les opérations 2 | #' Ces intervenants sont l'opérateur, le commanditaire et le valideur 3 | #' 4 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des 5 | #' différentes tables. 6 | #' 7 | #' @return La passerelle complétée. 8 | #' @export 9 | #' 10 | #' @importFrom dplyr select left_join rename 11 | #' @importFrom stringr str_extract 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- mef_creer_passerelle() %>% 16 | #' mef_ajouter_intervenants() 17 | #' } 18 | #' 19 | mef_ajouter_intervenants <- function(df) 20 | 21 | { 22 | # simplification des tables pour ne conserver que le nécessaire 23 | int_simp <- ref_intervenant %>% 24 | select(int_id, 25 | int_libelle_sandre) 26 | 27 | ope_simp <- operation %>% 28 | select( 29 | ope_id, 30 | ope_int_id_operateur_peche, 31 | ope_int_id_commanditaire, 32 | ope_int_id_validation_technique 33 | ) 34 | 35 | # Jointure pour ajouter operateur, commanditaire etc. à la table ope_simp 36 | ope_simp <- ope_simp %>% 37 | left_join( 38 | y = int_simp %>% 39 | rename( 40 | ope_int_id_operateur_peche = int_id, 41 | operateur_peche = int_libelle_sandre 42 | ) 43 | ) %>% 44 | left_join( 45 | y = int_simp %>% 46 | rename( 47 | ope_int_id_commanditaire = int_id, 48 | commanditaire = int_libelle_sandre 49 | ) 50 | ) %>% 51 | left_join( 52 | y = int_simp %>% 53 | rename( 54 | ope_int_id_validation_technique = int_id, 55 | validation_technique = int_libelle_sandre 56 | ) 57 | ) 58 | 59 | # ajout de variables booleennes pour taguer si l'opération est OFB ou AFB (commanditaire etc.) 60 | df <- df %>% 61 | left_join(ope_simp) %>% 62 | mutate( 63 | operateur_ofb = str_extract(string = operateur_peche, 64 | pattern = "\\((.*)\\)"), 65 | operateur_ofb = ifelse( 66 | operateur_ofb %in% c("(OFB)", "(AFB)"), 67 | yes = TRUE, 68 | no = FALSE 69 | ), 70 | commanditaire_ofb = str_extract(string = commanditaire, 71 | pattern = "\\((.*)\\)"), 72 | commanditaire_ofb = ifelse( 73 | commanditaire_ofb %in% c("(OFB)", "(AFB)"), 74 | yes = TRUE, 75 | no = FALSE 76 | ), 77 | 78 | validation_ofb = str_extract(string = validation_technique, 79 | pattern = "\\((.*)\\)"), 80 | validation_ofb = ifelse( 81 | validation_ofb %in% c("(OFB)", "(AFB)"), 82 | yes = TRUE, 83 | no = FALSE 84 | ) 85 | 86 | ) 87 | 88 | df 89 | 90 | } 91 | -------------------------------------------------------------------------------- /R/mef_ajouter_ipr.R: -------------------------------------------------------------------------------- 1 | #' Ajouter les notes IPR à une table passerelle 2 | #' 3 | #' @param passerelle Dataframe mettant en correspondance les identifiants des différentes tables. 4 | #' 5 | #' @return Dataframe avec la valeur de l'IPR, et la classe de qualité. 6 | #' @export 7 | #' 8 | #' @importFrom lubridate ymd_hms dmy 9 | #' 10 | #' @examples 11 | #' \dontrun{ 12 | #' mon_df_ipr <- mef_ajouter_ipr(passerelle = passerelle) 13 | #' } 14 | #' 15 | mef_ajouter_ipr <- function(passerelle) 16 | 17 | { 18 | 19 | prov <- passerelle %>% 20 | left_join(y = operation_ipr %>% 21 | select(ope_id = opi_ope_id, ipr = opi_ipr, cli_id = opi_cli_id)) %>% # récupération IPR 22 | distinct() %>%# suppression des doublons 23 | left_join(y = classe_ipr %>% select(cli_id, cli_libelle)) 24 | 25 | prov 26 | 27 | } 28 | -------------------------------------------------------------------------------- /R/mef_ajouter_libelle.R: -------------------------------------------------------------------------------- 1 | #' Rajouter le libellé du site 2 | #' 3 | #' @description `r lifecycle::badge("deprecated")`. 4 | #' Fonction remplacée par "mef_ajouter_libelle_site()". 5 | #' 6 | #' @param passerelle Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 7 | #' 8 | #' @return La passerelle à laquelle ont été ajoutés les libellés des points de prélèvement. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr left_join select mutate_at mutate vars 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- mef_ajouter_libelle(passerelle = passerelle) 16 | #' } 17 | mef_ajouter_libelle <- function(passerelle) 18 | 19 | { 20 | passerelle %>% 21 | left_join(y = point_prelevement %>% 22 | select(pop_id, pop_libelle = pop_libelle_wama)) %>% 23 | left_join(y = station %>% 24 | select(sta_id, sta_libelle_sandre)) %>% 25 | mutate_at(vars(pop_libelle, sta_libelle_sandre), 26 | as.character) %>% 27 | mutate(pop_libelle = ifelse(is.na(pop_libelle), 28 | sta_libelle_sandre, 29 | pop_libelle)) %>% 30 | mutate(pop_libelle = ifelse(is.na(pop_libelle), 31 | pop_id, 32 | pop_libelle)) %>% 33 | select(-sta_libelle_sandre) 34 | 35 | } 36 | -------------------------------------------------------------------------------- /R/mef_ajouter_lots.R: -------------------------------------------------------------------------------- 1 | #' Ajouter les lots de poissons capturés à la passerelle 2 | #' 3 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 4 | #' df doit contenir une variable "pre_id" (identifiant du prélèvement élémentaire). 5 | #' 6 | #' @return La passerelle complétée. 7 | #' @export 8 | #' 9 | #' @importFrom dplyr left_join select 10 | #' 11 | #' @examples 12 | #' \dontrun{ 13 | #' passerelle <- passerelle %>% 14 | #' mef_ajouter_lots() 15 | #' } 16 | mef_ajouter_lots <- function(df) 17 | 18 | { 19 | 20 | df %>% 21 | left_join(y = lot_poissons %>% 22 | select(pre_id = lop_pre_id, 23 | lop_id, 24 | tyl_id = lop_tyl_id, 25 | tlo_id = lop_tlo_id, 26 | esp_id = lop_esp_id, 27 | lop_effectif)) %>% 28 | left_join(y = ref_espece %>% 29 | select(esp_id, 30 | esp_code_alternatif)) %>% 31 | select(-esp_id) 32 | 33 | } 34 | -------------------------------------------------------------------------------- /R/mef_ajouter_mei.R: -------------------------------------------------------------------------------- 1 | #' Ajouter les mesures individuelles à la passerelle 2 | #' 3 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 4 | #' df doit contenir le champ "lop_id" qui sert à la jointure avec la table mesure_individuelle. 5 | #' 6 | #' @return La passerelle complétée. 7 | #' @export 8 | #' 9 | #' @importFrom dplyr left_join rename 10 | #' 11 | #' @examples 12 | #' \dontrun{ 13 | #' passerelle <- passerelle %>% 14 | #' mef_ajouter_mei() 15 | #' } 16 | mef_ajouter_mei <- function(df) 17 | 18 | { 19 | df %>% 20 | left_join(y = mesure_individuelle %>% 21 | rename(lop_id = mei_lop_id)) 22 | } 23 | -------------------------------------------------------------------------------- /R/mef_ajouter_metriques.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à une passerelle les métriques IPR observées, théoriques et leur contribution 2 | #' à l'indice IPR agrégé 3 | #' 4 | #' @param df Dataframe qui doit comprendre une colonnes "ope_id" (identifiant de l'opération de pêche). 5 | #' 6 | #' @return Le dataframe passerelle complété par les métriques. 7 | #' @export 8 | #' 9 | #' @importFrom lubridate year ymd_hms 10 | #' @importFrom stringr str_replace 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' passerelle_avec_metriques <- mef_ajouter_metriques(df = ma_passerelle) 15 | #' } 16 | mef_ajouter_metriques <- function(df) 17 | 18 | { 19 | 20 | df %>% 21 | left_join(y = operation_ipr %>% # ajout table operation_ipr 22 | select(ope_id = opi_ope_id, 23 | ends_with("theorique"), 24 | ends_with("observe"), 25 | opi_ner:opi_dti)) %>% 26 | rename_at(.vars = vars(starts_with("opi_")), # simplification des noms des métriques 27 | .funs = ~str_replace(., pattern = "opi_", replacement = "")) 28 | 29 | } 30 | -------------------------------------------------------------------------------- /R/mef_ajouter_moyen_prospection.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle le moyen de prospection 2 | #' 3 | #' Ex : A pied / En bateau. Les modalités sont précisées dans la table ref_moyen_prospection. 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' df doit contenir une variable "ope_id" (identifiant de l'opération de pêche). 7 | #' 8 | #' @return La passerelle complétée. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr left_join select 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- passerelle %>% 16 | #' mef_ajouter_moyen_prospection() 17 | #' } 18 | mef_ajouter_moyen_prospection <- function(df) 19 | 20 | { 21 | df %>% 22 | left_join(y = operation_description_peche %>% 23 | select(ope_id = odp_ope_id, 24 | mop_id = odp_mop_id)) %>% 25 | left_join(y = ref_moyen_prospection %>% 26 | select(mop_id, 27 | mop_libelle)) %>% 28 | select(c(names(df), "mop_libelle")) 29 | 30 | } 31 | -------------------------------------------------------------------------------- /R/mef_ajouter_objectif.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle l'objectif de l'opération 2 | #' 3 | #' Par objectif, on entent la contribution à un réseau (DCE, RCS, RRP, etc.), le suivi de poopulations, 4 | #' des études, du suivi de restauration, etc. Les modalités sont précisées dans la table ref_objectif. 5 | #' 6 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 7 | #' df doit contenir une variable "ope_id" (identifiant de l'opération de pêche). 8 | #' 9 | #' @return La passerelle complétée. 10 | #' @export 11 | #' 12 | #' @importFrom dplyr left_join select 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' passerelle <- passerelle %>% 17 | #' mef_ajouter_objectif() 18 | #' } 19 | mef_ajouter_objectif <- function(df) 20 | 21 | { 22 | df %>% 23 | left_join(y = operation_objectif %>% 24 | select(ope_id = opo_ope_id, 25 | obj_id = opo_obj_id)) %>% 26 | left_join(y = ref_objectif %>% 27 | select(obj_id, 28 | obj_libelle)) 29 | 30 | } 31 | -------------------------------------------------------------------------------- /R/mef_ajouter_ope_date.R: -------------------------------------------------------------------------------- 1 | #' Rajouter à la passerelle la date et l'année de chaque opération. 2 | #' 3 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 4 | #' df doit contenir une variable "ope_id" (identifiant de l'opération de pêche). 5 | #' 6 | #' @return La passerelle à laquelle ont été ajoutés la date et l'année. 7 | #' @export 8 | #' 9 | #' @importFrom lubridate ymd_hms dmy 10 | #' 11 | #' @examples 12 | #' \dontrun{ 13 | #' passerelle <- mef_ajouter_ope_date(df = passerelle) 14 | #' } 15 | mef_ajouter_ope_date <- function(df) 16 | 17 | { 18 | 19 | df %>% 20 | left_join(y = operation %>% select(ope_id, ope_date)) %>% # récupération de la date 21 | mutate(ope_date = as.character(ope_date), # mise au format de la date 22 | annee = lubridate::ymd_hms(ope_date), # création variable année 23 | annee = lubridate::year(annee), 24 | ope_date = ymd_hms(ope_date)) 25 | 26 | } 27 | -------------------------------------------------------------------------------- /R/mef_ajouter_ope_desc_peche.R: -------------------------------------------------------------------------------- 1 | #' Rajouter à la passerelle les variables de description de la pêche pour chaque opération (quand disponible). 2 | #' 3 | #' Ces variables sont issues de la table "operation_description_peche". 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' 7 | #' @return La passerelle à laquelle ont été ajoutés les variables environnementales 8 | #' @export 9 | #' 10 | #' @importFrom dplyr left_join select mutate_all 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' passerelle <- mef_ajouter_ope_desc_peche(df = passerelle) 15 | #' } 16 | mef_ajouter_ope_desc_peche <- function(df) 17 | 18 | { 19 | 20 | ope_dp <- df %>% 21 | left_join( # jointure table operation_description_peche 22 | y = operation_description_peche %>% 23 | select(ope_id = odp_ope_id, 24 | odp_duree_peche, 25 | odp_longueur, 26 | odp_largeur_lame_eau, 27 | odp_temperature_instantanee, 28 | odp_conductivite, 29 | odp_tension:odp_nombre_epuisettes 30 | ) %>% 31 | mutate_all(function(x) ifelse(x == 0, NA, x)) # indeed zeros are missing values 32 | ) 33 | 34 | ope_dp 35 | 36 | } 37 | -------------------------------------------------------------------------------- /R/mef_ajouter_passage.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle, quand le prélèvement élémentaire est un passage, le numéro de passage 2 | #' 3 | #' Le type de prélèvement doit donc être indiqué dans le data frame (Groupe de points, 4 | #' Passage ou Ambiance). On applique mef_ajouter_passage() après mef_ajouter_type_prelevement(). 5 | #' 6 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 7 | #' df doit contenir une variable "pre_id" (identifiant du prélèvement élémentaire). 8 | #' 9 | #' @return La passerelle complétée. 10 | #' @export 11 | #' 12 | #' @importFrom dplyr left_join select 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' passerelle <- passerelle %>% 17 | #' mef_ajouter_type_prelevement() %>% 18 | #' mef_ajouter_passage() 19 | #' } 20 | mef_ajouter_passage <- function(df) 21 | 22 | { 23 | df %>% 24 | left_join(y = passage %>% 25 | rename(pre_id = pas_id)) 26 | 27 | } 28 | -------------------------------------------------------------------------------- /R/mef_ajouter_proba_presence_ipr.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à un dataframe les probabilités de présence des taxons IPR 2 | #' 3 | #' Ces probabilités sont issues de Oberdorff et al. (2002) 4 | #' Development and validation of a fish‐based index for the assessment of ‘river health’in France. 5 | #' Freshwater Biology, 47(9), 1720-1734). 6 | #' 7 | #' Comme les codes taxonomiques actuels diffèrent de ceux de l'IPR, il peut être nécessaire, avant d'utiliser 8 | #' la fonction 'mef_ajouter_proba_presence_ipr()', d'appliquer le référentiel taxonomique IPR au dataframe 9 | #' au moyen de la fonction 'mef_recoder_esp_code_alt()'. 10 | #' 11 | #' Le dataframe 'probabilite_presence_ipr' doit auparavant être chargé. 12 | #' 13 | #' @param df Dataframe qui doit comprendre les colonnes "ope_id" et "esp_id". 14 | #' 15 | #' @return Le dataframe complété avec les probabilités de présence. 16 | #' @export 17 | #' 18 | #' @importFrom dplyr left_join select 19 | #' 20 | #' @examples 21 | #' \dontrun{ 22 | #' df <- df %>% 23 | #' mef_ajouter_proba_presence_ipr() 24 | #' } 25 | mef_ajouter_proba_presence_ipr <- function(df) 26 | 27 | { 28 | 29 | df <- df %>% 30 | left_join(y = probabilite_presence_ipr %>% 31 | select(ope_id = ppi_opi_ope_id, # survey id is renamed to join fbi 32 | esp_id = ppi_esp_id, # species id is renamed to join ref_espece 33 | ppi_valeur_probabilite, # proba occurrence 34 | ppi_param_effectif # observed catches 35 | ) 36 | ) 37 | 38 | df 39 | 40 | } 41 | -------------------------------------------------------------------------------- /R/mef_ajouter_qualification.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle la qualification de la donnée 2 | #' 3 | #' ex : Correcte / Incorrecte / Incertaine. 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' df doit contenir une variable "ope_id" (identifiant de l'opération de pêche). 7 | #' 8 | #' @return La passerelle complétée. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr left_join select 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- passerelle %>% 16 | #' mef_ajouter_qualification() 17 | #' } 18 | mef_ajouter_qualification <- function(df) 19 | 20 | { 21 | df %>% 22 | left_join(y = operation %>% 23 | select(ope_id, 24 | niq_id = ope_niq_id)) %>% 25 | left_join(y = ref_niveau_qualification %>% 26 | select(niq_id, 27 | niq_libelle)) %>% 28 | select(-niq_id) 29 | } 30 | -------------------------------------------------------------------------------- /R/mef_ajouter_stats_taille.R: -------------------------------------------------------------------------------- 1 | #' Ajouter les tailles (longueurs) mini, maxi, médiane et moyenne pour chaque espèce à 2 | #' chaque opération 3 | #' 4 | #' La fonction fait appel à de nombreux dataframes de la base Aspe qui doivent impérativement avoir 5 | #' été chargés auparavant (mesure_individuelle, lots, operation, etc.). Elle n'opère pas de distinction 6 | #' entre longueur totale et longueur fourche. 7 | #' 8 | #' @param df Dataframe avec des variables espèce (esp_code_alternatif) et opération (ope_id). 9 | #' 10 | #' @return La passerelle à laquelle ont été ajoutés les statistiques de tailles. 11 | #' @export 12 | #' 13 | #' @importFrom stats median 14 | #' @importFrom dplyr select distinct right_join rename group_by summarise ungroup starts_with 15 | #' 16 | #' @examples 17 | #' \dontrun{ 18 | #' passerelle <- mef_ajouter_stats_taille(passerelle = passerelle) 19 | #' } 20 | mef_ajouter_stats_taille <- function(df) 21 | 22 | { 23 | 24 | longueurs <- mef_creer_passerelle() %>% 25 | mef_ajouter_lots() %>% 26 | select(ope_id, lop_id, esp_code_alternatif) %>% 27 | distinct() %>% 28 | right_join(y = mesure_individuelle %>% 29 | rename(lop_id = mei_lop_id)) %>% 30 | group_by(ope_id, esp_code_alternatif) %>% 31 | summarise( 32 | taille_max = max(mei_taille, na.rm = TRUE), 33 | taille_min = min(mei_taille, na.rm = TRUE), 34 | taille_moy = mean(mei_taille, na.rm = TRUE), 35 | taille_med = median(mei_taille, na.rm = TRUE) 36 | ) %>% 37 | ungroup() %>% 38 | select(ope_id, 39 | esp_code_alternatif, 40 | starts_with("taille_")) 41 | 42 | df <- df %>% 43 | left_join(longueurs) 44 | 45 | df 46 | 47 | } 48 | 49 | 50 | -------------------------------------------------------------------------------- /R/mef_ajouter_surf_calc.R: -------------------------------------------------------------------------------- 1 | #' Rajouter la superficie échantillonnée calculée pour chaque opération à la passerelle 2 | #' 3 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 4 | #' df doit contenir une variable "ope_id" (identifiant de l'opération de pêche). 5 | #' 6 | #' @return La passerelle à laquelle a été ajoutée la superficie échantillonnée qui est une valeur calculée 7 | #' stockée dans le champ ope_surf_calculee de la table operation. 8 | #' @export 9 | #' 10 | #' @importFrom dplyr left_join select 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' passerelle <- mef_ajouter_surf_calc(df = passerelle) 15 | #' } 16 | mef_ajouter_surf_calc <- function(df) 17 | 18 | { 19 | df %>% 20 | left_join(y = operation %>% 21 | select(ope_id, 22 | ope_surface_calculee)) 23 | 24 | } 25 | -------------------------------------------------------------------------------- /R/mef_ajouter_type_longueur.R: -------------------------------------------------------------------------------- 1 | #' Ajouter le type de longueur à la passerelle 2 | #' 3 | #' ex : totale, fourche. 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' df doit contenir une variable "lop_id" (identifiant du lot). 7 | #' 8 | #' @return La passerelle complétée. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr left_join select 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- passerelle %>% 16 | #' mef_ajouter_type_longueur() 17 | #' } 18 | mef_ajouter_type_longueur <- function(df) 19 | 20 | { 21 | df %>% 22 | left_join(lot_poissons %>% 23 | select(lop_id, 24 | tlo_id = lop_tlo_id)) %>% 25 | left_join(y = ref_type_longueur %>% 26 | select(tlo_id, 27 | tlo_libelle)) 28 | } 29 | -------------------------------------------------------------------------------- /R/mef_ajouter_type_lot.R: -------------------------------------------------------------------------------- 1 | #' Ajouter le type de lot à la passerelle 2 | #' 3 | #' NB Les tables "lot_poissons" et "ref_type_lot" doivent avoir été chargées auparavant. 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' df doit contenir une variable "lop_id" (identifiant du lot). 7 | #' 8 | #' @return La passerelle complétée. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr left_join select 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- passerelle %>% 16 | #' mef_ajouter_type_lot() 17 | #' } 18 | mef_ajouter_type_lot <- function(df) 19 | 20 | { 21 | df %>% 22 | left_join(y = lot_poissons %>% 23 | select(lop_id, 24 | tyl_id = lop_tyl_id)) %>% 25 | left_join(y = ref_type_lot %>% 26 | select(tyl_id, 27 | tyl_libelle)) 28 | } 29 | -------------------------------------------------------------------------------- /R/mef_ajouter_type_materiel.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle le type de matériel employé 2 | #' 3 | #' ex : Héron 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' 7 | #' @return La passerelle complétée. 8 | #' @export 9 | #' 10 | #' @importFrom dplyr left_join select 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' passerelle <- passerelle %>% 15 | #' mef_ajouter_type_materiel() 16 | #' } 17 | mef_ajouter_type_materiel <- function(df) 18 | 19 | { 20 | df %>% 21 | left_join(y = operation_description_peche %>% 22 | select(ope_id = odp_ope_id, 23 | mom_id = odp_mom_id)) %>% 24 | left_join(y = ref_modele_materiel %>% 25 | select(mom_id, 26 | mom_libelle)) %>% 27 | select(-mom_id) 28 | } 29 | -------------------------------------------------------------------------------- /R/mef_ajouter_type_prelevement.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle le type de prélèvement élémentaire 2 | #' 3 | #' Par type de prélèvement, on entend les modalités du tpe_libelle de la 4 | #' table ref_type_prelevement_elementaire 5 | #' 6 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 7 | #' 8 | #' @return La passerelle complétée. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr left_join select 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- passerelle %>% 16 | #' mef_ajouter_type_prelevement() 17 | #' } 18 | mef_ajouter_type_prelevement <- function(df) 19 | 20 | { 21 | df %>% 22 | left_join(y = prelevement_elementaire %>% 23 | select(pre_id, 24 | tpe_id = pre_tpe_id)) %>% 25 | left_join(y = ref_type_prelevement_elementaire) %>% 26 | select(-tpe_ordre_affichage, 27 | -tpe_id) 28 | 29 | } 30 | -------------------------------------------------------------------------------- /R/mef_ajouter_type_protocole.R: -------------------------------------------------------------------------------- 1 | #' Ajouter le type de protocole à la passerelle 2 | #' 3 | #' ex : Indice Abondance Saumon. 4 | #' Nécessite d'avoir chargé les tables "operation" et "ref_protocole". 5 | #' 6 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 7 | #' 8 | #' @return La passerelle complétée. 9 | #' @export 10 | #' 11 | #' @importFrom dplyr left_join select 12 | #' 13 | #' @examples 14 | #' \dontrun{ 15 | #' passerelle <- passerelle %>% 16 | #' mef_ajouter_type_protocole() 17 | #' } 18 | mef_ajouter_type_protocole <- function(df) 19 | 20 | { 21 | df %>% 22 | left_join(y = operation %>% 23 | select(ope_id, 24 | pro_id = ope_pro_id)) %>% 25 | left_join(y = ref_protocole %>% 26 | select(pro_id, 27 | pro_libelle)) %>% 28 | select(-pro_id) 29 | } 30 | -------------------------------------------------------------------------------- /R/mef_ajouter_utilisateurs.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle les utilisateurs sur les opérations 2 | #' 3 | #' Ces utilisateurs sont le créateur et la personne qui a effectué la dernière modification. 4 | #' Ils sont identifiés par leur adresse email. 5 | #' 6 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des 7 | #' différentes tables. 8 | #' 9 | #' @return La passerelle complétée. 10 | #' @export 11 | #' 12 | #' @importFrom dplyr select left_join rename 13 | #' 14 | #' @examples 15 | #' \dontrun{ 16 | #' passerelle <- mef_creer_passerelle() %>% 17 | #' mef_ajouter_utilisateurs() 18 | #' } 19 | #' 20 | mef_ajouter_utilisateurs <- function(df) 21 | 22 | { 23 | # simplification des tables pour ne conserver que le nécessaire 24 | 25 | uti_simp <- utilisateur %>% 26 | select(uti_id, 27 | int_id = uti_int_id, 28 | uti_mail) 29 | 30 | ope_simp <- operation %>% 31 | select(ope_id, 32 | ope_uti_id_creation, 33 | ope_uti_id_derniere_modification) 34 | 35 | # Jointure pour ajouter à la table ope_simp le créateur et modificateur 36 | ope_simp <- ope_simp %>% 37 | left_join(y = uti_simp %>% 38 | rename(ope_uti_id_creation = uti_id, 39 | createur = uti_mail)) %>% 40 | left_join(y = uti_simp %>% 41 | rename(ope_uti_id_derniere_modification = uti_id, 42 | modificateur = uti_mail)) 43 | 44 | df <- df %>% 45 | left_join(ope_simp) 46 | 47 | df 48 | 49 | } 50 | -------------------------------------------------------------------------------- /R/mef_ajouter_validation.R: -------------------------------------------------------------------------------- 1 | #' Ajouter à la passerelle l'a qualification de a donnée'état d'avancement de la saisie 2 | #' 3 | #' ex : En cours de saisie / Validé niveau 1. 4 | #' 5 | #' @param df Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 6 | #' 7 | #' @return La passerelle complétée. 8 | #' @export 9 | #' 10 | #' @importFrom dplyr left_join select 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' passerelle <- passerelle %>% 15 | #' mef_ajouter_validation() 16 | #' } 17 | mef_ajouter_validation <- function(df) 18 | 19 | { 20 | df %>% 21 | left_join(y = operation %>% 22 | select(ope_id, 23 | eta_id = ope_eta_id)) %>% 24 | left_join(y = ref_etat_avancement %>% 25 | select(eta_id, 26 | eta_libelle)) %>% 27 | select(-eta_id) 28 | } 29 | -------------------------------------------------------------------------------- /R/mef_compter_pres_abs_env.R: -------------------------------------------------------------------------------- 1 | #' Dénombrer le nb d'opérations avec chaque paramètre environnemental renseigné pour chacune 2 | #' des espèces 3 | #' 4 | #' @param df Dataframe avec les variables valeur_parametre, esp_code_alternatif, presence, parametre, annee, n. 5 | #' 6 | #' @return Un dataframe de 4 colonnes correspondant à l'espèce, au paramètre et aux nombres de présence et d'absence. 7 | #' @export 8 | #' 9 | #' @importFrom dplyr filter group_by ungroup tally left_join mutate 10 | #' @importFrom tidyr pivot_wider 11 | #' 12 | #' @examples 13 | #' \dontrun{ 14 | #' df_nb_pres_abs_par_parametre_env <- mef_compter_pres_abs_env(df = df_captures_et_env) 15 | #' } 16 | mef_compter_pres_abs_env <- function(df) 17 | 18 | { 19 | 20 | pres_abs_env <- df %>% 21 | filter(!is.na(valeur_parametre)) %>% 22 | group_by(esp_code_alternatif, presence, parametre, annee) %>% 23 | tally() %>% 24 | mutate(presence = ifelse(is.na(presence), FALSE, presence)) %>% 25 | ungroup() %>% 26 | pivot_wider( 27 | id_cols = esp_code_alternatif:annee, 28 | names_from = presence, 29 | values_from = n 30 | ) %>% 31 | rename(presences = `TRUE`, absences = `FALSE`) 32 | 33 | pres_abs_env 34 | 35 | } 36 | 37 | -------------------------------------------------------------------------------- /R/mef_filtrer_nb_mini_annees.R: -------------------------------------------------------------------------------- 1 | #' Filtrer un dataframe pour ne conserver que les objets présents un nombre 2 | #' minimum d'années 3 | #' 4 | #' @param df Dataframe qui doit contenir un champ d'identifiant des observations (ex : pop_id). 5 | #' @param nb_mini_annees Nombre entier indiquant le seuil de sélection (nb mini d'années 6 | #' de données sur le point). Par défaut sa valeur est 1 donc tous les points avec 7 | #' au moins une donnée sont sélectionnées. 8 | #' @param var_id Caractère. Nom de la variable d'identification des observations. 9 | #' Par exemple si la variable d'identification des objets est "pop_id", seuls seront conservés 10 | #' les points pour lesquels il y a plus de nb_mini_annees années de données. Si la variable 11 | #' d'identification est "sta_id", seuls seront conservées les stations pour lesquels il y a 12 | #' plus de nb_mini_annees années de données. 13 | #' 14 | #' @return Dataframe filtré, c'est-à-dire exourgé des objets qui n'ont pas assez d'années 15 | #' de données. 16 | #' @export 17 | #' @importFrom purrr set_names 18 | #' 19 | #' @examples 20 | #' \dontrun{ 21 | #' data_22_filtre <- mef_filtrer_nb_mini_annees(df = data_22, nb_mini_annees = 1, var_id = "sta_id") 22 | #' } 23 | mef_filtrer_nb_mini_annees <- function(df, nb_mini_annees, var_id) 24 | 25 | { 26 | 27 | var_ids <- df %>% 28 | group_by(get(!!var_id)) %>% 29 | summarise(n = n_distinct(annee)) %>% 30 | ungroup() %>% 31 | filter(n >= nb_mini_annees) %>% 32 | set_names(c(var_id, "n")) %>% 33 | pull(get(!!var_id)) %>% 34 | as.character() 35 | 36 | df %>% 37 | filter(get(!!var_id) %in% var_ids) 38 | 39 | } 40 | -------------------------------------------------------------------------------- /R/mef_ipr_radar.R: -------------------------------------------------------------------------------- 1 | #' Mettre un dataframe au format pour ls graphiques en radar. 2 | #' 3 | #' La fonction radarchart() du package \code{fmsb} nécessite en entrée un dataframe 4 | #' au format spécifique. 5 | #' 6 | #' @param metriques_df Un dataframe contenant les métriques par station et par année, 7 | #' produit par la fonction ipr_extraire_metriques(). 8 | #' @param pop_id Numérique entier. Identifiant du point de prélèvement (pop_id). 9 | #' @export 10 | #' 11 | #' @return Un dataframe mis en forme. 12 | #' 13 | #' @importFrom tibble column_to_rownames 14 | #' @importFrom dplyr filter mutate pull select 15 | #' 16 | #' @examples 17 | #' \dontrun{ 18 | #' mef_ipr_radar <- ipr_mef_radar(metriques_df = metriques_22, pop_id = 41964) 19 | #' } 20 | mef_ipr_radar <- function(metriques_df, pop_id) { 21 | 22 | pop_data <- metriques_df %>% 23 | filter(pop_id == !!pop_id) %>% # 24 | mutate(annee_car = as.character(annee)) %>% 25 | distinct() %>% 26 | column_to_rownames(var = "annee_car") 27 | 28 | mon_titre <- pop_data %>% # titre pour le graphique, en concaténant le nom de la station et l'année 29 | pull(pop_libelle) %>% 30 | as.character() %>% 31 | .[1] 32 | 33 | pop_data <- pop_data %>% 34 | select(annee, ner:dti) # sélection des colonnes nécessaires pour le graphique 35 | 36 | maxi <- pop_data %>% # valeur maximale pour les axes 37 | select(-annee) %>% 38 | max() %>% 39 | ceiling() 40 | 41 | bornes_inf <- rep(x = 0, times = 7) 42 | bornes_sup <- rep(x = maxi, times = 7) 43 | 44 | rbind(bornes_sup, bornes_inf, pop_data) %>% 45 | select(-annee) 46 | 47 | } 48 | 49 | -------------------------------------------------------------------------------- /R/mef_pivoter_var_env.R: -------------------------------------------------------------------------------- 1 | #' Pivoter le dataframe pour regrouper les variables environnementales sur 2 colonnes 2 | #' 3 | #' 4 | #' @param df Dataframe avec les variables distance_mer, temp_janvier, etc. 5 | #' 6 | #' @return Le dataframe pivoté, en forme pour les graphiques avec ggplot2. 7 | #' @export 8 | #' 9 | #' @importFrom tidyr pivot_longer 10 | #' 11 | #' @examples 12 | #' \dontrun{ 13 | #' df_long <- mef_pivoter_var_env(df_court) 14 | #' mes_graphiques[[1]] 15 | #' } 16 | mef_pivoter_var_env <- function(df) 17 | 18 | { 19 | 20 | df %>% 21 | pivot_longer( 22 | cols = distance_mer:temp_janvier, 23 | names_to = "parametre", 24 | values_to = "valeur_parametre", 25 | values_drop_na = TRUE 26 | ) 27 | 28 | } 29 | 30 | -------------------------------------------------------------------------------- /R/mef_recoder_esp_code_alt.R: -------------------------------------------------------------------------------- 1 | #' Recodage des codes taxons 'esp_code_alternatif' 2 | #' 3 | #' @param df Dataframe contenant la variable esp_code_alternatif'. 4 | #' @param type_recodage Caractère, soit "especes" (par défaut), soit "ipr". 5 | #' Dans le premier cas, les codes taxons de sous-espèces ou écotype sont recodés à l'espèce. 6 | #' Dans le second cas, les codes taxons sont recodés selon la taxonomie de l'IPR, ici 7 | #' conformément au script 'IPR_v1.0.3_calc_consult.R' 8 | #' téléchargé depuis [https://seee.eaufrance.fr/](https://seee.eaufrance.fr/) le 24/04/2023. 9 | #' 10 | #' @return Le dataframe mis à jour. 11 | #' @export 12 | #' 13 | #' @importFrom stringr str_to_lower 14 | #' @importFrom stringi stri_trans_general 15 | #' @importFrom dplyr mutate case_when 16 | #' 17 | #' @examples 18 | #' \dontrun{ 19 | #' # Calcul des captures par espèces pour chaque opération de pêche 20 | 21 | #' # chargement des packages 22 | #'library(dplyr) 23 | #'library(aspe) 24 | #' 25 | #' # chargement des données (à adapter) 26 | #'load(file = "raw_data/tables_sauf_mei_2023_04_07_09_39_32.RData") 27 | #' 28 | #' # création du tableau 29 | #'captures <- mef_creer_passerelle() %>% 30 | #' mef_ajouter_lots() %>% 31 | #' mef_ajouter_esp() %>% 32 | #' mef_recoder_esp_code_alt() %>% 33 | #' group_by(ope_id, esp_code_alternatif) %>% 34 | #' summarise(effectif = sum(lop_effectif)) %>% 35 | #' ungroup() 36 | #' } 37 | mef_recoder_esp_code_alt <- function(df, type_recodage = "especes") { 38 | 39 | # gestion des cas où l'utisateur a mis des majuscules ou des accents 40 | type_recodage <- str_to_lower(type_recodage) %>% 41 | stri_trans_general(id = "Latin-ASCII") 42 | 43 | if(!(type_recodage %in% c("ipr", "especes"))) 44 | 45 | { 46 | 47 | stop("type_recodage est soit 'ipr' soit 'especes'") 48 | 49 | }else{ 50 | # recodage à l'espèce (fusion des sous-espèces de truite commune et carpe commune) 51 | df <- df %>% 52 | mutate(esp_code_alternatif = case_when( 53 | esp_code_alternatif %in% c("CCU", "CMI") ~ "CCO", 54 | esp_code_alternatif %in% c("TRL", "TRM") ~ "TRF", 55 | TRUE ~ esp_code_alternatif 56 | )) 57 | 58 | # recadage selon la taxonomie IPR (fusion des néotaxons + d'espèces écologiquement proches) 59 | if(type_recodage == "ipr" ) { 60 | 61 | df <- df %>% 62 | mutate(esp_code_alternatif = case_when( 63 | esp_code_alternatif == "BRB" ~ "BRE", 64 | esp_code_alternatif == "CHP" ~ "CHA", 65 | esp_code_alternatif == "VAR" ~ "VAN", 66 | esp_code_alternatif %in% c("CAS", "CAG", "CAD", "CAA") ~ "CAX", 67 | esp_code_alternatif %in% c("GOL", "GOO", "GOU") ~ "GOX", 68 | esp_code_alternatif %in% c("VAI", "VAC", "VAB") ~ "PHX", 69 | TRUE ~ esp_code_alternatif 70 | )) 71 | 72 | } 73 | 74 | df 75 | 76 | } 77 | 78 | } 79 | -------------------------------------------------------------------------------- /R/mef_ssech_abs.R: -------------------------------------------------------------------------------- 1 | #' Sous-échantillonner parmi les absences 2 | #' 3 | #' La comparaison entre les sites de présence et d'absence d'une espèce n'a de sens quer si leur nombre 4 | #' est comparable. IL ne sert à rien d'avoir l'altitude de 100 000 sites où le saumon est absent 5 | #' si l'on n'a que 1000 sites où il est présent. On allège donc le dataframe en tirant aléatoirement 6 | #' autant d'opérations d'absence qu'il y a de présence. 7 | #' 8 | 9 | #' @param df Dataframe avec les variables valeur_parametre, esp_code_alternatif, presence, parametre, n. 10 | #' @param seed Numérique. La racine du générateur de nombres aléatoires pour le tirage. 11 | #' @return Un dataframe issu de df mais avec moins de lignes. 12 | #' @export 13 | #' 14 | #' @importFrom dplyr group_by ungroup left_join select mutate 15 | #' @importFrom tidyr nest unnest 16 | #' @importFrom purrr map2 17 | #' @importFrom utils data 18 | #' 19 | #' @examples 20 | #' \dontrun{ 21 | #' df_allege <- mef_ssech_abs(df = df_pres_abs_env) 22 | #' } 23 | mef_ssech_abs <- function(df, seed = 123) 24 | 25 | { 26 | set.seed = seed 27 | 28 | pres_abs_env <- df %>% 29 | mef_compter_pres_abs_env() 30 | 31 | # split des données en dataframes selon espece x presence / absence 32 | df_nested <- df %>% 33 | group_by(esp_code_alternatif, 34 | presence, 35 | parametre) %>% 36 | nest() %>% 37 | ungroup() %>% 38 | left_join( 39 | y = pres_abs_env %>% 40 | select(esp_code_alternatif, 41 | parametre, 42 | presences), 43 | by = c("esp_code_alternatif", "parametre") 44 | ) 45 | 46 | # sous-échantillonnage 47 | df_ssech <- df_nested %>% 48 | mutate(ssech = map2( 49 | .x = data, 50 | .y = presences, 51 | .f = sample_n, 52 | replace = TRUE 53 | )) 54 | 55 | # assemblage 56 | df <- df_ssech %>% 57 | select(-data) %>% 58 | unnest(ssech) 59 | 60 | # allègement du dataframe 61 | df <- df %>% 62 | select(-presences, 63 | -effectif) %>% 64 | mutate(parametre = as.factor(parametre), 65 | annee = as.integer(annee)) 66 | 67 | df 68 | 69 | 70 | } 71 | -------------------------------------------------------------------------------- /R/mef_ssech_esp_env.R: -------------------------------------------------------------------------------- 1 | #' Sous-échantillonner le df environnement et occurrences 2 | #' 3 | #' La comparaison entre les sites de présence et d'absence d'une espèce n'a de sens que si leur nombre 4 | #' est comparable. IL ne sert à rien d'avoir l'altitude de 100 000 sites où le saumon est absent 5 | #' si l'on n'a que 100 sites où il est présent. On allège donc le dataframe en tirant aléatoirement 6 | #' autant un nombre d'opérations déterminé par le minimum du nb d'absences et de celui de présences. 7 | #' Le sous-échantillonnage est contraint par année. 8 | #' 9 | #' 10 | #' @param df Dataframe avec les variables valeur_parametre, esp_code_alternatif, presence, parametre, n. 11 | #' @param seed Numérique. La racine du générateur de nombres aléatoires pour le tirage. 12 | #' @return Un dataframe issu de df mais avec moins de lignes. 13 | #' @export 14 | #' 15 | #' @importFrom dplyr group_by ungroup left_join select mutate filter 16 | #' @importFrom tidyr nest unnest 17 | #' @importFrom purrr map2 18 | #' @importFrom utils data 19 | #' 20 | #' @examples 21 | #' \dontrun{ 22 | #' df_allege <- mef_ssech_esp_env(df = df_pres_abs_env) 23 | #' } 24 | mef_ssech_esp_env <- function(df, seed = 123) 25 | 26 | { 27 | set.seed = seed 28 | 29 | pres_abs_env <- df %>% 30 | mef_compter_pres_abs_env() %>% 31 | mutate(n_ssech = ifelse(absences < presences, absences, presences)) %>% 32 | filter(n_ssech > 0) # sinon le sample_n bloque 33 | 34 | # split des données en dataframes selon espece x presence / absence 35 | # le right_join exclut les cas où n_ssech est NA 36 | df_nested <- df %>% 37 | right_join(y = pres_abs_env %>% 38 | select(esp_code_alternatif, parametre, annee)) %>% 39 | group_by(esp_code_alternatif, 40 | presence, 41 | parametre, 42 | annee) %>% 43 | nest() %>% 44 | ungroup() %>% 45 | left_join( 46 | y = pres_abs_env %>% 47 | select(esp_code_alternatif, 48 | parametre, 49 | n_ssech, 50 | annee), 51 | by = c("esp_code_alternatif", "parametre", "annee") 52 | ) 53 | 54 | # sous-échantillonnage 55 | df_ssech <- df_nested %>% 56 | mutate(ssech = map2( 57 | .x = data, 58 | .y = n_ssech, 59 | .f = sample_n, 60 | replace = FALSE 61 | )) 62 | 63 | # assemblage 64 | df <- df_ssech %>% 65 | select(-data) %>% 66 | unnest(ssech) 67 | 68 | # allègement du dataframe 69 | df <- df %>% 70 | select(-n_ssech) %>% 71 | mutate(parametre = as.factor(parametre), 72 | annee = as.integer(annee)) 73 | 74 | df 75 | 76 | 77 | } 78 | -------------------------------------------------------------------------------- /R/misc_charger_donnees_test.R: -------------------------------------------------------------------------------- 1 | #' Charger un extrait de la base Aspe qui permet d'effectuer des tests 2 | #' 3 | #' Ces données servent aussi aux vignettes. 4 | #' 5 | #' @return Les dataframes dans l'environnement de travail. 6 | #' @export 7 | #' 8 | #' @importFrom purrr map 9 | #' 10 | #' @examples 11 | #' \dontrun{ 12 | #' # chargement des données 13 | #' misc_charger_donnees_test() 14 | #' 15 | #' # vérification que les dataframes sont bien accessibles 16 | #' ls() 17 | #' 18 | #' # assemblage du jeu de données 19 | #' passerelle <- aspe::mef_creer_passerelle() 20 | #' } 21 | misc_charger_donnees_test <- function(){ 22 | all_dfs <- list.files(path = "../data", 23 | full.names = TRUE) 24 | 25 | data_dfs <- list.files(path = "../data", 26 | full.names = TRUE, 27 | pattern = "^data_") 28 | 29 | test_dfs <- setdiff(all_dfs, data_dfs) 30 | 31 | map(.x = test_dfs, 32 | .f = load, 33 | envir = .GlobalEnv) 34 | } 35 | -------------------------------------------------------------------------------- /R/misc_derniere_date.R: -------------------------------------------------------------------------------- 1 | #' Obtenir la date maxi saisie dans la base Aspe 2 | #' 3 | #' Cette fonction extrait l'ensemble des champs contenant la chaîne de caractère "date" 4 | #' dans l'ensemble des dataframes, en prend le max et omettant les dates ultérieures 5 | #' à la date système. 6 | #' 7 | #' @return La date maximale trouvée 8 | #' @export 9 | #' 10 | #' @importFrom purrr map2 reduce 11 | #' @importFrom dplyr pull mutate filter 12 | #' @importFrom lubridate ymd 13 | #' @importFrom stringr str_sub 14 | #' 15 | #' @examples 16 | #' \dontrun{ 17 | #' date_max <- misc_derniere_date() 18 | #' } 19 | misc_derniere_date <- function() 20 | 21 | { 22 | 23 | vars <- 24 | expl_trouver_variable("date") # identifie les variables contenant la chaîne "date" et les tables 25 | 26 | map2( 27 | .x = vars$table, # pour chaque variable, collecte du max 28 | .y = vars$variable, 29 | .f = function(table, variable) { 30 | table %>% get() %>% pull(variable) %>% max(na.rm = TRUE) 31 | } 32 | ) %>% 33 | reduce(rbind) %>% 34 | as.data.frame() %>% 35 | mutate(date_max = str_sub(V1, 1, 10), # pour homogénéiser entre ymd et ymd_hms 36 | date_max = lubridate::ymd(date_max)) %>% # passage en format date 37 | filter(date_max < Sys.Date()) %>% # suppression des dates ultérieures à aujourd'hui 38 | pull(date_max) %>% 39 | max(na.rm = TRUE) # max des max 40 | 41 | } 42 | -------------------------------------------------------------------------------- /R/misc_nom_dernier_fichier.R: -------------------------------------------------------------------------------- 1 | #' Obtenir le nom du plus récent des fichiers 2 | #' 3 | #' @description Recherche dans un répertoire, parmi les fichiers dont le nom correspond au pattern, 4 | #' celui qui est le dernier créé. 5 | #' 6 | #' @param repertoire Chaîne de caractère. Chemin vers le répertoire à explorer. 7 | #' Par défaut c'est le répertoire de travail. 8 | #' @param pattern Chaîne de caractère (exprtession régulière) à retrouver dans le nom du fichier. 9 | #' @param recursive Booléen (TRUE ou FALSE). Indique si la recherche inclut les sous-répertoire. 10 | #' La valeur par défaut est FALSE donc les sous-répertoires sont exclus de la recherche. 11 | #' 12 | #' @return Le nom du plus récent des fichiers respectant la condition indiquée au pattern. 13 | #' @export 14 | #' 15 | #' @importFrom dplyr filter 16 | #' 17 | #' @examples 18 | #' \dontrun{ 19 | #' mon_fichier <- misc_nom_dernier_fichier(repertoire = "raw_data", pattern = "RData$") 20 | #' } 21 | misc_nom_dernier_fichier <- 22 | function(repertoire = NULL, 23 | pattern, 24 | recursive = FALSE) { 25 | 26 | if(is.null(repertoire)) {repertoire <- getwd()} 27 | 28 | list.files( 29 | path = repertoire, 30 | pattern = pattern, 31 | full.names = TRUE, 32 | recursive = recursive 33 | ) %>% 34 | file.info() %>% 35 | filter(ctime == max(ctime)) %>% 36 | rownames() 37 | 38 | } 39 | -------------------------------------------------------------------------------- /R/utils.R: -------------------------------------------------------------------------------- 1 | #' Taguer en dataframes ou non les objets dans globalEnv 2 | #' 3 | #' @return Booléen. Vecteur indiquant lesquels des objets sont des dataframes 4 | #' 5 | #' @noRd 6 | #' 7 | #' @examples 8 | #' \dontrun{ 9 | #' # load some data 10 | #' misc_charger_donnees_test() 11 | #' 12 | #' a <- 1 13 | #' b <- "zegj" 14 | #' 15 | #' # tag the objects in the environment 16 | #' tags <- lister_dfs() 17 | #' 18 | #' # assemble and view 19 | #' data.frame(name = ls(), 20 | #' tags) %>% 21 | #' View 22 | #' } 23 | lister_dfs <- function() 24 | 25 | { 26 | objets <- ls(envir = globalenv()) 27 | 28 | test_1obj <- function(obj) { 29 | is.data.frame(get(obj)) 30 | } 31 | 32 | test <- map(.x = objets, 33 | .f = test_1obj) 34 | 35 | test %>% 36 | unlist() 37 | 38 | } 39 | 40 | 41 | -------------------------------------------------------------------------------- /_pkgdown.yml: -------------------------------------------------------------------------------- 1 | # Workflow derived from https://github.com/r-lib/actions/tree/v2/examples 2 | # Need help debugging build failures? Start at https://github.com/r-lib/actions#where-to-find-help 3 | on: 4 | push: 5 | branches: [main, master] 6 | pull_request: 7 | branches: [main, master] 8 | release: 9 | types: [published] 10 | workflow_dispatch: 11 | 12 | name: pkgdown 13 | 14 | jobs: 15 | pkgdown: 16 | runs-on: ubuntu-latest 17 | # Only restrict concurrency for non-PR jobs 18 | concurrency: 19 | group: pkgdown-${{ github.event_name != 'pull_request' || github.run_id }} 20 | env: 21 | GITHUB_PAT: ${{ secrets.GITHUB_TOKEN }} 22 | steps: 23 | - uses: actions/checkout@v3 24 | 25 | - uses: r-lib/actions/setup-pandoc@v2 26 | 27 | - uses: r-lib/actions/setup-r@v2 28 | with: 29 | use-public-rspm: true 30 | 31 | - uses: r-lib/actions/setup-r-dependencies@v2 32 | with: 33 | extra-packages: any::pkgdown, local::. 34 | needs: website 35 | 36 | - name: Build site 37 | run: pkgdown::build_site_github_pages(new_process = FALSE, install = FALSE) 38 | shell: Rscript {0} 39 | 40 | - name: Deploy to GitHub pages 🚀 41 | if: github.event_name != 'pull_request' 42 | uses: JamesIves/github-pages-deploy-action@v4.4.1 43 | with: 44 | clean: false 45 | branch: gh-pages 46 | folder: docs 47 | 48 | url: https://pascalirz.github.io/aspe/ 49 | template: 50 | bootstrap: 5 51 | includes: 52 | after_body: > 53 | 55 | -------------------------------------------------------------------------------- /aspe.Rproj: -------------------------------------------------------------------------------- 1 | Version: 1.0 2 | 3 | RestoreWorkspace: No 4 | SaveWorkspace: No 5 | AlwaysSaveHistory: No 6 | 7 | EnableCodeIndexing: Yes 8 | UseSpacesForTab: Yes 9 | NumSpacesForTab: 2 10 | Encoding: UTF-8 11 | 12 | RnwWeave: Sweave 13 | LaTeX: pdfLaTeX 14 | 15 | AutoAppendNewline: Yes 16 | StripTrailingWhitespace: Yes 17 | 18 | BuildType: Package 19 | PackageUseDevtools: Yes 20 | PackageInstallArgs: --no-multiarch --with-keep.source 21 | PackageCheckArgs: --as-cran 22 | PackageRoxygenize: rd,collate,namespace,vignette 23 | -------------------------------------------------------------------------------- /data-raw/data_dictionnaire.R: -------------------------------------------------------------------------------- 1 | ## Dictionnaire de données 2 | 3 | # Le intitulés détaillés des champs sont stockés dans le dump de la base sous forme de commentaires. 4 | # Ils peuvent être extraits par la fonction `expl_commentaires_champs()` du package `aspe`. 5 | 6 | # recherche du nom du fichier le plus récent au format .gz dans le répertoire des données brutes 7 | dump <- aspe::misc_nom_dernier_fichier(repertoire = "../../raw_data", 8 | pattern = "gz$") 9 | 10 | # extraction des commentaires 11 | data_dictionnaire <- expl_commentaires_champs(fichier_dump = dump) 12 | 13 | DT::datatable(data_dictionnaire, 14 | rownames = FALSE) 15 | 16 | usethis::use_data(data_dictionnaire, overwrite = T) 17 | 18 | -------------------------------------------------------------------------------- /data-raw/data_liste_rouge.R: -------------------------------------------------------------------------------- 1 | # Listes rouges des poissons et des crustacés 2 | 3 | ## Les données sont téléchargées depuis [https://inpn.mnhn.fr/espece/listerouge/fr/poissons_eau_douce_metropole_2019](https://inpn.mnhn.fr/espece/listerouge/fr/poissons_eau_douce_metropole_2019). 4 | 5 | poissons <- read_csv2("inst/extdata/2019_fish_RL_mainland_FR__202173.csv") %>% 6 | rename(esp_code_taxref = CD_REF) %>% 7 | left_join(data_passerelle_taxo) %>% 8 | filter(!NOMS_COMMUNS == "Saumon de l'Allier") %>% # sous-espèce de TRF 9 | select(esp_nom_latin, 10 | esp_code_taxref, 11 | esp_code_alternatif, 12 | endemisme = ENDEMISME, 13 | statut_lr_fr = STATUT, 14 | tendance_lr_fr = TENDANCE, 15 | statut_lr_int = STATUT_I, 16 | statut_lr_eu = STATUT_EU 17 | ) %>% 18 | mutate_at(vars(starts_with("statut_lr")), 19 | fct_relevel, 20 | c("DD", "LC", "NT", "VU", "EN", "CR", "EX")) %>% 21 | filter(!is.na(esp_code_alternatif)) 22 | 23 | ecrevisses <- read_csv2("inst/extdata/2012_crustacea_RL_mainland_FR_202245.csv") %>% 24 | rename(esp_code_taxref = CD_REF) %>% 25 | right_join(data_passerelle_taxo) %>% 26 | filter(!is.na(CD_NOM)) %>% 27 | select(esp_nom_latin, 28 | esp_code_taxref, 29 | esp_code_alternatif, 30 | endemisme = ENDEMISME, 31 | statut_lr_fr = STATUT, 32 | tendance_lr_fr = TENDANCE, 33 | statut_lr_int = STATUT_I, 34 | statut_lr_eu = STATUT_EU 35 | ) %>% 36 | mutate_at(vars(starts_with("statut_lr")), 37 | as.factor) %>% 38 | mutate_at(vars(starts_with("statut_lr")), 39 | fct_relevel, 40 | c("DD", "LC", "NT", "VU", "EN", "CR", "EX")) %>% 41 | filter(!is.na(esp_code_alternatif)) 42 | 43 | data_liste_rouge <- rbind(poissons, 44 | ecrevisses) 45 | 46 | 47 | usethis::use_data(data_liste_rouge, overwrite = T) 48 | 49 | -------------------------------------------------------------------------------- /data-raw/data_passerelle_taxo.R: -------------------------------------------------------------------------------- 1 | ## Table de correspondance taxonomique 2 | 3 | # Les données sont téléchargées depuis 4 | # https://api.sandre.eaufrance.fr/referentiels/v1/apt.csv?compress=true&filter=CodeAlternatifAp/OrgCdAlternatifASPE 5 | # et stockées dans inst/extdata 6 | 7 | library(tidyverse) 8 | 9 | 10 | 11 | # lecture 12 | df <- readr::read_csv2("inst/extdata/APT_20230718_SANDRE.csv") %>% 13 | select(CdAppelTaxon, 14 | starts_with("OrgCdAlternatif"), 15 | starts_with("CdAlternatif")) %>% 16 | slice(-1) 17 | 18 | organismes <- df %>% 19 | select(CdAppelTaxon, 20 | starts_with("OrgCdAlternatif")) %>% 21 | pivot_longer(cols = OrgCdAlternatif1:OrgCdAlternatif11, 22 | names_to = "variable", 23 | values_to = "organisme") %>% 24 | mutate(variable = str_replace(variable, pattern = "OrgCd", replacement = "")) 25 | 26 | codes <- df %>% 27 | select(CdAppelTaxon, 28 | starts_with("CdAlternatif")) %>% 29 | pivot_longer(cols = CdAlternatif1:CdAlternatif11, 30 | names_to = "variable", 31 | values_to = "code") %>% 32 | mutate(variable = str_replace(variable, pattern = "Cd", replacement = "")) 33 | 34 | passerelle_taxo <- organismes %>% 35 | left_join(codes) %>% 36 | # cbind(codes %>% select(-CdAppelTaxon)) %>% 37 | filter(organisme %in% c("ASPE", "TAXREF")) 38 | 39 | mes_codes_sandre <- passerelle_taxo %>% 40 | filter(organisme == "ASPE") %>% 41 | pull(CdAppelTaxon) %>% 42 | unique() 43 | 44 | passerelle_taxo <- passerelle_taxo %>% 45 | filter(CdAppelTaxon %in% mes_codes_sandre) %>% 46 | select(CdAppelTaxon, organisme, code) %>% 47 | pivot_wider(names_from = organisme, 48 | values_from = code) %>% 49 | rename(esp_code_sandre = CdAppelTaxon, 50 | esp_code_alternatif = ASPE, 51 | esp_code_taxref = TAXREF) 52 | 53 | # jointure avec le ref_espece de la base aspe 54 | data_passerelle_taxo <- passerelle_taxo %>% 55 | left_join(y = ref_espece %>% 56 | select(esp_id, 57 | esp_code_alternatif, 58 | esp_nom_latin)) %>% 59 | mutate( 60 | esp_code_taxref = case_when( 61 | is.na(esp_code_taxref) & esp_nom_latin == "Cyprinus carpio" ~ 67058, 62 | is.na(esp_code_taxref) & esp_code_alternatif == "GFL" ~ 70166, 63 | is.na(esp_code_taxref) & esp_code_alternatif == "MUC" ~ 69772, 64 | is.na(esp_code_taxref) & esp_code_alternatif == "CAA" ~ 67208, 65 | is.na(esp_code_taxref) & esp_code_alternatif == "VAX" ~ 194072, 66 | TRUE ~ as.double(esp_code_taxref) 67 | ) 68 | ) %>% 69 | filter(esp_code_sandre != 2094) # pb de l'ancien code de l'aspe qui traine dans le référentiel 70 | 71 | 72 | usethis::use_data(data_passerelle_taxo, overwrite = T) 73 | 74 | -------------------------------------------------------------------------------- /data-raw/data_protection_especes.R: -------------------------------------------------------------------------------- 1 | ## Protection réglementaire 2 | 3 | # La liste des espèces de poissons protégées sur l'ensemble du territoire national est donnée 4 | # par l'arrêté du 8 décembre 1988 fixant la liste des espèces de poissons protégées sur l'ensemble 5 | # du territoire national. 6 | # Celle des écrevisses l'est par l'arrêté du 21 juillet 1983 relatif à la protection des écrevisses autochtones. 7 | 8 | library(tidyverse) 9 | 10 | data_protection_especes <- readxl::read_xlsx("inst/extdata/species_protection_status.xlsx") 11 | 12 | usethis::use_data(data_protection_especes, overwrite = T) 13 | 14 | -------------------------------------------------------------------------------- /data-raw/data_traits_bio.R: -------------------------------------------------------------------------------- 1 | ### Code pour assemblar la table de traits depuis https://www.freshwaterecology.info/ ---- 2 | 3 | # chargement packages 4 | library(aspe) 5 | library(dplyr) 6 | 7 | # tableau de traits 8 | # téléchargé depuis https://www.freshwaterecology.info/ en juillet 2023. 9 | data_traits_bio <- readxl::read_xlsx("inst/extdata/freshwaterecology.info_species_traits.xlsx") %>% 10 | select(-Numéro) %>% 11 | rename(esp_nom_latin = Species, 12 | reference_species = `Espèce modèle`) %>% 13 | # recodage pour être en phase avec le réferentiel espèces de la base Aspe 14 | mutate(esp_nom_latin = case_when( 15 | esp_nom_latin == "Salmo trutta trutta" ~ "Salmo trutta", 16 | TRUE ~ esp_nom_latin)) 17 | 18 | # Vérifications ---- 19 | # Quelles espèces sont présentes dans la base sans correspondance avec la base de traits ? 20 | 21 | ## chargement des données Aspe 22 | rdata_tables <- 23 | misc_nom_dernier_fichier(repertoire = "../../raw_data/rdata", 24 | pattern = "^tables") 25 | 26 | load(file = rdata_tables) 27 | 28 | ## assemblage du jeu de données 29 | captures <- mef_creer_passerelle() %>% # création de la passerelle 30 | mef_ajouter_lots() %>% # ajout des lots 31 | mef_ajouter_esp() %>% 32 | group_by(esp_code_alternatif, 33 | esp_nom_latin, 34 | esp_nom_commun) %>% 35 | summarise(effectif = sum(lop_effectif, na.rm = TRUE)) %>% 36 | ungroup() %>% 37 | # recodages (temporaire ; à supprimer pour l'essentiel quand le référentiel taxo Aspe sera Ok) 38 | mutate(esp_nom_latin = case_when( 39 | esp_nom_latin == "Leuciscus cephalus" ~ "Squalius cephalus", 40 | esp_nom_latin == "Atherinapresbyter" ~ "Atherina presbyter", 41 | esp_nom_latin == "Gymnocephalus cernuus" ~ "Gymnocephalus cernua", 42 | esp_nom_latin == "Carassius auratus auratus" ~ "Carassius auratus", 43 | TRUE ~ esp_nom_latin)) 44 | 45 | # jointure entre données Aspe et tableau de traits 46 | taxons_sans_traits <- captures %>% 47 | anti_join(y = data_traits_bio) %>% 48 | arrange(-effectif) %>% 49 | filter(!str_detect(esp_nom_commun, "indétermi|Ecrevis|Crab|Hybrid")) 50 | 51 | data_traits_bio <- data_traits_bio %>% 52 | left_join(captures) %>% 53 | select(esp_code_alternatif, 54 | esp_nom_latin, 55 | esp_nom_commun, 56 | `acid tolerance`:`reproduction (fiBS)`) %>% 57 | filter(!is.na(esp_code_alternatif)) 58 | 59 | 60 | 61 | 62 | # si le dataframe test ne montre aucun taxon inattendu c'est Ok 63 | usethis::use_data(data_traits_bio, overwrite = T) 64 | 65 | -------------------------------------------------------------------------------- /data/classe_ipr.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/classe_ipr.rda -------------------------------------------------------------------------------- /data/data_dictionnaire.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/data_dictionnaire.rda -------------------------------------------------------------------------------- /data/data_liste_rouge.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/data_liste_rouge.rda -------------------------------------------------------------------------------- /data/data_passerelle_taxo.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/data_passerelle_taxo.rda -------------------------------------------------------------------------------- /data/data_protection_especes.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/data_protection_especes.rda -------------------------------------------------------------------------------- /data/data_taille_poids.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/data_taille_poids.rda -------------------------------------------------------------------------------- /data/data_traits_bio.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/data_traits_bio.rda -------------------------------------------------------------------------------- /data/lot_poissons.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/lot_poissons.rda -------------------------------------------------------------------------------- /data/mesure_individuelle.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/mesure_individuelle.rda -------------------------------------------------------------------------------- /data/operation.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/operation.rda -------------------------------------------------------------------------------- /data/operation_description_peche.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/operation_description_peche.rda -------------------------------------------------------------------------------- /data/operation_donnees_environnementales.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/operation_donnees_environnementales.rda -------------------------------------------------------------------------------- /data/operation_ipr.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/operation_ipr.rda -------------------------------------------------------------------------------- /data/operation_objectif.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/operation_objectif.rda -------------------------------------------------------------------------------- /data/point_prelevement.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/point_prelevement.rda -------------------------------------------------------------------------------- /data/prelevement_elementaire.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/prelevement_elementaire.rda -------------------------------------------------------------------------------- /data/ref_espece.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_espece.rda -------------------------------------------------------------------------------- /data/ref_logique_3.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_logique_3.rda -------------------------------------------------------------------------------- /data/ref_logique_4.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_logique_4.rda -------------------------------------------------------------------------------- /data/ref_moyen_prospection.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_moyen_prospection.rda -------------------------------------------------------------------------------- /data/ref_objectif.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_objectif.rda -------------------------------------------------------------------------------- /data/ref_protocole.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_protocole.rda -------------------------------------------------------------------------------- /data/ref_type_longueur.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_type_longueur.rda -------------------------------------------------------------------------------- /data/ref_type_lot.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_type_lot.rda -------------------------------------------------------------------------------- /data/ref_type_prelevement_elementaire.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_type_prelevement_elementaire.rda -------------------------------------------------------------------------------- /data/ref_type_projection.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/ref_type_projection.rda -------------------------------------------------------------------------------- /data/station.rda: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/data/station.rda -------------------------------------------------------------------------------- /inst/CITATION: -------------------------------------------------------------------------------- 1 | year <- sub("-.*", "", meta$Date) 2 | version <- meta$Version 3 | note <- sprintf("R package version %s", version) 4 | 5 | citHeader("To cite package aspe in publications use:") 6 | 7 | bibentry( 8 | bibtype = "Manual", 9 | title = "aspe: An R Package to Analyse and Visualise River Fish Data in France", 10 | author = c(as.person("P. Irz"), as.person("C. Mondy"), as.person("B. Richard"), as.person("E. Dortel"), as.person("L. Bonnafoux")), 11 | journal = "Github repo", 12 | year = year, 13 | volume = note, 14 | url = "https://github.com/PascalIrz/aspe/", 15 | textVersion = paste0("Irz, P., Mondy, C., Richard, B., Dortel, E. and Bonnafoux, L. (", 16 | year, 17 | "). aspe: An R Package to Analyse and Visualise River Fish Data in France. ", 18 | note, ", ", 19 | "https://github.com/PascalIrz/aspe/" 20 | ) 21 | ) 22 | -------------------------------------------------------------------------------- /inst/extdata/freshwaterecology.info_species_traits.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/inst/extdata/freshwaterecology.info_species_traits.xlsx -------------------------------------------------------------------------------- /inst/extdata/species_protection_status.xlsx: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/inst/extdata/species_protection_status.xlsx -------------------------------------------------------------------------------- /inst/extdata/species_traits.xlsx.old: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/inst/extdata/species_traits.xlsx.old -------------------------------------------------------------------------------- /man/aspe-package.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/aspe-package.R 3 | \docType{package} 4 | \name{aspe-package} 5 | \alias{aspe} 6 | \alias{aspe-package} 7 | \title{aspe: An R Package to Analyse and Visualise River Fish Data in France} 8 | \description{ 9 | The aspe package provides a suite of tools for most of the common processing of the ASPE database \doi{10.1051/kmae/2022021}, including importation of the tables from a dump of the PostGreSQL database, calculation of abundances, densities, size distributions, along with graphical output and spatial processing. 10 | } 11 | \seealso{ 12 | Useful links: 13 | \itemize{ 14 | \item \url{https://github.com/PascalIrz/aspe/} 15 | \item \doi{10.5281/zenodo.7458005} 16 | \item \url{https://pascalirz.github.io/aspe/} 17 | \item Report bugs at \url{https://github.com/PascalIrz/aspe/issues} 18 | } 19 | 20 | } 21 | \author{ 22 | \strong{Maintainer}: Pascal Irz \email{pascal.irz@ofb.gouv.fr} (\href{https://orcid.org/0000-0002-2066-8935}{ORCID}) 23 | 24 | Other contributors: 25 | \itemize{ 26 | \item Cédric Mondy \email{cedric.mondy@ofb.gouv.fr} (\href{https://orcid.org/0000-0003-2788-0936}{ORCID}) [contributor] 27 | \item Benoît Richard \email{benoit.richard@ofb.gouv.fr} (\href{https://orcid.org/0000-0003-4522-027X}{ORCID}) [contributor] 28 | \item Emmanuelle Dortel \email{emmanuelle.dortel@cefe.cnrs.fr} [contributor] 29 | \item Lilian Bonnafoux \email{l.bonnafoux@peche63.com} [contributor] 30 | } 31 | 32 | } 33 | \keyword{internal} 34 | -------------------------------------------------------------------------------- /man/data_dictionnaire.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/data_dictionnaire.R 3 | \docType{data} 4 | \name{data_dictionnaire} 5 | \alias{data_dictionnaire} 6 | \title{Signification des champs de la base Aspe} 7 | \format{ 8 | An object of class \code{data.frame} with 742 rows and 3 columns. 9 | } 10 | \usage{ 11 | data(data_dictionnaire) 12 | } 13 | \description{ 14 | Signification des champs de la base Aspe 15 | } 16 | \examples{ 17 | \donttest{ 18 | data(data_dictionnaire) 19 | data_dictionnaire} 20 | } 21 | \keyword{datasets} 22 | -------------------------------------------------------------------------------- /man/data_liste_rouge.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/data_liste_rouge.R 3 | \docType{data} 4 | \name{data_liste_rouge} 5 | \alias{data_liste_rouge} 6 | \title{Données sur le statut liste rouge des espèces de poissons} 7 | \format{ 8 | An object of class \code{tbl_df} (inherits from \code{tbl}, \code{data.frame}) with 106 rows and 8 columns. 9 | } 10 | \usage{ 11 | data(data_liste_rouge) 12 | } 13 | \description{ 14 | Tableau avec en lignes desespèces de poissons et en colonnes les données sur le 15 | statut liste rouge de ces espèces. 16 | } 17 | \examples{ 18 | \donttest{ 19 | data(data_liste_rouge) 20 | data_liste_rouge} 21 | } 22 | \keyword{datasets} 23 | -------------------------------------------------------------------------------- /man/data_passerelle_taxo.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/data_passerelle_taxo.R 3 | \docType{data} 4 | \name{data_passerelle_taxo} 5 | \alias{data_passerelle_taxo} 6 | \title{Table de passage entre les identifiants des espèces} 7 | \format{ 8 | An object of class \code{tbl_df} (inherits from \code{tbl}, \code{data.frame}) with 266 rows and 5 columns. 9 | } 10 | \usage{ 11 | data(data_passerelle_taxo) 12 | } 13 | \description{ 14 | Tableau indiquant les correspondances entre les identifiants esp_id de la base Aspe, 15 | asp_code_alternatif à trois lettres, taxref, sandre et le nom latin. 16 | } 17 | \examples{ 18 | \donttest{ 19 | data(data_passerelle_taxo) 20 | data_passerelle_taxo} 21 | } 22 | \keyword{datasets} 23 | -------------------------------------------------------------------------------- /man/data_protection_especes.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/data_protection_especes.R 3 | \docType{data} 4 | \name{data_protection_especes} 5 | \alias{data_protection_especes} 6 | \title{Données sur la protection réglementaire des espèces (poissons et écrevisses)} 7 | \format{ 8 | An object of class \code{tbl_df} (inherits from \code{tbl}, \code{data.frame}) with 30 rows and 2 columns. 9 | } 10 | \usage{ 11 | data(data_protection_especes) 12 | } 13 | \description{ 14 | Tableau avec une ligne par espèce protégée et une colonne indiquant le texte de référence. 15 | } 16 | \examples{ 17 | \donttest{ 18 | data("data_protection_especes") 19 | data_protection_especes} 20 | } 21 | \keyword{datasets} 22 | -------------------------------------------------------------------------------- /man/data_taille_poids.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/data_taille_poids.R 3 | \docType{data} 4 | \name{data_taille_poids} 5 | \alias{data_taille_poids} 6 | \title{Relations taille - poids} 7 | \format{ 8 | An object of class \code{tbl_df} (inherits from \code{tbl}, \code{data.frame}) with 204 rows and 7 columns. 9 | } 10 | \usage{ 11 | data(data_taille_poids) 12 | } 13 | \description{ 14 | Tableau des relations taille calculées depuis la base ASPE ainsi que celles 15 | issues de Fishbase. Pour ces dernières, les paramètres a et b ont été moyennés par espèce 16 | en distinguant longueur fourche et longueur totale. 17 | NB : Les unités sont les mêmes que dans la base de référence Fishbase, 18 | à savoir pour la taille (en fait la longueur), le cm, et pour le poids (en fait 19 | la masse), le gramme. Si l'on utilise les données de la base ASPE, il faut donc 20 | opérer une conversion de longueur car celles-ci sont en mm. 21 | } 22 | \examples{ 23 | \donttest{ 24 | data(data_taille_poids) 25 | data_taille_poids} 26 | } 27 | \keyword{datasets} 28 | -------------------------------------------------------------------------------- /man/data_traits_bio.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/data_traits_bio.R 3 | \docType{data} 4 | \name{data_traits_bio} 5 | \alias{data_traits_bio} 6 | \title{Données sommaires sur les espèces de poissons} 7 | \format{ 8 | An object of class \code{tbl_df} (inherits from \code{tbl}, \code{data.frame}) with 87 rows and 20 columns. 9 | } 10 | \usage{ 11 | data(data_traits_bio) 12 | } 13 | \description{ 14 | Tableau d'une centaine de lignes correspondant aux espèces de poissons 15 | référencées par leur code à trois lettres et de colonnes précisant le 16 | statut de ces espèces ainsi que leur principaux habitats. 17 | } 18 | \examples{ 19 | \donttest{ 20 | data(data_traits_bio) 21 | data_traits_bio} 22 | } 23 | \keyword{datasets} 24 | -------------------------------------------------------------------------------- /man/def_attribut_id.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/def_attribut_id.R 3 | \name{def_attribut_id} 4 | \alias{def_attribut_id} 5 | \title{Définir les attributs des prélèvements} 6 | \usage{ 7 | def_attribut_id(df, var_id, var_tmp, var_pro = NULL) 8 | } 9 | \arguments{ 10 | \item{df}{dataframe} 11 | 12 | \item{var_id}{variable(s) identifiant les prélèvements} 13 | 14 | \item{var_tmp}{variable identifiant la date de prélèvement} 15 | 16 | \item{var_pro}{variable identifiant le protocole de pêche (optionnelle)} 17 | } 18 | \value{ 19 | tb data frame 20 | } 21 | \description{ 22 | Définir les attributs des prélèvements 23 | } 24 | \examples{ 25 | \dontrun{ 26 | df <- mef_creer_passerelle() \%>\% 27 | mef_ajouter_ope_date() \%>\% 28 | mef_ajouter_type_protocole() 29 | def_id <- def_attribut_id (var_id = pop_id, 30 | var_tmp = annee, 31 | var_pro = pro_libelle) 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /man/expl_commentaires_champs.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/expl_commentaires_champs.R 3 | \name{expl_commentaires_champs} 4 | \alias{expl_commentaires_champs} 5 | \title{Obtenir les commentaires qui donnent la signification des champs des tables} 6 | \usage{ 7 | expl_commentaires_champs(fichier_dump) 8 | } 9 | \arguments{ 10 | \item{fichier_dump}{Le chemin vers le fichier d'extension .sql (décompressé) ou 11 | .sql.gz (archive).} 12 | } 13 | \value{ 14 | Un dataframe avec pour chacun des champs sa table d'appartenance et sa signification. 15 | } 16 | \description{ 17 | Obtenir les commentaires qui donnent la signification des champs des tables 18 | } 19 | \examples{ 20 | \dontrun{ 21 | expl_commentaires_champs(fichier_dump = "../raw_data/dump.sql") 22 | } 23 | 24 | 25 | } 26 | -------------------------------------------------------------------------------- /man/expl_lister_champs.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/expl_lister_champs.R 3 | \name{expl_lister_champs} 4 | \alias{expl_lister_champs} 5 | \title{Lister les champs contenus dans les différents dataframes d'un fichier .RData} 6 | \usage{ 7 | expl_lister_champs(rdata) 8 | } 9 | \arguments{ 10 | \item{rdata}{Caractère. Chemin vers le fichier .RData} 11 | } 12 | \value{ 13 | Un dataframe avec pour chacun des champs (colonnes) son nom et celui de la table 14 | qui le contient 15 | } 16 | \description{ 17 | Lister les champs contenus dans les différents dataframes d'un fichier .RData 18 | } 19 | \examples{ 20 | \dontrun{ 21 | synthese <- expl_lister_champs('processed_data/toutes_tables_aspe_sauf_mei.RData') 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /man/expl_trouver_table.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/expl_trouver_table.R 3 | \name{expl_trouver_table} 4 | \alias{expl_trouver_table} 5 | \title{Rechercher les dataframes dont le nom contient un pattern} 6 | \usage{ 7 | expl_trouver_table(nom_contient) 8 | } 9 | \arguments{ 10 | \item{nom_contient}{Chaine de caractères recherchés parmi les noms des tables.} 11 | } 12 | \value{ 13 | Un vecteur caractères contenant les noms des tables. 14 | } 15 | \description{ 16 | Cette fonction est utile pour explorer la base quand on a une idée de ce que son nom 17 | peut contenir. Par exemple pour les tables liées au point on peut chercher, parmi les noms 18 | des dataframes chargés, ceux contenant la chaîne de caractères "point". 19 | } 20 | \examples{ 21 | \dontrun{ 22 | expl_trouver_table(nom_contient = "point") 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/expl_trouver_variable.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/expl_trouver_variable.R 3 | \name{expl_trouver_variable} 4 | \alias{expl_trouver_variable} 5 | \title{Rechercher les variables dont le nom contient un pattern} 6 | \usage{ 7 | expl_trouver_variable(nom_contient) 8 | } 9 | \arguments{ 10 | \item{nom_contient}{Chaine de caractères recherchés parmi les noms des variables 11 | des différentes tables.} 12 | } 13 | \value{ 14 | Un dataframe indiquant les noms de variables contenant la chaine recherchée 15 | ainsi que leur table d'appartenance. 16 | } 17 | \description{ 18 | Rechercher les variables dont le nom contient un pattern 19 | } 20 | \examples{ 21 | \dontrun{ 22 | expl_trouver_variable(nom_contient = "ope") 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/export_tables_csv.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/export_tables_csv.R 3 | \name{export_tables_csv} 4 | \alias{export_tables_csv} 5 | \title{Exporter tous les dataframes de l'environnement en csv} 6 | \usage{ 7 | export_tables_csv(repertoire = NA) 8 | } 9 | \arguments{ 10 | \item{repertoire}{Texte. Chemin vers le répertoire où les fichiers csv seront stockés.} 11 | } 12 | \value{ 13 | Les fichiers csv 14 | } 15 | \description{ 16 | Exporter tous les dataframes de l'environnement en csv 17 | } 18 | \examples{ 19 | \dontrun{ 20 | export_tables_csv(repertoire = "../output") 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /man/export_tables_rdata.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/export_tables_rdata.R 3 | \name{export_tables_rdata} 4 | \alias{export_tables_rdata} 5 | \title{Exporter les dataframes au format .RData} 6 | \usage{ 7 | export_tables_rdata(repertoire = NA, n_fichiers_mei = 1) 8 | } 9 | \arguments{ 10 | \item{repertoire}{Caractères. Chemin vers le répertoire où les fichiers seront écrits.} 11 | 12 | \item{n_fichiers_mei}{Entier. Nombre de fichiers pour découper le dataframe des mesures individuelles.} 13 | } 14 | \value{ 15 | Les fichiers sont sauvegardés dans le répertoire choisi. Si aucun chemin n'est indiqué, 16 | ça sera dans un sous-répertoire "processed_data" du répertoire de travail qui est créé au besoin. 17 | Par défaut (n_fichiers_mei = 1) les fichiers sont au nombre de deux, l'un pour les mesures individuelles et l'autre pour les 18 | autres tables. Ils sont respectivement nommés mei_aaaa_mm_jj_hh_mm_ss (d'après les dates et heures 19 | de la sauvegarde), et tables_sauf_mei_aaaa_mm_jj_hh_mm_ss. Si n_fichiers_mei est supérieur à 1, il faudra 20 | ultérieurement empiler (ex avec rbind) les différents dataframes mei pour reconstituer la table complète. 21 | } 22 | \description{ 23 | Exporter les dataframes au format .RData 24 | } 25 | \examples{ 26 | \dontrun{ 27 | export_tables_rdata() 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /man/figures/hex_logo_aspe.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/man/figures/hex_logo_aspe.png -------------------------------------------------------------------------------- /man/figures/lifecycle-archived.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecyclearchivedarchived -------------------------------------------------------------------------------- /man/figures/lifecycle-defunct.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecycledefunctdefunct -------------------------------------------------------------------------------- /man/figures/lifecycle-deprecated.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecycledeprecateddeprecated -------------------------------------------------------------------------------- /man/figures/lifecycle-experimental.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecycleexperimentalexperimental -------------------------------------------------------------------------------- /man/figures/lifecycle-maturing.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecyclematuringmaturing -------------------------------------------------------------------------------- /man/figures/lifecycle-questioning.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecyclequestioningquestioning -------------------------------------------------------------------------------- /man/figures/lifecycle-stable.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecyclestablestable -------------------------------------------------------------------------------- /man/figures/lifecycle-superseded.svg: -------------------------------------------------------------------------------- 1 | lifecyclelifecyclesupersededsuperseded -------------------------------------------------------------------------------- /man/geo_aggr_richesse.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/geo_aggr_richesse.R 3 | \name{geo_aggr_richesse} 4 | \alias{geo_aggr_richesse} 5 | \title{Aggréger les richesses par entité hydrographique} 6 | \usage{ 7 | geo_aggr_richesse( 8 | ope_geo_data, 9 | echelle = c("Zone_Hydro", "Sous_Secteur_Hydro", "Secteur_Hydro", "Region_Hydro"), 10 | bassin_geo_poly 11 | ) 12 | } 13 | \arguments{ 14 | \item{ope_geo_data}{Objet de classe sf contenant les captures par opération.} 15 | 16 | \item{echelle}{Caractère. Au choix entre "ZoneHydro", "SousSecteurHydro", "SecteurHydro" 17 | et "RegionHydro".} 18 | 19 | \item{bassin_geo_poly}{Objet de classe sf contenant les polygones délimitant les 20 | entités hydrographiques.} 21 | } 22 | \value{ 23 | Un dataframe avec les richesses par entité hydrographique. 24 | } 25 | \description{ 26 | Calculer à partir des données Aspe le nombre d'espèces différentes recensées par 27 | Zone HYdro, Sous-secteur Hydro, Secteur Hydro ou Région hydro. 28 | } 29 | \details{ 30 | Comme la fonction effectue une jointure entre les inventaires et les entités hydrographiques, 31 | il faut que les deux objets géographiques aient au moins un nom de champ en commun. 32 | } 33 | \examples{ 34 | \dontrun{ 35 | richesse_par_unite_spatiale <- geo_aggr_richesse(ope_geo_data = data_geo, 36 | echelle = "Secteur_Hydro", 37 | bassin_geo_poly = bv_simp) 38 | } 39 | } 40 | -------------------------------------------------------------------------------- /man/geo_ajouter_crs.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/geo_ajouter_crs.R 3 | \name{geo_ajouter_crs} 4 | \alias{geo_ajouter_crs} 5 | \title{Ajouter le code EPSG du CRS à un dataframe} 6 | \usage{ 7 | geo_ajouter_crs(df, var_id_crs) 8 | } 9 | \arguments{ 10 | \item{df}{Le dataframe de données.} 11 | 12 | \item{var_id_crs}{Caractère. Le nom de la variable qui contient l'identifiant du CRS 13 | au sens de la variable "typ_id" du dataframe "ref_type_projection" de la base Aspe. 14 | selon la} 15 | } 16 | \value{ 17 | Le dataframe complété. 18 | } 19 | \description{ 20 | Ajouter le code EPSG du CRS à un dataframe 21 | } 22 | \examples{ 23 | \dontrun{ 24 | pop <- point_prelevement \%>\% 25 | geo_ajouter_crs(var_id_crs = pop_typ_id) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /man/geo_attribuer.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/geo_attribuer.R 3 | \name{geo_attribuer} 4 | \alias{geo_attribuer} 5 | \title{Rajouter à l'objet sf des points de prélèvement les départements et (ou) les bassins auxquels 6 | ils appartiennent.} 7 | \usage{ 8 | geo_attribuer(points_geo, poly_sf, crs_sortie = NA) 9 | } 10 | \arguments{ 11 | \item{points_geo}{Objet sf des points qui se verront attribuer des poilygones. 12 | points_geo doit avoir un CRS.} 13 | 14 | \item{poly_sf}{Objet sf des polygones à attribuer (ex: départements, secteurs hydro).} 15 | 16 | \item{crs_sortie}{Numérique. Identifiant EPSG du CRS de sortie. Par défaut, c'est celui de 17 | points_geo.} 18 | } 19 | \value{ 20 | L'bjet sf des points de prélèvement complété des informations sur les départements 21 | et les bassins. 22 | } 23 | \description{ 24 | Rajouter à l'objet sf des points de prélèvement les départements et (ou) les bassins auxquels 25 | ils appartiennent. 26 | } 27 | \examples{ 28 | \dontrun{ 29 | points_geo <- points_geo \%>\% 30 | geo_attribuer(poly_sf = secteurs_hydro_carthage) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /man/geo_convertir_coords_df.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/geo_convertir_coords_df.R 3 | \name{geo_convertir_coords_df} 4 | \alias{geo_convertir_coords_df} 5 | \title{Extraire des coordonnées homogénéisées à partir d'un dataframe contenant des coordonnées en différents CRS} 6 | \usage{ 7 | geo_convertir_coords_df( 8 | df, 9 | var_x, 10 | var_y, 11 | var_id, 12 | var_crs_initial, 13 | crs_sortie = 4326 14 | ) 15 | } 16 | \arguments{ 17 | \item{df}{Dataframe contenant au moins trois colonnes pour les coordonnées et le 18 | système de coordonnées (CRS)} 19 | 20 | \item{var_x}{Colonne qui contient la longitude.} 21 | 22 | \item{var_y}{Colonne qui contient la latitude.} 23 | 24 | \item{var_id}{Colonne qui contient les identifiants des objets (=lignes) de df.} 25 | 26 | \item{var_crs_initial}{Colonne qui contient le numéro EPSG du CRS de chacune 27 | des observations (par exemple des stations ou des points).} 28 | 29 | \item{crs_sortie}{Numérique entier. Le numéro EPSG du CRS de sortie. Par défaut 30 | c'est en WGS84 (crs = 4326).} 31 | } 32 | \value{ 33 | Un dataframe à deux colonnes contenant les coordonnées dans le CRS de sortie. 34 | } 35 | \description{ 36 | Les observations (lignes du df) sont reprojetées dans le CRS de sortie. 37 | } 38 | \details{ 39 | Le dataframe d'entrée doit comprendre des colonnes indiquant longitude, latitude, 40 | code EPSG du système de coordonnées, identifiant de l'observation. 41 | } 42 | \examples{ 43 | \dontrun{ 44 | # Comme la table station de la base Aspe ne comprend pas le code EPSG mais un code de CRS interne, 45 | # il faut le rajouter avant la conversion. 46 | data <- station \%>\% 47 | left_join(y = ref_type_projection, by = c("sta_typ_id" = "typ_id")) 48 | 49 | coords_wgs84 <- geo_convertir_coords_df (df = data, 50 | var_x = sta_coordonnees_x, 51 | var_y = sta_coordonnees_y, 52 | var_id = sta_id, 53 | var_crs_initial = typ_code_epsg) 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /man/gg_ajouter_arriere_plan_int.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_ajouter_arriere_plan_int.R 3 | \name{gg_ajouter_arriere_plan_int} 4 | \alias{gg_ajouter_arriere_plan_int} 5 | \title{Ajouter un arrière plan de classes à un ggplot} 6 | \usage{ 7 | gg_ajouter_arriere_plan_int(graphique, df_classes) 8 | } 9 | \arguments{ 10 | \item{graphique}{Graphique ggplot.} 11 | 12 | \item{df_classes}{Dataframe contenant les limites de classes comme classe_ipr.} 13 | } 14 | \value{ 15 | Le graphique complété par son arrière-plan coloré. 16 | } 17 | \description{ 18 | Ajouter un arrière plan de classes à un ggplot 19 | } 20 | \examples{ 21 | \dontrun{ 22 | ggplot(data = data) \%>\% 23 | gg_ajouter_arriere_plan_int() 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /man/gg_colo_ext_pops.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_colo_ext_pops.R 3 | \name{gg_colo_ext_pops} 4 | \alias{gg_colo_ext_pops} 5 | \title{Produire le graphique de la dynamique du peuplement pour chacun des points de prélèvement 6 | du dataframe} 7 | \usage{ 8 | gg_colo_ext_pops(df, interactif = FALSE, largeur = 6, hauteur = 5, ...) 9 | } 10 | \arguments{ 11 | \item{df}{Le dataframe contenant les données, mises en forme par la fonction \code{\link[=mef_colo_ext_pops]{mef_colo_ext_pops()}}} 12 | 13 | \item{interactif}{Valeur logique définissant le type de graphique produit: statique (FALSE) ou interactif (TRUE)} 14 | 15 | \item{largeur, hauteur}{dimensions des graphiques interactifs} 16 | 17 | \item{...}{arguments passés à la fonction \code{ggiraph::opts_sizing()}} 18 | } 19 | \value{ 20 | Une liste contenant les graphiques produits avec ggplot2. 21 | } 22 | \description{ 23 | Produire le graphique de la dynamique du peuplement pour chacun des points de prélèvement 24 | du dataframe 25 | } 26 | \examples{ 27 | \dontrun{ 28 | mes_graphiques <- gg_colo_ext_pops(df = mon_df) 29 | mes_graphiques[[1]] 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /man/gg_density_env_esp.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_density_env_esp.R 3 | \name{gg_density_env_esp} 4 | \alias{gg_density_env_esp} 5 | \title{Produire le graphique des distributions comparées des paramètres environnementaux 6 | entre les sites de présence et d'absence d'une espèce.} 7 | \usage{ 8 | gg_density_env_esp( 9 | df, 10 | espece, 11 | parametres = NA, 12 | quantile_max = 0.99, 13 | log = c("surface_bv", "distance_source", "pente", "largeur"), 14 | coul_pres = "blue", 15 | coul_abs = "red" 16 | ) 17 | } 18 | \arguments{ 19 | \item{df}{Le dataframe contenant les données environnementales et les présences / absences des 20 | espèces, par opération, avec les champs parametre, valeur_parametre, esp_code_alternatif, 21 | presence.} 22 | 23 | \item{espece}{Caractère. Code trois lettres de l'espèce (ex : "BRO" pour le brochet).} 24 | 25 | \item{parametres}{Vecteur caractère listant des paramètres environnementaux 26 | à représenter. Par défaut toutes les modalités de la variale "parametre" sont représentées.} 27 | 28 | \item{quantile_max}{Numérique sur l'intervalle 0-1. Sert à exclure les valeurs extrêmes 29 | si nécessaire pour les représentations graphiques. Par exemple quantile_max = 0.99 signifie 30 | que les 1p100 des valeurs les plus élevées sont exclues.} 31 | 32 | \item{log}{Vecteur caractère listant celles des variables environnementales pour lesquelles 33 | l'axe des absisses est en échelle log. Par défaut ce sont les variables surface_bv, 34 | distance_source, pente et largeur.} 35 | 36 | \item{coul_pres}{Caractère. Couleur ou code hexadécimal couleur pour les présences.} 37 | 38 | \item{coul_abs}{Caractère. Couleur ou code hexadécimal couleur pour les absences.} 39 | } 40 | \value{ 41 | Une liste contenant un graphique par paramètre environnemental. 42 | } 43 | \description{ 44 | Produire le graphique des distributions comparées des paramètres environnementaux 45 | entre les sites de présence et d'absence d'une espèce. 46 | } 47 | \examples{ 48 | \dontrun{ 49 | mes_graphiques <- gg_density_env_esp(df = mon_df, espece = "BRO", quantile_max = 0.95, 50 | log = c('surface_bv', 'distance_source')) 51 | mes_graphiques[[1]] 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /man/gg_gerer_seuils_classes_ipr_int.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_gerer_seuils_classes_ipr_int.R 3 | \name{gg_gerer_seuils_classes_ipr_int} 4 | \alias{gg_gerer_seuils_classes_ipr_int} 5 | \title{Gérer les limites de classes d'indices sur classe_ipr} 6 | \usage{ 7 | gg_gerer_seuils_classes_ipr_int(df_classes, metriques = FALSE, sup_500m) 8 | } 9 | \arguments{ 10 | \item{df_classes}{Dataframe d'entrée, en général classe_ipr} 11 | 12 | \item{metriques}{Booléen. Si TRUE, on considère qu'il s'agit des métriques et non de 13 | l'indice agrégé. Les seuils sont donc divisés par 7 (le nombre des métriques dans l'IPR).} 14 | 15 | \item{sup_500m}{Booléen. TRUE si les stations sont au-dessus de 500m d'altitude, ce qui change 16 | un seuil de classe IPR.} 17 | } 18 | \value{ 19 | Le dataframe filtré selon l'altitude 20 | } 21 | \description{ 22 | Gérer les limites de classes d'indices sur classe_ipr 23 | } 24 | \examples{ 25 | \dontrun{ 26 | classe_classes_ipr <- classe_ipr \%>\% 27 | gg_gerer_seuils_classes_ipr_int() 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /man/gg_histo_longueur.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_histo_longueur.R 3 | \name{gg_histo_longueur} 4 | \alias{gg_histo_longueur} 5 | \alias{mei_grapher_histo_longueur} 6 | \title{Produire l'histogramme de distribution des longueurs individuelles pour une opération 7 | de pêche} 8 | \usage{ 9 | gg_histo_longueur( 10 | indiv_df, 11 | operation, 12 | especes, 13 | type_longueur = c("Totale", "Fourche", "Estim\\\\u00e9e d\\\\'apr\\\\u00e8s le poids"), 14 | n_intervalles = 30 15 | ) 16 | } 17 | \arguments{ 18 | \item{indiv_df}{Le dataframe contanant les données nécessaires.} 19 | 20 | \item{operation}{Entier. Identifiant de l'opération de pêche au sens du champ ope_id.} 21 | 22 | \item{especes}{Vecteur caractères. Identifiants des codes espèces en trois lettres. 23 | Classiquement une seule espèce est désignée mais on peut préférer regrouper des 24 | sous-espèces avec des identifiants différents ou conserver les identifications 25 | au genre.} 26 | 27 | \item{type_longueur}{Vecteur caractères. Intitulé(s) du ou des type(s) de longueur 28 | à prendre en compte pour construire l'histogramme. Trois modalités sont proposées, 29 | qui correspondent aux modélités du champ tlo_libelle de la table ref_type_longueur.} 30 | 31 | \item{n_intervalles}{Nombre entier. Nombre d'intervalles de longueur sur l'axe des 32 | abscisses. La valeur par défaut est 30.} 33 | } 34 | \value{ 35 | L'histogramme. C'est un objet de classe ggplot qui peut donc être repris par la 36 | suite pour en modifier la mise en forme. 37 | } 38 | \description{ 39 | Produire l'histogramme de distribution des longueurs individuelles pour une opération 40 | de pêche 41 | } 42 | \examples{ 43 | \dontrun{ 44 | gg_histo_longueur (indiv_df = data_ind_56, 45 | operation = 6313, 46 | especes = "GOU", 47 | type_longueur = c("Fourche", "Estimée d'après le poids"), 48 | n_intervalles = 25) 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /man/gg_temp_abondance.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_temp_abondance.R 3 | \name{gg_temp_abondance} 4 | \alias{gg_temp_abondance} 5 | \title{Graphique de la série chronologique des abondances ou densités par espèce} 6 | \usage{ 7 | gg_temp_abondance(df, var_espece, var_abondance, nb_colonnes = 6) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe contenant les données. Il doit contenir au moins lz variable "annee" ainsi 11 | que deux autres, l'une pour l'espèce et l'autre pour l'abondance ou la densité.} 12 | 13 | \item{var_espece}{Nom de la variable contenant les identifiants des espèces.} 14 | 15 | \item{var_abondance}{Nom de la variable contenant les valeurs d'abondance ou de densité} 16 | 17 | \item{nb_colonnes}{Entier. Nombre (maxi) de colonnes de graphiques s'il y a plusieurs stations. 18 | Par défaut nb_colonnes = 4.} 19 | } 20 | \value{ 21 | Un graphique ggplot2. 22 | } 23 | \description{ 24 | Graphique de la série chronologique des abondances ou densités par espèce 25 | } 26 | \examples{ 27 | \dontrun{ 28 | dept_densites_an \%>\% 29 | filter(dept == mon_dept) \%>\% 30 | gg_temp_abondance(var_espece = esp_nom_commun, 31 | var_abondance = densite_qd_pres_moy) 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /man/gg_temp_env.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_temp_env.R 3 | \name{gg_temp_env} 4 | \alias{gg_temp_env} 5 | \alias{gg_env_fn_annee} 6 | \title{Produire le graphique de l'évolution temporelle de facteurs environnementaux moyens comparés 7 | entre les sites de présence et d'absence des espèces} 8 | \usage{ 9 | gg_temp_env( 10 | df, 11 | parametres = NA, 12 | log_y = c("surface_bv", "distance_source", "pente", "largeur"), 13 | annee_debut = 1995, 14 | annee_fin = NA, 15 | y_libre = FALSE, 16 | coul_pres = "blue", 17 | coul_abs = "red" 18 | ) 19 | } 20 | \arguments{ 21 | \item{df}{Le dataframe contenant les données avec les variables presence, parametre, 22 | valeur_parametre, annee} 23 | 24 | \item{parametres}{Vecteur caractères. Les paramètre (ex : "altitude") représentés.} 25 | 26 | \item{log_y}{Vecteur caractères. Les paramètre (ex : "altitude") représentés en échelle log. 27 | Par défaut, sa valeur est c('surface_bv', 'distance_source', 'pente', 'largeur'), ce qui 28 | correspond aux paramètres dont la distribution de rapproche d'une log-normale.} 29 | 30 | \item{annee_debut}{Entier. Année mini à représenter.} 31 | 32 | \item{annee_fin}{Entier. Année maxi à représenter.} 33 | 34 | \item{y_libre}{TRUE/FALSE (valeur par défaut). Les axes des ordonnées peuvent (TRUE) différer 35 | selon les espèces, ce qui permet un "zoom", ou bien être les mêmes pour toutes, ce qui permet 36 | de les comparer les unes aux autres.} 37 | 38 | \item{coul_pres}{Caractère. Couleur ou code hexadécimal couleur pour les présences.} 39 | 40 | \item{coul_abs}{Caractère. Couleur ou code hexadécimal couleur pour les absences.} 41 | } 42 | \value{ 43 | Une liste dont les éléments sont des graphiques ggplot2 (un par paramètre). 44 | } 45 | \description{ 46 | Produire le graphique de l'évolution temporelle de facteurs environnementaux moyens comparés 47 | entre les sites de présence et d'absence des espèces 48 | } 49 | \examples{ 50 | \dontrun{ 51 | mes_graphiques <- gg_temp_env(df = mon_df, log_y = c('surface_bv', 'distance_source')) 52 | mes_graphiques[[1]] 53 | } 54 | } 55 | -------------------------------------------------------------------------------- /man/gg_temp_ipr_pc_bon.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/gg_temp_ipr_pc_bon.R 3 | \name{gg_temp_ipr_pc_bon} 4 | \alias{gg_temp_ipr_pc_bon} 5 | \alias{ipr_grapher_pc_bon} 6 | \title{Produire un graphique du pourcentage de stations en bon état au plan IPR sur un jeu de 7 | stations, en fonction de l'année} 8 | \usage{ 9 | gg_temp_ipr_pc_bon(ipr_df, titre = NA) 10 | } 11 | \arguments{ 12 | \item{ipr_df}{Dataframe contenant les données, issu de la fonction extraire_ipr().} 13 | 14 | \item{titre}{Caractère. Titre du graphique.} 15 | } 16 | \value{ 17 | Le graphique issu de ggplot2. 18 | } 19 | \description{ 20 | Produire un graphique du pourcentage de stations en bon état au plan IPR sur un jeu de 21 | stations, en fonction de l'année 22 | } 23 | \examples{ 24 | \dontrun{ 25 | gg_temp_ipr_pc_bon(ipr_df = data_56, 26 | titre = "Morbihan") 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /man/imp_corres_aspe_taxref.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_corres_aspe_taxref.R 3 | \name{imp_corres_aspe_taxref} 4 | \alias{imp_corres_aspe_taxref} 5 | \title{Importer une table de correspondance entre les codes espèces 3 lettres Aspe et leurs codes Taxref} 6 | \usage{ 7 | imp_corres_aspe_taxref( 8 | url = 9 | "https://api.sandre.eaufrance.fr/referentiels/v1/apt.csv?compress=true&filter=CodeAlternatifAp/OrgCdAlternatifASPE" 10 | ) 11 | } 12 | \arguments{ 13 | \item{url}{Caractère. URL du jeu de données à télécharger. 14 | Par défaut "https://api.sandre.eaufrance.fr/referentiels/v1/apt.csv?compress=true& 15 | filter=\if{html}{\out{}}\if{html}{\out{}}\if{html}{\out{}}CodeAlternatifAp/OrgCdAlternatif\if{html}{\out{}}\if{html}{\out{}}ASPE\if{html}{\out{}}\if{html}{\out{}}\if{html}{\out{}}"} 16 | } 17 | \value{ 18 | Dataframe. Table de correspondence. 19 | } 20 | \description{ 21 | La donnée ne provient pas de la base ASPE, mais de l'API SANDRE. Les données importées ont été 22 | filtrées afin de ne pas récupérer l'intégralité du référentiel "Appellation de taxons". Seuls 23 | } 24 | \examples{ 25 | \dontrun{ 26 | taxref <- imp_corres_aspe_taxref() 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /man/imp_extraire_date_fichier.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_extraire_date_fichier.R 3 | \name{imp_extraire_date_fichier} 4 | \alias{imp_extraire_date_fichier} 5 | \title{Obtenir la date du dump SQL de la base Aspe} 6 | \usage{ 7 | imp_extraire_date_fichier(fichier, date = "modification") 8 | } 9 | \arguments{ 10 | \item{fichier}{Le chemin vers le fichier.} 11 | 12 | \item{date}{Date souhaitée, soit "creation", soit "modification" (par défaut).} 13 | } 14 | \value{ 15 | La date de création ou de modification. 16 | } 17 | \description{ 18 | Obtenir la date du dump SQL de la base Aspe 19 | } 20 | \examples{ 21 | \dontrun{ 22 | date-dump <- imp_extraire_date_fichier(fichier = "../raw_data/dump.sql", 23 | date = "creation") 24 | } 25 | 26 | 27 | } 28 | -------------------------------------------------------------------------------- /man/imp_extraire_noms_tables.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_extraire_noms_tables.R 3 | \name{imp_extraire_noms_tables} 4 | \alias{imp_extraire_noms_tables} 5 | \title{Extraire les noms des tables à partir des lignes du dump} 6 | \usage{ 7 | imp_extraire_noms_tables(lignes_dump) 8 | } 9 | \arguments{ 10 | \item{lignes_dump}{Nom de la liste qui contient les lignes du dump.} 11 | } 12 | \value{ 13 | Un vecteur caractères contenant les noms des tables. 14 | } 15 | \description{ 16 | Extraire les noms des tables à partir des lignes du dump 17 | } 18 | \examples{ 19 | 20 | \dontrun{ 21 | imp_extraire_noms_tables (lignes_dump = mes_lignes_du_dump) 22 | } 23 | 24 | 25 | } 26 | -------------------------------------------------------------------------------- /man/imp_extraire_noms_tables2.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_extraire_noms_tables2.R 3 | \name{imp_extraire_noms_tables2} 4 | \alias{imp_extraire_noms_tables2} 5 | \title{Extraire les noms des tables à partir des lignes du dump} 6 | \usage{ 7 | imp_extraire_noms_tables2(lignes_dump) 8 | } 9 | \arguments{ 10 | \item{lignes_dump}{Nom de la liste qui contient les lignes du dump.} 11 | } 12 | \value{ 13 | Un vecteur caractères contenant les noms des tables. 14 | } 15 | \description{ 16 | Extraire les noms des tables à partir des lignes du dump 17 | } 18 | \examples{ 19 | 20 | \dontrun{ 21 | imp_extraire_noms_tables (lignes_dump = mes_lignes_du_dump) 22 | } 23 | 24 | 25 | } 26 | -------------------------------------------------------------------------------- /man/imp_importer_dump_sql.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_importer_dump_sql.R 3 | \name{imp_importer_dump_sql} 4 | \alias{imp_importer_dump_sql} 5 | \title{Importer le dump SQL de la base Aspe} 6 | \usage{ 7 | imp_importer_dump_sql(fichier_dump) 8 | } 9 | \arguments{ 10 | \item{fichier_dump}{Le chemin vers le fichier d'extension .sql (décompressé) ou 11 | .sql.gz (archive).} 12 | } 13 | \value{ 14 | Les dataframes correspondant à chacune des tables de la base. 15 | } 16 | \description{ 17 | Importer le dump SQL de la base Aspe 18 | } 19 | \examples{ 20 | 21 | \dontrun{ 22 | imp_importer_dump_sql(fichier_dump = "../raw_data/dump.sql") 23 | } 24 | 25 | 26 | } 27 | -------------------------------------------------------------------------------- /man/imp_scinder_dump.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_scinder_dump.R 3 | \name{imp_scinder_dump} 4 | \alias{imp_scinder_dump} 5 | \title{Scinder le dump en deux parties pour les traiter séparément et éviter de 6 | saturer la mémoire vive} 7 | \usage{ 8 | imp_scinder_dump(fichier_dump, repertoire_sortie = NA) 9 | } 10 | \arguments{ 11 | \item{fichier_dump}{Le chemin vers le fichier d'extension .sql (décompressé) ou 12 | .sql.gz (archive).} 13 | 14 | \item{repertoire_sortie}{Le chemin vers le répertoire de sortie (qui doit avoir 15 | été créé auparavant). Par défaut c'est celui qui contient le dump.} 16 | } 17 | \value{ 18 | Deux fichiers au format .RData contenant l'un les lignes de la table 19 | mesure_individuelle et l'autre tout le reste du dump 20 | } 21 | \description{ 22 | ATTENTION : Si le chemin d'accès au fichier est trop long, il est possible que 23 | la fonction retourne une erreur : 24 | Error in gzfile(file, "wb") : argument 'description' incorrect 25 | In if (!nzchar(file)) stop("'file' must be non-empty string") : 26 | a condition a une longueur > 1 et seul le premier élément est utilisé 27 | Dans ce cas, déplacez le dump pour accourcir le chemin d'accès. 28 | } 29 | \examples{ 30 | \dontrun{ 31 | imp_scinder_dump(fichier_dump = "../raw_data/dump.sql") 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /man/imp_tables_a_partir_des_lignes.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_tables_a_partir_des_lignes.R 3 | \name{imp_tables_a_partir_des_lignes} 4 | \alias{imp_tables_a_partir_des_lignes} 5 | \title{Importer des tables à partir des lignes du dump de la base Aspe} 6 | \usage{ 7 | imp_tables_a_partir_des_lignes(lignes_dump, tables_a_extraire = NA) 8 | } 9 | \arguments{ 10 | \item{lignes_dump}{Nom de la liste contenant les lignes du dump.} 11 | 12 | \item{tables_a_extraire}{Un vecteur contenant les noms des tables à extraire. 13 | Par défaut toutes les tables sont extraites, ce qui peut prendre du temps 14 | inutilement.} 15 | } 16 | \value{ 17 | Les dataframes correspondant à chacune des tables de la base. 18 | } 19 | \description{ 20 | Importer des tables à partir des lignes du dump de la base Aspe 21 | } 22 | \examples{ 23 | \dontrun{ 24 | imp_tables_a_partir_des_lignes(lignes_dump = lignes_autres_tables) 25 | } 26 | 27 | 28 | } 29 | -------------------------------------------------------------------------------- /man/imp_trouver_index_fin.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/imp_trouver_index_fin.R 3 | \name{imp_trouver_index_fin} 4 | \alias{imp_trouver_index_fin} 5 | \title{Trouver la ligne de fin qui correspond à une table désignée par sa ligne de début} 6 | \usage{ 7 | imp_trouver_index_fin(vecteur_index_lignes_fin, ligne_debut) 8 | } 9 | \arguments{ 10 | \item{vecteur_index_lignes_fin}{Vecteur contenant les numéros de toutes les lignes contenant la séquence caractéristique 11 | de la fin d'une table.} 12 | 13 | \item{ligne_debut}{Numéro de la ligne de début de la table.} 14 | } 15 | \value{ 16 | Le numéro de la ligne de fin de la table. 17 | } 18 | \description{ 19 | Par exemple pour trouver le numéro de la ligne de fin d'une table qui débuterait à la ligne 6517552 20 | } 21 | \examples{ 22 | \dontrun{ 23 | imp_trouver_index_fin(vecteur_index_lignes_fin = mon_vecteur, ligne_debut = 6517552) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /man/ip_completer_classes_couleur.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/ip_completer_classes_couleur.R 3 | \name{ip_completer_classes_couleur} 4 | \alias{ip_completer_classes_couleur} 5 | \title{Ajouter les codes couleurs aux classes IPR} 6 | \usage{ 7 | ip_completer_classes_couleur( 8 | df_classes_ip, 9 | var_numero_classe = cli_classe, 10 | var_libelle_classe = cli_libelle 11 | ) 12 | } 13 | \arguments{ 14 | \item{df_classes_ip}{Dataframe contenant les intitulés des classes, typiquement 15 | le dataframe classe_ipr de la base Aspe.} 16 | 17 | \item{var_numero_classe}{Variable contenant les numéros de classes de 1 (meilleur état) 18 | à 5 (le pire).} 19 | 20 | \item{var_libelle_classe}{Variable contenant les libellés de classes.} 21 | } 22 | \value{ 23 | Le dataframe complété. La colonne ajoutée est "classe_couleur". 24 | } 25 | \description{ 26 | Ajouter les codes couleurs aux classes IPR 27 | } 28 | \examples{ 29 | \dontrun{ 30 | classe_ipr_plus <- classe_ipr_plus \%>\% 31 | ip_completer_classes_couleur(var_numero_classe = cip_classe, 32 | var_libelle_classe = cip_libelle) 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /man/ipr_formater_pour_macro.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/ipr_formater_pour_macro.R 3 | \name{ipr_formater_pour_macro} 4 | \alias{ipr_formater_pour_macro} 5 | \title{Mettre les données nécessaires au calcul de l'IPR au format requis en entrée de la macro 6 | Excel de calcul de l'indice} 7 | \usage{ 8 | ipr_formater_pour_macro( 9 | passerelle, 10 | date_debut, 11 | date_fin = format(Sys.Date(), "\%d/\%m/\%Y") 12 | ) 13 | } 14 | \arguments{ 15 | \item{passerelle}{Dataframe mettant en correspondance les identifiants des différentes tables.} 16 | 17 | \item{date_debut}{Date de début de la période à extraire au format jj/mm/aaaa.} 18 | 19 | \item{date_fin}{Date de fin de la période à extraire au format jj/mm/aaaa. Par défaut c'est la 20 | date du jour où la fonction est exécutée.} 21 | } 22 | \value{ 23 | Un dataframe au format souhaité, mais dont les colonnes doivent ensuite être renommées 24 | avec la fonction renommer_pour_macro(). 25 | } 26 | \description{ 27 | Mettre les données nécessaires au calcul de l'IPR au format requis en entrée de la macro 28 | Excel de calcul de l'indice 29 | } 30 | \examples{ 31 | \dontrun{ 32 | data_macro <- ipr_formater_pour_macro(passerelle = passerelle, date_debut = '01/01/2020') 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /man/ipr_pivoter_1colonne_par_an.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/ipr_pivoter_1colonne_par_an.R 3 | \name{ipr_pivoter_1colonne_par_an} 4 | \alias{ipr_pivoter_1colonne_par_an} 5 | \title{Convertir une table des IPR du format long au format large} 6 | \usage{ 7 | ipr_pivoter_1colonne_par_an(ipr_df) 8 | } 9 | \arguments{ 10 | \item{ipr_df}{Le dataframe au format long contenant les IPR, issi de la fonction extraire-ipr()} 11 | } 12 | \value{ 13 | Un dataframe contenant les mêmes données, mais agencé avec une colonne par année. 14 | } 15 | \description{ 16 | On appelle format large la présentation des données avec une colonne par année. 17 | S'il y a plusieurs valeurs de l'IPR pour un même point une année donnée, 18 | la valeur retournée sera la moyenne. 19 | } 20 | \examples{ 21 | \dontrun{ 22 | ipr_large_df <- ipr_pivoter_1colonne_par_an(ipr_df = mon_df_ipr) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/ipr_renommer_pour_macro.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/ipr_renommer_pour_macro.R 3 | \name{ipr_renommer_pour_macro} 4 | \alias{ipr_renommer_pour_macro} 5 | \title{Sélectionner et nommer les colonnes au format requis en entrée de la macro 6 | Excel de calcul de l'indice} 7 | \usage{ 8 | ipr_renommer_pour_macro(data, fichier_macro) 9 | } 10 | \arguments{ 11 | \item{data}{Le dataframe contenant les données, issu de la fonction formater_pour_macro().} 12 | 13 | \item{fichier_macro}{Caractère. Chemin vers le fichier Excel de la macro.} 14 | } 15 | \value{ 16 | Le dataframe 17 | } 18 | \description{ 19 | Sélectionner et nommer les colonnes au format requis en entrée de la macro 20 | Excel de calcul de l'indice 21 | } 22 | \examples{ 23 | \dontrun{ 24 | data_macro <- ipr_renommer_pour_macro(data = data_macro, 25 | fichier_macro = "raw_data/CalculIPRv1.3.xls") 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /man/mef_ajouter_abs.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_abs.R 3 | \name{mef_ajouter_abs} 4 | \alias{mef_ajouter_abs} 5 | \title{Ajouter à un dataframe de présences les lignes des absences (avec effectif et densité nuls)} 6 | \usage{ 7 | mef_ajouter_abs(df, var_id, var_taxon, var_effectif) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe avec les variables ope_id, esp_code_alternatif, effectif, dens_ind_1000m2 et annee.} 11 | 12 | \item{var_id}{Nom de la variable contenant les identifiants des observations (ex : ope_id), sans guillements.} 13 | 14 | \item{var_taxon}{Nom de la variable contenant les identifiants des taxons (ex : esp_code_alternatif), 15 | sans guillements.} 16 | 17 | \item{var_effectif}{Nom de la variable contenant les effectifs (ex : lop_effectif), sans guillements.} 18 | } 19 | \value{ 20 | Le dataframe avec des lignes supplémentaires pour chacune des espèces absentes à chacune 21 | des opérations. 22 | } 23 | \description{ 24 | La fonction fait appel au dataframe "operation" de la base Aspe qui doit impérativement avoir 25 | été chargé auparavant. 26 | } 27 | \examples{ 28 | \dontrun{ 29 | df_complet <- mef_ajouter_abs(df = df_presences, 30 | var_id = ope_id, 31 | var_taxon = esp_code_alternatif, 32 | var_effectif = effectif) 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /man/mef_ajouter_ambiance.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_ambiance.R 3 | \name{mef_ajouter_ambiance} 4 | \alias{mef_ajouter_ambiance} 5 | \title{Ajouter à la passerelle, quand le prélèvement élémentaire est une ambiance, ses données} 6 | \usage{ 7 | mef_ajouter_ambiance(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir le champ "pre_id" (identifiant du prélèvement individuel).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | \if{html}{\out{
}}\preformatted{Le type de prélèvement doit donc être indiqué dans le data frame (Groupe de points, 18 | Passage ou Ambiance). On applique mef_ajouter_ambiance() après mef_ajouter_type_prelevement(). 19 | }\if{html}{\out{
}} 20 | } 21 | \examples{ 22 | \dontrun{ 23 | passerelle <- passerelle \%>\% 24 | mef_ajouter_type_prelevement() \%>\% 25 | mef_ajouter_ambiance() 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /man/mef_ajouter_dept.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_dept.R 3 | \name{mef_ajouter_dept} 4 | \alias{mef_ajouter_dept} 5 | \title{Ajouter à la passerelle les numéros de départements.} 6 | \usage{ 7 | mef_ajouter_dept(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | La passerelle doit comprendre des colonnes "sta_id" et "pop_id".} 12 | } 13 | \value{ 14 | La passerelle complétée par le département. 15 | } 16 | \description{ 17 | Si le code commune de la station est renseigné dans la table station, ses deux premiers caractères 18 | indiquent le département. S'il est manquant mais renseigné dans la table point_prelevement, 19 | c'est cette information qui est utilisée. Malgré tout l'information est manquantes dans 20 | certains cas 21 | } 22 | \examples{ 23 | \dontrun{ 24 | passerelle <- passerelle \%>\% 25 | mef_ajouter_dept() 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /man/mef_ajouter_esp.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_esp.R 3 | \name{mef_ajouter_esp} 4 | \alias{mef_ajouter_esp} 5 | \title{Ajouter à un dataframe le code espèce à 3 lettres, son nom commun et scientifique} 6 | \usage{ 7 | mef_ajouter_esp(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | La passerelle doit comprendre un champ avec le code taxon esp_id (typiquement, on utilise donc 12 | mef_ajouter_esp() après mef_ajouter_lots())} 13 | } 14 | \value{ 15 | La passerelle complétée. 16 | } 17 | \description{ 18 | Les codes sont "historiques", hérités du Conseil Supérieur de la Pêche. 19 | } 20 | \examples{ 21 | \dontrun{ 22 | passerelle <- mef_creer_passerelle() \%>\% 23 | mef_ajouter_lots() \%>\% 24 | mef_ajouter_esp() 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /man/mef_ajouter_groupe_points.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_groupe_points.R 3 | \name{mef_ajouter_groupe_points} 4 | \alias{mef_ajouter_groupe_points} 5 | \title{Ajouter à la passerelle, quand le prélèvement élémentaire est un groupe de points, ses données} 6 | \usage{ 7 | mef_ajouter_groupe_points(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir le champ "pre_id" (identifiant du prélèvement individuel).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | \if{html}{\out{
}}\preformatted{Le type de prélèvement doit donc être indiqué dans le data frame (Groupe de points, 18 | Passage ou Ambiance). On applique mef_ajouter_groupe_points() après mef_ajouter_type_prelevement(). 19 | }\if{html}{\out{
}} 20 | } 21 | \examples{ 22 | \dontrun{ 23 | passerelle <- passerelle \%>\% 24 | mef_ajouter_type_prelevement() \%>\% 25 | mef_ajouter_groupe_points() 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /man/mef_ajouter_intervenants.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_intervenants.R 3 | \name{mef_ajouter_intervenants} 4 | \alias{mef_ajouter_intervenants} 5 | \title{Ajouter à la passerelle les intervenants sur les opérations 6 | Ces intervenants sont l'opérateur, le commanditaire et le valideur} 7 | \usage{ 8 | mef_ajouter_intervenants(df) 9 | } 10 | \arguments{ 11 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des 12 | différentes tables.} 13 | } 14 | \value{ 15 | La passerelle complétée. 16 | } 17 | \description{ 18 | Ajouter à la passerelle les intervenants sur les opérations 19 | Ces intervenants sont l'opérateur, le commanditaire et le valideur 20 | } 21 | \examples{ 22 | \dontrun{ 23 | passerelle <- mef_creer_passerelle() \%>\% 24 | mef_ajouter_intervenants() 25 | } 26 | 27 | } 28 | -------------------------------------------------------------------------------- /man/mef_ajouter_ipr.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_ipr.R 3 | \name{mef_ajouter_ipr} 4 | \alias{mef_ajouter_ipr} 5 | \title{Ajouter les notes IPR à une table passerelle} 6 | \usage{ 7 | mef_ajouter_ipr(passerelle) 8 | } 9 | \arguments{ 10 | \item{passerelle}{Dataframe mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | Dataframe avec la valeur de l'IPR, et la classe de qualité. 14 | } 15 | \description{ 16 | Ajouter les notes IPR à une table passerelle 17 | } 18 | \examples{ 19 | \dontrun{ 20 | mon_df_ipr <- mef_ajouter_ipr(passerelle = passerelle) 21 | } 22 | 23 | } 24 | -------------------------------------------------------------------------------- /man/mef_ajouter_libelle.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_libelle.R 3 | \name{mef_ajouter_libelle} 4 | \alias{mef_ajouter_libelle} 5 | \title{Rajouter le libellé du site} 6 | \usage{ 7 | mef_ajouter_libelle(passerelle) 8 | } 9 | \arguments{ 10 | \item{passerelle}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | La passerelle à laquelle ont été ajoutés les libellés des points de prélèvement. 14 | } 15 | \description{ 16 | \ifelse{html}{\href{https://lifecycle.r-lib.org/articles/stages.html#deprecated}{\figure{lifecycle-deprecated.svg}{options: alt='[Deprecated]'}}}{\strong{[Deprecated]}}. 17 | Fonction remplacée par "mef_ajouter_libelle_site()". 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- mef_ajouter_libelle(passerelle = passerelle) 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /man/mef_ajouter_libelle_site.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_libelle_site.R 3 | \name{mef_ajouter_libelle_site} 4 | \alias{mef_ajouter_libelle_site} 5 | \title{Rajouter le libellé du site} 6 | \usage{ 7 | mef_ajouter_libelle_site(df, origine_libelle = "auto") 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe qui, selon le choix de l'argument "origine_libelle", doit contenir les variables 11 | "sta_id" et/ou "pop_id".} 12 | 13 | \item{origine_libelle}{Caractère. Peut prendre les valeurs "point_wama", "station_sandre", ou "auto" 14 | car la base Aspe contient différents champs indiquant la localisation. La valeur par défaut est "auto", 15 | qui assure que le champ ne reste jamais vide (nécessaire pour certains traitements). Dans ce cas, 16 | le champ retourné est nommé "pop_libelle" et sa valeur est par priorités décroissantes 17 | "pop_libelle", "sta_libelle_sandre" et enfin "pop_id".} 18 | } 19 | \value{ 20 | Le dataframe auquel ont été ajoutés les libellés. 21 | } 22 | \description{ 23 | Rajoute à un dataframe le libellé du site, qui peut être le point ou la station. 24 | } 25 | \details{ 26 | Cette fonction nécessite que les dataframes de la base Aspe soient chargés dans l'environnement. 27 | } 28 | \examples{ 29 | \dontrun{ 30 | # chargement des packages 31 | library(dplyr) 32 | library(aspe) 33 | 34 | # chargement des données (à adapter) 35 | load(file = "raw_data/tables_sauf_mei_2023_04_07_09_39_32.RData") 36 | 37 | # création du tableau 38 | aspe_df <- mef_creer_passerelle() \%>\% 39 | mef_ajouter_libelle_site(origine_libelle = "station_sandre") 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /man/mef_ajouter_lots.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_lots.R 3 | \name{mef_ajouter_lots} 4 | \alias{mef_ajouter_lots} 5 | \title{Ajouter les lots de poissons capturés à la passerelle} 6 | \usage{ 7 | mef_ajouter_lots(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "pre_id" (identifiant du prélèvement élémentaire).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | Ajouter les lots de poissons capturés à la passerelle 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- passerelle \%>\% 22 | mef_ajouter_lots() 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_mei.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_mei.R 3 | \name{mef_ajouter_mei} 4 | \alias{mef_ajouter_mei} 5 | \title{Ajouter les mesures individuelles à la passerelle} 6 | \usage{ 7 | mef_ajouter_mei(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir le champ "lop_id" qui sert à la jointure avec la table mesure_individuelle.} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | Ajouter les mesures individuelles à la passerelle 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- passerelle \%>\% 22 | mef_ajouter_mei() 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_metriques.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_metriques.R 3 | \name{mef_ajouter_metriques} 4 | \alias{mef_ajouter_metriques} 5 | \title{Ajouter à une passerelle les métriques IPR observées, théoriques et leur contribution 6 | à l'indice IPR agrégé} 7 | \usage{ 8 | mef_ajouter_metriques(df) 9 | } 10 | \arguments{ 11 | \item{df}{Dataframe qui doit comprendre une colonnes "ope_id" (identifiant de l'opération de pêche).} 12 | } 13 | \value{ 14 | Le dataframe passerelle complété par les métriques. 15 | } 16 | \description{ 17 | Ajouter à une passerelle les métriques IPR observées, théoriques et leur contribution 18 | à l'indice IPR agrégé 19 | } 20 | \examples{ 21 | \dontrun{ 22 | passerelle_avec_metriques <- mef_ajouter_metriques(df = ma_passerelle) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_moyen_prospection.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_moyen_prospection.R 3 | \name{mef_ajouter_moyen_prospection} 4 | \alias{mef_ajouter_moyen_prospection} 5 | \title{Ajouter à la passerelle le moyen de prospection} 6 | \usage{ 7 | mef_ajouter_moyen_prospection(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "ope_id" (identifiant de l'opération de pêche).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | Ex : A pied / En bateau. Les modalités sont précisées dans la table ref_moyen_prospection. 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- passerelle \%>\% 22 | mef_ajouter_moyen_prospection() 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_objectif.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_objectif.R 3 | \name{mef_ajouter_objectif} 4 | \alias{mef_ajouter_objectif} 5 | \title{Ajouter à la passerelle l'objectif de l'opération} 6 | \usage{ 7 | mef_ajouter_objectif(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "ope_id" (identifiant de l'opération de pêche).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | Par objectif, on entent la contribution à un réseau (DCE, RCS, RRP, etc.), le suivi de poopulations, 18 | des études, du suivi de restauration, etc. Les modalités sont précisées dans la table ref_objectif. 19 | } 20 | \examples{ 21 | \dontrun{ 22 | passerelle <- passerelle \%>\% 23 | mef_ajouter_objectif() 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /man/mef_ajouter_ope_date.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_ope_date.R 3 | \name{mef_ajouter_ope_date} 4 | \alias{mef_ajouter_ope_date} 5 | \title{Rajouter à la passerelle la date et l'année de chaque opération.} 6 | \usage{ 7 | mef_ajouter_ope_date(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "ope_id" (identifiant de l'opération de pêche).} 12 | } 13 | \value{ 14 | La passerelle à laquelle ont été ajoutés la date et l'année. 15 | } 16 | \description{ 17 | Rajouter à la passerelle la date et l'année de chaque opération. 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- mef_ajouter_ope_date(df = passerelle) 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /man/mef_ajouter_ope_desc_peche.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_ope_desc_peche.R 3 | \name{mef_ajouter_ope_desc_peche} 4 | \alias{mef_ajouter_ope_desc_peche} 5 | \title{Rajouter à la passerelle les variables de description de la pêche pour chaque opération (quand disponible).} 6 | \usage{ 7 | mef_ajouter_ope_desc_peche(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | La passerelle à laquelle ont été ajoutés les variables environnementales 14 | } 15 | \description{ 16 | Ces variables sont issues de la table "operation_description_peche". 17 | } 18 | \examples{ 19 | \dontrun{ 20 | passerelle <- mef_ajouter_ope_desc_peche(df = passerelle) 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /man/mef_ajouter_ope_env.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_ope_env.R 3 | \name{mef_ajouter_ope_env} 4 | \alias{mef_ajouter_ope_env} 5 | \title{Rajouter les variables environnementales pour chaque opération à la passerelle (quand disponible)} 6 | \usage{ 7 | mef_ajouter_ope_env(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | La passerelle à laquelle ont été ajoutés les variables environnementales. 14 | } 15 | \description{ 16 | Ces variables sont en premier lieu renseignées depuis la table "operation_ipr", faute de quoi elles 17 | sont complétées depuis la table "point_prelevement". 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- mef_ajouter_ope_env(df = passerelle) 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /man/mef_ajouter_passage.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_passage.R 3 | \name{mef_ajouter_passage} 4 | \alias{mef_ajouter_passage} 5 | \title{Ajouter à la passerelle, quand le prélèvement élémentaire est un passage, le numéro de passage} 6 | \usage{ 7 | mef_ajouter_passage(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "pre_id" (identifiant du prélèvement élémentaire).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | \if{html}{\out{
}}\preformatted{Le type de prélèvement doit donc être indiqué dans le data frame (Groupe de points, 18 | Passage ou Ambiance). On applique mef_ajouter_passage() après mef_ajouter_type_prelevement(). 19 | }\if{html}{\out{
}} 20 | } 21 | \examples{ 22 | \dontrun{ 23 | passerelle <- passerelle \%>\% 24 | mef_ajouter_type_prelevement() \%>\% 25 | mef_ajouter_passage() 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /man/mef_ajouter_proba_presence_ipr.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_proba_presence_ipr.R 3 | \name{mef_ajouter_proba_presence_ipr} 4 | \alias{mef_ajouter_proba_presence_ipr} 5 | \title{Ajouter à un dataframe les probabilités de présence des taxons IPR} 6 | \usage{ 7 | mef_ajouter_proba_presence_ipr(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe qui doit comprendre les colonnes "ope_id" et "esp_id".} 11 | } 12 | \value{ 13 | Le dataframe complété avec les probabilités de présence. 14 | } 15 | \description{ 16 | Ces probabilités sont issues de Oberdorff et al. (2002) 17 | Development and validation of a fish‐based index for the assessment of ‘river health’in France. 18 | Freshwater Biology, 47(9), 1720-1734). 19 | } 20 | \details{ 21 | Comme les codes taxonomiques actuels diffèrent de ceux de l'IPR, il peut être nécessaire, avant d'utiliser 22 | la fonction 'mef_ajouter_proba_presence_ipr()', d'appliquer le référentiel taxonomique IPR au dataframe 23 | au moyen de la fonction 'mef_recoder_esp_code_alt()'. 24 | 25 | Le dataframe 'probabilite_presence_ipr' doit auparavant être chargé. 26 | } 27 | \examples{ 28 | \dontrun{ 29 | df <- df \%>\% 30 | mef_ajouter_proba_presence_ipr() 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /man/mef_ajouter_qualification.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_qualification.R 3 | \name{mef_ajouter_qualification} 4 | \alias{mef_ajouter_qualification} 5 | \title{Ajouter à la passerelle la qualification de la donnée} 6 | \usage{ 7 | mef_ajouter_qualification(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "ope_id" (identifiant de l'opération de pêche).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | ex : Correcte / Incorrecte / Incertaine. 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- passerelle \%>\% 22 | mef_ajouter_qualification() 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_stats_taille.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_stats_taille.R 3 | \name{mef_ajouter_stats_taille} 4 | \alias{mef_ajouter_stats_taille} 5 | \title{Ajouter les tailles (longueurs) mini, maxi, médiane et moyenne pour chaque espèce à 6 | chaque opération} 7 | \usage{ 8 | mef_ajouter_stats_taille(df) 9 | } 10 | \arguments{ 11 | \item{df}{Dataframe avec des variables espèce (esp_code_alternatif) et opération (ope_id).} 12 | } 13 | \value{ 14 | La passerelle à laquelle ont été ajoutés les statistiques de tailles. 15 | } 16 | \description{ 17 | La fonction fait appel à de nombreux dataframes de la base Aspe qui doivent impérativement avoir 18 | été chargés auparavant (mesure_individuelle, lots, operation, etc.). Elle n'opère pas de distinction 19 | entre longueur totale et longueur fourche. 20 | } 21 | \examples{ 22 | \dontrun{ 23 | passerelle <- mef_ajouter_stats_taille(passerelle = passerelle) 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /man/mef_ajouter_surf_calc.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_surf_calc.R 3 | \name{mef_ajouter_surf_calc} 4 | \alias{mef_ajouter_surf_calc} 5 | \title{Rajouter la superficie échantillonnée calculée pour chaque opération à la passerelle} 6 | \usage{ 7 | mef_ajouter_surf_calc(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "ope_id" (identifiant de l'opération de pêche).} 12 | } 13 | \value{ 14 | La passerelle à laquelle a été ajoutée la superficie échantillonnée qui est une valeur calculée 15 | stockée dans le champ ope_surf_calculee de la table operation. 16 | } 17 | \description{ 18 | Rajouter la superficie échantillonnée calculée pour chaque opération à la passerelle 19 | } 20 | \examples{ 21 | \dontrun{ 22 | passerelle <- mef_ajouter_surf_calc(df = passerelle) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_type_longueur.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_type_longueur.R 3 | \name{mef_ajouter_type_longueur} 4 | \alias{mef_ajouter_type_longueur} 5 | \title{Ajouter le type de longueur à la passerelle} 6 | \usage{ 7 | mef_ajouter_type_longueur(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "lop_id" (identifiant du lot).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | ex : totale, fourche. 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- passerelle \%>\% 22 | mef_ajouter_type_longueur() 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_type_lot.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_type_lot.R 3 | \name{mef_ajouter_type_lot} 4 | \alias{mef_ajouter_type_lot} 5 | \title{Ajouter le type de lot à la passerelle} 6 | \usage{ 7 | mef_ajouter_type_lot(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables. 11 | df doit contenir une variable "lop_id" (identifiant du lot).} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | \if{html}{\out{
}}\preformatted{NB Les tables "lot_poissons" et "ref_type_lot" doivent avoir été chargées auparavant. 18 | }\if{html}{\out{
}} 19 | } 20 | \examples{ 21 | \dontrun{ 22 | passerelle <- passerelle \%>\% 23 | mef_ajouter_type_lot() 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /man/mef_ajouter_type_materiel.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_type_materiel.R 3 | \name{mef_ajouter_type_materiel} 4 | \alias{mef_ajouter_type_materiel} 5 | \title{Ajouter à la passerelle le type de matériel employé} 6 | \usage{ 7 | mef_ajouter_type_materiel(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | La passerelle complétée. 14 | } 15 | \description{ 16 | ex : Héron 17 | } 18 | \examples{ 19 | \dontrun{ 20 | passerelle <- passerelle \%>\% 21 | mef_ajouter_type_materiel() 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /man/mef_ajouter_type_prelevement.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_type_prelevement.R 3 | \name{mef_ajouter_type_prelevement} 4 | \alias{mef_ajouter_type_prelevement} 5 | \title{Ajouter à la passerelle le type de prélèvement élémentaire} 6 | \usage{ 7 | mef_ajouter_type_prelevement(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | La passerelle complétée. 14 | } 15 | \description{ 16 | Par type de prélèvement, on entend les modalités du tpe_libelle de la 17 | table ref_type_prelevement_elementaire 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- passerelle \%>\% 22 | mef_ajouter_type_prelevement() 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_type_protocole.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_type_protocole.R 3 | \name{mef_ajouter_type_protocole} 4 | \alias{mef_ajouter_type_protocole} 5 | \title{Ajouter le type de protocole à la passerelle} 6 | \usage{ 7 | mef_ajouter_type_protocole(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | La passerelle complétée. 14 | } 15 | \description{ 16 | ex : Indice Abondance Saumon. 17 | Nécessite d'avoir chargé les tables "operation" et "ref_protocole". 18 | } 19 | \examples{ 20 | \dontrun{ 21 | passerelle <- passerelle \%>\% 22 | mef_ajouter_type_protocole() 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_ajouter_utilisateurs.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_utilisateurs.R 3 | \name{mef_ajouter_utilisateurs} 4 | \alias{mef_ajouter_utilisateurs} 5 | \title{Ajouter à la passerelle les utilisateurs sur les opérations} 6 | \usage{ 7 | mef_ajouter_utilisateurs(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des 11 | différentes tables.} 12 | } 13 | \value{ 14 | La passerelle complétée. 15 | } 16 | \description{ 17 | Ces utilisateurs sont le créateur et la personne qui a effectué la dernière modification. 18 | Ils sont identifiés par leur adresse email. 19 | } 20 | \examples{ 21 | \dontrun{ 22 | passerelle <- mef_creer_passerelle() \%>\% 23 | mef_ajouter_utilisateurs() 24 | } 25 | 26 | } 27 | -------------------------------------------------------------------------------- /man/mef_ajouter_validation.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ajouter_validation.R 3 | \name{mef_ajouter_validation} 4 | \alias{mef_ajouter_validation} 5 | \title{Ajouter à la passerelle l'a qualification de a donnée'état d'avancement de la saisie} 6 | \usage{ 7 | mef_ajouter_validation(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe "passerelle" mettant en correspondance les identifiants des différentes tables.} 11 | } 12 | \value{ 13 | La passerelle complétée. 14 | } 15 | \description{ 16 | ex : En cours de saisie / Validé niveau 1. 17 | } 18 | \examples{ 19 | \dontrun{ 20 | passerelle <- passerelle \%>\% 21 | mef_ajouter_validation() 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /man/mef_colo_ext_pops.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_colo_ext_pops.R 3 | \name{mef_colo_ext_pops} 4 | \alias{mef_colo_ext_pops} 5 | \title{Formater le tableau des captures sur un ensemble de points} 6 | \usage{ 7 | mef_colo_ext_pops(df, id_point = NULL) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe contenant les captures et contenant les champs pop_id, pop_libelle, 11 | annee, esp_code_alternatif, effectif.} 12 | 13 | \item{id_point}{Caractère. Identifiant du ou des point(s) au sens du champ pop_id de la base Aspe. 14 | Par défaut, tous les identifiants présents dans le tableau df sont pris en compte.} 15 | } 16 | \value{ 17 | Un dataframe pour un ensemble de points de prélèvement qui est mis en forme 18 | pour produire des graphiques avec la fonction gg_colo_ext_pop(). 19 | } 20 | \description{ 21 | L'objectif est de visualiser la dynamique du peuplement. Permet d'identifier les taxons 22 | qui apparaissent ou disparaissent ainsi que les abondances. 23 | } 24 | \examples{ 25 | \dontrun{ 26 | colo_ext_mon_point <- captures \%>\% 27 | mef_colo_ext_pops() 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /man/mef_compter_pres_abs_env.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_compter_pres_abs_env.R 3 | \name{mef_compter_pres_abs_env} 4 | \alias{mef_compter_pres_abs_env} 5 | \title{Dénombrer le nb d'opérations avec chaque paramètre environnemental renseigné pour chacune 6 | des espèces} 7 | \usage{ 8 | mef_compter_pres_abs_env(df) 9 | } 10 | \arguments{ 11 | \item{df}{Dataframe avec les variables valeur_parametre, esp_code_alternatif, presence, parametre, annee, n.} 12 | } 13 | \value{ 14 | Un dataframe de 4 colonnes correspondant à l'espèce, au paramètre et aux nombres de présence et d'absence. 15 | } 16 | \description{ 17 | Dénombrer le nb d'opérations avec chaque paramètre environnemental renseigné pour chacune 18 | des espèces 19 | } 20 | \examples{ 21 | \dontrun{ 22 | df_nb_pres_abs_par_parametre_env <- mef_compter_pres_abs_env(df = df_captures_et_env) 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /man/mef_creer_passerelle.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_creer_passerelle.R 3 | \name{mef_creer_passerelle} 4 | \alias{mef_creer_passerelle} 5 | \title{Création d'un tableau "passerelle"} 6 | \usage{ 7 | mef_creer_passerelle() 8 | } 9 | \value{ 10 | Un dataframe contenant les correspondances entre les identifiants. 11 | } 12 | \description{ 13 | Cette fonction crée un tableau de correspondance pour simplifier la navigation parmi les tables de la base Aspe. 14 | La base comprend plus d'une centaine de tables dont la plupart contiennent des référentiels associant des codes 15 | à des modalités. Par exemple la table ref_protocole associe le code pro_id à la modalité 16 | "Pêche partielle par points (grand milieu)". Ces tables sont dites "périphériques". 17 | Chaque table comprend une clé primaire (suffixe "_id"), identifiant unique de chacune de ses lignes. 18 | Les tables qui constituent la colonne vertébrale de la base sont station, point_prelevement, 19 | operation, prelevement_elementaire, lot_poissons et mesure_individuelle. 20 | } 21 | \details{ 22 | Ces tables sont liées de manières hiérarchique. Ainsi, chaque mesure individuelle se rapporte à un lot, qui 23 | se rapporte à un prélèvement élémentaire, qui se rapporte à une opération ... jusqu'à la station. 24 | Pour savoir sur quelle station a été capturé ce goujon de 87mm, il faut donc remonter toute la chaîne. 25 | Pour simplifier cette procédure, et éviter d'avoir à la reproduire à chaque requête de sélection, 26 | on peut construire un tableau de correspondance des clés primaires. On n'incluera toutefois pas la 27 | table mesure_individuelle car elle comprend des millions de lignes, ce qui alourdirait considérablement 28 | le tableau. Le traitement du contenu de cette table passe par la fonction mef_ajouter_mei(). 29 | 30 | Pour que la fonction opère, il est nécessaire que les tables ci-dessus (sauf mesure_individuelle) 31 | soient toutes dans l'environnement. 32 | } 33 | \examples{ 34 | \dontrun{ 35 | ma_passerelle <- mef_creer_passerelle() 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /man/mef_filtrer_id.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_filtrer_id.R 3 | \name{mef_filtrer_id} 4 | \alias{mef_filtrer_id} 5 | \title{Filtrer les prélèvements} 6 | \usage{ 7 | mef_filtrer_id( 8 | df, 9 | tb, 10 | var_id, 11 | var_sta = NULL, 12 | var_pro = NULL, 13 | min_obs, 14 | max_na_cons = NULL, 15 | max_pro = NULL, 16 | max_chg = NULL 17 | ) 18 | } 19 | \arguments{ 20 | \item{df}{data frame} 21 | 22 | \item{tb}{data frame} 23 | 24 | \item{var_id}{variable(s) identifiant les prélèvements} 25 | 26 | \item{var_sta}{variable identifiant les points de prélèvements (optionnelle)} 27 | 28 | \item{var_pro}{variable identifiant le protocole de pêche (optionnelle)} 29 | 30 | \item{min_obs}{numerique définissant le nombre minimal d'observations par prélèvement} 31 | 32 | \item{max_na_cons}{numerique définissant le nombre maximal de valeurs manquantes consécutives par prélèvement} 33 | 34 | \item{max_pro}{numerique définissant le nombre maximal de protocoles de pêche par prélèvement} 35 | 36 | \item{max_chg}{numerique définissant le nombre maximal de changement de protocole de pêche par prélèvement} 37 | } 38 | \value{ 39 | df 40 | } 41 | \description{ 42 | Filtrer les prélèvements 43 | } 44 | \examples{ 45 | \dontrun{ 46 | df <- mef_creer_passerelle() \%>\% 47 | mef_ajouter_ope_date() \%>\% 48 | mef_ajouter_ope_saison() \%>\% 49 | mef_ajouter_type_protocole() 50 | tb <- def_attribut_id (df, 51 | var_id = c(pop_id,saison), 52 | var_tmp = annee, 53 | var_pro = pro_libelle) 54 | df_id <- mef_filtrer_id(df, 55 | tb, 56 | var_id = c(pop_id, saison), 57 | var_sta = pop_id, 58 | var_pro = pro_libelle, 59 | min_obs = 10, 60 | max_na_cons = 3, 61 | max_pro = 1) 62 | df_id <- mef_filtrer_id(df, 63 | tb, 64 | var_id = pop_id, 65 | min_obs = 10, 66 | max_na_cons = 3) 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /man/mef_filtrer_nb_mini_annees.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_filtrer_nb_mini_annees.R 3 | \name{mef_filtrer_nb_mini_annees} 4 | \alias{mef_filtrer_nb_mini_annees} 5 | \title{Filtrer un dataframe pour ne conserver que les objets présents un nombre 6 | minimum d'années} 7 | \usage{ 8 | mef_filtrer_nb_mini_annees(df, nb_mini_annees, var_id) 9 | } 10 | \arguments{ 11 | \item{df}{Dataframe qui doit contenir un champ d'identifiant des observations (ex : pop_id).} 12 | 13 | \item{nb_mini_annees}{Nombre entier indiquant le seuil de sélection (nb mini d'années 14 | de données sur le point). Par défaut sa valeur est 1 donc tous les points avec 15 | au moins une donnée sont sélectionnées.} 16 | 17 | \item{var_id}{Caractère. Nom de la variable d'identification des observations. 18 | Par exemple si la variable d'identification des objets est "pop_id", seuls seront conservés 19 | les points pour lesquels il y a plus de nb_mini_annees années de données. Si la variable 20 | d'identification est "sta_id", seuls seront conservées les stations pour lesquels il y a 21 | plus de nb_mini_annees années de données.} 22 | } 23 | \value{ 24 | Dataframe filtré, c'est-à-dire exourgé des objets qui n'ont pas assez d'années 25 | de données. 26 | } 27 | \description{ 28 | Filtrer un dataframe pour ne conserver que les objets présents un nombre 29 | minimum d'années 30 | } 31 | \examples{ 32 | \dontrun{ 33 | data_22_filtre <- mef_filtrer_nb_mini_annees(df = data_22, nb_mini_annees = 1, var_id = "sta_id") 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /man/mef_filtrer_ope_id.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_filtrer_ope_id.R 3 | \name{mef_filtrer_ope_id} 4 | \alias{mef_filtrer_ope_id} 5 | \title{Filtrer les opérations de pêche} 6 | \usage{ 7 | mef_filtrer_ope_id( 8 | df, 9 | var_id, 10 | var_tmp, 11 | var_surf = NULL, 12 | var_pro = NULL, 13 | var_pds = NULL, 14 | var_mei = NULL, 15 | var_pas = NULL, 16 | var_date = NULL, 17 | default = FALSE 18 | ) 19 | } 20 | \arguments{ 21 | \item{df}{data frame} 22 | 23 | \item{var_id}{variable(s) identifiant les prélèvements} 24 | 25 | \item{var_tmp}{variable identifiant la date de prélèvement} 26 | 27 | \item{var_surf}{variable identifiant la surface de pêche (optionnelle)} 28 | 29 | \item{var_pro}{variable identifiant le protocole de pêche (optionnelle)} 30 | 31 | \item{var_pds}{variable identifiant la présence d'information sur les poids (optionnelle)} 32 | 33 | \item{var_mei}{variable identifiant la présence d'information sur les mesures individuelles (optionnelle)} 34 | 35 | \item{var_pas}{variable identifiant le numéro du passage de pêche (optionnelle)} 36 | 37 | \item{var_date}{variable identifiant une date additionnelle de pêche (optionnelle)} 38 | 39 | \item{default}{logique} 40 | } 41 | \value{ 42 | df 43 | } 44 | \description{ 45 | Filtrer les opérations de pêche 46 | } 47 | \examples{ 48 | \dontrun{ 49 | df <- mef_creer_passerelle() \%>\% 50 | mef_ajouter_ope_date() \%>\% 51 | mef_ajouter_surf_calc() \%>\% 52 | mef_ajouter_type_protocole() \%>\% 53 | mef_filtrer_ope_id(var_id = pop_id, 54 | var_tmp = annee, 55 | var_surf = ope_surface_calculee, 56 | var_pro = pro_libelle, 57 | default=TRUE) 58 | df <- mef_creer_passerelle() \%>\% 59 | mef_ajouter_ope_date() \%>\% 60 | mef_ajouter_surf_calc() \%>\% 61 | mef_ajouter_type_protocole() \%>\% 62 | mef_ajouter_poids() \%>\% 63 | mef_filtrer_ope_id(var_id = pop_id, 64 | var_tmp = annee, 65 | var_surf = ope_surface_calculee, 66 | var_pds = lop_poids) 67 | df <- df \%>\% 68 | mef_filtrer_ope_id(var_id = pop_id, 69 | var_tmp = annee, 70 | var_pro = pro_libelle, 71 | default=TRUE) 72 | } 73 | } 74 | -------------------------------------------------------------------------------- /man/mef_ipr_radar.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ipr_radar.R 3 | \name{mef_ipr_radar} 4 | \alias{mef_ipr_radar} 5 | \title{Mettre un dataframe au format pour ls graphiques en radar.} 6 | \usage{ 7 | mef_ipr_radar(metriques_df, pop_id) 8 | } 9 | \arguments{ 10 | \item{metriques_df}{Un dataframe contenant les métriques par station et par année, 11 | produit par la fonction ipr_extraire_metriques().} 12 | 13 | \item{pop_id}{Numérique entier. Identifiant du point de prélèvement (pop_id).} 14 | } 15 | \value{ 16 | Un dataframe mis en forme. 17 | } 18 | \description{ 19 | La fonction radarchart() du package \code{fmsb} nécessite en entrée un dataframe 20 | au format spécifique. 21 | } 22 | \examples{ 23 | \dontrun{ 24 | mef_ipr_radar <- ipr_mef_radar(metriques_df = metriques_22, pop_id = 41964) 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /man/mef_pivoter_var_env.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_pivoter_var_env.R 3 | \name{mef_pivoter_var_env} 4 | \alias{mef_pivoter_var_env} 5 | \title{Pivoter le dataframe pour regrouper les variables environnementales sur 2 colonnes} 6 | \usage{ 7 | mef_pivoter_var_env(df) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe avec les variables distance_mer, temp_janvier, etc.} 11 | } 12 | \value{ 13 | Le dataframe pivoté, en forme pour les graphiques avec ggplot2. 14 | } 15 | \description{ 16 | Pivoter le dataframe pour regrouper les variables environnementales sur 2 colonnes 17 | } 18 | \examples{ 19 | \dontrun{ 20 | df_long <- mef_pivoter_var_env(df_court) 21 | mes_graphiques[[1]] 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /man/mef_recoder_esp_code_alt.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_recoder_esp_code_alt.R 3 | \name{mef_recoder_esp_code_alt} 4 | \alias{mef_recoder_esp_code_alt} 5 | \title{Recodage des codes taxons 'esp_code_alternatif'} 6 | \usage{ 7 | mef_recoder_esp_code_alt(df, type_recodage = "especes") 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe contenant la variable esp_code_alternatif'.} 11 | 12 | \item{type_recodage}{Caractère, soit "especes" (par défaut), soit "ipr". 13 | Dans le premier cas, les codes taxons de sous-espèces ou écotype sont recodés à l'espèce. 14 | Dans le second cas, les codes taxons sont recodés selon la taxonomie de l'IPR, ici 15 | conformément au script 'IPR_v1.0.3_calc_consult.R' 16 | téléchargé depuis \url{https://seee.eaufrance.fr/} le 24/04/2023.} 17 | } 18 | \value{ 19 | Le dataframe mis à jour. 20 | } 21 | \description{ 22 | Recodage des codes taxons 'esp_code_alternatif' 23 | } 24 | \examples{ 25 | \dontrun{ 26 | # Calcul des captures par espèces pour chaque opération de pêche 27 | # chargement des packages 28 | library(dplyr) 29 | library(aspe) 30 | 31 | # chargement des données (à adapter) 32 | load(file = "raw_data/tables_sauf_mei_2023_04_07_09_39_32.RData") 33 | 34 | # création du tableau 35 | captures <- mef_creer_passerelle() \%>\% 36 | mef_ajouter_lots() \%>\% 37 | mef_ajouter_esp() \%>\% 38 | mef_recoder_esp_code_alt() \%>\% 39 | group_by(ope_id, esp_code_alternatif) \%>\% 40 | summarise(effectif = sum(lop_effectif)) \%>\% 41 | ungroup() 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /man/mef_ssech_abs.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ssech_abs.R 3 | \name{mef_ssech_abs} 4 | \alias{mef_ssech_abs} 5 | \title{Sous-échantillonner parmi les absences} 6 | \usage{ 7 | mef_ssech_abs(df, seed = 123) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe avec les variables valeur_parametre, esp_code_alternatif, presence, parametre, n.} 11 | 12 | \item{seed}{Numérique. La racine du générateur de nombres aléatoires pour le tirage.} 13 | } 14 | \value{ 15 | Un dataframe issu de df mais avec moins de lignes. 16 | } 17 | \description{ 18 | La comparaison entre les sites de présence et d'absence d'une espèce n'a de sens quer si leur nombre 19 | est comparable. IL ne sert à rien d'avoir l'altitude de 100 000 sites où le saumon est absent 20 | si l'on n'a que 1000 sites où il est présent. On allège donc le dataframe en tirant aléatoirement 21 | autant d'opérations d'absence qu'il y a de présence. 22 | } 23 | \examples{ 24 | \dontrun{ 25 | df_allege <- mef_ssech_abs(df = df_pres_abs_env) 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /man/mef_ssech_esp_env.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/mef_ssech_esp_env.R 3 | \name{mef_ssech_esp_env} 4 | \alias{mef_ssech_esp_env} 5 | \title{Sous-échantillonner le df environnement et occurrences} 6 | \usage{ 7 | mef_ssech_esp_env(df, seed = 123) 8 | } 9 | \arguments{ 10 | \item{df}{Dataframe avec les variables valeur_parametre, esp_code_alternatif, presence, parametre, n.} 11 | 12 | \item{seed}{Numérique. La racine du générateur de nombres aléatoires pour le tirage.} 13 | } 14 | \value{ 15 | Un dataframe issu de df mais avec moins de lignes. 16 | } 17 | \description{ 18 | La comparaison entre les sites de présence et d'absence d'une espèce n'a de sens que si leur nombre 19 | est comparable. IL ne sert à rien d'avoir l'altitude de 100 000 sites où le saumon est absent 20 | si l'on n'a que 100 sites où il est présent. On allège donc le dataframe en tirant aléatoirement 21 | autant un nombre d'opérations déterminé par le minimum du nb d'absences et de celui de présences. 22 | Le sous-échantillonnage est contraint par année. 23 | } 24 | \examples{ 25 | \dontrun{ 26 | df_allege <- mef_ssech_esp_env(df = df_pres_abs_env) 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /man/misc_charger_donnees_test.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/misc_charger_donnees_test.R 3 | \name{misc_charger_donnees_test} 4 | \alias{misc_charger_donnees_test} 5 | \title{Charger un extrait de la base Aspe qui permet d'effectuer des tests} 6 | \usage{ 7 | misc_charger_donnees_test() 8 | } 9 | \value{ 10 | Les dataframes dans l'environnement de travail. 11 | } 12 | \description{ 13 | Ces données servent aussi aux vignettes. 14 | } 15 | \examples{ 16 | \dontrun{ 17 | # chargement des données 18 | misc_charger_donnees_test() 19 | 20 | # vérification que les dataframes sont bien accessibles 21 | ls() 22 | 23 | # assemblage du jeu de données 24 | passerelle <- aspe::mef_creer_passerelle() 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /man/misc_derniere_date.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/misc_derniere_date.R 3 | \name{misc_derniere_date} 4 | \alias{misc_derniere_date} 5 | \title{Obtenir la date maxi saisie dans la base Aspe} 6 | \usage{ 7 | misc_derniere_date() 8 | } 9 | \value{ 10 | La date maximale trouvée 11 | } 12 | \description{ 13 | Cette fonction extrait l'ensemble des champs contenant la chaîne de caractère "date" 14 | dans l'ensemble des dataframes, en prend le max et omettant les dates ultérieures 15 | à la date système. 16 | } 17 | \examples{ 18 | \dontrun{ 19 | date_max <- misc_derniere_date() 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /man/misc_nom_dernier_fichier.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/misc_nom_dernier_fichier.R 3 | \name{misc_nom_dernier_fichier} 4 | \alias{misc_nom_dernier_fichier} 5 | \title{Obtenir le nom du plus récent des fichiers} 6 | \usage{ 7 | misc_nom_dernier_fichier(repertoire = NULL, pattern, recursive = FALSE) 8 | } 9 | \arguments{ 10 | \item{repertoire}{Chaîne de caractère. Chemin vers le répertoire à explorer. 11 | Par défaut c'est le répertoire de travail.} 12 | 13 | \item{pattern}{Chaîne de caractère (exprtession régulière) à retrouver dans le nom du fichier.} 14 | 15 | \item{recursive}{Booléen (TRUE ou FALSE). Indique si la recherche inclut les sous-répertoire. 16 | La valeur par défaut est FALSE donc les sous-répertoires sont exclus de la recherche.} 17 | } 18 | \value{ 19 | Le nom du plus récent des fichiers respectant la condition indiquée au pattern. 20 | } 21 | \description{ 22 | Recherche dans un répertoire, parmi les fichiers dont le nom correspond au pattern, 23 | celui qui est le dernier créé. 24 | } 25 | \examples{ 26 | \dontrun{ 27 | mon_fichier <- misc_nom_dernier_fichier(repertoire = "raw_data", pattern = "RData$") 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /tests/testthat.R: -------------------------------------------------------------------------------- 1 | # This file is part of the standard setup for testthat. 2 | # It is recommended that you do not modify it. 3 | # 4 | # Where should you do additional test configuration? 5 | # Learn more about the roles of various files in: 6 | # * https://r-pkgs.org/tests.html 7 | # * https://testthat.r-lib.org/reference/test_package.html#special-files 8 | 9 | library(testthat) 10 | library(aspe) 11 | 12 | test_check("aspe") 13 | -------------------------------------------------------------------------------- /tests/testthat/test-mef_ajouter_lots.R: -------------------------------------------------------------------------------- 1 | test_that("mef_ajouter_lots works", { 2 | 3 | misc_charger_donnees_test() 4 | 5 | passerelle <- mef_creer_passerelle() 6 | 7 | passerelle2 <- passerelle %>% 8 | mef_ajouter_lots() 9 | 10 | object <- setdiff(names(passerelle2), 11 | names(passerelle)) 12 | 13 | testthat::expect_identical(object, 14 | c("tyl_id", "tlo_id", "lop_effectif", "esp_code_alternatif")) 15 | }) 16 | -------------------------------------------------------------------------------- /tests/testthat/test-mef_creer_passerelle.R: -------------------------------------------------------------------------------- 1 | test_that("mef_creer_passerelle works", { 2 | 3 | misc_charger_donnees_test() 4 | 5 | passerelle <- mef_creer_passerelle() 6 | 7 | testthat::expect_identical(names(passerelle), 8 | c("sta_id", "pop_id", "ope_id", "pre_id", "lop_id")) 9 | }) 10 | -------------------------------------------------------------------------------- /vignettes/.gitignore: -------------------------------------------------------------------------------- 1 | *.html 2 | *.R 3 | -------------------------------------------------------------------------------- /vignettes/img/message_erreur_import.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/PascalIrz/aspe/8f806525376ecb32fb0fcc34ce3985a76bfcad59/vignettes/img/message_erreur_import.png --------------------------------------------------------------------------------