Aller au contenu principal
Physique, Chimie et Informatique

Programmation

3 janv. 2022

Sous-sections de Programmation

Physique, Chimie et Informatique > Programmation

Modélisation de données expérimentales

Physique, Chimie et Informatique > Programmation

Utilisation de numpy pour créer et gérer des vecteurs

import numpy as np

Remarque : Différence avec R, les indices commencent à 0.

Création manuelle à partir d’un ensemble de valeurs

tab = np.array([1, 2, 2.5, 3.2, 1.8])

Type de la structure

print(type(tab))

Type des données

print(tab.dtype)  # float64

Nombre de dimensions

print(tab.ndim)  # 1 vecteur, 2 matrice

Nombre de lignes et de colonnes

print(tab.shape)

Nombre total de valeurs

print(tab.size)

Type des données

tab = np.array([1, 2, 4])
print(tab.dtype)  # int64

tab = np.array([1, 2, 4], dtype=float)
print(tab.dtype)  # float64

tab = np.array([False, True, False, False], dtype=bool)
print(tab.dtype)  # bool

Remarque : il est possible de créer des tableaux d’objets tels que les dictionnaires (dtype=object)

Création d’une séquence de valeurs

Suite arithmétique de raison 1

tab = np.arange(start=0, stop=10)
print(tab)

Suite arithmétique de raison step

tab = np.arange(start=0, stop=10, step=2)
print(tab)

Suite linéaire (nombre de valeurs fourni et point final est inclus)

tab = np.linspace(start=0, stop=10, num=11)
print(tab)

Vecteur de valeurs toutes égales à 1

tab = np.ones(shape=5)
print(tab)

Vecteur de valeurs toutes égales à 0

tab = np.zeros(5)
print(tab)

Vecteur de valeurs toutes égales à 3.2

tab = np.full(shape=5, fill_value=3.2)
print(tab)

Conversion d’une liste en vecteur

lst = [4, 5, 6, 16, 18, 48, 64]
print(lst)
tab = np.asarray(lst, dtype=float)
print(tab)

Nombres aléatoires

Création d’un vecteur d’entiers aléatoires

À retenir

Pour size on peut utiliser un nombre à la place du tuple.

tab = np.random.randint(1, high=100, size=(1000,))
print(tab)

Création d’un vecteur de floats aléatoires compris entre 0 (inclus) et 1 (exclus)

tab = np.random.rand(1000)
print(tab)

Manipulation de fichiers

Chargement à partir d’un fichier

Remarque : Pas d’entête.

tab = np.loadtxt("vecteur.txt", dtype=float)
print(tab)

Sauvegarde d’un vecteur dans un fichier texte

lst = [np.random.randint(1, 10000) for i in range(1000)]
tab = np.asarray(lst, dtype=float)
np.savetxt("backup.txt", tab)

Redimensionnements

Ajout d’une valeur à la fin d’un tableau

tab = np.array([1, 2, 3, 4])
tab = np.append(
    tab, 5
)  # Ne modifie pas en place le tableau mais crée un nouveau tableau
print(tab)

Suppression d’un élément

tab = np.delete(
    tab, 2
)  # Ne modifie pas en place le tableau mais crée un nouveau tableau
print(tab)

Modification de la dimension (les nouvelles cases sont remplies par des 0)

tab.resize((10,))
print(tab)

Remarque : Autre écriture possible si vecteur :

tab.resize(10)

Concaténation de deux vecteurs

tab1 = np.random.rand(20)
tab2 = np.random.rand(15)
tab = np.append(tab1, tab2)
print(tab)

Filtrage - Extraction

À l’aide d’un vecteur de booléens

tab = np.array([1, 2, 3, 4])
cond = np.array([False, True, False, True])
print(tab[cond])
Avertissement
  • Si la longueur de cond trop petite, les valeurs qui manquent sont égales à False.
  • Si la longueur de cond trop grande, une exception est levée.

Une opération booléenne sur un vecteur retourne un vecteur de booléens

cond = tab > 2
print(cond)

Filtrage à l’aide d’une condition

new_tab = tab[tab > 2]
print(new_tab)

Fonctions accessibles

Si tab est défini par

tab = np.random.rand(1000)

Valeur maximale

