# data[].attributes.attachment_link.readable_text
﻿# Créé par Jean Michel et Christophe, le 23/05/2020 en Python 3.4

import numpy as np
from matplotlib import pyplot

#Renvoie une valeur aléatoire de la variable L[0] d'incertitude-type L[1]
def Alea(L):
    tirage=np.random.normal()
    return L[0]+L[1]*tirage

#Compléter les trois lignes suivantes avec la grandeur physique et son incertitude
C=[5e-9,1e-9] # Capacité en F
S=[5000e-4,2e-4] # Surface des armatures du condensateur en m²
e=[1.8e-3,0.1e-3] #Distances entre les armatures du condensateur en m

#Méthode de Monte Carlo pour déterminer la permittivité relative du diélectrique et son incertitude
LwK=[]
Iteration=100000

for j in range(Iteration):
    AleawK=Alea(C)*Alea(e)/(Alea(S)*8.85e-12)
    LwK.append(AleawK)

MoywK=sum(LwK)/Iteration
uwK=(1/(Iteration-1)*sum((np.array(LwK)-MoywK)**2.))**0.5

print('Permittivité relative εr du diélectrique :', MoywK,' ')
print('u(εr) :', uwK,' ')
pyplot.hist(LwK, range = (1, 3), bins = 50, color = 'blue', edgecolor = 'black')
pyplot.xlabel('εr')
pyplot.ylabel('effectif')
pyplot.title('Pour 100 000 iterations')
pyplot.show()

# data[].attributes.attachment_link.readable_text
﻿# Créé par Jean Michel et Christophe, le 23/05/2020 en Python 3.4

import numpy as np
import math
import matplotlib.pyplot as plt

# Définitions des variables et du nombre de points à tracer
alpha = 40
v_ini = 10
g = 9.8
m = 0.050
nbt = 21
# Définitions des fonctions à tracer
t = np.linspace(0, 1.3, nbt)
vx = np.cos(math.pi/180*alpha)*v_ini
vy = np.sin(math.pi/180*alpha)*v_ini-g*t
y = np.sin(math.pi/180*alpha)*v_ini*t-0.5*g*t*t

# Graphes à tracer : formules, couleurs, titres, échelles
plt.plot(t,0.5*m*(vx*vx+vy*vy),'b+', label="Ec(t)") # ligne à compéter
plt.plot(t, m*g*y,'r+', label="Epp(t)") # ligne à compéter
plt.plot(t, m*g*y+0.5*m*(vx*vx+vy*vy),'g+', label="Em(t)") # ligne à compéter
plt.legend()
plt.xlim(0,1.3)
plt.ylim(0,2.8)
plt.title('Evolution au cours du temps des différentes énergies', color='black', fontsize=16)
plt.xlabel('temps (s)', color ='grey')
plt.ylabel('Energies (J)', color ='grey')

plt.show()





# data[].attributes.attachment_link.readable_text
﻿# Créé par Jean Michel et Christophe, le 23/05/2020 en Python 3.4

import matplotlib.pyplot as plt

x = [0.0,0.01,0.03,0.07,0.12,0.19,0.28,0.38]
t = [0,0.1,0.2,0.3,0.4,0.5,0.6,0.7]
vx = [0,0.15,0.31,0.46,0.61,0.77,0.92,1.07]

nb_pas = len(t)-1
ech_v = 0.01 # échelle des vecteurs
plt.title("Vecteurs accélérations du mouvement rectiligne",color='green',fontsize=12) # titre au graphe avec couleur et taille de police
plt.xlabel('x (m)', color='grey')# titre à l’axe des abscisses
plt.ylabel('y (m)', color='grey')
for i in range(1, nb_pas):
    plt.axis([0,0.3,0,0.2]) # impose les valeurs min et max sur l’axe des abscisses et des ordonnées
    Dt=t[i+1]-t[i-1]  # formule pour déterminer l'intervalle de temps
    ax = (vx[i+1]-vx[i-1])/(2*Dt)

    plt.arrow(x[i], 0.1, ax*ech_v, 0*ech_v, head_width = 0.005, \
    head_length = 0.005 , length_includes_head = True, color="g" )

    plt.pause(Dt)
    plt.plot(x[i], 0.1,"ro")

# data[].attributes.attachment_link.readable_text
﻿# Créé par Jean Michel et Christophe, le 23/05/2020 en Python 3.4

import numpy as np
import matplotlib.pyplot as plt
from scipy import stats


# Les 2 lignes suivantes sont à compléter
a = np.array([0.39,0.72,1.0,1.5])# valeurs de demi grand axe en UA
T = np.array([88,225,365,686])# valeurs de périodes de révolution en jours

a3=a*a*a
T2=T*T

plt.xlabel("a³(U.A³)")
plt.ylabel("T²(j²)")
plt.scatter(a3,T2,c='red',marker='+', s=70)
plt.title("Vérification de la troisième loi de Kepler",color='grey')
plt.grid()
plt.axis([0,4,0,500000])
slope, intercept, r_value, p_value, std_err = stats.linregress(a3,T2) # calcul de regression linéaire
print("la valeur du coefficient directeur est : ",round(slope,1)," j².U.A⁻³") # affiche le coefficient directeur dans la console

plt.show() # affiche la figure à l'écran

# data[].attributes.attachment_link.readable_text
﻿# Créé par Jean Michel et Christophe, le 23/05/2020 en Python 3.4

from math import *

# Les 3 lignes suivantes sont à compléter
thêta = [0, 27, 53, 77, 100, 121, 141, 160, 178, 196, 215, 234, 255, 277, 301, 327, 354, 381] # angle en degré par rapport à l'axe horizontal
r =[1.381, 1.394, 1.430, 1.479, 1.535, 1.587, 1.629, 1.656, 1.666, 1.659, 1.636, 1.598, 1.548, 1.493, 1.441, 1.401, 1.382, 1.389] # rayon vecteur en U.A = distance Soleil-Mars
jours = 42 # intervalle de temps en jours entre deux dates du tableau

nb_pas = len(thêta)# nombre d'intervalles pour les calculs

for i in range(1, nb_pas) :
    A = 0.5 * r[i] * r[i-1] * sin((thêta[i]-thêta[i-1])*pi/180) #aire modélisée par un triangle
    print("L'aire balayée par le rayon vecteur au point", i, "est de",round(A,2),"U.A\u00B2 en",jours,"jours.")#affiche l'aire avec 3 chiffres derrière la virgule

squares = []
for i in range(1, nb_pas-1) :
    squares.append(0.5 * r[i] * r[i-1] * sin((thêta[i]-thêta[i-1])*pi/180))

#Aire totale = somme des aires complètes + aire du dernier triangle curviligne
S=(sum(squares)+0.5* r[1]*r[0]* sin((thêta[1]-thêta[0])*pi/180)*(360-thêta[nb_pas-2])/(thêta[nb_pas-1]-thêta[nb_pas-2]))
#Calcul de valaur moyenne des aires des triangles curvilignes
M=sum(squares)/(nb_pas-2)

print("la moyenne des aires balayées par le rayon vecteur aux différents points i est ",round(M,3),"U.A\u00B2en",jours,"jours.")
print("l'aire de l'ellipse est : ",round(S,2),"U.A\u00B2")

# data[].attributes.attachment_link.readable_text
﻿# Créé par Jean Michel et Christophe, le 23/05/2020 en Python 3.4

import numpy as np
import matplotlib.pyplot as plt

# Les 2 lignes suivantes sont à compléter
thêta = [0, 27, 53, 77, 100, 121, 141, 160, 178, 196, 215, 234, 255, 277, 301, 327, 354, 381] # angle en degré par rapport à l'axe horizontal
r =[1.381, 1.394, 1.430, 1.479, 1.535, 1.587, 1.629, 1.656, 1.666, 1.659, 1.636, 1.598, 1.548, 1.493, 1.441, 1.401, 1.382, 1.389] # rayon vecteur en U.A = distance Soleil-Mars
radian = np.radians(thêta) # Convertir les degrés en radians

# Convertir les coordonnées polaires en coordonnées cartésiennes
x=r*np.cos(radian)
y=r*np.sin(radian)

plt.scatter(x,y,c='red',marker='+', s=70)
plt.scatter(0,0,c='yellow',marker='.', s=2000)
plt.scatter(0,0,c='black',marker='+', s=70)
plt.title("Trajectoire de Mars dans le référentiel héliocentrique",color='grey')
plt.xlabel("x (U.A)")
plt.ylabel("y (U.A)")
plt.annotate('Soleil', xy = (-0.05, -0.2))

plt.show() # affiche la figure à l'écran

# data[].attributes.attachment_link.readable_text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
__author__ = "Didier Lommelé"
__copyright__ = ""
__credits__ = []
__license__ = "CC BY-NC-SA"
__version__ = "1.1.1"
__maintainer__ = "Didier Lommelé"
__email__ = "didier.lommele@ac-nanct-metz.fr"
__status__ = "Académie de Nancy-Metz -Traam"

