Apprendre Python avec ChemTHEATER 05-1

Partie 5 Graphique des données ChemTHEATER sur une carte (Partie 1)

Chap.0 Débit global

Dans la partie 5, la concentration de substance chimique mesurée est représentée sur une carte à l'aide des données ChemTHEATER. Pour ainsi dire, c'est un simple SIG.
Dans la première partie, nous visons à créer une animation en connectant le traitement des données au traçage sur la carte, et dans la seconde partie, les données d'image de sortie.

Chargement de la bibliothèque Chap.1

Si vous n'avez pas installé Cartopy, installez-le à l'avance.

conda install -c conda-forge cartopy

Ensuite, chargez la bibliothèque suivante.

%matplotlib inline
import os
import numpy as np
import pandas as pd
import itertools
import matplotlib.pyplot as plt
from cartopy import crs as ccrs

Encore une fois, nous commencerons par importer les bibliothèques nécessaires au traitement.
La première ligne est, comme d'habitude, une commande pour afficher la sortie de matplotlib.
Dans la partie 5, les bibliothèques suivantes seront utilisées. (Reportez-vous à la deuxième ligne et aux suivantes)
Les deux sont déjà installés dans Anaconda3 (version Windows 64 bits).
Cette fois, nous utiliserons cartopy pour afficher la carte sur le graphique de matplotlib.

Lecture des données Chap.2

Maintenant que la bibliothèque est prête, chargez les données. Puisque nous utiliserons les données des mammifères marins cette fois-ci, recherchez le type d'échantillon comme «Biotiques - Mammifères - Mammifères marins» dans la recherche d'échantillon de ChemTHEATER. Dans les résultats de la recherche, cliquez sur "Exporter les échantillons" et "Exporter les données de mesure" pour télécharger respectivement les fichiers de liste d'échantillons et de liste de valeurs de mesure. Enregistrez le fichier dans n'importe quel répertoire et lisez-le à partir de votre ordinateur portable comme suit.

data_file = "measureddata_20191002074038.tsv"    #Remplacez la chaîne de caractères saisie dans la variable par le nom de fichier tsv de vos données mesurées
data = pd.read_csv(data_file, delimiter="\t")
data = data.drop(["ProjectID", "ScientificName", "RegisterDate", "UpdateDate"], axis=1)    #Supprimer les colonnes en double lors de la jonction avec des échantillons ultérieurement
data

7103 rows × 9 columns

sample_file = "samples_20191002074035.tsv"    #Remplacez la chaîne de caractères entrée dans la variable par le nom de fichier tsv de vos échantillons
sample = pd.read_csv(sample_file, delimiter="\t")
sample

202 rows × 66 columns

Chap.3 Préparation des données

Préparez-vous à pouvoir tracer le DataFrame lu au Chap.2 sur la carte. Tout d'abord, combinez les données mesurées et les échantillons et supprimez la colonne N / A.

df = pd.merge(data, sample, on="SampleID")

df = df.dropna(how='all', axis=1)
df

7103 rows × 39 columns

Ensuite, extrayez les données nécessaires. Cette fois, nous traiterons des données sur quatre types de substances chimiques (ΣPCBs, ΣDDTs, ΣCHLs, ΣHCHs) avec l'unité [ng / g lipid].

data_lipid = df[df["Unit"] == "ng/g lipid"]
data_lipid = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") | (data_lipid["ChemicalName"] == "ΣDDTs") |
                        (data_lipid["ChemicalName"] == "ΣCHLs") | (data_lipid["ChemicalName"] == "ΣHCHs")]

Ceci termine l'extraction des données nécessaires. Pour confirmation, obtenez une liste des espèces et des noms chimiques inclus dans cet ensemble de données.

lipid_species = data_lipid["ScientificName"].unique()
lipid_chemicals = data_lipid["ChemicalName"].unique()

lipid_species, lipid_chemicals

(array(['Peponocephala electra', 'Neophocaena phocaenoides',
        'Sousa chinensis', 'Stenella coeruleoalba'], dtype=object),
 array(['ΣPCBs', 'ΣDDTs', 'ΣCHLs', 'ΣHCHs'], dtype=object))

Ici aussi, DataFrame / data_lipid est sorti au format CSV afin que les mêmes données puissent être utilisées dans la deuxième partie. La sortie CSV utilise la méthode to_csv de Pandas.

data_lipid.to_csv("data.csv")

Chap.4 Tracer sur la carte

Sec.4-1 Schéma de base

Ensuite, nous tracerons sur la carte, qui est la partie principale de ce temps. Mais d'abord, vérifions attentivement comment créer une carte.
Puisque le graphique sera cette fois sorti sur la carte, la carte sera sortie en premier. En Python, vous pouvez utiliser cartopy pour générer une carte sur matplotlib.

ax = plt.axes(projection=ccrs.PlateCarree())
ax.coastlines()
plt.show()

Ensuite, vérifiez la capture qui est superposée sur la carte. Cette fois, les points dans l'espace bidimensionnel de latitude et de longitude sont tracés en tant que points de mesure, de sorte que les données sont dessinées sous forme de carte de dispersion.
Avant de dessiner, triez les données pour chaque espèce incluse dans data_lipid.