print(np.max(tab))

Indice de la valeur maximale

print(np.argmax(tab))

Valeur minimale

print(np.min(tab))

Indice de la valeur minimale

print(np.argmin(tab))

Tri des valeurs

print(np.sort(tab))

Indices du vecteur trié

print(np.argsort(tab))

Vecteur constitué de valeurs toutes différentes

print(np.unique(tab))

Calculs sur les vecteurs

Moyenne

print(np.mean(tab))

Médiane

print(np.median(tab))

Variance

print(np.var(tab))

Quantile

print(np.percentile(tab, 50))

Somme

print(np.sum(tab))

Somme cumulée

print(np.cumsum(tab))

Calculs entre vecteurs

Avertissement

Principe : les calculs se font éléménts par éléments entre les vecteurs

x = np.array([1, 2, 3, 4, 5])
y = np.array([1, 2, 3, 4, 6])
z = x * y
u = x + y
v = x / y
w = x - y
t = x < y
print(z, u, v, w, t)

Fonctions matricielles

Produit scalaire

z = np.vdot(x, y)
print(z)

Calcul de la norme

n = np.linalg.norm(x)
print(n)

tab = np.array([2.1, 3.4, 6.7, 8.1, 3.5, 7.2])
tab = tab.reshape(2, 3)
print(tab.shape)
Physique, Chimie et Informatique > Programmation

Simulation d'un titrage conductimétrique

"""
Simulation du suivi conductimétrique pour le titrage
du sérum physiologique.
"""

import matplotlib.pyplot as plt
import csv
from scipy.stats import linregress


class Ion:
    """
    Définition d'un ion à prendre en compte dans le
    calcul de la conductivité d'une solution.
    """

    def __init__(self, nom, conduc=0, charge=0, n=0):
        self.nom = nom
        self.charge = charge  # Charge électrique (multiple de e)
        self.conductivite = conduc  # Conductivité molaire ionique
        self.quantite = n  # Quantité de matière (moles)

    @property
    def quantite(self):
        return self._quantite

    @quantite.setter
    def quantite(self, n):

        if n < 0:
            self._quantite = 0
        else:
            self._quantite = n

    def info(self):
        chaine = "Nom : {}\n".format(self.nom)
        chaine += "Charge électrique : {}e\n".format(self.charge)
        chaine += "Quantité de matière : {} mol\n".format(self.quantite)
        return chaine


class Solution:
    """
    Définition d'une solution ionique.
    """

    def __init__(self, liste_ions=[], volume=0):
        self.ions = liste_ions
        self.volume = volume

    def conductivite(self):

        conduc = 0
        for ion in self.ions:
            contrib = ion.conductivite * ion.quantite / self.volume
            conduc += contrib
        return conduc


def creation_fichier_resultat(nom_fichier, entete_x, entete_y, list_x, list_y):

    with open(nom_fichier, "w") as fichier:
        writer = csv.writer(fichier, dialect="excel")
        writer.writerow([entete_x, entete_y])

        for i in range(len(list_x)):
            writer.writerow((list_x[i], list_y[i]))


def affichage(list_v, list_conduc, list_regres):
    # Création d'une figure
    fig = plt.figure()
    # Création d'une sous-figure
    ax = fig.add_subplot(111)
    # Affichage des données
    ax.plot(list_v, list_conduc, "ro")
    ax.plot(list_v, list_regres, "b-")
    # Limites pour l'axe des abscisses
    ax.set_xlim(min(list_v) - 1e-3, max(list_v) + 1e-3)
    # Utilisation de l'écriture scientifique pour les valeurs
    ax.ticklabel_format(axis="both", style="sci", scilimits=(0, 0))
    # Label de l'axe des abscisses
    ax.set_xlabel(r"$V_2$ (L)")
    # Label de l'axe des ordonnées
    ax.set_ylabel(r"$\sigma$ ($\mathrm{S}\cdot\mathrm{m}^{-1}$)")
    # Affichage de la grille
    ax.grid()
    # Légende
    ax.set_title(r"Suivi conductimétrique sans effet de dilution")
    # Sauvegarde de la figure
    fig.savefig("conductimetrie_01.pdf")
    # Affichage de la figure
    plt.show()