"""
from matplotlib import pyplot
from math import *

def Moyenne(Liste):
    S=0
    for elem in Liste:
        S=S+elem
    return (S/len(Liste))

def Ecart_type(Liste,moyenne):
    S=0
    for elem in Liste:
        S=S+(abs(elem-moyenne)*abs(elem-moyenne))
    S=S/len(Liste)
    return (S**(0.5))

LISTE=[12.2,11.8,12.1,11.9,12.0,12.05,11.98,11.95,13.05] #la liste des valeurs

sup=max(LISTE)+0.05*(max(LISTE)-min(LISTE)) #pour centrer les résultats
inf=min(LISTE)-0.05*(max(LISTE)-min(LISTE))

#calculs de la moyenne, de l'ecart type et de l'incertitude type
moy=Moyenne(LISTE)
ec=Ecart_type(LISTE,moy)
it=ec/((len(LISTE))**0.5)

#choix de la largeur d'une colonne
pas=it

#On découpe en 10 tranches
bins1 = [moy-5*pas,moy-4*pas,moy-3*pas,moy-2*pas,moy-1*pas,moy,moy+pas,moy+2*pas,moy+3*pas,moy+4*pas,moy+5*pas]


res = pyplot.hist(LISTE, range = (inf, sup),color='blue', bins = bins1)
pyplot.show()

# data[].attributes.body
à dézipper avec fichiers source format .md

# data[].attributes.attachment_link.readable_text
Auteur : Laurent Agénor ( laurent.agenor@ac-nancy-metz.fr)

Date : 2020/05/28

Modèle du condensateur
Citer des ordres de grandeur de valeurs de capacités usuelles.
Relation entre charge et tension
Identifier et tester le comportement capacitif d'un dipôle.

Capacité d'un condensateur.
Illustrer qualitativement, par exemple à l'aide d'un microcontrôleur, d'un multimètre ou d'une carte d'acquisition, l'effet de la géométrie d'un condensateur sur la valeur de sa capacité.

Modèle du circuit RC série :
Charge d'un condensateur par une source idéale de tension, décharge d'un condensateur, temps caractéristique.
Établir et résoudre l'équation différentielle vérifiée par la tension aux bornes d'un condensateur dans le cas de sa charge par une source idéale de tension et dans le cas de sa décharge.

Étudier la réponse d'un dispositif modélisé par un dipôle RC. Capteurs capacitifs.
Expliquer le principe de fonctionnement de quelques capteurs capacitifs.

Déterminer le temps caractéristique d'un dipôle RC à l'aide d'un microcontrôleur, d'une carte d'acquisition ou d'un oscilloscope.

Capacité mathématique:
Résoudre une équation différentielle linéaire du premier ordre à coefficients constants avec un second membre constant.

Réaliser
un montage électrique pour étudier la charge et la décharge d'un condensateur dans un circuit RC.

Trois capacités expérimentales sont communes à l'ensemble des thèmes :
-respecter les règles de sécurité liées au travail en laboratoire;
-mettre en œuvre un dispositif d'acquisition et de traitement de données: microcontrôleur,interface d'acquisition, tableur, langage de programmation;
-utiliser un logiciel de simulation.

Le condensateur est un dipôle élementaire qui, comme le résistor, peut constituer une composante de la modélisation d'un dipôle dit alors capacitif.

Qu'est-ce qui permet de mettre en évidence le caractère capacitif d'un dipôle ?

Comment quantifier cette caractéristique ?

Les deux activités proposées permettent de répondre à ces questions.

L'activité 1 est une phase préparatoire qui peut se mener en classe inversée. Des scripts python à modifier servent à faire le lien entre les équations, les outils numériques et les comportements du condensateur.

L'activité 2 se fait en classe sous forme de travaux pratiques. Elle utilise une carte à microcontroleur et fait appel à des notions de programmation en C/C++ pour la carte et en python.

# data[].attributes.attachment_link.description
Auteur : Laurent Agénor ( laurent.agenor@ac-nancy-metz.fr) Date : 2020/05/28 Modèle du condensateur Citer des ordres de grandeur de valeurs de capacités usuelles. Relation entre charge et tension Identifier et tester le comportement capacitif d'un dipôle. Capacité d'un condensateur.

# data[].attributes.attachment_link.readable_text
On pourra s'appuyer sur les documents 1, 2 et 3 pour réaliser les activités 1 et 2.

Capacité d'un condensateur.
Illustrer qualitativement, par exemple à l'aide d'un microcontrôleur, d'un multimètre ou d'une carte d'acquisition, l'effet de la géométrie d'un condensateur sur la valeur de sa capacité.

Capteurs capacitifs.
Expliquer le principe de fonctionnement de quelques capteurs capacitifs.
Étudier la réponse d'un dispositif modélisé par un dipôle RC.
Déterminer le temps caractéristique d'un dipôle RC à l'aide d'un microcontrôleur, d'une carte d'acquisition ou d'un oscilloscope.

Le condensateur est utilisé principalement pour:

stabiliser une alimentation électrique (il se décharge lors des chutes de tension et se charge lors des pics de tension) ;

traiter des signaux périodiques (filtrage...) ;

séparer le courant alternatif du courant continu, ce dernier étant bloqué par le condensateur ;

stocker de l'énergie, auquel cas on parle de supercondensateur;

mesurer des grandeurs physiques à l'aide de capteurs capacitifs.

Angle

distance

profondeur

etc.

Exemple : Détecteurs capacitifs

Source : Automation24

Les détecteurs capacitifs détectent sans contact divers objets. Contrairement aux détecteurs inductifs qui ne détectent que des objets métalliques, les détecteurs capacitifs permettent également la détection de matières non métalliques.

Des applications typiques se trouvent dans les industries suivantes : bois, papier, verre, plastique, agroalimentaire, chimie et semi-conducteurs.

Ce type de détecteur est recommandé quand :

Les distances de détection sont relativement faibles.

Les conditions de montage nécessitent la noyabilité du détecteur.

On doit effectuer la détection d'un matériau non conducteur à travers une paroi elle-même non conductrice (exemple : détection de verre à travers un emballage en carton).

Principe de fonctionnement

Les détecteurs de proximité capacitifs sont conçus pour fonctionner par création d'un champ électrostatique et par détection des modifications de ce champ créées par une cible approchant de la face de détection.

Schéma source : lycees.ac-rouen

La capacité C du condensateur, qui est sa caractéristique électrique caractéristique, se modifie selon qu'il y ait présence ou pas d'objet dans le champ électrique.

Pour un capteur capacitif, c'est qui se modifie donc selon la présence d'un objet dans la zone utile.

D'une façon générale, pour un condensateur plan :

Les capteurs capacitifs voient donc leurs capacités modifiées, soit par modification de leur permittivité relative , soit par modification de la distance entre les armatures ou par modification de la surface .

Capacité d'un condensateur.
Illustrer qualitativement, par exemple à l'aide d'un microcontrôleur, d'un multimètre ou d'une carte d'acquisition, l'effet de la géométrie d'un condensateur sur la valeur de sa capacité.

Cette partie s'adresse aux élèves qui souhaitent expérimenter en autonomie après avoir fait les activités 1 et 2..

( Source : Laure Bourgeois)

Pour fabriquer un tel condensateur, vous avez à votre disposition un rouleau d'aluminium (conducteur) ainsi que du papier (isolant). Dans le rouleau d'aluminium, découper un morceau carré (de côté environ égal à 20 cm) jouant le rôle de première armature, puis un second morceau de dimension plus grande jouant le rôle de seconde armature. Dans une feuille de papier découper également un morceau de taille approximativement égale à celle du plus grand morceau d'aluminium, jouant le rôle d'isolant.

C'est la structure des écrans tactiles capacitifs.

Calculer la valeur de la capacité de condensateurs en faisant varier différents éléments de sa géométrie.

la surface S du condensateur

la distance d entre plaques

Quelle est la valeur de la capacité de votre condensateur maison, sans pression puis lorsque vous posez un livre dessus ?

Modèle du condensateur
Citer des ordres de grandeur de valeurs de capacités usuelles.
Relation entre charge et tension
Identifier et tester le comportement capacitif d'un dipôle.

Le condensateur est un composant électronique élémentaire, constitué de deux armatures conductrices (appelées " électrodes ") en influence totale et séparées par un isolant polarisable (ou " diélectrique "). Sa propriété principale est de pouvoir stocker des charges électriques opposées sur ses armatures.

La valeur absolue de ses charges est proportionnelle à la valeur absolue de la tension qui lui est appliquée. Le condensateur est caractérisé par le coefficient de proportionnalité entre charge et tension appelé capacité électrique et exprimée en farads (F). La relation caractéristique d'un condensateur idéal est :

Pendant la charge du condensateur, et varient dans le temps, ce sont des variables, on pourra noter :

L'intensité du courant électrique est un débit de charges :

on en déduit :
Le courant de charge (ou décharge) d'un condensateur est donc proportionnel à sa capacité et à la dérivée de la tension à ses bornes.

Modèle du circuit RC série :
Charge d'un condensateur par une source idéale de tension, décharge d'un condensateur, temps caractéristique.
Établir et résoudre l'équation différentielle vérifiée par la tension aux bornes d'un condensateur dans le cas de sa charge par une source idéale de tension et dans le cas de sa décharge.

Capacité mathématique:
Résoudre une équation différentielle linéaire du premier ordre à coefficients constants avec un second membre constant.

Trois capacités expérimentales sont communes à l'ensemble des thèmes :
-respecter les règles de sécurité liées au travail en laboratoire;
-mettre en œuvre un dispositif d'acquisition et de traitement de données: microcontrôleur,interface d'acquisition, tableur, langage de programmation;
-utiliser un logiciel de simulation.

Une équation différentielle d'ordre 1 est une équation qui peut s'écrire sous la forme :

On va prendre comme approximation pour l'expression précédente :

et

avec

et

Quelques exemples d'équation différentielle d'ordre 1 :

Chute libre :
Moteur à courant continu : Évolution de population de coléoptère (modèle basique) : Évolution de population de coléoptère (modèle logistique) :
Ces équations admettent des solutions uniques.

# data[].attributes.attachment_link.description
On pourra s'appuyer sur les documents 1, 2 et 3 pour réaliser les activités 1 et 2. Capacité d'un condensateur. Illustrer qualitativement, par exemple à l'aide d'un microcontrôleur, d'un multimètre ou d'une carte d'acquisition, l'effet de la géométrie d'un condensateur sur la valeur de sa capacité. Capteurs capacitifs.

# data[].attributes.attachment_link.readable_text
Citer des ordres de grandeur de valeurs de capacités usuelles.
Relation entre charge et tension.
Identifier et tester le comportement capacitif d'un dipôle.

Capacité d'un condensateur.

Illustrer qualitativement, par exemple à l'aide d'un microcontrôleur, d'un multimètre ou d'une carte d'acquisition, l'effet de la géométrie d'un condensateur sur la valeur de sa capacité.

Modèle du circuit RC série :

Charge d'un condensateur par une source idéale de tension, décharge d'un condensateur, temps caractéristique.
Établir et résoudre l'équation différentielle vérifiée par la tension aux bornes d'un condensateur dans le cas de sa charge par une source idéale de tension et dans le cas de sa décharge.

Capteurs capacitifs.

Expliquer le principe de fonctionnement de quelques capteurs capacitifs.Étudier la réponse d'un dispositif modélisé par un dipôle RC.

Déterminer le temps caractéristique d'un dipôle RC à l'aide d'un microcontrôleur, d'une carte d'acquisition ou d'un oscilloscope.

Capacité mathématique:

Résoudre une équation différentielle linéaire du premier ordre à coefficients constants avec un second membre constant.

Trois capacités expérimentales sont communes à l'ensemble des thèmes :

-respecter les règles de sécurité liées au travail en laboratoire; langage de programmation;
-mettre en œuvre un dispositif d'acquisition et de traitement de données: microcontrôleur,interface d'acquisition, tableur,
-utiliser un logiciel de simulation.

Pour un circuit RC série, nous allons étudier la charge et la décharge d'un condensateur. Certaines propriétés des dipôles capacitifs seront mis en évidence.

Cette partie vise à montrer également que la résolution numérique rejoint la résolution analytique et qu'elle admet certaines limites et avantages.

On approche la notion de filtrage également.

Considérons le montage suivant :

Le Générateur Basse Fréquence ( GBF) est "réglé" de façon à délivrer un signal créneaux 0-5V. Ainsi, il y aura deux phases de fonctionnement :

Remarques :

Cette méthode, appelée méthode d' Euler, est-elle efficace ? Pour le savoir, il faudrait comparer la courbe obtenue avec la solution vraie.

1.Tester le script suivant [ici 🡕] qui trace les deux courbes, charge et décharge sur le même graphique.
2. Donner les solutions analytiques des équations différentielles suivantes:

et

Modifier le pas de résolution en jouant sur le nombre n de points calculés. Conclusion ?

Le script suivant permet de créer un signal créneaux qui est fonction du temps:

au lieu de :

Tester [ici 🡕].

Modifier la période de u(t), que se passe-t-il lorsque T est trop petit (par exemple T=3.tau)

Il devient alors facile de tester le circuit RC avec n'importe quel type de signal, il suffit de définir .

Une des méthodes pour déterminer la capacité d'un condensateur consiste à mesurer la valeur efficace de et/ou son déphasage par rapport à en fonction de la fréquence.

Cette propriété peut être visualisée [ici 🡕].
On peut tester avec différentes valeurs de R et de C.
Cette propriété est exploitée dans l' activité2.

# data[].attributes.attachment_link.description
Citer des ordres de grandeur de valeurs de capacités usuelles. Relation entre charge et tension. Identifier et tester le comportement capacitif d'un dipôle. Capacité d'un condensateur. Illustrer qualitativement, par exemple à l'aide d'un microcontrôleur, d'un multimètre ou d'une carte d'acquisition, l'effet de la géométrie d'un condensateur sur la valeur de sa capacité.

# data[].attributes.attachment_link.readable_text
Il s'agit plus ici d'une introduction à une activité qu'un TP élève. Chacun pourra s'inspirer de ce document pour créer son propre TP

Modèle du circuit RC série :
Charge d'un condensateur par une source idéale de tension, décharge d'un condensateur, temps caractéristique.
Établir et résoudre l'équation différentielle vérifiée par la tension aux bornes d'un condensateur dans le cas de sa charge par une source idéale de tension et dans le cas de sa décharge.

Étudier la réponse d'un dispositif modélisé par un dipôle RC. Capteurs capacitifs.
Expliquer le principe de fonctionnement de quelques capteurs capacitifs.

Déterminer le temps caractéristique d'un dipôle RC à l'aide d'un microcontrôleur, d'une carte d'acquisition ou d'un oscilloscope.

Réaliser
un montage électrique pour étudier la charge et la décharge d'un condensateur dans un circuit RC.

Trois capacités expérimentales sont communes à l'ensemble des thèmes :
-respecter les règles de sécurité liées au travail en laboratoire;
-mettre en œuvre un dispositif d'acquisition et de traitement de données: microcontrôleur,interface d'acquisition, tableur, langage de programmation;
-utiliser un logiciel de simulation.

Mesurer la capacité d'un condensateur par la méthode des 63%.
On souhaite faire une série de mesures pour éventuellement en faire une étude statistique.

Le condensateur initialement déchargé va être chargé jusqu'à atteindre 63% de sa charge finale. En mesurant ce temps, on a accés à RC.

d'où le nom de " méthode des 63%"

Dans l'ordre, elle fera :

Python récupère les données envoyées sur le port série (USB). On choisit le nombre de mesure à effectuer. Les valeurs récupérées sont stockée dans une liste. Quelques histogrammes sont tracés à partir de ces valeurs en modifiant le nombre de catégories. (5,10,15 et 20)

Le circuit RC série doit être connecté sur la carte Arduino(TM) tel que présenté sur le schéma suivant :

Source ac-Caen :[ici 🡕]

Un exemple de montage est proposé ci-dessous:

On pourra trouver le programme arduino [ici 🡕] et le programme python [là 🡕]

Faire le montage physique d'abord.

Lancer le programme arduino et configurer la type de carte et le port. (Outils) Bien retenir le numéro du port utilisé.

Ouvrir le programme arduino et le téleverser dans la carte. (CTRL+U)

Lancer l'excécution du programme arduino. Eviter d'ouvrir sans le refermer le moniteur série ou le traceur série pour laisser le port libre pour python

Ouvrir le programme python et modifier les lignes suivantes :

Configuration du port série
Mettre le numéro de port série retenu à la question 2

Nombre de mesures
ATTENTION à ne pas prendre un nombre trop élevé, tester d'abord avec de petites valeurs.
Ajuster la valeur de n:

Lancer le programme python pour faire l'acquisition.

Cinq histogrammes sont tracés pour visualiser la distribution des mesures selon 5, 10, 15 ou 20 catégories et enregistrés. Il est necessaire de fermer un histogramme pour visualiser le suivant.

Série 1: et n = 10000,

R.C=220899.99999999997=220900 μ F R.C = 220899.99999999997 = 220900 \mu F .
Série 1: et n = 1000,

Série 2: et n = 1000,

Série 3: et n = 1000,

Série 1: et n = 1000,

Série 2: et n = 1000,

Série 3: et n = 1000,

Série 1: et n = 10000,

Série 1: et n = 10000,

Série 1: et n = 10000,

Série 1: et n = 10000,

Site de référence Arduino TM en français [ici 🡕]

/* Programme permettant la mesure de la constante de temps d'un circuit RC série par la méthode des 63%. Le montage accompagnant ce programme est constitué d'un circuit série RC alimenté par une tension en créneau. arduino D2 pinU u _______ | R |_______ uc pinUc A0 arduino | | C / interrupteur (option) arduino GND masse 0V _______|___| * u = 0 V : décharge du condensateur. On peut adjoindre un interrupteur pour une décharge plus rapide. * u = 5 V : charge du condensateur. Dans une boucle sans fin, les étapes sont les suivantes : u = 0, le programme attend que le condensateur soit complètement déchargé puis, le temps système est mémorisé puis, u = 5 V, le programme attend que le condensateur soit chargé à 63% de 5V puis le temps sytème est à nouveau mémorisé puis, l'écart entre les deux temps mémorisés est envoyé sur le port série. */ unsigned long temps0, temps1; // Deux variables temps pour mesurer le temps en microseconde => tau = temps1 - temps2 const byte pinU = 2; // Numéro de la broche (pin) alimentant le circuit RC, u(t) const byte pinUc = 0; // Numéro de la broche pour la mesure de la tension aux bornes du condensateur uc(t) const int seuil = 646; // 0.6321205588285577*1023 = 646.6593316816145 void setup() { Serial.begin(9600) ; // Initialisation de la communication série pinMode(pinU, OUTPUT); // On définit la borne d'alimentation du circuit en Sortie } void loop() { // Phase 1 : uc(t) est mis à 0V ############################### uc(t) = 0 ############################################ digitalWrite(pinU, 0); while (analogRead(pinUc) > 0) { // Mesure de uc(t)(valeur entre 0 et 1023) tant que uc(t) <> 0 //delay(1); // delai(1) : attente de 1 ms pour assurer le temps de conversion du CAN } // La boucle attend que le condensateur soit déchargé temps0 = micros(); // On relève t0 // Phase 2 : uc(t) est mis à 5V ############################### uc(t) = 5 V ########################################### digitalWrite(pinU, 1); while (analogRead(pinUc) < seuil) { // Tant que le niveau lu est inférieur à 646 (63.2% de 1023) //delay(1); // delai(1) pour assurer la stabilité de la mesure (temps de conversion) } temps1 = micros(); // Une fois sorti de la boucle on mesure t1 Serial.println(temps1 - temps0); // Tau est envoyé sur le port série (en microseconde) }

# data[].attributes.attachment_link.description
Il s'agit plus ici d'une introduction à une activité qu'un TP élève. Chacun pourra s'inspirer de ce document pour créer son propre TP Modèle du circuit RC série : Charge d'un condensateur par une source idéale de tension, décharge d'un condensateur, temps caractéristique.

# data[].attributes.headline
Programmes Python compressés en un dossier

# data[].attributes.subject
Programmes Python compressés en un dossier

# data[].attributes.headline
TP  Suivre et modéliser l’évolution de la température d’un système incompressible

# data[].attributes.subject
TP  Suivre et modéliser l’évolution de la température d’un système incompressible

# data[].attributes.headline
Tracer l'évolution temporelle d'une concentration, d'une vitesse volumique d'apparition ou de disparition et tester une relation donnée entre la vitesse volumique de disparition et la concentration d'un réactif.

# data[].attributes.subject
Tracer l'évolution temporelle d'une concentration, d'une vitesse volumique d'apparition ou de disparition et tester une relation donnée entre la vitesse volumique de disparition et la concentration d'un réactif.

# data[].attributes.attachment_link.readable_text
﻿# Loi de vitesse d'ordre 1 : Décomposition du chlorure de benzène diazonium C6H5N2Cℓ(aq) → C6H5Cℓ(ℓ) + N2(g)
from matplotlib import pyplot as plt
from math import log
from scipy.stats import linregress

t = [0,115,192,355,480,752,1000,1280,1430] # date t
C = [71.2,59.7,51.9,40,31.1,20,13.6,8.4,6.8] # Concentration C mmol/L
lnC=[log(C[i])for i in range(len(t))] # calcul ln(C)

plt.figure(1)
plt.scatter(t,C,c="red",marker="+")
plt.xlabel("t(s)")
plt.ylabel("C(mmol/L)")
plt.title("évolution de la concentration au cours du temps")
plt.grid(True)

plt.figure(2)
plt.scatter(t,lnC,c="blue",marker="o")
plt.xlabel("t(s)")
plt.ylabel("ln(C)")
plt.axis([0,1.2*max(t),0,1.2*max(lnC)])
plt.grid(True)
plt.title("Loi de vitesse d'ordre 1")# affichage du titre
regression = linregress(t,lnC)# calcul de la régression linéaire
print("Pente =",round(regression[0],5))#impression du résultat de la régression : coefficient directeur a stocké en regression[0]
print("Ordonnée à l'origine =",round(regression[1],5)) #impression du résultat de la régression : ordonnée à l'origine b stockée en regression[1]
print("Coefficient de corrélation =", round(regression[2],2))
plt.plot([0.0, max(t)], [regression[1], regression[1]+max(t)*regression[0]], color = 'green', linestyle = 'solid')
# permet de relier le point (0,b) et (max(t),b + a * max(t))

V=[]
T=[]
for i in range (1,8):
    V.append(-(C[i+1]-C[i-1])/(t[i+1]-t[i-1]))
    T.append(t[i])
plt.figure(3)
plt.scatter(T,V,c="purple",marker="o")
plt.xlabel("t(s)")
plt.ylabel("Vitesse(mmol/L/s)")
plt.title("évolution de la vitesse au cours du temps")
plt.axis([0,1.2*max(T),0,1.2*max(V)])
plt.grid(True)

plt.show()

# data[].attributes.body
Rémy Brumerelle

# data[].attributes.attachment_link.readable_text
﻿#from lycee import *
from matplotlib import pyplot as plt
import math

#CARACTÉRISTIQUES DES TENSIONS:
tmax= float (input('Indiquer la durée en seconde du signal représentée sur l axe des abscisses = ')) #durée du signal (sur l'axe des abscisses). Modifiable

T= float (input('Indiquer la période du signal en seconde = ')) #période (s). Modifiable

ω=2*3.14159/T #pulsation. ω = rapport du "tour complet" (2*pi) par la durée nécessaire pour le parcourir = "vitesse angulaire" (rad/s)

Phi1= float (input('Indiquer la phase à l origine  de la tension U1 en rad = '))
Phi2= float (input('Indiquer la phase à l origine  de la tension U2 en rad = ')) #phase à l'origine (rad). Modifiable


U1max= float (input('Indiquer l amplitude maximale de la tension U1 en V = '))
U2max= float (input('Indiquer l amplitude maximale de la tension U2 en V = ')) #amplitude. Modifiable

n= int (input('Indiquer le nombre de points de calcul nécessaires à la simulation '))
#nombre d'intervalles (n+1 points). Modifiable (augmenter si la courbe n'est pas assez 'lisse')

t=[k*tmax/n for k in range(n+1)] #liste des n+1 valeurs de t [0,n] (axe des abscisses)
U1=[U1max*math.sin(ω*t+Phi1) for t in t] #calcul des n+1 valeurs de U (ordonnées). Une tension, mais cela pourrait être une intensité, une élongation...
U2=[U2max*math.sin(ω*t+Phi2) for t in t]
UTOTALE=[U1[k]+U2[k] for k in range(n+1)]

plt.plot(t,U1,c='red',label="tension U1")
plt.plot(t,U2,c='blue',label="tension U2")
plt.plot(t,UTOTALE,c='green',label="tension U1+U2")
plt.title("Représentation graphique de signaux sinusoïdaux")
plt.xlabel("t(s)")
plt.ylabel("U(V)")
plt.axis([0,tmax,-U1max-U2max-1,U1max+U2max+1])
plt.grid()

plt.legend()
plt.show()




# data[].attributes.headline
Programme Python pour la représentation des vecteurs accélération lors du mouvement d'un point.

# data[].attributes.subject
Programme Python pour la représentation des vecteurs accélération lors du mouvement d'un point.

# data[].attributes.attachment_link.readable_text
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#

# capacités numériques terminale
# tracé des vecteurs accélération d'un point lors d'un mouvement
# Python 3.8

from math import *				# import de la bibliothèque maths pour les fonctions trigo et autres
from matplotlib.pyplot import *	# import du module pyplot de la bibliothèque matplotlib

############
# Données #
############

dt=0.1		# intervalle de temps en secondes
X=[]		# liste coordonnées x
Y=[]		# liste coordonnées y
VX=[]		# liste coordonnées vitesse x
VY=[]		# liste coordonnées vitesse y
AX=[]		# liste coordonnées accélération x
AY=[]		# liste coordonnées accélération y

#############
# Fonctions #
#############

# calcul dérivée
def derivee(dx,dt):
	return dx/dt

# calcul vitesse en x et en y
def calcul_vitesse(x,y):
	global dt
	vx=[]
	vy=[]
	n=len(x)
	vx.append(0) 	# pas de calcul au premier point
	vy.append(0)	# pas de calcul au premier point
	for i in range(1,n-1):
		vx.append(derivee(x[i+1]-x[i-1],2*dt))	# on prend x avant et x après
		vy.append(derivee(y[i+1]-y[i-1],2*dt))	# on prend y avant et y après
	vx.append(0)	# pas de calcul au dernier point
	vy.append(0)	# pas de calcul au dernier point
	return vx,vy
	
# calcul accélération en x et en y	
def calcul_acceleration(vx,vy):
	global dt
	ax=[]
	ay=[]
	n=len(vx)
	ax.append(0) 	# pas de calcul aux 2 premiers points
	ax.append(0)	# pas de calcul aux 2 premiers points
	ay.append(0) 	# pas de calcul aux 2 premiers points
	ay.append(0)	# pas de calcul aux 2 premiers points
	for i in range(2,n-2):
		ax.append(derivee(vx[i+1]-vx[i-1],2*dt))	# on prend vx avant et vx après
		ay.append(derivee(vy[i+1]-vy[i-1],2*dt))	# on prend vy avant et vy après
	ax.append(0)	# pas de calcul aux 2 derniers points
	ax.append(0)	# pas de calcul aux 2 derniers points
	ay.append(0)	# pas de calcul aux 2 derniers points
	ay.append(0)	# pas de calcul aux 2 derniers points
	return ax,ay

# tracé de la trajectoire et des vecteurs accélération
def trace(x,y,ax,ay):
	plot(x,y, marker='+') # trace les points (x,y) de la trajectoire
	quiver(x,y,ax,ay,color="red", width=0.003) # trace les vecteurs (ax,ay) aux points (x,y)
	axis('equal')	# repère orthonormé
	xlabel('x')		# axe x
	ylabel('y')		# axe y
	title('Trajectoire et vecteur accélération en chaque point')	# titre graphique
	show()			# on affiche le tracé

# calcul des points (x,y) de la trajectoire
def calcule(xt,yt,t1,t2,np):
	global dt
	assert t1<t2, "t2 doit être supérieur à t1"	# on s'assure que t1<t2
	dt=(t2-t1)/np	# intervalle de temps (on prend np points) (variable globale)
	x=[]
	y=[]
	t=t1
	while t<t2:
		x.append(eval(xt))
		y.append(eval(yt))
		t=t+dt
	return x,y	

#######################
# programme principal #
#######################

print("Tracé des vecteurs accélération d'un point lors d'un mouvement")
print("\nDonner les équations horaires du mouvement en fonction du temps t :")
xt=input("x(t)= ? ")		# expression de l'équation horaire de x
yt=input("y(t)= ? ")		# expression de l'équation horaire de y
print("\nDonner l'intervalle de temps en secondes :")
t1=float(input("t1= ? "))	# début
t2=float(input("t2= ? "))	# fin
np=int(input("\nNombre de points ? "))	# nombre de points pour déterminer l'intervalle de temps
X,Y=calcule(xt,yt,t1,t2,np)			# on calcule les points de la trajectoire
VX,VY=calcul_vitesse(X,Y)			# on calcule les vitesses
AX,AY=calcul_acceleration(VX,VY)	# on calcule les accélérations
trace(X,Y,AX,AY)					# on trace la trajectoire et les vecteurs accélération


# data[].attributes.headline
Document d'accompagnement pour la représentation des vecteurs accélération lors du mouvement d'un point.

# data[].attributes.subject
Document d'accompagnement pour la représentation des vecteurs accélération lors du mouvement d'un point.

# data[].attributes.headline
Activité expérimentale : loi phénoménologique de Newton

# data[].attributes.subject
Activité expérimentale : loi phénoménologique de Newton

# data[].attributes.body
Cas d'un réchauffement

# data[].attributes.body
une page spéciale

# data[].attributes.attachment_link.description
Pour accéder à l'interface "Ma Classe à la Maison" proposée par le CNED : Ma classe à la maison Collège Ma classe à la maison Lycée Le tutoriel video "Ma Classe à la Maison" , Le guide des bonnes pratiques et des conseils pour gérer les élèves à distance , Et la possibilité de réinitialiser le lien de connexion

# data[].attributes.body
Relation Bernouilli

# data[].attributes.headline
Sciences physiques Complément des sciences de l'ingénieur en terminale générale

# data[].attributes.subject
Sciences physiques Complément des sciences de l'ingénieur en terminale générale

# data[].attributes.attachment_link.readable_text
﻿# programme titrage A + 3B de l'acide citrique par la soude
from matplotlib import pyplot as plt
Ca= float(input("Entrer la valeur Ca de la concentration de l'acide à titrer en mol/L : Ca = "))
Va= float(input("Entrer le volume Va d'acide titré en mL : Va = "))
V= float(input("Entrer le volume de la burette graduée en mL : V = "))
Cb= float(input("Entrer la valeur de la concentration Cb de la base contenue dans la burette graduée en mol/L : Cb = "))
N=int(input("Nombre N de points de la courbe"))
Vb=[]
naf=[]
nbf=[]
Vbe=3*Ca*Va/Cb
for i in range (0,N+1):
    Vb.append(V*i/N)
    if Vb[i]< Vbe :
        nbf.append(0)
        naf.append(Ca*Va/1000-Cb*Vb[i]/(3*1000))
    else :
        nbf.append(Cb*Vb[i]/1000-3*Ca*Va/1000)
        naf.append(0)
plt.title("Evolution des quantités d'acide et de base au cours du titrage")
plt.xlabel("Volume de base versé Vb(mL)")
plt.ylabel("quantités de matière en mol")
plt.grid(True)
plt.plot(Vb,naf,c='red',label="Quantité d'acide présente dans le bécher : na(mol)")
plt.plot(Vb,nbf,c='blue',label="Quantité de base présente dans le bécher : nb(mol")
plt.legend()
plt.show()

# data[].attributes.attachment_link.readable_text
﻿# titrage de l'acide acétique  par l'hydroxyde de sodium
from matplotlib import pyplot as plt
Ca= float(input(" Entrer la valeur Ca de la concentration de l'acide à titrer en mol/L : Ca = " ))
Va= float(input("Entrer le volume Va d'acide titré en mL : Va = "))
V= float(input("Entrer le volume de la burette graduée en mL : V = "))
Cb= float(input("Entrer la valeur de la concentration Cb de la base contenue dans la burette graduée en mol/L : Cb = "))
N=int(input("Nombre N de points de chaque courbe"))
Vb=[]
naf=[]
nbf=[]
Vbe=Ca*Va/Cb
print('Vbe',Vbe)
for i in range (0,N+1):
    Vb.append(V*i/N)
    if Vb[i]< Vbe :
        nbf.append(0)
        naf.append(Ca*Va/1000-Cb*Vb[i]/1000)
    else :
        nbf.append(Cb*Vb[i]/1000-Ca*Va/1000)
        naf.append(0)
plt.title("Evolution des quantités d'acide et de base au cours du titrage")
plt.xlabel("Volume de base versé Vb(mL)")
plt.ylabel("quantités de matière en mol")
plt.grid(True)
plt.plot(Vb,naf,c='red',label="Quantité d'acide présente dans le bécher : naf(mol)")
plt.plot(Vb,nbf,c='blue',label="Quantité de base présente dans le bécher : nbf(mol)")
plt.legend()
plt.show()

# data[].attributes.attachment_link.readable_text
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
__author__ = "Didier Lommelé"
__copyright__ = ""
__credits__ = []
__license__ = "CC BY-NC-SA"
__version__ = "1.1.1"
__maintainer__ = "Didier Lommelé"
__email__ = "didier.lommele@ac-nanct-metz.fr"
__status__ = "Académie de Nancy-Metz -GTP Physique"
"""