df_0 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[0])]    #ΣPCB de Kazuhagondou
df_1 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[1])]    #ΣPCB de Sunameri
df_2 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[2])]    #Sinaus Iro Dolphin ΣPCBs
df_3 = data_lipid[(data_lipid["ChemicalName"] == "ΣPCBs") & (data_lipid["ScientificName"] == lipid_species[3])]    #Suji Dolphin ΣPCBs

Lorsque les données sont davantage divisées, essayez de les réveiller dans un diagramme de dispersion. Le dessin graphique de matplotlib peut être superposé dessus, vous pouvez donc ajouter des images une par une.

fig = plt.figure()
ax = plt.axes()

#CollectionLongitudeFrom,Extraire les informations de latitude et de longitude de CollectionLatitudeFrom
ax.scatter(x = np.array(df_0["CollectionLongitudeFrom"]), y = np.array(df_0["CollectionLatitudeFrom"]), c = "red", alpha=0.5)
ax.scatter(x = np.array(df_1["CollectionLongitudeFrom"]), y = np.array(df_1["CollectionLatitudeFrom"]), c = "blue", alpha=0.5)
ax.scatter(x = np.array(df_2["CollectionLongitudeFrom"]), y = np.array(df_2["CollectionLatitudeFrom"]), c = "yellow", alpha=0.5)
ax.scatter(x = np.array(df_3["CollectionLongitudeFrom"]), y = np.array(df_3["CollectionLatitudeFrom"]), c = "green", alpha=0.5)
plt.show()

Sec.4-2 Diagramme de dispersion + projection cylindrique à distance régulière

Maintenant que nous avons dessiné la figure de base, dessinons-la en la superposant.

fig = plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.coastlines()
ax.scatter(x = np.array(df_0["CollectionLongitudeFrom"]), y = np.array(df_0["CollectionLatitudeFrom"]), c = "red", alpha=0.5)
ax.scatter(x = np.array(df_1["CollectionLongitudeFrom"]), y = np.array(df_1["CollectionLatitudeFrom"]), c = "blue", alpha=0.5)
ax.scatter(x = np.array(df_2["CollectionLongitudeFrom"]), y = np.array(df_2["CollectionLatitudeFrom"]), c = "yellow", alpha=0.5)
ax.scatter(x = np.array(df_3["CollectionLongitudeFrom"]), y = np.array(df_3["CollectionLatitudeFrom"]), c = "green", alpha=0.5)
plt.show()

Sec.4-3 Amélioration de Sec.4-2

J'ai pu sortir pour le moment avec Sec.4-2. Cependant, dans l'état actuel, la portée de la carte est définie automatiquement. Ceci est uniquement traité automatiquement afin que toute la plage dans laquelle les données existent soit automatiquement traitée, de sorte que la plage change en fonction des données à traiter. Ici, la carte est fixée dans une plage appropriée.

En utilisant les méthodes set_xlim et set_ylim de matplotlib, la plage de la direction de l'axe X et la direction de l'axe Y du graphe à dessiner peut être déterminée respectivement.

fig = plt.figure()
ax = plt.axes(projection=ccrs.PlateCarree())
ax.coastlines()
ax.scatter(x = np.array(df_0["CollectionLongitudeFrom"]), y = np.array(df_0["CollectionLatitudeFrom"]), c = "red", alpha=0.5)
ax.scatter(x = np.array(df_1["CollectionLongitudeFrom"]), y = np.array(df_1["CollectionLatitudeFrom"]), c = "blue", alpha=0.5)
ax.scatter(x = np.array(df_2["CollectionLongitudeFrom"]), y = np.array(df_2["CollectionLatitudeFrom"]), c = "yellow", alpha=0.5)
ax.scatter(x = np.array(df_3["CollectionLongitudeFrom"]), y = np.array(df_3["CollectionLatitudeFrom"]), c = "green", alpha=0.5)
ax.set_xlim(90,180)    #Plage dans le sens de l'axe X (longitudinal) pour dessiner
ax.set_ylim(15, 60)    #Plage dans la direction de l'axe Y (latitude) pour dessiner
ax.set_title("ΣPCBs")
plt.show()

Chap.5 Sortie en une seule feuille

Comme vous pouvez le voir dans

Chap.3, ce DataFrame contient des données de 4 types de substances chimiques, donc sortons-les sous la forme de 4 côte à côte. </ p>

Tout d'abord, comme nous l'avons fait au chapitre 4, nous trions les données pour chaque substance chimique, mais comme il y a 16 combinaisons au total (4 types de substances biologiques et chimiques chacune), nous les énumérerons ici. Collectivement, il prend la forme d'une lecture séquentielle lors du dessin. À ce stade, il est nécessaire de générer chaque combinaison (par exemple, les ΣPCB de Snameri), utilisez donc la fonction de l'itérateur de Python ^{1 pour produire directement. Nous demanderons 2 . En d'autres termes, le produit direct de la liste des substances chimiques (lipid_chemicals) et de la liste des noms d'espèces (lipid_species) est obtenu, et les 16 modèles de combinaison sont dérivés.}