def determination_intervalles(liste1, liste2):
    """
    Fonction qui, à partir de la liste liste1, possédant des valeurs
    décroissantes puis croissantes, retourne un tuple constitué de quatre
    listes ; la première ne contenant que les valeurs décroissantes, la
    deuxième les valeurs croissantes de la liste 1. Les deux autres listes
    correspondent aux parties correspondantes de la liste 2.
    """
    indice_du_min = liste1.index(min(liste1))
    liste1_1 = liste1[0:indice_du_min]
    liste1_2 = liste1[indice_du_min:]

    liste2_1 = liste2[0:indice_du_min]
    liste2_2 = liste2[indice_du_min:]
    return (liste2_1, liste1_1, liste2_2, liste1_2)


def regression_lineaire(vol_1, conduc_1, vol_2, conduc_2):
    lr1 = linregress(vol_1, conduc_1)
    lr2 = linregress(vol_2, conduc_2)

    drl = []
    for vol in vol_1:
        drl.append(lr1[0] * vol + lr1[1])
    for vol in vol_2:
        drl.append(lr2[0] * vol + lr2[1])

    return drl


def main():
    C = 3.2e-2  # Concentration des ions chlorure
    V = 10e-3  # Volume de sérum physiologique
    C2 = 2e-2  # Concentration des ions argent
    V2_max = 24  # Volume maximal de titrant versé (en mL)
    V_eau = 0.100  # Volume d'eau ajouté
    xE = C * V  # Avancement à l'équivalence

    ion_argent = Ion("ion argent", 6.2e-3, 1)
    ion_chlorure = Ion("ion chlorure", 7.6e-3, -1)
    ion_sodium = Ion("ion sodium", 5.0e-3, 1, C * V)
    ion_nitrate = Ion("ion nitrate", 7.1e-3, -1)

    sol = Solution([ion_argent, ion_chlorure, ion_sodium, ion_nitrate])

    # Volumes de titrant versés
    volumes = [i * 1e-3 for i in range(V2_max + 1)]
    conduc = []  # valeurs des conductivités dans la solution

    for V2 in volumes:
        n2 = C2 * V2
        ion_argent.quantite = n2 - xE
        ion_chlorure.quantite = C * V - n2
        ion_nitrate.quantite = n2
        # Partie à adapter si on veut montrer l'effet de la dilution
        sol.volume = V_eau + V + V2
        conduc.append(sol.conductivite())

    creation_fichier_resultat(
        "valeurs.csv", "Volumes (L)", "Conductivité (S.m^-1)", volumes, conduc
    )

    vol_1, conduc_1, vol_2, conduc_2 = determination_intervalles(conduc, volumes)
    droites_regression = regression_lineaire(vol_1, conduc_1, vol_2, conduc_2)

    affichage(volumes, conduc, droites_regression)

    print(volumes)
    print(vol_1, vol_2)


main()
11 oct. 2020
Physique, Chimie et Informatique > Programmation

Illustration des différents schemas pour la dérivation numérique

Code le plus simple possible et donc pas modulable du tout

"""
Différences finies centrées, ordre 02 en h.
Mise en évidence des erreurs de troncature et d'arrondis.
"""
from math import sin, cos

def df(x):
    return cos(x)


def err_centree(x, f, df, h):
    return abs(df(x) - (f(x + h / 2) - f(x - h / 2)) / h)


def err_progressive(x, f, df, h):
    return abs(df(x) - (f(x + h) - f(x)) / h)


def err_retrograde(x, f, df, h):
    return abs(df(x) - (f(x) - f(x - h)) / h)


def main():
    f = lambda x: sin(x)   # Fonction étudiée
    df = lambda x: cos(x)  # Fonction dérivée de la fonction étudiée
    x0 = 1                 # Point où le nombre dérivé est calculé
    hs = [1 / (10**i) for i in range(1, 15)]  # Liste des pas h

    print(
        "h \t\t Diff. finies Prog.   Diff. finies Retro.   Diff. finies centrées"
    )
    for h in hs:
        print("{:.1e} \t  {:.4e} \t  {:.4e} \t  {:.4e}".format(
            h, err_progressive(x0, f, df, h), err_retrograde(x0, f, df, h),
            err_centree(x0, f, df, h)))


main()