from random import randint
from tkinter import *
fen1 = Tk()

fen1.title('Méthode statistique')

#les fonctions 

def init():
    global txt,entr,but
    txt.grid(row =1)
    entr.grid(row =1, column =2)
    but.grid(row=1,column=3)

def fonction1():
    global txt,entr,but,symbs,vals,incerts,n,form1,form2,etiq,col2,col3,col4,but2,Labels,txtform
    n=int(entr.get())
    txt.grid_forget()
    entr.grid_forget()
    but.grid_forget()
    #col1=Label(fen1, text ='*')
    
    txts=[]
    
    
    for i in range (n):
        txts.append("Grandeur n° "+str(i+1))
        Labels.append(Label(fen1, text =txts[i]))
        symbs.append(Entry(fen1, width=10))
        vals.append(Entry(fen1, width=10))
        incerts.append(Entry(fen1, width=10))
   
    col2.grid(row =1, column =2)
    col3.grid(row=1,column=3)
    col4.grid(row=1,column=4)
    for i in range (n):
        Labels[i].grid(row =i+2, column =1)
        symbs[i].grid(row =i+2, column =2)
        vals[i].grid(row =i+2, column =3)
        incerts[i].grid(row =i+2, column =4)
    
    txtform.grid(row=n+2,column=1, columnspan=3)
    form1.grid(row=n+3,column=1)  
    etiq.grid(row=n+3,column=2)
    form2.grid(row=n+3,column=3, columnspan=2)  
    but2.grid(row=n+4,column=3)
    

