commit d0265d2c42284f6afed913a59f9117b5b4410b5b
parent 271838f150ff3b8c8daf999bfe22158a8e759754
Author: Vincent Forest <vincent.forest@meso-star.com>
Date: Sat, 22 Apr 2023 18:36:10 +0200
Rédige le texte qui accompagne le script fd.sh
L'ensemble des listings dans le sources noweb sont désormais lettrés.
Diffstat:
1 file changed, 104 insertions(+), 70 deletions(-)
diff --git a/src/sgs_compute_sensitivity_translation.nw b/src/sgs_compute_sensitivity_translation.nw
@@ -1557,101 +1557,135 @@ nsteps=14
pi_step=0.1
@
-\paragraph{TODO} Ajouter cette ligne pendant la description du
-script [[<<fd.sh>>]].
-<<paramètres des calculs Monte Carlo>>=
-printf "%s %s\n" "${h}" "${pi_step}"
-@
+Dans un nouveau script [[fd.sh]] nous pouvons alors calculer par différences
+finies la sensibilité du flux à $\PI$ à partir des estimations Monte Carlo en
+sortie de [[<<mc.sh>>]], des résultats lus via l'entrée standard. Pour pouvoir
+comparer les résultats, ce second script recopie en sortie les sensibilités
+estimées par Monte Carlo ([[sen_mc]]) en plus d'écrire ces mêmes sensibilités
+calculées par différences finies ([[sen_fd]]). Leur écarts types respectifs
+([[err_mc]] et [[err_fd]]) sont également des données de sortie. On notera enfin
+que l'ensemble des résultats seront adimentionnés aux dimensions de la
+configuration géométrique et seront par conséquent donnés pour une valeur de
+$\PI$ indépendante de la hauteur du parallélépipède ([[pi_over_h]]).
-<<mc2.sh>>=
+<<fd.sh>>=
#!/bin/sh -e
-# Estimation par Monte Carlo de la sensibilité et de la fraction de
-# la luminance qui dépend de pi
-
-h=1 # Hauteur de la boîte
-lower="0,0,0"
-upper="1,1,${h}"
-
-pi="0"
-i="0"
+# Calcule la sensibilité par différences finies à partir des
+# estimations par Monte Carlo de la fraction du flux qui dépend de pi
-# Affiche la hauteur de la paroi du haut et le delta entre chaque
-# valeur de pi
-printf "%s %s\n" "${h}" "${pi_step}"
+# Liste des données pour chaque ligne écrite en sortie
+printf "pi_over_h sen_mc err_mc sen_fd err_fd\n"
-while [ "${i}" -lt "${nsteps}" ]; do
- out=$(./sgs \
- -n "${nrealisations}" \
- -b low="${lower}":upp="${upper}":pi="${pi}")
+<<fonctions utilitaires à [[fd.sh]]>>
- printf "%s " "${pi}"
- echo "${out}" | sed -n '1{N;s/^'\
-'[^~]\{1,\}~ \([^[:blank:]]\{1,\}\) +\/- \([^\n]\{1,\}\)\n'\
-'[^~]\{1,\}~ \([^[:blank:]]\{1,\}\) +\/- \([^$]\{1,\}\)$'\
-'/\1 \2 \3 \4/p}'
+<<lire les paramètres d'entrée>>
- i=$((i + 1))
- pi=$(printf "%s + %s\n" "${pi}" "${pi_step}" | bc)
+<<pour chaque valeur de pi considérée>> do
+ <<lire la valeur du flux autour de pi>>
+ <<calculer par différences finies la sensibilité du flux à pi>>
+ <<lire l'estimation Monte Carlo de la sensibilité du flux à pi>>
+ <<écrire les résultats adimensionner aux dimensions du système>>
+ <<passer au calcul suivant>>
done
@
-<<fd.sh>>=
-#!/bin/sh -e
-
-# Calcule la sensibilité par différences finies à partir des
-# estimations par Monte Carlo de la fraction de luminance qui dépend
-# de pi
-
-float_to_bc()
-{
- sed 's/\([+-]\{0,1\}[0-9]\{0,\}\.\{0,1\}[0-9]\{1,\}\)'\
-'[eE]+\{0,1\}\(-\{0,1\}\)\([0-9]\{1,\}\)/(\1*10^\2\3)/g'
-}
-
-bc_cmd()
-{
- bc -l | sed '/\./s/\.\{0,\}0\{1,\}$//'
-}
+Pour les calculs en différences finies nous avons besoin de connaître les
+paramètres utilisés par les estimations Monte Carlo, comme le $\delta$ entre
+chaque valeur de $\PI$ ([[pi_step]]) ou encore la hauteur du parallélépipède
+nécessaire pour adimensionner nos résultats ([[h]]). Pour passer ces données
+d'un script à l'autre, on modifie le script [[mc.sh]] pour les écrire en
+en-tête de ses sorties, en-tête qui peut alors être lu par le script
+[[fd.sh]].
+<<paramètres des calculs Monte Carlo>>=
+printf "%s %s\n" "${h}" "${pi_step}"
+@
+<<lire les paramètres d'entrée>>=
read -r header
h=$(echo "${header}" | cut -d' ' -f1)
pi_step=$(echo "${header}" | cut -d' ' -f2)
+@
-printf "pi_over_h sen_mc err_mc sen_fd err_fd\n"
+Autre donnée nécessaire pour adimensionner nos résultats, la valeur maximale du
+flux. Celle-ci correspond à la valeur de $\varphi$ lorsque la boîte est fermée,
+c'est à dire lorsque $\PI = 0$ soit la valeur de $\PI$ du premier résultat en
+sortie de [[mc.sh]]. Après l'en-tête nous lisons donc ce résultat que l'on
+stocke dans la variable [[p]] avant d'en extraire la valeur $\varphi$
+([[phi_max]]).
+<<lire les paramètres d'entrée>>=
read -r p
-read -r c
-
-# Conserver la valeur du flux pour pi = 0
phi_max=$(echo "${p}" | cut -d' ' -f4 | float_to_bc)
+@
-while read -r n; do
+La boucle principale du script consiste à lire l'entrée standard jusqu'à ce
+qu'il n'y ait plus de résultat Monte Carlo à traiter. À chaque itération, le
+résultat Monte Carlo pour la valeur de $\PI$ courante est stocké dans la
+variable [[c]] tandis que le résultat précédent et suivant sont respectivement
+stockés dans les variables [[p]] et [[n]].
- pi=$(echo "${c}" | cut -d' ' -f1 | float_to_bc)
- sen_mc=$(echo "${c}" | cut -d' ' -f2 | float_to_bc)
- err_mc=$(echo "${c}" | cut -d' ' -f3 | float_to_bc)
+<<pour chaque valeur de pi considérée>>=
+read -r c
+while read -r n;
+@
+<<passer au calcul suivant>>=
+p="${c}"
+c="${n}"
+@
+
+Il suffit alors d'extraire le flux ([[phi]]) et son erreur ([[err]]) aux valeurs
+de $\PI$ précédente ([[p]]) et suivante ([[n]]) pour calculer par différences
+finies la sensibilité et l'erreur associée pour la valeur de $\PI$ courante:
+
+<<lire la valeur du flux autour de pi>>=
+phi_p=$(echo "${p}" | cut -d' ' -f4 | float_to_bc)
+err_p=$(echo "${p}" | cut -d' ' -f5 | float_to_bc)
+phi_n=$(echo "${n}" | cut -d' ' -f4 | float_to_bc)
+err_n=$(echo "${n}" | cut -d' ' -f5 | float_to_bc)
+@
+<<calculer par différences finies la sensibilité du flux à pi>>=
+sen_fd=$(echo "(${phi_n}-${phi_p})/(2*${pi_step})" | bc_cmd)
+err_fd=$(echo "(${err_n}+${err_p})/(2*${pi_step})" | bc_cmd)
+@
- pi_over_h=$(echo "${pi}/${h}" | bc_cmd)
- sen_mc=$(echo "${sen_mc}/${phi_max}*${h}" | bc_cmd)
- err_mc=$(echo "${err_mc}/${phi_max}*${h}" | bc_cmd)
+On utilise alors le résultat Monte Carlo au $\PI$ considéré pour en retrouver
+non seulement sa valeur mais aussi pour extraire l'estimation Monte Carlo de la
+sensibilité de $\varphi$ à $\PI$. Ne reste plus qu'à écrire l'ensemble des
+résultats attendus.
- lum_p=$(echo "${p}" | cut -d' ' -f4 | float_to_bc)
- err_p=$(echo "${p}" | cut -d' ' -f5 | float_to_bc)
- lum_n=$(echo "${n}" | cut -d' ' -f4 | float_to_bc)
- err_n=$(echo "${n}" | cut -d' ' -f5 | float_to_bc)
+<<lire l'estimation Monte Carlo de la sensibilité du flux à pi>>=
+pi=$(echo "${c}" | cut -d' ' -f1 | float_to_bc)
+sen_mc=$(echo "${c}" | cut -d' ' -f2 | float_to_bc)
+err_mc=$(echo "${c}" | cut -d' ' -f3 | float_to_bc)
+@
+<<écrire les résultats adimensionner aux dimensions du système>>=
+pi_over_h=$(echo "${pi}/${h}" | bc_cmd)
+sen_mc=$(echo "${sen_mc}/${phi_max}*${h}" | bc_cmd)
+err_mc=$(echo "${err_mc}/${phi_max}*${h}" | bc_cmd)
+sen_fd=$(echo "${sen_fd}/${phi_max}*${h}" | bc_cmd)
+err_fd=$(echo "${err_fd}/${phi_max}*${h}" | bc_cmd)
+printf "%s %s %s %s %s\n" \
+ "${pi_over_h}" "${sen_mc}" "${err_mc}" "${sen_fd}" "${err_fd}"
+@
- sen_fd=$(echo "(${lum_n}-${lum_p})/(2*${pi_step})" | bc_cmd)
- err_fd=$(echo "(${err_n}+${err_p})/(2*${pi_step})" | bc_cmd)
- sen_fd=$(echo "${sen_fd}/${phi_max}*${h}" | bc_cmd)
- err_fd=$(echo "${err_fd}/${phi_max}*${h}" | bc_cmd)
+On complète finalement notre script par les fonctions utilitaires utilisées tout
+du long, à savoir la fonction [[float_to_bc]] qui convertie un nombre à virgule
+flottante dans le format attendu par le programme \texttt{bc}, et la fonction
+[[bc_cmd]] qui exécute le programme \texttt{bc} et en post-traite le résultat pour
+supprimer les zéros qui suivent le dernier chiffre significatif.
- printf "%s %s %s %s %s %s %s\n" \
- "${pi_over_h}" "${sen_mc}" "${err_mc}" "${sen_fd}" "${err_fd}"
+<<fonctions utilitaires à [[fd.sh]]>>=
+float_to_bc()
+{
+ sed 's/\([+-]\{0,1\}[0-9]\{0,\}\.\{0,1\}[0-9]\{1,\}\)'\
+'[eE]+\{0,1\}\(-\{0,1\}\)\([0-9]\{1,\}\)/(\1*10^\2\3)/g'
+}
- p="${c}"
- c="${n}"
-done
+bc_cmd()
+{
+ bc -l | sed '/\./s/\.\{0,\}0\{1,\}$//'
+}
@
\bibliographystyle{apalike}
