diff --git a/Documentation_texfol/Graphiques/.gitignore b/Documentation_texfol/Graphiques/.gitignore
index 5015fed72c6c632394ccbf0e8c4a6d36caf5ee2d..b8a731e6efc8d0b3b35fa7b6d8aa879a554409be 100644
--- a/Documentation_texfol/Graphiques/.gitignore
+++ b/Documentation_texfol/Graphiques/.gitignore
@@ -8,3 +8,4 @@ window.pdf
periodicity.pdf
copy.pdf
set_all_outerm.pdf
+overlap.pdf
diff --git a/Documentation_texfol/Graphiques/GNUmakefile b/Documentation_texfol/Graphiques/GNUmakefile
index fd3e40cccbd0c76de71b1586807e670c3c6e025d..d28a44144f9cf5342e4dc0ae51f2fb484640a6f1 100644
--- a/Documentation_texfol/Graphiques/GNUmakefile
+++ b/Documentation_texfol/Graphiques/GNUmakefile
@@ -1,4 +1,4 @@
-sources = window processes m3 call_graph input_output degeneracy periodicity copy set_all_outerm
+sources = window processes m3 call_graph input_output degeneracy periodicity copy set_all_outerm overlap
objects := $(addsuffix .pdf, ${sources})
diff --git a/Documentation_texfol/Graphiques/input_output.odg b/Documentation_texfol/Graphiques/input_output.odg
index 7a08dfba602812b958e15b1a32b7730743284f18..b1cdf9644be29ca5ffff78b80a3f16ec257acf8c 100644
Binary files a/Documentation_texfol/Graphiques/input_output.odg and b/Documentation_texfol/Graphiques/input_output.odg differ
diff --git a/Documentation_texfol/Graphiques/overlap.odg b/Documentation_texfol/Graphiques/overlap.odg
new file mode 100644
index 0000000000000000000000000000000000000000..122ab36df16342bb36ec005b44090e9d568ce7cd
Binary files /dev/null and b/Documentation_texfol/Graphiques/overlap.odg differ
diff --git a/Documentation_texfol/documentation.tex b/Documentation_texfol/documentation.tex
index c6419f19778a3a56c3bcf0d7242e02ced8004b75..4a7f8a7853d62c7f28c091da583e7b81cb181771 100644
--- a/Documentation_texfol/documentation.tex
+++ b/Documentation_texfol/documentation.tex
@@ -59,6 +59,8 @@ de la vitesse.
But du programme : produire une base de données de tourbillons. Le
programme ne traite qu'une date.
+Compilation et exécution testées avec NAG Fortran Compiler Release 6.2.
+
\subsection{Cas pathologiques}
\verb+out_cont+ est vide si et seulement s'il n'y a
@@ -950,6 +952,13 @@ Le graphe est orienté acyclique. L'ordre topologique est tout trouvé :
numérotation par dates successives. Le graphe non orienté associé est
une forêt.
+Notons ici $k_b$, $k_e$, $\max \delta$ et $n_p$ les valeurs contenues
+dans les variables Fortran \verb+k_begin+, \verb+k_end+,
+\verb+max_delta+ et \verb+n_proc+ respectivement.
+
+On ne cherche des superpositions qu'entres tourbillons visibles, en
+excluant les tourbillons interpolés.
+
Pour comparer les tourbillons à deux dates, il semble coûteux de
n'utiliser que les listes de tourbillons aux deux dates. Cela implique
une double boucle sur les listes de tourbillons, à l'intérieur d'une
@@ -958,11 +967,33 @@ $8000 \times 8000 \times 5000$ comparaisons. Pour éviter cette
comparaison aveugle, on peut conserver l'information sur la position
des tourbillons dans des cartes aux différentes dates. La conservation
en mémoire vive à 5000 dates semble aussi trop lourde. Il faut se
-restreindre aux cinq (\verb+max_delta+ + 1) dates nécessaires à la
+restreindre aux cinq ($\max \delta$ + 1) dates nécessaires à la
profondeur de vue.
+Un tourbillon donné $i_1$ à une date donnée $k$ peut avoir des
+successeurs à différentes distances temporelles. Supposons que nous
+ayons trouvé un successeur du tourbillon $(k, i_1)$ à une distance
+$\delta$. Un tourbillon $(k + \delta', i_2)$ Ã une distance
+$\delta' > \delta$ peut être enregistré comme successeur de $(k, i_1)$
+si $(k + \delta', i_2)$ n'a pas de prédécesseur à distance strictement
+inférieure à $\delta'$. De même, un tourbillon donné à une date donnée
+peut avoir des prédécesseurs à différentes distances
+temporelles. Cf. figure (\ref{fig:overlap}) et commentaires sur
+overlap.
+\begin{figure}[htbp]
+ \centering
+ \includegraphics{overlap}
+ \caption{Un morceau d'un graphe de recouvrement. Un tourbillon peut
+ avoir des prédécesseurs et des successeurs à différentes distances
+ temporelles. Dans cet exemple, $i_1$ ne peut pas avoir de
+ successeur à distance strictement inférieure à $\delta$. $i_2$ ne
+ peut pas être le successeur de $i'_1$ : le recouvrement de $i_2$
+ et $i'_1$ n'est pas examiné dans la procédure overlap.}
+ \label{fig:overlap}
+\end{figure}
+
Lorsqu'on compare des tourbillons à distance temporelle delta (entre 1
-et \verb+max_delta+), on veut tester s'ils n'ont pas de prédécesseur ou
+et $\max \delta$), on veut tester s'ils n'ont pas de prédécesseur ou
successeur visible à une date intermédiaire. Il faut donc, si on crée
un arc entre deux dates successives, ou delta arcs à distance delta
(par interpolation de tourbillons invisibles), enregistrer ce fait en
@@ -975,11 +1006,8 @@ chaque tourbillon, non seulement s'il a des prédécesseurs visibles et
s'il a des successeurs visibles, mais aussi à quelle distance
temporelle.
-On ne cherche des superpositions qu'entres tourbillons visibles, en
-excluant les tourbillons interpolés.
-
On pourrait écrire l'algorithme principal en explicitant les
-\verb+get_snpashot+, en explicitant le cas m < \verb+n_proc+ et en supprimant la
+\verb+get_snpashot+, en explicitant le cas m < $n_p$ et en supprimant la
variable \verb+k_end_main_loop+. Ce serait mieux du point de vue de la
performance, mais je pense que ce serait finalement moins clair.
@@ -1003,6 +1031,8 @@ Ces procédures sont appelées par :
\end{itemize}
Cf. discussion autour de l'équation~(\ref{eq:length_pi}).
+Compilation et exécution testées avec NAG Fortran Compiler Release 6.2.
+
\subsection{Entrées et sorties}
On n'enregistre pas de contours pour les tourbillons interpolés. Les
@@ -1057,8 +1087,8 @@ suivants :
Les entrées-sorties sont dans : l'algorithme principal directement
(lecture de longitude et latitude), \verb+get_snapshot+ (lecture des
-shapefiles), \verb+overlap+ (écriture dans
-\verb+edgelist_$m.txt+, arcs entre \verb+k_begin+(m) et
+shapefiles), \verb+write_overlap+ (écriture dans
+\verb+edgelist_$m.txt+, arcs entre $k_b$(m) et
\verb+k_end_main_loop+(m)), \verb+write_eddy+ (écriture dans
\verb+extremum+, \verb+outermost_contour+, \verb+max_speed_contour+),
\verb+dispatch_snapshot+ directement (écriture dans
@@ -1087,9 +1117,9 @@ par \verb+overlap+.
\begin{description}
\item[max\_delta] Scalaire entier. Intervalle maximal d'indices de
dates auxquelles on cherche des recouvrements. Normalement 4.
-\item[flow] : Vecteur de type snapshot, de taille \verb+max_delta+ +
+\item[flow] : Vecteur de type snapshot, de taille $\max \delta$ +
1, chaque élément correspondant à une date. Environ 40 MiB pour
- \verb+max_delta+ = 4.
+ $\max \delta$ = 4.
\item[dist\_lim] Scalaire entier constant, = 3° / résolution.
\item[weight\_delta] Scalaire réel.
\end{description}
@@ -1100,7 +1130,7 @@ différents appels à overlap avec delta $\ge 2$ : il faut que le numéro
de tourbillon interpolé soit bien incrémenté.
i désigne un indice de tourbillon, j un indice de position dans la
-fenêtre temporelle (entre 1 et \verb+max_delta+ + 1) et k un indice de
+fenêtre temporelle (entre 1 et $\max \delta$ + 1) et k un indice de
date. Cf. figure (\ref{fig:window}) et algorithme
(\ref{alg:main_sequential}).
\begin{figure}[htbp]
@@ -1112,21 +1142,21 @@ date. Cf. figure (\ref{fig:window}) et algorithme
\end{figure}
\begin{algorithm}[htbp]
\begin{algorithmic}
- \STATE \COMMENT{\{max\_delta $\ge 1$; n\_dates $\ge$ max\_delta +
+ \STATE \COMMENT{\{$\max \delta$ $\ge 1$; n\_dates $\ge$ $\max \delta$ +
1\}}
\STATE \COMMENT{prologue}
\STATE entrer(longitude, latitude)
\STATE \COMMENT{longitude et latitude dans l'ordre croissant}
- \FOR{k = 1 \TO max\_delta + 1}
+ \FOR{k = 1 \TO $\max \delta$ + 1}
\STATE appel de get\_snapshot(flow(k), k)
\ENDFOR
- \FOR{delta = 1 \TO max\_delta}
+ \FOR{delta = 1 \TO $\max \delta$}
- \FOR{k = delta + 1 \TO max\_delta + 1}
+ \FOR{k = delta + 1 \TO $\max \delta$ + 1}
\STATE appel de overlap(flow, k, k, delta)
@@ -1135,24 +1165,24 @@ date. Cf. figure (\ref{fig:window}) et algorithme
\STATE \COMMENT{boucle principale}
- \FOR{k = max\_delta + 2 \TO n\_dates}
+ \FOR{k = $\max \delta$ + 2 \TO n\_dates}
- \STATE appel de dispatch\_snapshot(flow(1), k - max\_delta - 1)
- \STATE flow(:max\_delta) = flow(2:)
+ \STATE appel de dispatch\_snapshot(flow(1), k - $\max \delta$ - 1)
+ \STATE flow(:$\max \delta$) = flow(2:)
- \STATE appel de get\_snapshot(flow(max\_delta + 1), k)
+ \STATE appel de get\_snapshot(flow($\max \delta$ + 1), k)
- \FOR{delta = 1 \TO max\_delta}
+ \FOR{delta = 1 \TO $\max \delta$}
- \STATE appel de overlap(flow, max\_delta + 1, k, delta)
+ \STATE appel de overlap(flow, $\max \delta$ + 1, k, delta)
\ENDFOR
\ENDFOR
\STATE \COMMENT{épilogue}
- \FOR{j = 1 \TO max\_delta + 1}
+ \FOR{j = 1 \TO $\max \delta$ + 1}
- \STATE appel de dispatch\_snapshot(flow(j), n\_dates - max\_delta - 1
+ \STATE appel de dispatch\_snapshot(flow(j), n\_dates - $\max \delta$ - 1
+ j)
\ENDFOR
\end{algorithmic}
@@ -1171,119 +1201,130 @@ Cf. figure (\ref{fig:processes}).
boucle principale, en bleu, vert et marron dans l'épilogue.}
\label{fig:processes}
\end{figure}
-Il faut, pour m < \verb+n_proc+ :
+Il faut, pour $m < n_p$ :
\begin{equation}
\label{eq:stitching}
- \mathtt{k\_end}(m)
- = \mathtt{k\_begin}(m + 1) + \mathtt{max\_delta} - 1
+ k_e(m)
+ = k_b(m + 1) + \max \delta - 1
\end{equation}
-k\_end - \verb+k_begin+ + 1 appels à \verb+get_snapshot+, pour les
-dates \verb+k_begin+ Ã k\_end. k\_end - \verb+k_begin+ + 1 appels Ã
-\verb+dispatch_snapshot+, pour les dates \verb+k_begin+ Ã k\_end. Si m
-> 1 alors \verb+max_delta+ envois. Si m < \verb+n_proc+ alors
-\verb+max_delta+ réceptions.
+Notons, pour un processus donné :
+\begin{equation*}
+ \Delta k := k_e - k_b
+\end{equation*}
+$\Delta k + 1$ appels à \verb+get_snapshot+, pour les dates $k_b$ Ã
+$k_e$. $\Delta k + 1$ appels à \verb+dispatch_snapshot+, pour les
+dates $k_b$ Ã $k_e$. Si $m > 1$ alors $\max \delta$ envois. Si
+$m < n_p$ alors $\max \delta$ réceptions.
-Nombre d'appels à \verb+get_snapshot+ avec lecture. Si m <
-\verb+n_proc+ : k\_end - \verb+k_begin+ - \verb+max_delta+ + 1. Si m =
-\verb+n_proc+ : k\_end - \verb+k_begin+ + 1.
+Nombre d'appels à \verb+get_snapshot+ avec lecture. Si $m < n_p$ :
+$\Delta k - \max \delta + 1$. Si $m = n_p$ : $k_e - k_b + 1$.
overlap avec delta = 1 est appelé pour tous les indices k compris
-entre \verb+k_begin+ + 1 et \verb+k_end_main_loop+, seulement. Nombre
-d'appels à overlap avec delta = 1 : \verb+k_end_main_loop+ -
-\verb+k_begin+. Donc si m < \verb+n_proc+ : k\_end - \verb+k_begin+ -
-\verb+max_delta+ + 1 appels. Si m = \verb+n_proc+ : k\_end -
-\verb+k_begin+ appels.
+entre $k_b + 1$ et \verb+k_end_main_loop+, seulement. Nombre d'appels
+Ã overlap avec delta = 1 : \verb+k_end_main_loop+ - $k_b$. Donc si
+$m < n_p$ : $k_e - k_b - \max \delta + 1$ appels. Si $m = n_p$ :
+$k_e - k_b$ appels.
Nombre d'appels à overlap avec delta $\ge 2$ dans le prologue :
\begin{equation*}
- \sum_{\delta = 2} ^{\mathtt{max\_delta}}
- (\mathtt{max\_delta} - \delta +1)
- = \frac{\mathtt{max\_delta} (\mathtt{max\_delta} - 1)}{2}
+ \sum_{\delta = 2} ^{\max \delta} (\max \delta - \delta +1)
+ = \frac{\max \delta (\max \delta - 1)}{2}
\end{equation*}
-Dans la boucle principale : (\verb+max_delta+ - 1)(\verb+k_end_main_loop+ -
-\verb+k_begin+ - \verb+max_delta+). Dans l'épilogue, si m < \verb+n_proc+ :
+Dans la boucle principale :
+$(\max \delta - 1)(\mathtt{k\_end\_main\_loop} - k_b - \max
+\delta)$. Dans l'épilogue, si $m < n_p$ :
\begin{equation*}
- \frac{\mathtt{max\_delta} (\mathtt{max\_delta} - 1)}{2}
+ \frac{\max \delta (\max \delta - 1)}{2}
\end{equation*}
-Total si m < \verb+n_proc+ : (\verb+max_delta+ - 1)(k\_end -
-\verb+k_begin+ - \verb+max_delta+ + 1). Total si m = \verb+n_proc+ :
+Total si $m < n_p$ :
+$(\max \delta - 1)(k_e - k_b - \max \delta + 1)$. Total si m =
+$n_p$ :
\begin{equation*}
- (\mathtt{max\_delta} - 1)
- \left(
- \mathtt{k\_end} - \mathtt{k\_begin} - \frac{\mathtt{max\_delta}}{2}
- \right)
+ (\max \delta - 1) \left(k_e - k_b - \frac{\max \delta}{2} \right)
\end{equation*}
-Si k\_end - \verb+k_begin+ était le même pour m = \verb+n_proc+ et m <
-\verb+n_proc+, le processus m=\verb+n_proc+ aurait des plus grands nombres
-d'appels aux trois procédures. Notons $\Delta k$ = k\_end - \verb+k_begin+,
-considéré comme une fonction de m. Si, pour m < \verb+n_proc+ :
+Si $k_e - k_b$ était le même pour $m = n_p$ et $m < n_p$, le processus
+$m = n_p$ aurait des plus grands nombres d'appels aux trois
+procédures. Considérons $\Delta k$ comme une fonction de $m$. Si, pour
+$m < n_p$ :
\begin{equation}
\label{eq:charge}
- \Delta k(m) \approx \Delta k(\mathtt{n\_proc}) + \mathtt{max\_delta}
+ \Delta k(m) \approx \Delta k(n_p) + \max \delta
\end{equation}
alors la charge devrait être à peu près équilibrée.
On peut prendre, pour tout m :
\begin{equation*}
- \mathtt{k\_begin}(m)
- = 1 + E[(m - 1) \mathtt{n\_dates} / \mathtt{n\_proc}]
+ k_b(m) = 1 + E[(m - 1) \mathtt{n\_dates} / n_p]
\end{equation*}
(On prend la partie entière au lieu de nint pour pouvoir démontrer des
-encadrements.) D'où, avec la contrainte (\ref{eq:stitching}), pour m
-< \verb+n_proc+ :
+encadrements.) D'où, avec la contrainte (\ref{eq:stitching}), pour
+$m < n_p$ :
\begin{equation*}
- \mathtt{k\_end}(m)
- = E(m\ \mathtt{n\_dates} / \mathtt{n\_proc}) + \mathtt{max\_delta}
+ k_e(m) = E(m\ \mathtt{n\_dates} / n_p) + \max \delta
\end{equation*}
-Alors on peut montrer que $\Delta k(m) - \Delta k(\mathtt{n\_proc})$
-vaut \verb+max_delta+ ou \verb+max_delta+ - 1. On a donc l'approximation
+Alors on peut montrer que $\Delta k(m) - \Delta k(n_p)$
+vaut $\max \delta$ ou $\max \delta$ - 1. On a donc l'approximation
(\ref{eq:charge}). Chaque processus fait aussi le même nombre de
lectures de ssh, u, v.
-Pour \verb+n_proc+ $\ne 1$ et m < \verb+n_proc+, le processus m + 1 ne doit pas
-relire une date déjà lue par le processus m. On doit donc avoir :
+Pour $n_p \ne 1$ et $m < n_p$, le processus $m + 1$ ne doit pas relire
+une date déjà lue par le processus $m$. On doit donc avoir :
\begin{equation}
\label{eq:min_delta_k}
- \mathtt{k\_begin}(m + 1) > \mathtt{k\_begin}(m) + \mathtt{max\_delta}
+ k_b(m + 1) > k_b(m) + \max \delta
\end{equation}
Ce qui est équivalent à :
\begin{equation*}
- E(m \mathtt{n\_dates} / \mathtt{n\_proc})
- - E[(m - 1) \mathtt{n\_dates} / \mathtt{n\_proc}]
- > \mathtt{max\_delta}
+ E(m \mathtt{n\_dates} / n_p)
+ - E[(m - 1) \mathtt{n\_dates} / n_p]
+ > \max \delta
\end{equation*}
Or on peut montrer que :
\begin{equation*}
- E(m \mathtt{n\_dates} / \mathtt{n\_proc})
- - E[(m - 1) \mathtt{n\_dates} / \mathtt{n\_proc}]
- > E(\mathtt{n\_dates} / \mathtt{n\_proc}) - 1
+ E(m \mathtt{n\_dates} / n_p)
+ - E[(m - 1) \mathtt{n\_dates} / n_p]
+ > E(\mathtt{n\_dates} / n_p) - 1
\end{equation*}
Il suffit donc que :
\begin{equation*}
- E(\mathtt{n\_dates} / \mathtt{n\_proc}) \ge \mathtt{max\_delta} + 1
+ E(\mathtt{n\_dates} / n_p) \ge \max \delta + 1
+\end{equation*}
+
+Si $m < n_p$ alors :
+\begin{equation*}
+ \Delta k > \frac{\mathtt{n\_dates}}{n_p} + \max \delta - 2
\end{equation*}
+Or :
+\begin{equation*}
+ \frac{\mathtt{n\_dates}}{n_p} \ge \max \delta + 1
+\end{equation*}
+donc :
+\begin{equation}
+ \label{eq:Delta_k}
+ \Delta k \ge 2 \max \delta
+\end{equation}
-L'équation (\ref{eq:stitching}) et l'inégalité (\ref{eq:min_delta_k})
-impliquent que, pour m < \verb+n_proc+ :
+L'équation (\ref{eq:stitching}) et l'inégalité (\ref{eq:min_delta_k}),
+ou encore l'équation (\ref{eq:Delta_k}), impliquent que, pour
+$m < n_p$ :
\begin{equation}
- \label{eq:delta_k}
- \mathtt{k\_begin} + \mathtt{max\_delta}
- \le \mathtt{k\_end} - \mathtt{max\_delta}
+ \label{eq:Delta_k_2}
+ k_b + \max \delta
+ \le k_e - \max \delta
\end{equation}
donc les appels de \verb+get_snapshot+ dans le prologue font des
lectures. Les appels de \verb+get_snapshot+ dans l'épilogue font des
-réceptions. L'inégalité (\ref{eq:delta_k}) implique en outre que, pour
-m < \verb+n_proc+, la boucle principale fait au moins une
-itération. Si m < \verb+n_proc+ : tous les appels Ã
-\verb+get_snapshot+ de la boucle principale sauf le dernier font des
-lectures ; le dernier appel à \verb+get_snapshot+ de la boucle
-principale fait une réception.
+réceptions. L'inégalité (\ref{eq:Delta_k_2}) implique en outre que, pour
+$m < n_p$, la boucle principale fait au moins une itération. Si
+$m < n_p$ : tous les appels à \verb+get_snapshot+ de la boucle
+principale sauf le dernier font des lectures ; le dernier appel Ã
+\verb+get_snapshot+ de la boucle principale fait une réception.
Si $m \ge 2$ alors :
\begin{equation*}
- \mathtt{k\_end\_main\_loop}(m - 1) = \mathtt{k\_begin}(m)
+ \mathtt{k\_end\_main\_loop}(m - 1) = k_b(m)
\end{equation*}
Exemples : cf. tableaux (\ref{tab:m2}) et (\ref{tab:m3}) et figure
@@ -1291,33 +1332,33 @@ Exemples : cf. tableaux (\ref{tab:m2}) et (\ref{tab:m3}) et figure
\begin{table}[htbp]
\centering
\begin{tabular}{llll}
- m & \verb+k_begin+ & k\_end & \verb+k_end_main_loop+ \\
+ $m$ & $k_b$ & $k_e$ & \verb+k_end_main_loop+ \\
\hline
1 & 1 & 9 & 6 \\
2 & 6 & 10 & 10
\end{tabular}
- \caption{max\_delta = 4, n\_dates = 10, n\_proc = 2. m = 1 : lecture
- dates 1 à 5, écriture date 1, réception date 6, écriture dates 2 Ã
- 4, réception dates 7 à 9, écriture dates 5 à 9. m = 2 : lecture 6
- à 10, envoi 6 à 9, écriture 10.}
+ \caption{$\max \delta = 4$, n\_dates = 10, $n_p = 2$. $m = 1$ :
+ lecture dates 1 à 5, écriture date 1, réception date 6, écriture
+ dates 2 à 4, réception dates 7 à 9, écriture dates 5 à 9. $m = 2$
+ : lecture 6 à 10, envoi 6 à 9, écriture 10.}
\label{tab:m2}
\end{table}
\begin{table}[htbp]
\centering
\begin{tabular}{llll}
- m & \verb+k_begin+ & k\_end & \verb+k_end_main_loop+ \\
+ $m$ & $k_b$ & $k_e$ & \verb+k_end_main_loop+ \\
\hline
1 & 1 & 9 & 6 \\
2 & 6 & 14 & 11 \\
3 & 11 & 15 & 15
\end{tabular}
- \caption{max\_delta = 4, n\_dates = 15, n\_proc = 3}
+ \caption{$\max \delta = 4$, n\_dates = 15, $n_p = 3$}
\label{tab:m3}
\end{table}
\begin{figure}[htbp]
\centering
\includegraphics[width=\textwidth]{m3}
- \caption{max\_delta = 4, n\_dates = 15, n\_proc = 3. Les numéros
+ \caption{$\max \delta = 4$, n\_dates = 15, $n_p = 3$. Les numéros
sont les indices de date. En bleu le prologue, en noir la boucle
principale, en rouge l'épilogue. Pour un processus donné, les
actions sur une même colonne sont dans une même boucle de
@@ -1326,21 +1367,160 @@ Exemples : cf. tableaux (\ref{tab:m2}) et (\ref{tab:m3}) et figure
\end{figure}
Le \verb+dispatch_snapshot+ dans la dernière boucle sur j n'est pas
-forcément une écriture. Exemple : \verb+n_proc+ = 2, \verb+max_delta+ = 4,
-n\_dates = 10, m = 2.
+forcément une écriture. Exemple : $n_p = 2$, $\max \delta = 4$,
+n\_dates = 10, $m = 2$.
+
+Si $m = 1$ alors \verb+write_eddy+ est appelé pour les dates $k_b$ Ã
+$k_e$. Si $m > 1$ alors \verb+write_eddy+ est appelé pour les dates
+$k_b + \max \delta$ à $k_e$. Avec l'équation (\ref{eq:stitching}), une
+date donnée est bien écrite par un seul processus.
+
+Pour tout processus $m$, appelons \og domaine du processus $m$\fg{}
+l'ensemble $\{k_b(m), \dots, k_e(m)\}$. Soit $m \le n_p - 2$. Avec les
+équations (\ref{eq:stitching}) et (\ref{eq:Delta_k}) :
+\begin{equation*}
+ k_e(m) \le k_e(m + 1) - \max \delta - 1
+\end{equation*}
+C'est-Ã -dire :
+\begin{equation*}
+ k_e(m) \le k_b(m + 2) - 2
+\end{equation*}
+Ainsi les domaines des processus $m$ et $m + 2$ sont disjoints. Les
+domaines de deux processus n'ont une intersection non vide que si les
+numéros des processus sont adjacents.
-Si m = 1 alors \verb+write_eddy+ est appelé pour les dates
-\verb+k_begin+ à k\_end. Si m > 1 alors \verb+write_eddy+ est appelé
-pour les dates \verb+k_begin+ + \verb+max_delta+ Ã k\_end. Avec
-l'équation (\ref{eq:stitching}), une date donnée est bien écrite par
-un seul processus.
+\subsubsection{Successeurs d'une date donnée}
+
+Soit un processus. Un appel à overlap dans ce processus peut avoir
+lieu dans le prologue, la boucle principale ou l'épilogue. Dans le
+prologue :
+\begin{equation*}
+ k_b \le k - \delta \le k_b + \max \delta - 1
+\end{equation*}
+Dans la boucle principale :
+\begin{equation}
+ \label{eq:pred_main_loop}
+ k_b + 1 \le k - \delta \le k_e - 1
+\end{equation}
+Dans l'épilogue :
+\begin{equation*}
+ k_e - 2 \max \delta + 2 \le k - \delta \le k_e - \max \delta
+\end{equation*}
+Donc, dans l'épilogue, avec l'équation (\ref{eq:Delta_k}) (si on est
+dans l'épilogue, c'est qu'on a $m < n_p$) :
+\begin{equation*}
+ k_b + 2 \le k - \delta \le k_e - \max \delta
+\end{equation*}
+Donc, dans tous les cas, au moment d'un appel à overlap :
+\begin{equation}
+ \label{eq:pred}
+ k_b \le k - \delta \le k_e - 1
+\end{equation}
+
+Soit un processus $m < n_p$, au moment d'un appel à overlap. On peut
+resserrer l'encadrement (\ref{eq:pred_main_loop}) dans la boucle
+principale :
+\begin{equation*}
+ k_b + 1 \le k - \delta \le \mathtt{k\_end\_main\_loop} - 1 = k_e - \max \delta
+\end{equation*}
+Avec l'inégalité (\ref{eq:Delta_k_2}), on a dans le prologue :
+\begin{equation*}
+ k_b \le k - \delta \le k_e - \max \delta - 1
+\end{equation*}
+Donc, quelle que soit la partie, prologue, boucle principale ou
+épilogue, on a si $m < n_p$, au moment d'un appel à overlap :
+\begin{equation*}
+ k_b(m) \le k - \delta \le k_e(m) - \max \delta = k_b(m + 1) - 1
+\end{equation*}
+C'est-Ã -dire :
+\begin{equation*}
+ k_b(m) \le k - \delta \le k_b(m + 1) - 1
+\end{equation*}
+Donc il ne peut y avoir deux appels à overlap avec la même valeur de
+$k - \delta$ dans deux processus différents. En d'autres termes, les
+successeurs des tourbillons à une date donnée sont cherchés par un
+seul processus.
+
+Soient deux appels à overlap, avec $(k_1, \delta_1)$ et $(k_2,
+\delta_2)$ tels que :
+\begin{align*}
+ & k_1 - \delta_1 = k_2 - \delta_2 \\
+ & \delta_1 < \delta_2
+\end{align*}
+Comme démontré plus haut, les deux appels sont forcément dans le même processus.
+\begin{equation*}
+ k_1 - k_2 = \delta_1 - \delta_2
+\end{equation*}
+donc $k_1 < k_2$. Si les deux appels sont dans le prologue alors la
+boucle extérieure sur $\delta$ est dans l'ordre croissant donc l'appel
+$(k_1, \delta_1)$ est avant l'appel $(k_2, \delta_2)$. Si un appel est
+dans le prologue et l'autre non alors celui dans le prologue est
+forcément à une date $k$ antérieure, donc c'est l'appel
+$(k_1, \delta_1)$. Si les deux appels sont dans la boucle principale
+alors la boucle extérieure sur $k$ est dans l'ordre croissant donc
+l'appel $(k_1, \delta_1)$ est avant l'appel $(k_2, \delta_2)$. Si un
+appel est dans la boucle principale et l'autre dans l'épilogue alors
+celui dans la boucle principale est forcément à une date $k$
+antérieure, donc c'est l'appel $(k_1, \delta_1)$. Si les deux appels
+sont dans l'épilogue alors la boucle extérieure sur $k$ est dans
+l'ordre croissant donc l'appel $(k_1, \delta_1)$ est avant l'appel
+$(k_2, \delta_2)$. Ainsi, dans tous les cas, l'appel $(k_1, \delta_1)$
+a lieu avant l'appel $(k_2, \delta_2)$. En d'autres termes, les
+successeurs d'une date donnée sont cherchés dans l'ordre croissant des
+$\delta$.
+
+\subsubsection{Prédécesseurs d'une date donnée}
+
+Pour un processus quelconque, au moment d'un appel à overlap :
+\begin{equation*}
+ k_b + 1 \le k \le k_e
+\end{equation*}
+
+Soient deux appels à overlap, avec une même valeur de $k$ : avec
+$(k, \delta_1)$ dans un processus $m_1$ et $(k, \delta_2)$ dans un
+processus $m_2$.
+
+Si $m_1 = m_2$ alors, puisque les deux appels ont le même $k$, ils
+sont dans la même partie (prologue, boucle principale ou
+épilogue). Les boucles sur $\delta$ dans les trois parties étant dans
+l'ordre croissant, si $\delta_1 < \delta_2$ alors l'appel
+$(k, \delta_1)$ a lieu avant l'appel $(k, \delta_2)$.
+
+Si $m_1 \ne m_2$ alors $k$ appartient aux domaines de $m_1$ et $m_2$
+donc $|m_1 - m_2| = 1$. Quitte à intervertir $m_1$ et $m_2$, on peut
+supposer sans perte de généralité que $m_1 = m_2 + 1$.
+\begin{equation*}
+ k \le k_e(m_2) = k_b(m_2 + 1) + \max \delta - 1 = k_b(m_1) + \max \delta - 1
+\end{equation*}
+Donc l'appel $(k, \delta_1, m_1)$ est dans le prologue. Donc :
+\begin{equation*}
+ \delta_1 \le k - k_b(m_1)
+\end{equation*}
+Par ailleurs :
+\begin{equation*}
+ k \ge k_b(m_1) + 1 = k_b(m_2 + 1) + 1 = k_e(m2) - \max \delta + 2
+\end{equation*}
+Donc l'appel $(k, \delta_2, m_2)$ est dans l'épilogue. Donc :
+\begin{equation*}
+ \delta_2 \ge k - k_e(m_2) + \max \delta = k - k_b(m_1) + 1
+\end{equation*}
+Donc $\delta_2 > \delta_1$. L'appel à overlap dans $m_2$ est précédé
+d'un \verb+receive_snapshot+ bloquant de la date $k$ en provenance du
+processus $m_1$. Le send correspondant dans le processus $m_1$ est
+après le prologue. Donc l'appel $(k, \delta_1, m_1)$ est terminé avant
+l'appel $(k, \delta_2, m_2)$.
+
+En résumé, dans tous les cas, si $\delta_1 < \delta_2$ alors l'appel
+$(k, \delta_1, m_1)$ est terminé avant l'appel $(k, \delta_2,
+m_2)$. Les prédécesseurs d'une date donnée sont cherchés dans l'ordre
+croissant des $\delta$.
\subsection{Algorithme principal, parallèle}
\begin{algorithmic}
- \STATE \COMMENT{\{max\_delta $\ge 1$; n\_dates $\ge$ max\_delta + 1;
- n\_proc
- $\le E\left(\frac{\mathtt{n\_dates}}{\mathtt{max\_delta} + 1}
+ \STATE \COMMENT{\{$\max \delta$ $\ge 1$; n\_dates $\ge$ $\max \delta$ + 1;
+ $n_p$
+ $\le E\left(\frac{\mathtt{n\_dates}}{\max \delta + 1}
\right)$\}}
\STATE \COMMENT{prologue}
@@ -1359,72 +1539,72 @@ un seul processus.
\STATE recevoir longitude, latitude du processus 1
\ENDIF
- \STATE k\_begin = 1 + E[(m - 1) n\_dates / n\_proc]
+ \STATE $k_b$ = 1 + E[(m - 1) n\_dates / $n_p$]
- \IF{m < n\_proc}
+ \IF{m < $n_p$}
- \STATE k\_end = E(m n\_dates / n\_proc) + max\_delta
+ \STATE $k_e$ = E(m n\_dates / $n_p$) + $\max \delta$
- \STATE k\_end\_main\_loop = k\_end - max\_delta + 1
+ \STATE k\_end\_main\_loop = $k_e$ - $\max \delta$ + 1
\ELSE
- \STATE k\_end = n\_dates
- \STATE k\_end\_main\_loop = k\_end
+ \STATE $k_e$ = n\_dates
+ \STATE k\_end\_main\_loop = $k_e$
\ENDIF
- \FOR{k = k\_begin \TO k\_begin + max\_delta}
+ \FOR{k = $k_b$ \TO $k_b$ + $\max \delta$}
- \STATE appel de get\_snapshot(flow(k - k\_begin + 1), k)
+ \STATE appel de get\_snapshot(flow(k - $k_b$ + 1), k)
\COMMENT{lecture}
\ENDFOR
- \FOR{delta = 1 \TO max\_delta}
+ \FOR{delta = 1 \TO $\max \delta$}
- \FOR{k = k\_begin + delta \TO k\_begin + max\_delta}
+ \FOR{k = $k_b$ + delta \TO $k_b$ + $\max \delta$}
- \STATE appel de overlap(flow, k - k\_begin + 1, k, delta)
+ \STATE appel de overlap(flow, k - $k_b$ + 1, k, delta)
\ENDFOR
\ENDFOR
\STATE \COMMENT{boucle principale}
- \FOR{k = k\_begin + max\_delta + 1 \TO k\_end\_main\_loop}
+ \FOR{k = $k_b$ + $\max \delta$ + 1 \TO k\_end\_main\_loop}
- \STATE appel de dispatch\_snapshot(flow(1), k - max\_delta - 1)
+ \STATE appel de dispatch\_snapshot(flow(1), k - $\max \delta$ - 1)
- \STATE flow(:max\_delta) = flow(2:)
+ \STATE flow(:$\max \delta$) = flow(2:)
- \STATE appel de get\_snapshot(flow(max\_delta + 1), k)
+ \STATE appel de get\_snapshot(flow($\max \delta$ + 1), k)
- \FOR{delta = 1 \TO max\_delta}
+ \FOR{delta = 1 \TO $\max \delta$}
- \STATE appel de overlap(flow, max\_delta + 1, k, delta)
+ \STATE appel de overlap(flow, $\max \delta$ + 1, k, delta)
\ENDFOR
\ENDFOR
\STATE \COMMENT{épilogue}
- \FOR{k = k\_end\_main\_loop + 1 \TO k\_end}
+ \FOR{k = k\_end\_main\_loop + 1 \TO $k_e$}
- \STATE \COMMENT{m < n\_proc et k $\ge$ k\_end - max\_delta + 2}
- \STATE appel de dispatch\_snapshot(flow(1), k - max\_delta - 1)
+ \STATE \COMMENT{m < $n_p$ et k $\ge$ $k_e$ - $\max \delta$ + 2}
+ \STATE appel de dispatch\_snapshot(flow(1), k - $\max \delta$ - 1)
- \STATE flow(:max\_delta) = flow(2:)
+ \STATE flow(:$\max \delta$) = flow(2:)
- \STATE appel de get\_snapshot(flow(max\_delta + 1), k)
+ \STATE appel de get\_snapshot(flow($\max \delta$ + 1), k)
\COMMENT{réception} \STATE \COMMENT{stitching}
- \FOR{delta = k - k\_end + max\_delta \TO max\_delta}
+ \FOR{delta = k - $k_e$ + $\max \delta$ \TO $\max \delta$}
- \STATE appel de overlap(max\_delta + 1, k, delta, flow)
+ \STATE appel de overlap(flow, $\max \delta$ + 1, k, delta)
\ENDFOR
\ENDFOR
- \FOR{j = 1 \TO max\_delta + 1}
+ \FOR{j = 1 \TO $\max \delta$ + 1}
- \STATE appel de dispatch\_snapshot(flow(j), k\_end - max\_delta - 1
+ \STATE appel de dispatch\_snapshot(flow(j), $k_e$ - $\max \delta$ - 1
+ j)
\ENDFOR
@@ -1472,6 +1652,15 @@ le multiple de $2 \pi$ à ajouter aux longitudes doit être le même pour
tous les points du contour, et égal au multiple à ajouter à la
longitude de l'extremum i2.
+Comment définir les composants \verb+delta_in+ et \verb+delta_out+ ?
+Cf. l'exemple de la figure \ref{fig:overlap}. Lorsqu'on arrive Ã
+$i'_1$, on ne veut pas tester le recouvrement de $i'_1$ et $i_2$. Il
+faut donc avoir conservé dans \verb+delta_in+ pour $i_2$ la distance
+strictement inférieure à $\delta$. \verb+delta_in+ doit donc contenir
+la distance temporelle minimale à laquelle des prédécesseurs ont été
+trouvés. De même, \verb+delta_out+ doit contenir la distance
+temporelle minimale à laquelle des successeurs ont été trouvés.
+
\subsubsection{weight}
D'autant plus proche de 0 que les tourbillons sont
diff --git a/candidate_overlap.f90 b/candidate_overlap.f90
index 871e3a1d025dbdd4be5fd37855ff14ca62ece2d6..9be2370ab773a9fca54e4707ba6fb626b5743f85 100644
--- a/candidate_overlap.f90
+++ b/candidate_overlap.f90
@@ -6,8 +6,9 @@ contains
function candidate_overlap(extr_map, list_vis, cyclone, delta_out, delta)
- ! Find the eddies in extr_map that are valid and have a given
- ! cyclonicity.
+ ! Find the eddies in extr_map that are valid, have a given
+ ! cyclonicity. Also, if delta_out < delta then the eddies should
+ ! not have a predecessor at time distance < delta.
use derived_types, only: eddy
@@ -18,11 +19,17 @@ contains
! extremum. 0 at other points.
type(eddy), intent(in):: list_vis(:)
- ! Visible eddies at a given date. We need components valid and
- ! cyclone to be defined.
+ ! Visible eddies at a given date. We need components valid,
+ ! cyclone and delta_in to be defined. Arriving in this subroutine,
+ ! list_vis%delta_in could be <= delta or huge(0).
logical, intent(in):: cyclone ! cyclonicity of the target extremum
- integer, intent(in):: delta_out, delta
+
+ integer, intent(in):: delta_out
+ ! Arriving in this subroutine, delta_out could be <= delta or
+ ! huge(0).
+
+ integer, intent(in):: delta
!---------------------------------------------------------------------
diff --git a/derived_types.f90 b/derived_types.f90
index 38704ad6de867dd64d18dc0ce8ef89d687ec6140..ef1c4af92a3afa97cf49181fb48607164a3e2659 100644
--- a/derived_types.f90
+++ b/derived_types.f90
@@ -27,12 +27,12 @@ module derived_types
logical interpolated
integer:: delta_in = huge(0)
- ! Maximum difference in time subscript where there is a direct
- ! predecessor. huge means there is no direct predecessor.
+ ! Minimum difference in time subscript where there is a direct
+ ! predecessor. Huge means there is no direct predecessor.
integer:: delta_out = huge(0)
- ! Maximum difference in time subscript where there is a direct
- ! successor. huge means there is no direct succcessor.
+ ! Minimum difference in time subscript where there is a direct
+ ! successor. Huge means there is no direct succcessor.
integer radius4
! ind_extr + radius4 - 1 in all four directions is inside outermost
diff --git a/overlap.f90 b/overlap.f90
index b76b99478b49ad586a6df78be5ea4dcb1ce57efb..fb76d9784057c3b76601823cdd95dc2d5cbb9879 100644
--- a/overlap.f90
+++ b/overlap.f90
@@ -52,7 +52,9 @@ contains
! Local:
- integer i1, i2, l, n_select, m
+ integer i1 ! eddy index of predecessor
+ integer i2 ! eddy index of successor
+ integer l, n_select, m
type(polyline) polyline_1, polyline_2
type(polygon) res_pol
@@ -80,10 +82,12 @@ contains
urc(1) = min(urc(1), nlon)
end if
+ ! Pre-select potential successors:
selection = candidate_overlap(flow(j)%extr_map(llc(1):urc(1), &
llc(2):urc(2)), flow(j)%list_vis, &
flow(j - delta)%list_vis(i1)%cyclone, &
flow(j - delta)%list_vis(i1)%delta_out, delta)
+
n_select = size(selection)
if (n_select /= 0) polyline_1 &
= merge(flow(j - delta)%list_vis(i1)%speed_cont%polyline, &
@@ -92,6 +96,8 @@ contains
DO l = 1, n_select
i2 = selection(l)
+ ! assertion {flow(j - delta)%list_vis(i1)%delta_out >=
+ ! delta .or. flow(j)%list_vis(i2)%delta_in >= delta}
polyline_2 = merge(flow(j)%list_vis(i2)%speed_cont%polyline, &
flow(j)%list_vis(i2)%out_cont%polyline, &
flow(j)%list_vis(i2)%speed_cont%n_points /= 0)
@@ -127,8 +133,10 @@ contains
flow(j)%list_vis(i2)%ssh_extr, &
weight(flow(j - delta)%list_vis(i1), &
flow(j)%list_vis(i2)))
- flow(j - delta)%list_vis(i1)%delta_out = delta
- flow(j)%list_vis(i2)%delta_in = delta
+ flow(j - delta)%list_vis(i1)%delta_out &
+ = min(flow(j - delta)%list_vis(i1)%delta_out, delta)
+ flow(j)%list_vis(i2)%delta_in &
+ = min(flow(j)%list_vis(i2)%delta_in, delta)
end if
end if
end DO