def fonction2():
    #on récupère les données entrées dans un tableau fonction2(a,symbs,vals,incerts)
    global symbs,vals,incerts,n,form1,form2,etiq,col2,col3,col4,but2,Labels,txtform,TUPLE
    Sym=[]
    Val=[]
    Inc=[]
    Form=""+str(form2.get())
    For=[str(form1.get()),Form]
    for i in range(n):
        Sym.append(symbs[i].get())
        Val.append(float(vals[i].get()))
        Inc.append(float(incerts[i].get()))
    #print(Sym,Val,Inc,Form)
    for i in range (n):
        Labels[i].grid_forget()
        symbs[i].grid_forget()
        vals[i].grid_forget()
        incerts[i].grid_forget()
    txtform.grid_forget()
    form1.grid_forget()
    form2.grid_forget()
    etiq.grid_forget()
    but2.grid_forget()
    col2.grid_forget()
    col3.grid_forget()
    col4.grid_forget()
    TUPLE=(Sym,Val,Inc,For)
    print(TUPLE)
    fonction3()
        
def tirage(val,inc):  
    delta=2*inc
    min=val-inc
    y=randint(1,10000)*(delta/10000)+min #on choisit un 10000 de l'écart
    return round(y,2)

def valeurs(t) :
    valeur=[]
    exp=[]
    for i in range (0,len(t[0])):
        valeur.append([t[0][i],tirage(t[1][i],t[2][i])])
    print("val",valeur)
        
    for j in range(0,len(valeur)):
        exp.append(str(valeur[j][0])+"="+str(valeur[j][1]))
    print("exp",exp)
    
    for z in range(0,len(exp)):
        exec(exp[z])
    
    calc=str(t[3][0])+"="+str(t[3][1])
    r=eval(str(t[3][1]))
    
     
    valeur.append([t[3][0],calc,r]) 
    print("valeur",valeur)
    
    return valeur
        