df_list = []
for k1, k2 in itertools.product(lipid_chemicals, lipid_species):
    df_list.append(data_lipid[(data_lipid["ChemicalName"] == k1) & (data_lipid["ScientificName"] == k2)])    #Extraire les données pour chaque combinaison

ax = [0]*4
fig = plt.figure(figsize=(16, 9))
for i in range(4): 
    ax[i] = fig.add_subplot(2, 2, i+1, projection=ccrs.PlateCarree())    #Zone ajoutée pour dessiner un graphique
    ax[i].coastlines()
    ax[i].scatter(x = np.array(df_list[4*i+0]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+0]["CollectionLatitudeFrom"]),
                  c = "red", alpha=0.5)    #Kazuhagondou
    ax[i].scatter(x = np.array(df_list[4*i+1]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+1]["CollectionLatitudeFrom"]), 
                  c = "blue", alpha=0.5)    #Snameri
    ax[i].scatter(x = np.array(df_list[4*i+2]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+2]["CollectionLatitudeFrom"]), 
                  c = "yellow", alpha=0.5)    #Sinaus Iro Dolphin
    ax[i].scatter(x = np.array(df_list[4*i+3]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+3]["CollectionLatitudeFrom"]), 
                  c = "green", alpha=0.5)    #Dauphin Suji
    ax[i].set_xlim(90,180)
    ax[i].set_ylim(15, 60)
    ax[i].set_title(lipid_chemicals[i])
plt.show()

Cela ne reflète que les points de mesure, alors essayez également de tracer les valeurs mesurées sur la carte. Reflétons-le dans le rayon de chaque point de pulvérisation. Tout ce que vous avez à faire est d'assigner les données de la colonne MeasuredValue au paramètre s de la méthode scatter qui dessine le diagramme de dispersion.

fig = plt.figure(figsize=(16, 9))
for i in range(4): 
    ax[i] = fig.add_subplot(2, 2, i+1, projection=ccrs.PlateCarree())
    ax[i].coastlines()
    ax[i].scatter(x = np.array(df_list[4*i+0]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+0]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+0]["MeasuredValue"]), c = "red", alpha=0.5)
    ax[i].scatter(x = np.array(df_list[4*i+1]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+1]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+1]["MeasuredValue"]), c = "blue", alpha=0.5)
    ax[i].scatter(x = np.array(df_list[4*i+2]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+2]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+2]["MeasuredValue"]), c = "yellow", alpha=0.5)
    ax[i].scatter(x = np.array(df_list[4*i+3]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+3]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+3]["MeasuredValue"]), c = "green", alpha=0.5)
    ax[i].set_xlim(90,180)
    ax[i].set_ylim(15, 60)
    plt.title(lipid_chemicals[i])
plt.show()

Si la valeur de MeasuredValue est substituée telle qu'elle est dans le rayon du point de diffusion, le cercle du graphique de ΣDDT deviendra grand et tout se chevauchera, donc ajustez pour que le rayon soit petit. Ici, la taille est uniformément fixée à 1/10.

fig = plt.figure(figsize=(16, 9))
rate = [10,10,10,10]    #Échelle d'indication variable
for i in range(4): 
    ax[i] = fig.add_subplot(2, 2, i+1, projection=ccrs.PlateCarree())
    ax[i].coastlines()
    ax[i].scatter(x = np.array(df_list[4*i+0]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+0]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+0]["MeasuredValue"])/rate[i], c = "red", alpha=0.3)
    ax[i].scatter(x = np.array(df_list[4*i+1]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+1]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+1]["MeasuredValue"])/rate[i], c = "blue", alpha=0.3)
    ax[i].scatter(x = np.array(df_list[4*i+2]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+2]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+2]["MeasuredValue"])/rate[i], c = "yellow", alpha=0.3)
    ax[i].scatter(x = np.array(df_list[4*i+3]["CollectionLongitudeFrom"]), y = np.array(df_list[4*i+3]["CollectionLatitudeFrom"]), s=np.array(df_list[4*i+3]["MeasuredValue"])/rate[i], c = "green", alpha=0.3)
    ax[i].set_xlim(90,180)
    ax[i].set_ylim(15, 60)
    plt.title(lipid_chemicals[i])
plt.show()

Vous pouvez maintenant tracer les résultats de mesure sur la carte. Cependant, comme toutes les données sont affichées de manière superposée, il est très difficile de voir, et sur cette figure, les changements dans le temps ne peuvent être vus. Dans la deuxième partie, nous animerons pour résoudre ces problèmes.

note de bas de page

^{1 Un itérateur est un mécanisme qui accède à plusieurs reprises à l'élément suivant dans un type qui recueille des données telles qu'une liste.}

^{2 Le produit direct consiste à créer un nouvel ensemble en extrayant un élément de chaque ensemble et en créant un ensemble comme indiqué dans la figure ci-dessous. Aussi avec le produit cartésien.}