def fonction3():
    global TUPLE,res,Labels2,n,but3,res2,res3
    
    Textes=valeurs(TUPLE)
    print(Textes)
    for i in range(n):
        Labels2.append(Label(fen1,width=25))
    res.grid(row=1,column=1)
    res2.grid(row=2+n+1,column=1)
    res3.grid(row=2+n+2,column=1)
    but3.grid(row=3,column=1)
    for i in range (n):
        Labels2[i].grid_forget()
        
    for i in range (n):
        texte=Textes[i][0]+" = "+str(Textes[i][1])
        Labels2[i].configure(text =texte)
        Labels2[i].grid(row=2+i,column=3)
    but3.grid(row=3,column=1)
    
    texte2=Textes[n][0]+" = "+str(Textes[n][2])
    res3.configure(text=texte2)
    but4.grid(row=2+n+3,column=1)
    res4.grid(row=2+n+4,column=1)
    
def fonction4(): 
    global TUPLE,res4
    t=TUPLE
    valeurs=[]
    exps=[""]*len(t[0])
    for i in range (0,len(t[0])):
        valeurs.append([t[0][i]])
    valeurs.append([t[3][0]])
    print("vals",valeurs)
    calc=str(t[3][0])+"="+str(t[3][1])
    print(calc)
    for i in range(10000): #onpeut changer le nombre de tirages
        for j in range (0,len(t[0])):
            temp=tirage(t[1][j],t[2][j])
            valeurs[j].append(temp)
            exps[j]=(str(valeurs[j][0])+"="+str(temp))
        print(exps)
        for z in range(0,len(exps)):
            exec(exps[z])
        r=eval(str(t[3][1]))
        valeurs[j+1].append(r)
        
    #print(valeurs)#dans cette matrice j'ai toutes les valeurs
    lis=[]
    for i in range(1,len(valeurs[-1])):
        lis.append(valeurs[-1][i])
    mo=Moyenne(lis)
    et=round(Ecart_type(lis,mo),3)
    texte3="La moyenne de "+str(valeurs[-1][0])+" est "+str(round(mo,3))+" avec un ecart-type de "+str(et)
    print(texte3)
    res4.configure(text=texte3)
    print(lis)
    
        
def Moyenne(Liste): 
    S=0
    for elem in Liste:
        S=S+elem
    return (S/len(Liste))
    
def Ecart_type(Liste,moyenne):
    S=0
    for elem in Liste:
        S=S+(abs(elem-moyenne)*abs(elem-moyenne))
    S=S/len(Liste)
    return (S**(0.5))    
    
    
###objets fenêtre 1 #####"
txt = Label(fen1, text ='Combien de grandeurs ?')
entr = Entry(fen1, width=10)
but=Button(fen1,text="Valider",command=fonction1)

###################################################
n=1 #nb lignes du tableau par défaut
symbs=[] #tab entry symbs
vals=[] #tab entry vals
incerts=[] #tab entry incerts
form1=Entry(fen1,width=5)
etiq=Label(fen1,text=" = ")
form2=Entry(fen1,width=45)
col2=Label(fen1, text ="Symbole")
col3=Label(fen1, text ='Valeur')
col4=Label(fen1, text ='Incertitude')
but2=Button(fen1,text="Valider",command=fonction2)
Labels=[]
txtform=Label(fen1,text="Formule reliant les grandeurs :")
###############################################################
TUPLE=() #données récupérées
######################################### affichage résul
res=Label(fen1,text="Un tirage aléatoire des valeurs :")
but3=Button(fen1,text="Nouveau tirage",command=fonction3)
Labels2=[]
res2=Label(fen1,text="Avec ces valeurs, on a:")
res3=Label(fen1)
but4=Button(fen1,text="Pour 10000 tirages",command=fonction4)
res4=Label(fen1)


init()
fen1.mainloop()

# data[].attributes.attachment_link.readable_text
﻿#Programme : détermination d'un taux d'avancement à partir de la mesure du pH
# AH + H2O = A- + H3O+

ni=float(input("Indiquer la quantité ni (en mol) d'acide présente dans l'eau :"))
V=float(input("Indiquer le volume V de la solution obtenue en litre:"))
pH=float(input("Indiquer le pH de la solution obtenue :"))


h = 10**(-pH) # h est la concentration en ions oxonium
xmax=ni # calcul de l'avancement maximal
xf=V*h # calcul de l'avancement à l'équilibre
taux=xf/xmax # calcul du taux d'avancement final
print("La taux d'avancement final =", round(taux,4))# taux arrondi à 4 chiffres après 0
# affichage de la valeur du taux d'avancement final

if taux > 0.99 :
    print("L'acide est fort")
else :
    print("L'acide est faible")
# affichage de la force de l'acide

# data[].attributes.attachment_link.readable_text
﻿# Tracé du diagramme de distribution des espèces conjuguées A/B

import numpy as np
from matplotlib import pyplot as plt

pKa= float(input("Entrer la valeur du pKa du couple acide-base : pKa = "))
Ci= float(input("Entrer la valeur de la concentration en quantité de matière de l'acide en mol/L: Ci ="))

pH=np.linspace(0,14,100)# 100 valeurs allant de 0 à 14
CA=Ci/(1+10**(pH-pKa))
CB=Ci-CA
pA=CA/Ci*100
pB=CB/Ci*100
plt.title("diagramme de distribution des espèces AH et A-")
plt.xlabel("pH")
plt.ylabel('Pourcentage des espèces(%)')

plt.grid(True)
plt.plot(pH,pA,c='red',label="Pourcentage de la forme acide AH")
plt.plot(pH,pB,c='green',label="Pourcentage de la forme basique A-")
plt.legend()
plt.show()

# data[].attributes.attachment_link.readable_text
﻿# Vérification graphique de la 3ème loi de Kepler à partir de données expérimentales :


################################
# Importation de bibliothèques #
################################

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


##########################
# Données expérimentales #
##########################

# Liste représentant la période de révolution de chaque planète exprimée en année
T = [0.2408, 0.6152, 1.0000, 1.8808, 11.862, 29.457, 84.020, 164.77]            # A COMPLETER #
# Liste représentantc'est le demi grand-axe de l'ellipse parcourue par chaque planète
a = [0.3871, 0.7233, 1.000, 1.5237, 5.2026, 9.5547, 19.218, 30.109]             # A COMPLETER #


#############
# Graphique #
#############

T2 = [T[i]**2 for i in range(len(T))]          # calcul de T²
a3 = [a[i]**3 for i in range(len(a))]          # calcul de a³
plt.title("Vérification graphique de la 3ème loi de Kepler")
plt.scatter(a3, T2, color='red', marker='+')
plt.xlabel("a³(ua³)")                          # A COMPLETER AVEC GRANDEUR ET UNITE SUR CET AXE #
plt.ylabel("T²(an²)")                          # A COMPLETER AVEC GRANDEUR ET UNITE SUR CET AXE #

# calcul de la régression linéaire entre les listes T² et a3
regression = linregress(a3, T2)
# affichage du résultat de la régression : coefficient directeur k stocké en regression[0]
print("Pente =", regression[0], "an²/ua³")
# affichage du résultat de la régression : ordonnée à l'origine m stockée en regression[1]
print("Ordonnée à l'origine =", regression[1],"an²")
# plus ce coefficient est proche de 1, plus le modèle mathématique "colle" aux données expérimentales
print("Coefficient de corrélation =", regression[2])
# trace une ligne entre le point (0, m) et (max(T²),m + k * max(T²))
plt.plot([0.0, max(a3)], [regression[1], regression[1] + max(a3) * regression[0]], color = 'green', linestyle = 'solid')
plt.grid(True)
plt.show()

# data[].attributes.attachment_link.readable_text
﻿# Deuxième loi de Kepler
from math import *
from matplotlib import pyplot as plt

dt=float(input("Entrer la valeur du pas de l'itération en jour : dt ="))
e=float(input("Entrer la valeur de l'excentricité e ="))
a=float(input("Entrer le demi grand axe de l'orbite en UA : a="))
T=int(input("Een jour Entrer la pétiode orbitale en jour : T="))
r0=a*(1-e)

t=[0]
angle=[0]
r=[r0]
x=[r0]
y=[0]

for i in range (0,4*T):
    t.append(i*dt)
    r.append(a*(1-e**2)/(1+e*cos(angle[i])))
    dangle=(2*pi*a*a*(1-e**2)**0.5)/(T*r[i]**2)*dt
    angle.append(angle[i]+dangle)
    x.append(r[i]*cos(angle[i]))
    y.append(r[i]*sin(angle[i]))

aire=[]
tt=[]
for i in range(0,4*T):
    aire.append((r[i+1]*r[i]*sin(angle[i+1]-angle[i])/2))
    tt.append(t[i])

plt.figure(1)
plt.scatter(x,y,c="red",marker="o")
plt.scatter(0,0,c="yellow",marker="o")
plt.xlabel("x(UA)")
plt.ylabel("y(UA)")
plt.axis("equal")
plt.title("Orbite de la comète de Halley")
plt.grid(True)

plt.figure(2)
plt.scatter(tt,aire,c="blue",marker="o")
plt.xlabel("tt(jours)")
plt.ylabel("aire(UA2)")
plt.axis([0,4*T,0,5*max(aire)])
plt.grid(True)


plt.show()


# data[].attributes.attachment_link.readable_text
# Vérification graphique de la 2ème loi de Kepler à partir de données expérimentales :

################################
# Importation de bibliothèques #
################################

from csv import *
from math import *
import matplotlib.pyplot as plt


#############
# Fonctions #
#############

def aire(angle, r):
    """Fonction calculant l'aire d'un secteur circulaire avec un rayon r en mètre et un angle en degré"""
    aire = (pi * angle * r**2)/360          # A COMPLETER #
    return aire


def aire_delta_t(j, n):
    """Fonction calculant l'aire balayée pendant la durée de n jours depuis la position j."""
    ua = 1.495978707e11 # unité astronomique en mètre
    aire_balayee = 0 # initialisation
    for i in range(n):
        # angle obtenu par différence de longitudes entre deux positions consécutives
        angle = (longitude[j+i+1] - longitude[j+i])
        # rayon calculé pour la position actuelle
        r = distance[j+i] * ua
        a = aire(angle, r)
        aire_balayee = aire_balayee + a
    return aire_balayee


##########################
# Données expérimentales #
##########################

# Ouverture du fichier csv contenant les données astronomiques relevées chaque
# jour pendant un an entre deux équinoxes d'automne du 23-09-2020 ou 22-09-2021
donnees=[]	# table des données
Fichier=open('kepler2.csv','r',encoding='UTF8')		# ouverture fichier kepler2.csv en lecture
lecteur=reader(Fichier,delimiter=";")				# lecteur de flux csv, separateur ;
for ligne in lecteur:					# on parcourt les lignes du fichier
    donnees.append(ligne)				# on ajoute chaque ligne dans la liste donnees


# Extraction de 3 listes de la table de donnes
date = [donnees[i][0] for i in range(1, len(donnees))]
longitude = [float(donnees[i][1]) for i in range(1, len(donnees))]
distance = [float(donnees[i][2]) for i in range(1, len(donnees))]


#############
# Graphique #
#############

jours = 1 # un nombre entier est attendu : c'est le nombre de jours écoulés entre deux relevés de la position de la Terre
A = [] # cette liste permet de stocker les calculs d'aire balayée
t = [] # cette liste permet de stocker les dates (jours) où les mesures ont été réalisées
for i in range (len(longitude)-1) :
    A.append(aire_delta_t(i, jours))
    t.append(jours*i)
plt.title("Vérification graphique de la deuxième loi de Kepler")
plt.scatter(t, A, color="red", marker="+")
plt.xlabel("t(jours)")                      # A COMPLETER AVEC GRANDEUR ET UNITE SUR CET AXE #
plt.ylabel("A(m²)")                         # A COMPLETER AVEC GRANDEUR ET UNITE SUR CET AXE #
##plt.axis([0, 1.2*max(t), 0, 1.2*max(A)])
plt.grid(True)
plt.show()

# data[].attributes.attachment_link.readable_text
﻿# Influence du pKA sur le taux d'avancement final à concentration Ci en acide égale
from matplotlib import pyplot as plt
import numpy as np

Ci=float(input("Indiquer la valeur de la concentration de l'acide en mol/L : Ci = "))

pKa=np.linspace(0,14,100)
Ka= 10**(-pKa)
Delta=Ka**2+4*Ka*Ci
tauxfinal = (-Ka + Delta**0.5)/(2*Ci)

plt.xlabel("pKa")
plt.ylabel("taux d'avancement final taux(%)")
plt.plot(pKa,tauxfinal,c="red",marker="o")
plt.grid()

plt.show()


# data[].attributes.attachment_link.readable_text
﻿# Influence de la concentration en quantité de soluté sur le taux d'avancement final
from matplotlib import pyplot as plt
import numpy as np

pKa=float(input("Indiquer la valeur du pKa du couple acide-base : pKa = "))
Ka = 10**(-pKa)
Ci=np.linspace(0,1,100)# fait varier Ci de 0 à 1 mol/L avec 100 valeurs
delta=Ka**2+4*Ka*Ci
tauxfinal = (-Ka + delta**0.5)/(2*Ci)
plt.xlabel("Ci(mol/L)")
plt.ylabel("taux d'avancement final (%)")
plt.plot(Ci,tauxfinal,c="red",marker="o")
plt.grid()

plt.show()


# data[].attributes.attachment_link.readable_text
﻿import matplotlib.pyplot as plt

t=[0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8]
x=[0,2,4,6,8,10,12,14,16]
y=[3.5,3.45,3.3,3.06,2.72,2.28,1.74,1.1,0.36]

dt = 0.2
longueur = len(x)
vx = [20]
vy = [0]
ax=[0]
ay=[0]


plt.figure (1)
plt.xlabel("x(m)")
plt.ylabel("y(m)")
plt.axis("equal")
plt.grid(True)
plt.title("Trajectoire de la balle de volley et vecteurs vitesse")
plt.scatter(x,y,c='blue',marker='o')
for i in range (1,longueur-1):
    vx.append((x[i+1]-x[i-1])/dt)
    vy.append((y[i+1]-y[i-1])/dt)

for i in range(0,longueur-1):
    plt.arrow(x[i], y[i], vx[i]/20, vy[i]/20, color="red",length_includes_head = True, head_width = 0.1, head_length = 0.1)



plt.figure (2)
plt.xlabel("x(m)")
plt.ylabel("y(m)")
plt.axis("equal")
plt.title("Trajectoire de la balle de volley et vecteurs accélération")
plt.scatter(x,y,c='blue',marker='o')
for i in range (1,longueur-2):
    ax.append((vx[i+1]-vx[i-1])/dt)
    ay.append((vy[i+1]-vy[i-1])/dt)
    plt.arrow(x[i], y[i], ax[i]/5, ay[i]/5,color="purple", length_includes_head = True, head_width = 0.1, head_length = 0.1)

plt.show()

# data[].attributes.attachment_link.readable_text
﻿import matplotlib.pyplot as plt

t=[0,0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8]
x=[0,2,4,6,8,10,12,14,16]
y=[3.5,3.45,3.3,3.06,2.72,2.28,1.74,1.1,0.36]

dt = 0.1
longueur = len(x)
vx = []
vy = []
dvx=[]
dvy=[]

plt.figure (1)
plt.xlabel("x(m)")
plt.ylabel("y(m)")
plt.title("Trajectoire de la balle de volley et vecteurs vitesse")
plt.scatter(x,y,c='blue',marker='o')
for i in range (0,longueur-1):
    vx.append((x[i+1]-x[i])/dt)
    vy.append((y[i+1]-y[i])/dt)
    plt.arrow(x[i], y[i], vx[i]/20, vy[i]/20, color="red",length_includes_head = True, head_width = 0.1, head_length = 0.1)

plt.figure (2)
plt.xlabel("x(m)")
plt.ylabel("y(m)")
plt.title("Trajectoire de la balle de volley et vecteurs variation de vitesse")
plt.scatter(x,y,c='blue',marker='o')
for i in range (0,longueur-2):
    dvx.append(vx[i+1]-vx[i])
    dvy.append(vy[i+1]-vy[i])
    plt.arrow(x[i], y[i], dvx[i], dvy[i],color="red", length_includes_head = True, head_width = 0.1, head_length = 0.1)

plt.show()

# data[].attributes.attachment_link.readable_text
﻿
# Ce programme permet de vérifier la troisième loi de Kepler

# A l'aide d'une représentation graphique, on veut montrer que T²/a^3 = constante, ou encore que T² = k x a^3

from matplotlib import pyplot
from scipy.stats import linregress

T=[0.2408,0.6152,1.0000,1.8808,11.862,29.457,84.020,164.77] # Cette liste est à compléter : c'est la période de révolution de chaque planète exprimée en année
a=[0.3871,0.7233,1.000,1.5237,5.2026,9.5547,19.218,30.109] # Cette liste est à compléter : c'est le demi grand-axe de l'ellipse parcourue par chaque planète

T2=[T[i]*T[i] for i in range(len(T))] # calcul de T²

a3=[a[i]*a[i]*a[i] for i in range(len(a))] # calcul de a^3

pyplot.scatter(a3, T2, color = 'red', marker = '+') # à vous d'indiquer les grandeurs portées sur l'axe des abscisses et celui des ordonnées
pyplot.grid(True)
pyplot.xlabel("a3(UA^3)")
pyplot.ylabel("T²(an²)")
pyplot.title("Vérification graphique de la 3ème loi de Kepler")

regression = linregress(a3,T2)                                  # calcul de la régression linéaire entre les listes T² et a3
print("Pente =", regression[0], "an²/UA^3")                     # affichage du résultat de la régression : coefficient directeur k stocké en regression[0]
print("Ordonnée à l'origine =", regression[1],"an²")            # affichage du résultat de la régression : ordonnée à l'origine m stockée en regression[1]
print("Coefficient de corrélation =", regression[2])            # plus ce coefficient est proche de 1, plus le modèle mathématique "colle" aux données expérimentales

pyplot.plot([0.0, max(a3)], [regression[1], regression[1]+max(a3)*regression[0]], color = 'green', linestyle = 'solid')
# permet de relier le point (0,m) et (max(T²),m + k * max(T²))

pyplot.show()


# data[].attributes.attachment_link.readable_text
﻿# Programme permettant de vérifier la 2ème loi de Kepler à partir de données expérimentales :

import numpy as np
import matplotlib.pyplot as plt
from math import *

thêta = [0,53,100,141,178,215,255,301,354] # cette liste est à compléter : il s'agit de l'angle en degré

r=[1.381,1.430,1.535,1.629,1.666,1.636,1.548,1.441,1.382] # cette liste est à compléter : il s'agit du rayon en unité astronomique

radian=np.radians(thêta)

jours=84 # un nombre entier est attendu : c'est le nombre de jours écoulés entre deux relevés de la position de Mars

A=[] # cette liste permet de stocker les calculs d'aire balayée
t=[] # cette liste permet de stocker les dates où les mesures ont été réalisées

# Pour calculer les surfaces des triangles curvilignes correspondant à la trajectoire effectuée par Mars entre deux dates
# consécutives du tableau, on les assimile à des triangles quelconques.
# La surface d’un de ces triangles est donnée par la formule : A(i) = 0.5 * (r(i+1) x r(i) x sin (θ(i+1)-θ(i)))

for i in range (len(thêta)-1) :
    A.append((r[i+1]*r[i]*sin((radian[i+1]-radian[i])))/2) # à vous de compléter !
    t.append(jours*i)

plt.title("Deuxième loi de Kepler")
plt.scatter(t,A,c="red",marker="+")
plt.xlabel("t(jours)")                      # à vous d'indiquer grandeur et unité sur cet axe
plt.ylabel("A(UA²)")                        # à vous d'indiquer grandeur et unité sur cet axe
plt.axis([0,1.2*max(t),0,1.2*max(A)])
plt.grid(True)
plt.show()

# data[].attributes.attachment_link.readable_text
﻿# Programme permettant de vérifier la 1ère loi de Kepler à partir de données expérimentales :

import numpy as np
import matplotlib.pyplot as plt
from math import * # permet d'importer toutes les fonctions et évite de taper math. avant une fonction

thêta = [0,53,100,141,178,215,255,301,354] # cette liste est à compléter : il s'agit de l'angle en degré

r=[1.381,1.430,1.535,1.629,1.666,1.636,1.548,1.441,1.382] # cette liste est à compléter : il s'agit du rayon en unité astronomique

radian=np.radians(thêta) # permet de convertir l'angle thêta en radian

x=[]
y=[]


#pour représenter la trajectoire de Mars dans le référentiel héliocentrique, il est plus simple d'utiliser les coordonnées cartésiennes ;
#la boucle suivante permet de réaliser ces calculs :

for i in range (len(thêta)) :
    x.append(r[i]*cos(radian[i]))
    y.append(r[i]*sin(radian[i]))                          # à vous de compléter cette partie !


plt.scatter(x,y,c="blue",marker="+")
plt.title("Trajectoire de Mars à partir de données expérimentales")
plt.xlabel("x(UA)")
plt.ylabel("y(UA)")
plt.axis("equal")
plt.grid(True)
plt.show()

# data[].attributes.body
Programmes python associés

# data[].attributes.body
Loi de refroidissement de Newton

# data[].attributes.headline
Activité  Loi de refroidissement de Newton

# data[].attributes.subject
Activité  Loi de refroidissement de Newton

# data[].attributes.body
Monte-Carlo

# data[].attributes.attachment_link.readable_text
﻿#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
__author__ = "Didier LommelÃ©"
__copyright__ = ""
__credits__ = []
__license__ = "CC BY-NC-SA"
__version__ = "1.1.1"
__maintainer__ = "Didier LommelÃ©"
__email__ = "didier.lommele@ac-nanct-metz.fr"
__status__ = "AcadÃ©mie de Nancy-Metz -GTP Physique"
"""

from random import randint
from tkinter import *
fen1 = Tk()

fen1.title('MÃ©thode statistique')

#les fonctions

def init():
    global txt,entr,but
    txt.grid(row =1)
    entr.grid(row =1, column =2)
    but.grid(row=1,column=3)

def fonction1():
    global txt,entr,but,symbs,vals,incerts,n,form1,form2,etiq,col2,col3,col4,but2,Labels,txtform
    n=int(entr.get())
    txt.grid_forget()
    entr.grid_forget()
    but.grid_forget()
    #col1=Label(fen1, text ='*')

    txts=[]


    for i in range (n):
        txts.append("Grandeur nÂ° "+str(i+1))
        Labels.append(Label(fen1, text =txts[i]))
        symbs.append(Entry(fen1, width=10))
        vals.append(Entry(fen1, width=10))
        incerts.append(Entry(fen1, width=10))

    col2.grid(row =1, column =2)
    col3.grid(row=1,column=3)
    col4.grid(row=1,column=4)
    for i in range (n):
        Labels[i].grid(row =i+2, column =1)
        symbs[i].grid(row =i+2, column =2)
        vals[i].grid(row =i+2, column =3)
        incerts[i].grid(row =i+2, column =4)

    txtform.grid(row=n+2,column=1, columnspan=3)
    form1.grid(row=n+3,column=1)
    etiq.grid(row=n+3,column=2)
    form2.grid(row=n+3,column=3, columnspan=2)
    but2.grid(row=n+4,column=3)


def fonction2():
    #on rÃ©cupÃ¨re les donnÃ©es entrÃ©es dans un tableau fonction2(a,symbs,vals,incerts)
    global symbs,vals,incerts,n,form1,form2,etiq,col2,col3,col4,but2,Labels,txtform,TUPLE
    Sym=[]
    Val=[]
    Inc=[]
    Form=""+str(form2.get())
    For=[str(form1.get()),Form]
    for i in range(n):
        Sym.append(symbs[i].get())
        Val.append(float(vals[i].get()))
        Inc.append(float(incerts[i].get()))
    #print(Sym,Val,Inc,Form)
    for i in range (n):
        Labels[i].grid_forget()
        symbs[i].grid_forget()
        vals[i].grid_forget()
        incerts[i].grid_forget()
    txtform.grid_forget()
    form1.grid_forget()
    form2.grid_forget()
    etiq.grid_forget()
    but2.grid_forget()
    col2.grid_forget()
    col3.grid_forget()
    col4.grid_forget()
    TUPLE=(Sym,Val,Inc,For)
    print(TUPLE)
    fonction3()

def tirage(val,inc):
    delta=2*inc
    min=val-inc
    y=randint(1,10000)*(delta/10000)+min #on choisit un 10000 de l'Ã©cart
    return round(y,2)

def valeurs(t) :
    valeur=[]
    exp=[]
    for i in range (0,len(t[0])):
        valeur.append([t[0][i],tirage(t[1][i],t[2][i])])
    print("val",valeur)

    for j in range(0,len(valeur)):
        exp.append(str(valeur[j][0])+"="+str(valeur[j][1]))
    print("exp",exp)

    for z in range(0,len(exp)):
        exec(exp[z])

    calc=str(t[3][0])+"="+str(t[3][1])
    r=eval(str(t[3][1]))


    valeur.append([t[3][0],calc,r])
    print("valeur",valeur)

    return valeur

def fonction3():
    global TUPLE,res,Labels2,n,but3,res2,res3

    Textes=valeurs(TUPLE)
    print(Textes)
    for i in range(n):
        Labels2.append(Label(fen1,width=25))
    res.grid(row=1,column=1)
    res2.grid(row=2+n+1,column=1)
    res3.grid(row=2+n+2,column=1)
    but3.grid(row=3,column=1)
    for i in range (n):
        Labels2[i].grid_forget()

    for i in range (n):
        texte=Textes[i][0]+" = "+str(Textes[i][1])
        Labels2[i].configure(text =texte)
        Labels2[i].grid(row=2+i,column=3)
    but3.grid(row=3,column=1)

    texte2=Textes[n][0]+" = "+str(Textes[n][2])
    res3.configure(text=texte2)
    but4.grid(row=2+n+3,column=1)
    res4.grid(row=2+n+4,column=1)

def fonction4():
    global TUPLE,res4
    t=TUPLE
    valeurs=[]
    exps=[""]*len(t[0])
    for i in range (0,len(t[0])):
        valeurs.append([t[0][i]])
    valeurs.append([t[3][0]])
    print("vals",valeurs)
    calc=str(t[3][0])+"="+str(t[3][1])
    print(calc)
    for i in range(10000): #onpeut changer le nombre de tirages
        for j in range (0,len(t[0])):
            temp=tirage(t[1][j],t[2][j])
            valeurs[j].append(temp)
            exps[j]=(str(valeurs[j][0])+"="+str(temp))
        print(exps)
        for z in range(0,len(exps)):
            exec(exps[z])
        r=eval(str(t[3][1]))
        valeurs[j+1].append(r)

    #print(valeurs)#dans cette matrice j'ai toutes les valeurs
    lis=[]
    for i in range(1,len(valeurs[-1])):
        lis.append(valeurs[-1][i])
    mo=Moyenne(lis)
    et=round(Ecart_type(lis,mo),3)
    texte3="La moyenne de "+str(valeurs[-1][0])+" est "+str(round(mo,3))+" avec un ecart-type de "+str(et)
    print(texte3)
    res4.configure(text=texte3)
    print(lis)


def Moyenne(Liste):
    S=0
    for elem in Liste:
        S=S+elem
    return (S/len(Liste))

def Ecart_type(Liste,moyenne):
    S=0
    for elem in Liste:
        S=S+(abs(elem-moyenne)*abs(elem-moyenne))
    S=S/len(Liste)
    return (S**(0.5))


###objets fenÃªtre 1 #####"
txt = Label(fen1, text ='Combien de grandeurs ?')
entr = Entry(fen1, width=10)
but=Button(fen1,text="Valider",command=fonction1)

###################################################
n=1 #nb lignes du tableau par dÃ©faut
symbs=[] #tab entry symbs
vals=[] #tab entry vals
incerts=[] #tab entry incerts
form1=Entry(fen1,width=5)
etiq=Label(fen1,text=" = ")
form2=Entry(fen1,width=45)
col2=Label(fen1, text ="Symbole")
col3=Label(fen1, text ='Valeur')
col4=Label(fen1, text ='Incertitude')
but2=Button(fen1,text="Valider",command=fonction2)
Labels=[]
txtform=Label(fen1,text="Formule reliant les grandeurs :")
###############################################################
TUPLE=() #donnÃ©es rÃ©cupÃ©rÃ©es
######################################### affichage rÃ©sul
res=Label(fen1,text="Un tirage alÃ©atoire des valeurs :")
but3=Button(fen1,text="Nouveau tirage",command=fonction3)
Labels2=[]
res2=Label(fen1,text="Avec ces valeurs, on a:")
res3=Label(fen1)
but4=Button(fen1,text="Pour 10000 tirages",command=fonction4)
res4=Label(fen1)


init()
fen1.mainloop()

# data[].attributes.body
concentration de la solution mère

# data[].attributes.body
Monte-Carlo

# data[].attributes.body
Méthode de Monte-Carlo

# data[].attributes.body
Constitution et transformation de la matière

# data[].attributes.body
pdf